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