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