PCI ASPM: cleanup initialization
[linux-3.10.git] / drivers / pci / pcie / aspm.c
1 /*
2  * File:        drivers/pci/pcie/aspm.c
3  * Enabling PCIE link L0s/L1 state and Clock Power Management
4  *
5  * Copyright (C) 2007 Intel
6  * Copyright (C) Zhang Yanmin (yanmin.zhang@intel.com)
7  * Copyright (C) Shaohua Li (shaohua.li@intel.com)
8  */
9
10 #include <linux/kernel.h>
11 #include <linux/module.h>
12 #include <linux/moduleparam.h>
13 #include <linux/pci.h>
14 #include <linux/pci_regs.h>
15 #include <linux/errno.h>
16 #include <linux/pm.h>
17 #include <linux/init.h>
18 #include <linux/slab.h>
19 #include <linux/jiffies.h>
20 #include <linux/delay.h>
21 #include <linux/pci-aspm.h>
22 #include "../pci.h"
23
24 #ifdef MODULE_PARAM_PREFIX
25 #undef MODULE_PARAM_PREFIX
26 #endif
27 #define MODULE_PARAM_PREFIX "pcie_aspm."
28
29 struct aspm_latency {
30         u32 l0s;                        /* L0s latency (nsec) */
31         u32 l1;                         /* L1 latency (nsec) */
32 };
33
34 struct pcie_link_state {
35         struct pci_dev *pdev;           /* Upstream component of the Link */
36         struct pcie_link_state *parent; /* pointer to the parent Link state */
37         struct list_head sibling;       /* node in link_list */
38         struct list_head children;      /* list of child link states */
39         struct list_head link;          /* node in parent's children list */
40
41         /* ASPM state */
42         u32 aspm_support:2;             /* Supported ASPM state */
43         u32 aspm_enabled:2;             /* Enabled ASPM state */
44         u32 aspm_default:2;             /* Default ASPM state by BIOS */
45
46         /* Clock PM state */
47         u32 clkpm_capable:1;            /* Clock PM capable? */
48         u32 clkpm_enabled:1;            /* Current Clock PM state */
49         u32 clkpm_default:1;            /* Default Clock PM state by BIOS */
50
51         u32 has_switch:1;               /* Downstream has switches? */
52
53         /* Latencies */
54         struct aspm_latency latency;    /* Exit latency */
55         /*
56          * Endpoint acceptable latencies. A pcie downstream port only
57          * has one slot under it, so at most there are 8 functions.
58          */
59         struct aspm_latency acceptable[8];
60 };
61
62 static int aspm_disabled, aspm_force;
63 static DEFINE_MUTEX(aspm_lock);
64 static LIST_HEAD(link_list);
65
66 #define POLICY_DEFAULT 0        /* BIOS default setting */
67 #define POLICY_PERFORMANCE 1    /* high performance */
68 #define POLICY_POWERSAVE 2      /* high power saving */
69 static int aspm_policy;
70 static const char *policy_str[] = {
71         [POLICY_DEFAULT] = "default",
72         [POLICY_PERFORMANCE] = "performance",
73         [POLICY_POWERSAVE] = "powersave"
74 };
75
76 #define LINK_RETRAIN_TIMEOUT HZ
77
78 static int policy_to_aspm_state(struct pcie_link_state *link)
79 {
80         switch (aspm_policy) {
81         case POLICY_PERFORMANCE:
82                 /* Disable ASPM and Clock PM */
83                 return 0;
84         case POLICY_POWERSAVE:
85                 /* Enable ASPM L0s/L1 */
86                 return PCIE_LINK_STATE_L0S | PCIE_LINK_STATE_L1;
87         case POLICY_DEFAULT:
88                 return link->aspm_default;
89         }
90         return 0;
91 }
92
93 static int policy_to_clkpm_state(struct pcie_link_state *link)
94 {
95         switch (aspm_policy) {
96         case POLICY_PERFORMANCE:
97                 /* Disable ASPM and Clock PM */
98                 return 0;
99         case POLICY_POWERSAVE:
100                 /* Disable Clock PM */
101                 return 1;
102         case POLICY_DEFAULT:
103                 return link->clkpm_default;
104         }
105         return 0;
106 }
107
108 static void pcie_set_clock_pm(struct pcie_link_state *link, int enable)
109 {
110         int pos;
111         u16 reg16;
112         struct pci_dev *child;
113         struct pci_bus *linkbus = link->pdev->subordinate;
114
115         list_for_each_entry(child, &linkbus->devices, bus_list) {
116                 pos = pci_find_capability(child, PCI_CAP_ID_EXP);
117                 if (!pos)
118                         return;
119                 pci_read_config_word(child, pos + PCI_EXP_LNKCTL, &reg16);
120                 if (enable)
121                         reg16 |= PCI_EXP_LNKCTL_CLKREQ_EN;
122                 else
123                         reg16 &= ~PCI_EXP_LNKCTL_CLKREQ_EN;
124                 pci_write_config_word(child, pos + PCI_EXP_LNKCTL, reg16);
125         }
126         link->clkpm_enabled = !!enable;
127 }
128
129 static void pcie_clkpm_cap_init(struct pcie_link_state *link, int blacklist)
130 {
131         int pos, capable = 1, enabled = 1;
132         u32 reg32;
133         u16 reg16;
134         struct pci_dev *child;
135         struct pci_bus *linkbus = link->pdev->subordinate;
136
137         /* All functions should have the same cap and state, take the worst */
138         list_for_each_entry(child, &linkbus->devices, bus_list) {
139                 pos = pci_find_capability(child, PCI_CAP_ID_EXP);
140                 if (!pos)
141                         return;
142                 pci_read_config_dword(child, pos + PCI_EXP_LNKCAP, &reg32);
143                 if (!(reg32 & PCI_EXP_LNKCAP_CLKPM)) {
144                         capable = 0;
145                         enabled = 0;
146                         break;
147                 }
148                 pci_read_config_word(child, pos + PCI_EXP_LNKCTL, &reg16);
149                 if (!(reg16 & PCI_EXP_LNKCTL_CLKREQ_EN))
150                         enabled = 0;
151         }
152         link->clkpm_enabled = enabled;
153         link->clkpm_default = enabled;
154         link->clkpm_capable = (blacklist) ? 0 : capable;
155 }
156
157 static bool pcie_aspm_downstream_has_switch(struct pcie_link_state *link)
158 {
159         struct pci_dev *child;
160         struct pci_bus *linkbus = link->pdev->subordinate;
161
162         list_for_each_entry(child, &linkbus->devices, bus_list) {
163                 if (child->pcie_type == PCI_EXP_TYPE_UPSTREAM)
164                         return true;
165         }
166         return false;
167 }
168
169 /*
170  * pcie_aspm_configure_common_clock: check if the 2 ends of a link
171  *   could use common clock. If they are, configure them to use the
172  *   common clock. That will reduce the ASPM state exit latency.
173  */
174 static void pcie_aspm_configure_common_clock(struct pcie_link_state *link)
175 {
176         int ppos, cpos, same_clock = 1;
177         u16 reg16, parent_reg, child_reg[8];
178         unsigned long start_jiffies;
179         struct pci_dev *child, *parent = link->pdev;
180         struct pci_bus *linkbus = parent->subordinate;
181         /*
182          * All functions of a slot should have the same Slot Clock
183          * Configuration, so just check one function
184          */
185         child = list_entry(linkbus->devices.next, struct pci_dev, bus_list);
186         BUG_ON(!child->is_pcie);
187
188         /* Check downstream component if bit Slot Clock Configuration is 1 */
189         cpos = pci_find_capability(child, PCI_CAP_ID_EXP);
190         pci_read_config_word(child, cpos + PCI_EXP_LNKSTA, &reg16);
191         if (!(reg16 & PCI_EXP_LNKSTA_SLC))
192                 same_clock = 0;
193
194         /* Check upstream component if bit Slot Clock Configuration is 1 */
195         ppos = pci_find_capability(parent, PCI_CAP_ID_EXP);
196         pci_read_config_word(parent, ppos + PCI_EXP_LNKSTA, &reg16);
197         if (!(reg16 & PCI_EXP_LNKSTA_SLC))
198                 same_clock = 0;
199
200         /* Configure downstream component, all functions */
201         list_for_each_entry(child, &linkbus->devices, bus_list) {
202                 cpos = pci_find_capability(child, PCI_CAP_ID_EXP);
203                 pci_read_config_word(child, cpos + PCI_EXP_LNKCTL, &reg16);
204                 child_reg[PCI_FUNC(child->devfn)] = reg16;
205                 if (same_clock)
206                         reg16 |= PCI_EXP_LNKCTL_CCC;
207                 else
208                         reg16 &= ~PCI_EXP_LNKCTL_CCC;
209                 pci_write_config_word(child, cpos + PCI_EXP_LNKCTL, reg16);
210         }
211
212         /* Configure upstream component */
213         pci_read_config_word(parent, ppos + PCI_EXP_LNKCTL, &reg16);
214         parent_reg = reg16;
215         if (same_clock)
216                 reg16 |= PCI_EXP_LNKCTL_CCC;
217         else
218                 reg16 &= ~PCI_EXP_LNKCTL_CCC;
219         pci_write_config_word(parent, ppos + PCI_EXP_LNKCTL, reg16);
220
221         /* Retrain link */
222         reg16 |= PCI_EXP_LNKCTL_RL;
223         pci_write_config_word(parent, ppos + PCI_EXP_LNKCTL, reg16);
224
225         /* Wait for link training end. Break out after waiting for timeout */
226         start_jiffies = jiffies;
227         for (;;) {
228                 pci_read_config_word(parent, ppos + PCI_EXP_LNKSTA, &reg16);
229                 if (!(reg16 & PCI_EXP_LNKSTA_LT))
230                         break;
231                 if (time_after(jiffies, start_jiffies + LINK_RETRAIN_TIMEOUT))
232                         break;
233                 msleep(1);
234         }
235         if (!(reg16 & PCI_EXP_LNKSTA_LT))
236                 return;
237
238         /* Training failed. Restore common clock configurations */
239         dev_printk(KERN_ERR, &parent->dev,
240                    "ASPM: Could not configure common clock\n");
241         list_for_each_entry(child, &linkbus->devices, bus_list) {
242                 cpos = pci_find_capability(child, PCI_CAP_ID_EXP);
243                 pci_write_config_word(child, cpos + PCI_EXP_LNKCTL,
244                                       child_reg[PCI_FUNC(child->devfn)]);
245         }
246         pci_write_config_word(parent, ppos + PCI_EXP_LNKCTL, parent_reg);
247 }
248
249 /*
250  * calc_L0S_latency: Convert L0s latency encoding to ns
251  */
252 static unsigned int calc_L0S_latency(unsigned int latency_encoding, int ac)
253 {
254         unsigned int ns = 64;
255
256         if (latency_encoding == 0x7) {
257                 if (ac)
258                         ns = -1U;
259                 else
260                         ns = 5*1000; /* > 4us */
261         } else
262                 ns *= (1 << latency_encoding);
263         return ns;
264 }
265
266 /*
267  * calc_L1_latency: Convert L1 latency encoding to ns
268  */
269 static unsigned int calc_L1_latency(unsigned int latency_encoding, int ac)
270 {
271         unsigned int ns = 1000;
272
273         if (latency_encoding == 0x7) {
274                 if (ac)
275                         ns = -1U;
276                 else
277                         ns = 65*1000; /* > 64us */
278         } else
279                 ns *= (1 << latency_encoding);
280         return ns;
281 }
282
283 static void pcie_aspm_get_cap_device(struct pci_dev *pdev, u32 *state,
284         unsigned int *l0s, unsigned int *l1, unsigned int *enabled)
285 {
286         int pos;
287         u16 reg16;
288         u32 reg32;
289         unsigned int latency;
290
291         *l0s = *l1 = *enabled = 0;
292         pos = pci_find_capability(pdev, PCI_CAP_ID_EXP);
293         pci_read_config_dword(pdev, pos + PCI_EXP_LNKCAP, &reg32);
294         *state = (reg32 & PCI_EXP_LNKCAP_ASPMS) >> 10;
295         if (*state != PCIE_LINK_STATE_L0S &&
296                 *state != (PCIE_LINK_STATE_L1|PCIE_LINK_STATE_L0S))
297                 *state = 0;
298         if (*state == 0)
299                 return;
300
301         latency = (reg32 & PCI_EXP_LNKCAP_L0SEL) >> 12;
302         *l0s = calc_L0S_latency(latency, 0);
303         if (*state & PCIE_LINK_STATE_L1) {
304                 latency = (reg32 & PCI_EXP_LNKCAP_L1EL) >> 15;
305                 *l1 = calc_L1_latency(latency, 0);
306         }
307         pci_read_config_word(pdev, pos + PCI_EXP_LNKCTL, &reg16);
308         *enabled = reg16 & (PCIE_LINK_STATE_L0S|PCIE_LINK_STATE_L1);
309 }
310
311 static void pcie_aspm_cap_init(struct pcie_link_state *link, int blacklist)
312 {
313         u32 support, l0s, l1, enabled;
314         struct pci_dev *child, *parent = link->pdev;
315         struct pci_bus *linkbus = parent->subordinate;
316
317         if (blacklist) {
318                 /* Set support state to 0, so we will disable ASPM later */
319                 link->aspm_support = 0;
320                 link->aspm_default = 0;
321                 link->aspm_enabled = PCIE_LINK_STATE_L0S | PCIE_LINK_STATE_L1;
322                 return;
323         }
324
325         /* Configure common clock before checking latencies */
326         pcie_aspm_configure_common_clock(link);
327
328         /* upstream component states */
329         pcie_aspm_get_cap_device(parent, &support, &l0s, &l1, &enabled);
330         link->aspm_support = support;
331         link->latency.l0s = l0s;
332         link->latency.l1 = l1;
333         link->aspm_enabled = enabled;
334
335         /* downstream component states, all functions have the same setting */
336         child = list_entry(linkbus->devices.next, struct pci_dev, bus_list);
337         pcie_aspm_get_cap_device(child, &support, &l0s, &l1, &enabled);
338         link->aspm_support &= support;
339         link->latency.l0s = max_t(u32, link->latency.l0s, l0s);
340         link->latency.l1 = max_t(u32, link->latency.l1, l1);
341
342         if (!link->aspm_support)
343                 return;
344
345         link->aspm_enabled &= link->aspm_support;
346         link->aspm_default = link->aspm_enabled;
347
348         /* ENDPOINT states*/
349         list_for_each_entry(child, &linkbus->devices, bus_list) {
350                 int pos;
351                 u32 reg32;
352                 unsigned int latency;
353                 struct aspm_latency *acceptable =
354                         &link->acceptable[PCI_FUNC(child->devfn)];
355
356                 if (child->pcie_type != PCI_EXP_TYPE_ENDPOINT &&
357                     child->pcie_type != PCI_EXP_TYPE_LEG_END)
358                         continue;
359
360                 pos = pci_find_capability(child, PCI_CAP_ID_EXP);
361                 pci_read_config_dword(child, pos + PCI_EXP_DEVCAP, &reg32);
362                 latency = (reg32 & PCI_EXP_DEVCAP_L0S) >> 6;
363                 latency = calc_L0S_latency(latency, 1);
364                 acceptable->l0s = latency;
365                 if (link->aspm_support & PCIE_LINK_STATE_L1) {
366                         latency = (reg32 & PCI_EXP_DEVCAP_L1) >> 9;
367                         latency = calc_L1_latency(latency, 1);
368                         acceptable->l1 = latency;
369                 }
370         }
371 }
372
373 static unsigned int __pcie_aspm_check_state_one(struct pci_dev *pdev,
374         unsigned int state)
375 {
376         struct pci_dev *parent_dev, *tmp_dev;
377         unsigned int l1_latency = 0;
378         struct pcie_link_state *link_state;
379         struct aspm_latency *acceptable;
380
381         parent_dev = pdev->bus->self;
382         link_state = parent_dev->link_state;
383         state &= link_state->aspm_support;
384         if (state == 0)
385                 return 0;
386         acceptable = &link_state->acceptable[PCI_FUNC(pdev->devfn)];
387
388         /*
389          * Check latency for endpoint device.
390          * TBD: The latency from the endpoint to root complex vary per
391          * switch's upstream link state above the device. Here we just do a
392          * simple check which assumes all links above the device can be in L1
393          * state, that is we just consider the worst case. If switch's upstream
394          * link can't be put into L0S/L1, then our check is too strictly.
395          */
396         tmp_dev = pdev;
397         while (state & (PCIE_LINK_STATE_L0S | PCIE_LINK_STATE_L1)) {
398                 parent_dev = tmp_dev->bus->self;
399                 link_state = parent_dev->link_state;
400                 if ((state & PCIE_LINK_STATE_L0S) &&
401                     (link_state->latency.l0s > acceptable->l0s))
402                         state &= ~PCIE_LINK_STATE_L0S;
403
404                 if ((state & PCIE_LINK_STATE_L1) &&
405                     (link_state->latency.l1 + l1_latency > acceptable->l1))
406                         state &= ~PCIE_LINK_STATE_L1;
407
408                 if (!parent_dev->bus->self) /* parent_dev is a root port */
409                         break;
410                 else {
411                         /*
412                          * parent_dev is the downstream port of a switch, make
413                          * tmp_dev the upstream port of the switch
414                          */
415                         tmp_dev = parent_dev->bus->self;
416                         /*
417                          * every switch on the path to root complex need 1 more
418                          * microsecond for L1. Spec doesn't mention L0S.
419                          */
420                         if (state & PCIE_LINK_STATE_L1)
421                                 l1_latency += 1000;
422                 }
423         }
424         return state;
425 }
426
427 static u32 pcie_aspm_check_state(struct pcie_link_state *link, u32 state)
428 {
429         pci_power_t power_state;
430         struct pci_dev *child;
431         struct pci_bus *linkbus = link->pdev->subordinate;
432
433         /* If no child, ignore the link */
434         if (list_empty(&linkbus->devices))
435                 return state;
436
437         list_for_each_entry(child, &linkbus->devices, bus_list) {
438                 /*
439                  * If downstream component of a link is pci bridge, we
440                  * disable ASPM for now for the link
441                  */
442                 if (child->pcie_type == PCI_EXP_TYPE_PCI_BRIDGE)
443                         return 0;
444
445                 if ((child->pcie_type != PCI_EXP_TYPE_ENDPOINT &&
446                      child->pcie_type != PCI_EXP_TYPE_LEG_END))
447                         continue;
448                 /* Device not in D0 doesn't need check latency */
449                 power_state = child->current_state;
450                 if (power_state == PCI_D1 || power_state == PCI_D2 ||
451                     power_state == PCI_D3hot || power_state == PCI_D3cold)
452                         continue;
453                 state = __pcie_aspm_check_state_one(child, state);
454         }
455         return state;
456 }
457
458 static void __pcie_aspm_config_one_dev(struct pci_dev *pdev, unsigned int state)
459 {
460         u16 reg16;
461         int pos = pci_find_capability(pdev, PCI_CAP_ID_EXP);
462
463         pci_read_config_word(pdev, pos + PCI_EXP_LNKCTL, &reg16);
464         reg16 &= ~0x3;
465         reg16 |= state;
466         pci_write_config_word(pdev, pos + PCI_EXP_LNKCTL, reg16);
467 }
468
469 static void __pcie_aspm_config_link(struct pcie_link_state *link, u32 state)
470 {
471         struct pci_dev *child, *parent = link->pdev;
472         struct pci_bus *linkbus = parent->subordinate;
473
474         /* If no child, disable the link */
475         if (list_empty(&linkbus->devices))
476                 state = 0;
477         /*
478          * If the downstream component has pci bridge function, don't
479          * do ASPM now.
480          */
481         list_for_each_entry(child, &linkbus->devices, bus_list) {
482                 if (child->pcie_type == PCI_EXP_TYPE_PCI_BRIDGE)
483                         return;
484         }
485         /*
486          * Spec 2.0 suggests all functions should be configured the
487          * same setting for ASPM. Enabling ASPM L1 should be done in
488          * upstream component first and then downstream, and vice
489          * versa for disabling ASPM L1. Spec doesn't mention L0S.
490          */
491         if (state & PCIE_LINK_STATE_L1)
492                 __pcie_aspm_config_one_dev(parent, state);
493
494         list_for_each_entry(child, &linkbus->devices, bus_list)
495                 __pcie_aspm_config_one_dev(child, state);
496
497         if (!(state & PCIE_LINK_STATE_L1))
498                 __pcie_aspm_config_one_dev(parent, state);
499
500         link->aspm_enabled = state;
501 }
502
503 static struct pcie_link_state *get_root_port_link(struct pcie_link_state *link)
504 {
505         struct pcie_link_state *root_port_link = link;
506         while (root_port_link->parent)
507                 root_port_link = root_port_link->parent;
508         return root_port_link;
509 }
510
511 /* Check the whole hierarchy, and configure each link in the hierarchy */
512 static void __pcie_aspm_configure_link_state(struct pcie_link_state *link,
513                                              u32 state)
514 {
515         struct pcie_link_state *leaf, *root = get_root_port_link(link);
516
517         state &= (PCIE_LINK_STATE_L0S | PCIE_LINK_STATE_L1);
518
519         /* Check all links who have specific root port link */
520         list_for_each_entry(leaf, &link_list, sibling) {
521                 if (!list_empty(&leaf->children) ||
522                     get_root_port_link(leaf) != root)
523                         continue;
524                 state = pcie_aspm_check_state(leaf, state);
525         }
526         /* Check root port link too in case it hasn't children */
527         state = pcie_aspm_check_state(root, state);
528         if (link->aspm_enabled == state)
529                 return;
530         /*
531          * We must change the hierarchy. See comments in
532          * __pcie_aspm_config_link for the order
533          **/
534         if (state & PCIE_LINK_STATE_L1) {
535                 list_for_each_entry(leaf, &link_list, sibling) {
536                         if (get_root_port_link(leaf) == root)
537                                 __pcie_aspm_config_link(leaf, state);
538                 }
539         } else {
540                 list_for_each_entry_reverse(leaf, &link_list, sibling) {
541                         if (get_root_port_link(leaf) == root)
542                                 __pcie_aspm_config_link(leaf, state);
543                 }
544         }
545 }
546
547 /*
548  * pcie_aspm_configure_link_state: enable/disable PCI express link state
549  * @pdev: the root port or switch downstream port
550  */
551 static void pcie_aspm_configure_link_state(struct pcie_link_state *link,
552                                            u32 state)
553 {
554         down_read(&pci_bus_sem);
555         mutex_lock(&aspm_lock);
556         __pcie_aspm_configure_link_state(link, state);
557         mutex_unlock(&aspm_lock);
558         up_read(&pci_bus_sem);
559 }
560
561 static void free_link_state(struct pcie_link_state *link)
562 {
563         link->pdev->link_state = NULL;
564         kfree(link);
565 }
566
567 static int pcie_aspm_sanity_check(struct pci_dev *pdev)
568 {
569         struct pci_dev *child_dev;
570         int child_pos;
571         u32 reg32;
572
573         /*
574          * Some functions in a slot might not all be PCIE functions, very
575          * strange. Disable ASPM for the whole slot
576          */
577         list_for_each_entry(child_dev, &pdev->subordinate->devices, bus_list) {
578                 child_pos = pci_find_capability(child_dev, PCI_CAP_ID_EXP);
579                 if (!child_pos)
580                         return -EINVAL;
581
582                 /*
583                  * Disable ASPM for pre-1.1 PCIe device, we follow MS to use
584                  * RBER bit to determine if a function is 1.1 version device
585                  */
586                 pci_read_config_dword(child_dev, child_pos + PCI_EXP_DEVCAP,
587                         &reg32);
588                 if (!(reg32 & PCI_EXP_DEVCAP_RBER) && !aspm_force) {
589                         dev_printk(KERN_INFO, &child_dev->dev, "disabling ASPM"
590                                 " on pre-1.1 PCIe device.  You can enable it"
591                                 " with 'pcie_aspm=force'\n");
592                         return -EINVAL;
593                 }
594         }
595         return 0;
596 }
597
598 static struct pcie_link_state *pcie_aspm_setup_link_state(struct pci_dev *pdev)
599 {
600         struct pcie_link_state *link;
601         int blacklist = !!pcie_aspm_sanity_check(pdev);
602
603         link = kzalloc(sizeof(*link), GFP_KERNEL);
604         if (!link)
605                 return NULL;
606         INIT_LIST_HEAD(&link->sibling);
607         INIT_LIST_HEAD(&link->children);
608         INIT_LIST_HEAD(&link->link);
609         link->pdev = pdev;
610         link->has_switch = pcie_aspm_downstream_has_switch(link);
611         if (pdev->pcie_type == PCI_EXP_TYPE_DOWNSTREAM) {
612                 struct pcie_link_state *parent;
613                 parent = pdev->bus->parent->self->link_state;
614                 if (!parent) {
615                         kfree(link);
616                         return NULL;
617                 }
618                 link->parent = parent;
619                 list_add(&link->link, &parent->children);
620         }
621         list_add(&link->sibling, &link_list);
622
623         pdev->link_state = link;
624
625         /* Check ASPM capability */
626         pcie_aspm_cap_init(link, blacklist);
627
628         /* Check Clock PM capability */
629         pcie_clkpm_cap_init(link, blacklist);
630
631         return link;
632 }
633
634 /*
635  * pcie_aspm_init_link_state: Initiate PCI express link state.
636  * It is called after the pcie and its children devices are scaned.
637  * @pdev: the root port or switch downstream port
638  */
639 void pcie_aspm_init_link_state(struct pci_dev *pdev)
640 {
641         u32 state;
642         struct pcie_link_state *link;
643
644         if (aspm_disabled || !pdev->is_pcie || pdev->link_state)
645                 return;
646         if (pdev->pcie_type != PCI_EXP_TYPE_ROOT_PORT &&
647             pdev->pcie_type != PCI_EXP_TYPE_DOWNSTREAM)
648                 return;
649
650         /* VIA has a strange chipset, root port is under a bridge */
651         if (pdev->pcie_type == PCI_EXP_TYPE_ROOT_PORT &&
652             pdev->bus->self)
653                 return;
654
655         down_read(&pci_bus_sem);
656         if (list_empty(&pdev->subordinate->devices))
657                 goto out;
658
659         mutex_lock(&aspm_lock);
660         link = pcie_aspm_setup_link_state(pdev);
661         if (!link)
662                 goto unlock;
663         /*
664          * Setup initial ASPM state
665          *
666          * If link has switch, delay the link config. The leaf link
667          * initialization will config the whole hierarchy. But we must
668          * make sure BIOS doesn't set unsupported link state.
669          */
670         if (link->has_switch) {
671                 state = pcie_aspm_check_state(link, link->aspm_default);
672                 __pcie_aspm_config_link(link, state);
673         } else {
674                 state = policy_to_aspm_state(link);
675                 __pcie_aspm_configure_link_state(link, state);
676         }
677
678         /* Setup initial Clock PM state */
679         state = (link->clkpm_capable) ? policy_to_clkpm_state(link) : 0;
680         pcie_set_clock_pm(link, state);
681 unlock:
682         mutex_unlock(&aspm_lock);
683 out:
684         up_read(&pci_bus_sem);
685 }
686
687 /* @pdev: the endpoint device */
688 void pcie_aspm_exit_link_state(struct pci_dev *pdev)
689 {
690         struct pci_dev *parent = pdev->bus->self;
691         struct pcie_link_state *link_state = parent->link_state;
692
693         if (aspm_disabled || !pdev->is_pcie || !parent || !link_state)
694                 return;
695         if (parent->pcie_type != PCI_EXP_TYPE_ROOT_PORT &&
696                 parent->pcie_type != PCI_EXP_TYPE_DOWNSTREAM)
697                 return;
698         down_read(&pci_bus_sem);
699         mutex_lock(&aspm_lock);
700
701         /*
702          * All PCIe functions are in one slot, remove one function will remove
703          * the whole slot, so just wait until we are the last function left.
704          */
705         if (!list_is_last(&pdev->bus_list, &parent->subordinate->devices))
706                 goto out;
707
708         /* All functions are removed, so just disable ASPM for the link */
709         __pcie_aspm_config_one_dev(parent, 0);
710         list_del(&link_state->sibling);
711         list_del(&link_state->link);
712         /* Clock PM is for endpoint device */
713
714         free_link_state(link_state);
715 out:
716         mutex_unlock(&aspm_lock);
717         up_read(&pci_bus_sem);
718 }
719
720 /* @pdev: the root port or switch downstream port */
721 void pcie_aspm_pm_state_change(struct pci_dev *pdev)
722 {
723         struct pcie_link_state *link_state = pdev->link_state;
724
725         if (aspm_disabled || !pdev->is_pcie || !pdev->link_state)
726                 return;
727         if (pdev->pcie_type != PCI_EXP_TYPE_ROOT_PORT &&
728                 pdev->pcie_type != PCI_EXP_TYPE_DOWNSTREAM)
729                 return;
730         /*
731          * devices changed PM state, we should recheck if latency meets all
732          * functions' requirement
733          */
734         pcie_aspm_configure_link_state(link_state, link_state->aspm_enabled);
735 }
736
737 /*
738  * pci_disable_link_state - disable pci device's link state, so the link will
739  * never enter specific states
740  */
741 void pci_disable_link_state(struct pci_dev *pdev, int state)
742 {
743         struct pci_dev *parent = pdev->bus->self;
744         struct pcie_link_state *link_state;
745
746         if (aspm_disabled || !pdev->is_pcie)
747                 return;
748         if (pdev->pcie_type == PCI_EXP_TYPE_ROOT_PORT ||
749             pdev->pcie_type == PCI_EXP_TYPE_DOWNSTREAM)
750                 parent = pdev;
751         if (!parent || !parent->link_state)
752                 return;
753
754         down_read(&pci_bus_sem);
755         mutex_lock(&aspm_lock);
756         link_state = parent->link_state;
757         link_state->aspm_support &= ~state;
758         if (state & PCIE_LINK_STATE_CLKPM)
759                 link_state->clkpm_capable = 0;
760
761         __pcie_aspm_configure_link_state(link_state, link_state->aspm_enabled);
762         if (!link_state->clkpm_capable && link_state->clkpm_enabled)
763                 pcie_set_clock_pm(link_state, 0);
764         mutex_unlock(&aspm_lock);
765         up_read(&pci_bus_sem);
766 }
767 EXPORT_SYMBOL(pci_disable_link_state);
768
769 static int pcie_aspm_set_policy(const char *val, struct kernel_param *kp)
770 {
771         int i;
772         struct pcie_link_state *link_state;
773
774         for (i = 0; i < ARRAY_SIZE(policy_str); i++)
775                 if (!strncmp(val, policy_str[i], strlen(policy_str[i])))
776                         break;
777         if (i >= ARRAY_SIZE(policy_str))
778                 return -EINVAL;
779         if (i == aspm_policy)
780                 return 0;
781
782         down_read(&pci_bus_sem);
783         mutex_lock(&aspm_lock);
784         aspm_policy = i;
785         list_for_each_entry(link_state, &link_list, sibling) {
786                 __pcie_aspm_configure_link_state(link_state,
787                         policy_to_aspm_state(link_state));
788                 if (link_state->clkpm_capable &&
789                     link_state->clkpm_enabled != policy_to_clkpm_state(link_state))
790                         pcie_set_clock_pm(link_state,
791                                           policy_to_clkpm_state(link_state));
792
793         }
794         mutex_unlock(&aspm_lock);
795         up_read(&pci_bus_sem);
796         return 0;
797 }
798
799 static int pcie_aspm_get_policy(char *buffer, struct kernel_param *kp)
800 {
801         int i, cnt = 0;
802         for (i = 0; i < ARRAY_SIZE(policy_str); i++)
803                 if (i == aspm_policy)
804                         cnt += sprintf(buffer + cnt, "[%s] ", policy_str[i]);
805                 else
806                         cnt += sprintf(buffer + cnt, "%s ", policy_str[i]);
807         return cnt;
808 }
809
810 module_param_call(policy, pcie_aspm_set_policy, pcie_aspm_get_policy,
811         NULL, 0644);
812
813 #ifdef CONFIG_PCIEASPM_DEBUG
814 static ssize_t link_state_show(struct device *dev,
815                 struct device_attribute *attr,
816                 char *buf)
817 {
818         struct pci_dev *pci_device = to_pci_dev(dev);
819         struct pcie_link_state *link_state = pci_device->link_state;
820
821         return sprintf(buf, "%d\n", link_state->aspm_enabled);
822 }
823
824 static ssize_t link_state_store(struct device *dev,
825                 struct device_attribute *attr,
826                 const char *buf,
827                 size_t n)
828 {
829         struct pci_dev *pdev = to_pci_dev(dev);
830         int state;
831
832         if (n < 1)
833                 return -EINVAL;
834         state = buf[0]-'0';
835         if (state >= 0 && state <= 3) {
836                 /* setup link aspm state */
837                 pcie_aspm_configure_link_state(pdev->link_state, state);
838                 return n;
839         }
840
841         return -EINVAL;
842 }
843
844 static ssize_t clk_ctl_show(struct device *dev,
845                 struct device_attribute *attr,
846                 char *buf)
847 {
848         struct pci_dev *pci_device = to_pci_dev(dev);
849         struct pcie_link_state *link_state = pci_device->link_state;
850
851         return sprintf(buf, "%d\n", link_state->clkpm_enabled);
852 }
853
854 static ssize_t clk_ctl_store(struct device *dev,
855                 struct device_attribute *attr,
856                 const char *buf,
857                 size_t n)
858 {
859         struct pci_dev *pci_device = to_pci_dev(dev);
860         int state;
861
862         if (n < 1)
863                 return -EINVAL;
864         state = buf[0]-'0';
865
866         down_read(&pci_bus_sem);
867         mutex_lock(&aspm_lock);
868         pcie_set_clock_pm(pci_device->link_state, !!state);
869         mutex_unlock(&aspm_lock);
870         up_read(&pci_bus_sem);
871
872         return n;
873 }
874
875 static DEVICE_ATTR(link_state, 0644, link_state_show, link_state_store);
876 static DEVICE_ATTR(clk_ctl, 0644, clk_ctl_show, clk_ctl_store);
877
878 static char power_group[] = "power";
879 void pcie_aspm_create_sysfs_dev_files(struct pci_dev *pdev)
880 {
881         struct pcie_link_state *link_state = pdev->link_state;
882
883         if (!pdev->is_pcie || (pdev->pcie_type != PCI_EXP_TYPE_ROOT_PORT &&
884                 pdev->pcie_type != PCI_EXP_TYPE_DOWNSTREAM) || !link_state)
885                 return;
886
887         if (link_state->aspm_support)
888                 sysfs_add_file_to_group(&pdev->dev.kobj,
889                         &dev_attr_link_state.attr, power_group);
890         if (link_state->clkpm_capable)
891                 sysfs_add_file_to_group(&pdev->dev.kobj,
892                         &dev_attr_clk_ctl.attr, power_group);
893 }
894
895 void pcie_aspm_remove_sysfs_dev_files(struct pci_dev *pdev)
896 {
897         struct pcie_link_state *link_state = pdev->link_state;
898
899         if (!pdev->is_pcie || (pdev->pcie_type != PCI_EXP_TYPE_ROOT_PORT &&
900                 pdev->pcie_type != PCI_EXP_TYPE_DOWNSTREAM) || !link_state)
901                 return;
902
903         if (link_state->aspm_support)
904                 sysfs_remove_file_from_group(&pdev->dev.kobj,
905                         &dev_attr_link_state.attr, power_group);
906         if (link_state->clkpm_capable)
907                 sysfs_remove_file_from_group(&pdev->dev.kobj,
908                         &dev_attr_clk_ctl.attr, power_group);
909 }
910 #endif
911
912 static int __init pcie_aspm_disable(char *str)
913 {
914         if (!strcmp(str, "off")) {
915                 aspm_disabled = 1;
916                 printk(KERN_INFO "PCIe ASPM is disabled\n");
917         } else if (!strcmp(str, "force")) {
918                 aspm_force = 1;
919                 printk(KERN_INFO "PCIe ASPM is forcedly enabled\n");
920         }
921         return 1;
922 }
923
924 __setup("pcie_aspm=", pcie_aspm_disable);
925
926 void pcie_no_aspm(void)
927 {
928         if (!aspm_force)
929                 aspm_disabled = 1;
930 }
931
932 /**
933  * pcie_aspm_enabled - is PCIe ASPM enabled?
934  *
935  * Returns true if ASPM has not been disabled by the command-line option
936  * pcie_aspm=off.
937  **/
938 int pcie_aspm_enabled(void)
939 {
940        return !aspm_disabled;
941 }
942 EXPORT_SYMBOL(pcie_aspm_enabled);
943