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