]> asedeno.scripts.mit.edu Git - linux.git/blob - drivers/pci/pcie/aspm.c
PM / QoS: Remove global notifiers
[linux.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 /* Note: those are not register definitions */
30 #define ASPM_STATE_L0S_UP       (1)     /* Upstream direction L0s state */
31 #define ASPM_STATE_L0S_DW       (2)     /* Downstream direction L0s state */
32 #define ASPM_STATE_L1           (4)     /* L1 state */
33 #define ASPM_STATE_L0S          (ASPM_STATE_L0S_UP | ASPM_STATE_L0S_DW)
34 #define ASPM_STATE_ALL          (ASPM_STATE_L0S | ASPM_STATE_L1)
35
36 struct aspm_latency {
37         u32 l0s;                        /* L0s latency (nsec) */
38         u32 l1;                         /* L1 latency (nsec) */
39 };
40
41 struct pcie_link_state {
42         struct pci_dev *pdev;           /* Upstream component of the Link */
43         struct pcie_link_state *root;   /* pointer to the root port link */
44         struct pcie_link_state *parent; /* pointer to the parent Link state */
45         struct list_head sibling;       /* node in link_list */
46         struct list_head children;      /* list of child link states */
47         struct list_head link;          /* node in parent's children list */
48
49         /* ASPM state */
50         u32 aspm_support:3;             /* Supported ASPM state */
51         u32 aspm_enabled:3;             /* Enabled ASPM state */
52         u32 aspm_capable:3;             /* Capable ASPM state with latency */
53         u32 aspm_default:3;             /* Default ASPM state by BIOS */
54         u32 aspm_disable:3;             /* Disabled ASPM state */
55
56         /* Clock PM state */
57         u32 clkpm_capable:1;            /* Clock PM capable? */
58         u32 clkpm_enabled:1;            /* Current Clock PM state */
59         u32 clkpm_default:1;            /* Default Clock PM state by BIOS */
60
61         /* Exit latencies */
62         struct aspm_latency latency_up; /* Upstream direction exit latency */
63         struct aspm_latency latency_dw; /* Downstream direction exit latency */
64         /*
65          * Endpoint acceptable latencies. A pcie downstream port only
66          * has one slot under it, so at most there are 8 functions.
67          */
68         struct aspm_latency acceptable[8];
69 };
70
71 static int aspm_disabled, aspm_force;
72 static bool aspm_support_enabled = true;
73 static DEFINE_MUTEX(aspm_lock);
74 static LIST_HEAD(link_list);
75
76 #define POLICY_DEFAULT 0        /* BIOS default setting */
77 #define POLICY_PERFORMANCE 1    /* high performance */
78 #define POLICY_POWERSAVE 2      /* high power saving */
79
80 #ifdef CONFIG_PCIEASPM_PERFORMANCE
81 static int aspm_policy = POLICY_PERFORMANCE;
82 #elif defined CONFIG_PCIEASPM_POWERSAVE
83 static int aspm_policy = POLICY_POWERSAVE;
84 #else
85 static int aspm_policy;
86 #endif
87
88 static const char *policy_str[] = {
89         [POLICY_DEFAULT] = "default",
90         [POLICY_PERFORMANCE] = "performance",
91         [POLICY_POWERSAVE] = "powersave"
92 };
93
94 #define LINK_RETRAIN_TIMEOUT HZ
95
96 static int policy_to_aspm_state(struct pcie_link_state *link)
97 {
98         switch (aspm_policy) {
99         case POLICY_PERFORMANCE:
100                 /* Disable ASPM and Clock PM */
101                 return 0;
102         case POLICY_POWERSAVE:
103                 /* Enable ASPM L0s/L1 */
104                 return ASPM_STATE_ALL;
105         case POLICY_DEFAULT:
106                 return link->aspm_default;
107         }
108         return 0;
109 }
110
111 static int policy_to_clkpm_state(struct pcie_link_state *link)
112 {
113         switch (aspm_policy) {
114         case POLICY_PERFORMANCE:
115                 /* Disable ASPM and Clock PM */
116                 return 0;
117         case POLICY_POWERSAVE:
118                 /* Disable Clock PM */
119                 return 1;
120         case POLICY_DEFAULT:
121                 return link->clkpm_default;
122         }
123         return 0;
124 }
125
126 static void pcie_set_clkpm_nocheck(struct pcie_link_state *link, int enable)
127 {
128         struct pci_dev *child;
129         struct pci_bus *linkbus = link->pdev->subordinate;
130         u32 val = enable ? PCI_EXP_LNKCTL_CLKREQ_EN : 0;
131
132         list_for_each_entry(child, &linkbus->devices, bus_list)
133                 pcie_capability_clear_and_set_word(child, PCI_EXP_LNKCTL,
134                                                    PCI_EXP_LNKCTL_CLKREQ_EN,
135                                                    val);
136         link->clkpm_enabled = !!enable;
137 }
138
139 static void pcie_set_clkpm(struct pcie_link_state *link, int enable)
140 {
141         /* Don't enable Clock PM if the link is not Clock PM capable */
142         if (!link->clkpm_capable)
143                 enable = 0;
144         /* Need nothing if the specified equals to current state */
145         if (link->clkpm_enabled == enable)
146                 return;
147         pcie_set_clkpm_nocheck(link, enable);
148 }
149
150 static void pcie_clkpm_cap_init(struct pcie_link_state *link, int blacklist)
151 {
152         int capable = 1, enabled = 1;
153         u32 reg32;
154         u16 reg16;
155         struct pci_dev *child;
156         struct pci_bus *linkbus = link->pdev->subordinate;
157
158         /* All functions should have the same cap and state, take the worst */
159         list_for_each_entry(child, &linkbus->devices, bus_list) {
160                 pcie_capability_read_dword(child, PCI_EXP_LNKCAP, &reg32);
161                 if (!(reg32 & PCI_EXP_LNKCAP_CLKPM)) {
162                         capable = 0;
163                         enabled = 0;
164                         break;
165                 }
166                 pcie_capability_read_word(child, PCI_EXP_LNKCTL, &reg16);
167                 if (!(reg16 & PCI_EXP_LNKCTL_CLKREQ_EN))
168                         enabled = 0;
169         }
170         link->clkpm_enabled = enabled;
171         link->clkpm_default = enabled;
172         link->clkpm_capable = (blacklist) ? 0 : capable;
173 }
174
175 /*
176  * pcie_aspm_configure_common_clock: check if the 2 ends of a link
177  *   could use common clock. If they are, configure them to use the
178  *   common clock. That will reduce the ASPM state exit latency.
179  */
180 static void pcie_aspm_configure_common_clock(struct pcie_link_state *link)
181 {
182         int same_clock = 1;
183         u16 reg16, parent_reg, child_reg[8];
184         unsigned long start_jiffies;
185         struct pci_dev *child, *parent = link->pdev;
186         struct pci_bus *linkbus = parent->subordinate;
187         /*
188          * All functions of a slot should have the same Slot Clock
189          * Configuration, so just check one function
190          */
191         child = list_entry(linkbus->devices.next, struct pci_dev, bus_list);
192         BUG_ON(!pci_is_pcie(child));
193
194         /* Check downstream component if bit Slot Clock Configuration is 1 */
195         pcie_capability_read_word(child, PCI_EXP_LNKSTA, &reg16);
196         if (!(reg16 & PCI_EXP_LNKSTA_SLC))
197                 same_clock = 0;
198
199         /* Check upstream component if bit Slot Clock Configuration is 1 */
200         pcie_capability_read_word(parent, PCI_EXP_LNKSTA, &reg16);
201         if (!(reg16 & PCI_EXP_LNKSTA_SLC))
202                 same_clock = 0;
203
204         /* Configure downstream component, all functions */
205         list_for_each_entry(child, &linkbus->devices, bus_list) {
206                 pcie_capability_read_word(child, PCI_EXP_LNKCTL, &reg16);
207                 child_reg[PCI_FUNC(child->devfn)] = reg16;
208                 if (same_clock)
209                         reg16 |= PCI_EXP_LNKCTL_CCC;
210                 else
211                         reg16 &= ~PCI_EXP_LNKCTL_CCC;
212                 pcie_capability_write_word(child, PCI_EXP_LNKCTL, reg16);
213         }
214
215         /* Configure upstream component */
216         pcie_capability_read_word(parent, PCI_EXP_LNKCTL, &reg16);
217         parent_reg = reg16;
218         if (same_clock)
219                 reg16 |= PCI_EXP_LNKCTL_CCC;
220         else
221                 reg16 &= ~PCI_EXP_LNKCTL_CCC;
222         pcie_capability_write_word(parent, PCI_EXP_LNKCTL, reg16);
223
224         /* Retrain link */
225         reg16 |= PCI_EXP_LNKCTL_RL;
226         pcie_capability_write_word(parent, PCI_EXP_LNKCTL, reg16);
227
228         /* Wait for link training end. Break out after waiting for timeout */
229         start_jiffies = jiffies;
230         for (;;) {
231                 pcie_capability_read_word(parent, PCI_EXP_LNKSTA, &reg16);
232                 if (!(reg16 & PCI_EXP_LNKSTA_LT))
233                         break;
234                 if (time_after(jiffies, start_jiffies + LINK_RETRAIN_TIMEOUT))
235                         break;
236                 msleep(1);
237         }
238         if (!(reg16 & PCI_EXP_LNKSTA_LT))
239                 return;
240
241         /* Training failed. Restore common clock configurations */
242         dev_err(&parent->dev, "ASPM: Could not configure common clock\n");
243         list_for_each_entry(child, &linkbus->devices, bus_list)
244                 pcie_capability_write_word(child, PCI_EXP_LNKCTL,
245                                            child_reg[PCI_FUNC(child->devfn)]);
246         pcie_capability_write_word(parent, PCI_EXP_LNKCTL, parent_reg);
247 }
248
249 /* Convert L0s latency encoding to ns */
250 static u32 calc_l0s_latency(u32 encoding)
251 {
252         if (encoding == 0x7)
253                 return (5 * 1000);      /* > 4us */
254         return (64 << encoding);
255 }
256
257 /* Convert L0s acceptable latency encoding to ns */
258 static u32 calc_l0s_acceptable(u32 encoding)
259 {
260         if (encoding == 0x7)
261                 return -1U;
262         return (64 << encoding);
263 }
264
265 /* Convert L1 latency encoding to ns */
266 static u32 calc_l1_latency(u32 encoding)
267 {
268         if (encoding == 0x7)
269                 return (65 * 1000);     /* > 64us */
270         return (1000 << encoding);
271 }
272
273 /* Convert L1 acceptable latency encoding to ns */
274 static u32 calc_l1_acceptable(u32 encoding)
275 {
276         if (encoding == 0x7)
277                 return -1U;
278         return (1000 << encoding);
279 }
280
281 struct aspm_register_info {
282         u32 support:2;
283         u32 enabled:2;
284         u32 latency_encoding_l0s;
285         u32 latency_encoding_l1;
286 };
287
288 static void pcie_get_aspm_reg(struct pci_dev *pdev,
289                               struct aspm_register_info *info)
290 {
291         u16 reg16;
292         u32 reg32;
293
294         pcie_capability_read_dword(pdev, PCI_EXP_LNKCAP, &reg32);
295         info->support = (reg32 & PCI_EXP_LNKCAP_ASPMS) >> 10;
296         info->latency_encoding_l0s = (reg32 & PCI_EXP_LNKCAP_L0SEL) >> 12;
297         info->latency_encoding_l1  = (reg32 & PCI_EXP_LNKCAP_L1EL) >> 15;
298         pcie_capability_read_word(pdev, PCI_EXP_LNKCTL, &reg16);
299         info->enabled = reg16 & PCI_EXP_LNKCTL_ASPMC;
300 }
301
302 static void pcie_aspm_check_latency(struct pci_dev *endpoint)
303 {
304         u32 latency, l1_switch_latency = 0;
305         struct aspm_latency *acceptable;
306         struct pcie_link_state *link;
307
308         /* Device not in D0 doesn't need latency check */
309         if ((endpoint->current_state != PCI_D0) &&
310             (endpoint->current_state != PCI_UNKNOWN))
311                 return;
312
313         link = endpoint->bus->self->link_state;
314         acceptable = &link->acceptable[PCI_FUNC(endpoint->devfn)];
315
316         while (link) {
317                 /* Check upstream direction L0s latency */
318                 if ((link->aspm_capable & ASPM_STATE_L0S_UP) &&
319                     (link->latency_up.l0s > acceptable->l0s))
320                         link->aspm_capable &= ~ASPM_STATE_L0S_UP;
321
322                 /* Check downstream direction L0s latency */
323                 if ((link->aspm_capable & ASPM_STATE_L0S_DW) &&
324                     (link->latency_dw.l0s > acceptable->l0s))
325                         link->aspm_capable &= ~ASPM_STATE_L0S_DW;
326                 /*
327                  * Check L1 latency.
328                  * Every switch on the path to root complex need 1
329                  * more microsecond for L1. Spec doesn't mention L0s.
330                  */
331                 latency = max_t(u32, link->latency_up.l1, link->latency_dw.l1);
332                 if ((link->aspm_capable & ASPM_STATE_L1) &&
333                     (latency + l1_switch_latency > acceptable->l1))
334                         link->aspm_capable &= ~ASPM_STATE_L1;
335                 l1_switch_latency += 1000;
336
337                 link = link->parent;
338         }
339 }
340
341 static void pcie_aspm_cap_init(struct pcie_link_state *link, int blacklist)
342 {
343         struct pci_dev *child, *parent = link->pdev;
344         struct pci_bus *linkbus = parent->subordinate;
345         struct aspm_register_info upreg, dwreg;
346
347         if (blacklist) {
348                 /* Set enabled/disable so that we will disable ASPM later */
349                 link->aspm_enabled = ASPM_STATE_ALL;
350                 link->aspm_disable = ASPM_STATE_ALL;
351                 return;
352         }
353
354         /* Get upstream/downstream components' register state */
355         pcie_get_aspm_reg(parent, &upreg);
356         child = list_entry(linkbus->devices.next, struct pci_dev, bus_list);
357         pcie_get_aspm_reg(child, &dwreg);
358
359         /*
360          * If ASPM not supported, don't mess with the clocks and link,
361          * bail out now.
362          */
363         if (!(upreg.support & dwreg.support))
364                 return;
365
366         /* Configure common clock before checking latencies */
367         pcie_aspm_configure_common_clock(link);
368
369         /*
370          * Re-read upstream/downstream components' register state
371          * after clock configuration
372          */
373         pcie_get_aspm_reg(parent, &upreg);
374         pcie_get_aspm_reg(child, &dwreg);
375
376         /*
377          * Setup L0s state
378          *
379          * Note that we must not enable L0s in either direction on a
380          * given link unless components on both sides of the link each
381          * support L0s.
382          */
383         if (dwreg.support & upreg.support & PCIE_LINK_STATE_L0S)
384                 link->aspm_support |= ASPM_STATE_L0S;
385         if (dwreg.enabled & PCIE_LINK_STATE_L0S)
386                 link->aspm_enabled |= ASPM_STATE_L0S_UP;
387         if (upreg.enabled & PCIE_LINK_STATE_L0S)
388                 link->aspm_enabled |= ASPM_STATE_L0S_DW;
389         link->latency_up.l0s = calc_l0s_latency(upreg.latency_encoding_l0s);
390         link->latency_dw.l0s = calc_l0s_latency(dwreg.latency_encoding_l0s);
391
392         /* Setup L1 state */
393         if (upreg.support & dwreg.support & PCIE_LINK_STATE_L1)
394                 link->aspm_support |= ASPM_STATE_L1;
395         if (upreg.enabled & dwreg.enabled & PCIE_LINK_STATE_L1)
396                 link->aspm_enabled |= ASPM_STATE_L1;
397         link->latency_up.l1 = calc_l1_latency(upreg.latency_encoding_l1);
398         link->latency_dw.l1 = calc_l1_latency(dwreg.latency_encoding_l1);
399
400         /* Save default state */
401         link->aspm_default = link->aspm_enabled;
402
403         /* Setup initial capable state. Will be updated later */
404         link->aspm_capable = link->aspm_support;
405         /*
406          * If the downstream component has pci bridge function, don't
407          * do ASPM for now.
408          */
409         list_for_each_entry(child, &linkbus->devices, bus_list) {
410                 if (pci_pcie_type(child) == PCI_EXP_TYPE_PCI_BRIDGE) {
411                         link->aspm_disable = ASPM_STATE_ALL;
412                         break;
413                 }
414         }
415
416         /* Get and check endpoint acceptable latencies */
417         list_for_each_entry(child, &linkbus->devices, bus_list) {
418                 u32 reg32, encoding;
419                 struct aspm_latency *acceptable =
420                         &link->acceptable[PCI_FUNC(child->devfn)];
421
422                 if (pci_pcie_type(child) != PCI_EXP_TYPE_ENDPOINT &&
423                     pci_pcie_type(child) != PCI_EXP_TYPE_LEG_END)
424                         continue;
425
426                 pcie_capability_read_dword(child, PCI_EXP_DEVCAP, &reg32);
427                 /* Calculate endpoint L0s acceptable latency */
428                 encoding = (reg32 & PCI_EXP_DEVCAP_L0S) >> 6;
429                 acceptable->l0s = calc_l0s_acceptable(encoding);
430                 /* Calculate endpoint L1 acceptable latency */
431                 encoding = (reg32 & PCI_EXP_DEVCAP_L1) >> 9;
432                 acceptable->l1 = calc_l1_acceptable(encoding);
433
434                 pcie_aspm_check_latency(child);
435         }
436 }
437
438 static void pcie_config_aspm_dev(struct pci_dev *pdev, u32 val)
439 {
440         pcie_capability_clear_and_set_word(pdev, PCI_EXP_LNKCTL,
441                                            PCI_EXP_LNKCTL_ASPMC, val);
442 }
443
444 static void pcie_config_aspm_link(struct pcie_link_state *link, u32 state)
445 {
446         u32 upstream = 0, dwstream = 0;
447         struct pci_dev *child, *parent = link->pdev;
448         struct pci_bus *linkbus = parent->subordinate;
449
450         /* Nothing to do if the link is already in the requested state */
451         state &= (link->aspm_capable & ~link->aspm_disable);
452         if (link->aspm_enabled == state)
453                 return;
454         /* Convert ASPM state to upstream/downstream ASPM register state */
455         if (state & ASPM_STATE_L0S_UP)
456                 dwstream |= PCI_EXP_LNKCTL_ASPM_L0S;
457         if (state & ASPM_STATE_L0S_DW)
458                 upstream |= PCI_EXP_LNKCTL_ASPM_L0S;
459         if (state & ASPM_STATE_L1) {
460                 upstream |= PCI_EXP_LNKCTL_ASPM_L1;
461                 dwstream |= PCI_EXP_LNKCTL_ASPM_L1;
462         }
463         /*
464          * Spec 2.0 suggests all functions should be configured the
465          * same setting for ASPM. Enabling ASPM L1 should be done in
466          * upstream component first and then downstream, and vice
467          * versa for disabling ASPM L1. Spec doesn't mention L0S.
468          */
469         if (state & ASPM_STATE_L1)
470                 pcie_config_aspm_dev(parent, upstream);
471         list_for_each_entry(child, &linkbus->devices, bus_list)
472                 pcie_config_aspm_dev(child, dwstream);
473         if (!(state & ASPM_STATE_L1))
474                 pcie_config_aspm_dev(parent, upstream);
475
476         link->aspm_enabled = state;
477 }
478
479 static void pcie_config_aspm_path(struct pcie_link_state *link)
480 {
481         while (link) {
482                 pcie_config_aspm_link(link, policy_to_aspm_state(link));
483                 link = link->parent;
484         }
485 }
486
487 static void free_link_state(struct pcie_link_state *link)
488 {
489         link->pdev->link_state = NULL;
490         kfree(link);
491 }
492
493 static int pcie_aspm_sanity_check(struct pci_dev *pdev)
494 {
495         struct pci_dev *child;
496         u32 reg32;
497
498         /*
499          * Some functions in a slot might not all be PCIe functions,
500          * very strange. Disable ASPM for the whole slot
501          */
502         list_for_each_entry(child, &pdev->subordinate->devices, bus_list) {
503                 if (!pci_is_pcie(child))
504                         return -EINVAL;
505
506                 /*
507                  * If ASPM is disabled then we're not going to change
508                  * the BIOS state. It's safe to continue even if it's a
509                  * pre-1.1 device
510                  */
511
512                 if (aspm_disabled)
513                         continue;
514
515                 /*
516                  * Disable ASPM for pre-1.1 PCIe device, we follow MS to use
517                  * RBER bit to determine if a function is 1.1 version device
518                  */
519                 pcie_capability_read_dword(child, PCI_EXP_DEVCAP, &reg32);
520                 if (!(reg32 & PCI_EXP_DEVCAP_RBER) && !aspm_force) {
521                         dev_info(&child->dev, "disabling ASPM on pre-1.1 PCIe device.  You can enable it with 'pcie_aspm=force'\n");
522                         return -EINVAL;
523                 }
524         }
525         return 0;
526 }
527
528 static struct pcie_link_state *alloc_pcie_link_state(struct pci_dev *pdev)
529 {
530         struct pcie_link_state *link;
531
532         link = kzalloc(sizeof(*link), GFP_KERNEL);
533         if (!link)
534                 return NULL;
535         INIT_LIST_HEAD(&link->sibling);
536         INIT_LIST_HEAD(&link->children);
537         INIT_LIST_HEAD(&link->link);
538         link->pdev = pdev;
539         if (pci_pcie_type(pdev) != PCI_EXP_TYPE_ROOT_PORT) {
540                 struct pcie_link_state *parent;
541                 parent = pdev->bus->parent->self->link_state;
542                 if (!parent) {
543                         kfree(link);
544                         return NULL;
545                 }
546                 link->parent = parent;
547                 list_add(&link->link, &parent->children);
548         }
549         /* Setup a pointer to the root port link */
550         if (!link->parent)
551                 link->root = link;
552         else
553                 link->root = link->parent->root;
554
555         list_add(&link->sibling, &link_list);
556         pdev->link_state = link;
557         return link;
558 }
559
560 /*
561  * pcie_aspm_init_link_state: Initiate PCI express link state.
562  * It is called after the pcie and its children devices are scanned.
563  * @pdev: the root port or switch downstream port
564  */
565 void pcie_aspm_init_link_state(struct pci_dev *pdev)
566 {
567         struct pcie_link_state *link;
568         int blacklist = !!pcie_aspm_sanity_check(pdev);
569
570         if (!aspm_support_enabled)
571                 return;
572
573         if (pdev->link_state)
574                 return;
575
576         /*
577          * We allocate pcie_link_state for the component on the upstream
578          * end of a Link, so there's nothing to do unless this device has a
579          * Link on its secondary side.
580          */
581         if (!pdev->has_secondary_link)
582                 return;
583
584         /* VIA has a strange chipset, root port is under a bridge */
585         if (pci_pcie_type(pdev) == PCI_EXP_TYPE_ROOT_PORT &&
586             pdev->bus->self)
587                 return;
588
589         down_read(&pci_bus_sem);
590         if (list_empty(&pdev->subordinate->devices))
591                 goto out;
592
593         mutex_lock(&aspm_lock);
594         link = alloc_pcie_link_state(pdev);
595         if (!link)
596                 goto unlock;
597         /*
598          * Setup initial ASPM state. Note that we need to configure
599          * upstream links also because capable state of them can be
600          * update through pcie_aspm_cap_init().
601          */
602         pcie_aspm_cap_init(link, blacklist);
603
604         /* Setup initial Clock PM state */
605         pcie_clkpm_cap_init(link, blacklist);
606
607         /*
608          * At this stage drivers haven't had an opportunity to change the
609          * link policy setting. Enabling ASPM on broken hardware can cripple
610          * it even before the driver has had a chance to disable ASPM, so
611          * default to a safe level right now. If we're enabling ASPM beyond
612          * the BIOS's expectation, we'll do so once pci_enable_device() is
613          * called.
614          */
615         if (aspm_policy != POLICY_POWERSAVE) {
616                 pcie_config_aspm_path(link);
617                 pcie_set_clkpm(link, policy_to_clkpm_state(link));
618         }
619
620 unlock:
621         mutex_unlock(&aspm_lock);
622 out:
623         up_read(&pci_bus_sem);
624 }
625
626 /* Recheck latencies and update aspm_capable for links under the root */
627 static void pcie_update_aspm_capable(struct pcie_link_state *root)
628 {
629         struct pcie_link_state *link;
630         BUG_ON(root->parent);
631         list_for_each_entry(link, &link_list, sibling) {
632                 if (link->root != root)
633                         continue;
634                 link->aspm_capable = link->aspm_support;
635         }
636         list_for_each_entry(link, &link_list, sibling) {
637                 struct pci_dev *child;
638                 struct pci_bus *linkbus = link->pdev->subordinate;
639                 if (link->root != root)
640                         continue;
641                 list_for_each_entry(child, &linkbus->devices, bus_list) {
642                         if ((pci_pcie_type(child) != PCI_EXP_TYPE_ENDPOINT) &&
643                             (pci_pcie_type(child) != PCI_EXP_TYPE_LEG_END))
644                                 continue;
645                         pcie_aspm_check_latency(child);
646                 }
647         }
648 }
649
650 /* @pdev: the endpoint device */
651 void pcie_aspm_exit_link_state(struct pci_dev *pdev)
652 {
653         struct pci_dev *parent = pdev->bus->self;
654         struct pcie_link_state *link, *root, *parent_link;
655
656         if (!parent || !parent->link_state)
657                 return;
658
659         down_read(&pci_bus_sem);
660         mutex_lock(&aspm_lock);
661         /*
662          * All PCIe functions are in one slot, remove one function will remove
663          * the whole slot, so just wait until we are the last function left.
664          */
665         if (!list_is_last(&pdev->bus_list, &parent->subordinate->devices))
666                 goto out;
667
668         link = parent->link_state;
669         root = link->root;
670         parent_link = link->parent;
671
672         /* All functions are removed, so just disable ASPM for the link */
673         pcie_config_aspm_link(link, 0);
674         list_del(&link->sibling);
675         list_del(&link->link);
676         /* Clock PM is for endpoint device */
677         free_link_state(link);
678
679         /* Recheck latencies and configure upstream links */
680         if (parent_link) {
681                 pcie_update_aspm_capable(root);
682                 pcie_config_aspm_path(parent_link);
683         }
684 out:
685         mutex_unlock(&aspm_lock);
686         up_read(&pci_bus_sem);
687 }
688
689 /* @pdev: the root port or switch downstream port */
690 void pcie_aspm_pm_state_change(struct pci_dev *pdev)
691 {
692         struct pcie_link_state *link = pdev->link_state;
693
694         if (aspm_disabled || !link)
695                 return;
696         /*
697          * Devices changed PM state, we should recheck if latency
698          * meets all functions' requirement
699          */
700         down_read(&pci_bus_sem);
701         mutex_lock(&aspm_lock);
702         pcie_update_aspm_capable(link->root);
703         pcie_config_aspm_path(link);
704         mutex_unlock(&aspm_lock);
705         up_read(&pci_bus_sem);
706 }
707
708 void pcie_aspm_powersave_config_link(struct pci_dev *pdev)
709 {
710         struct pcie_link_state *link = pdev->link_state;
711
712         if (aspm_disabled || !link)
713                 return;
714
715         if (aspm_policy != POLICY_POWERSAVE)
716                 return;
717
718         down_read(&pci_bus_sem);
719         mutex_lock(&aspm_lock);
720         pcie_config_aspm_path(link);
721         pcie_set_clkpm(link, policy_to_clkpm_state(link));
722         mutex_unlock(&aspm_lock);
723         up_read(&pci_bus_sem);
724 }
725
726 static void __pci_disable_link_state(struct pci_dev *pdev, int state, bool sem)
727 {
728         struct pci_dev *parent = pdev->bus->self;
729         struct pcie_link_state *link;
730
731         if (!pci_is_pcie(pdev))
732                 return;
733
734         if (pdev->has_secondary_link)
735                 parent = pdev;
736         if (!parent || !parent->link_state)
737                 return;
738
739         /*
740          * A driver requested that ASPM be disabled on this device, but
741          * if we don't have permission to manage ASPM (e.g., on ACPI
742          * systems we have to observe the FADT ACPI_FADT_NO_ASPM bit and
743          * the _OSC method), we can't honor that request.  Windows has
744          * a similar mechanism using "PciASPMOptOut", which is also
745          * ignored in this situation.
746          */
747         if (aspm_disabled) {
748                 dev_warn(&pdev->dev, "can't disable ASPM; OS doesn't have ASPM control\n");
749                 return;
750         }
751
752         if (sem)
753                 down_read(&pci_bus_sem);
754         mutex_lock(&aspm_lock);
755         link = parent->link_state;
756         if (state & PCIE_LINK_STATE_L0S)
757                 link->aspm_disable |= ASPM_STATE_L0S;
758         if (state & PCIE_LINK_STATE_L1)
759                 link->aspm_disable |= ASPM_STATE_L1;
760         pcie_config_aspm_link(link, policy_to_aspm_state(link));
761
762         if (state & PCIE_LINK_STATE_CLKPM) {
763                 link->clkpm_capable = 0;
764                 pcie_set_clkpm(link, 0);
765         }
766         mutex_unlock(&aspm_lock);
767         if (sem)
768                 up_read(&pci_bus_sem);
769 }
770
771 void pci_disable_link_state_locked(struct pci_dev *pdev, int state)
772 {
773         __pci_disable_link_state(pdev, state, false);
774 }
775 EXPORT_SYMBOL(pci_disable_link_state_locked);
776
777 /**
778  * pci_disable_link_state - Disable device's link state, so the link will
779  * never enter specific states.  Note that if the BIOS didn't grant ASPM
780  * control to the OS, this does nothing because we can't touch the LNKCTL
781  * register.
782  *
783  * @pdev: PCI device
784  * @state: ASPM link state to disable
785  */
786 void pci_disable_link_state(struct pci_dev *pdev, int state)
787 {
788         __pci_disable_link_state(pdev, state, true);
789 }
790 EXPORT_SYMBOL(pci_disable_link_state);
791
792 static int pcie_aspm_set_policy(const char *val, struct kernel_param *kp)
793 {
794         int i;
795         struct pcie_link_state *link;
796
797         if (aspm_disabled)
798                 return -EPERM;
799         for (i = 0; i < ARRAY_SIZE(policy_str); i++)
800                 if (!strncmp(val, policy_str[i], strlen(policy_str[i])))
801                         break;
802         if (i >= ARRAY_SIZE(policy_str))
803                 return -EINVAL;
804         if (i == aspm_policy)
805                 return 0;
806
807         down_read(&pci_bus_sem);
808         mutex_lock(&aspm_lock);
809         aspm_policy = i;
810         list_for_each_entry(link, &link_list, sibling) {
811                 pcie_config_aspm_link(link, policy_to_aspm_state(link));
812                 pcie_set_clkpm(link, policy_to_clkpm_state(link));
813         }
814         mutex_unlock(&aspm_lock);
815         up_read(&pci_bus_sem);
816         return 0;
817 }
818
819 static int pcie_aspm_get_policy(char *buffer, struct kernel_param *kp)
820 {
821         int i, cnt = 0;
822         for (i = 0; i < ARRAY_SIZE(policy_str); i++)
823                 if (i == aspm_policy)
824                         cnt += sprintf(buffer + cnt, "[%s] ", policy_str[i]);
825                 else
826                         cnt += sprintf(buffer + cnt, "%s ", policy_str[i]);
827         return cnt;
828 }
829
830 module_param_call(policy, pcie_aspm_set_policy, pcie_aspm_get_policy,
831         NULL, 0644);
832
833 #ifdef CONFIG_PCIEASPM_DEBUG
834 static ssize_t link_state_show(struct device *dev,
835                 struct device_attribute *attr,
836                 char *buf)
837 {
838         struct pci_dev *pci_device = to_pci_dev(dev);
839         struct pcie_link_state *link_state = pci_device->link_state;
840
841         return sprintf(buf, "%d\n", link_state->aspm_enabled);
842 }
843
844 static ssize_t link_state_store(struct device *dev,
845                 struct device_attribute *attr,
846                 const char *buf,
847                 size_t n)
848 {
849         struct pci_dev *pdev = to_pci_dev(dev);
850         struct pcie_link_state *link, *root = pdev->link_state->root;
851         u32 state;
852
853         if (aspm_disabled)
854                 return -EPERM;
855
856         if (kstrtouint(buf, 10, &state))
857                 return -EINVAL;
858         if ((state & ~ASPM_STATE_ALL) != 0)
859                 return -EINVAL;
860
861         down_read(&pci_bus_sem);
862         mutex_lock(&aspm_lock);
863         list_for_each_entry(link, &link_list, sibling) {
864                 if (link->root != root)
865                         continue;
866                 pcie_config_aspm_link(link, state);
867         }
868         mutex_unlock(&aspm_lock);
869         up_read(&pci_bus_sem);
870         return n;
871 }
872
873 static ssize_t clk_ctl_show(struct device *dev,
874                 struct device_attribute *attr,
875                 char *buf)
876 {
877         struct pci_dev *pci_device = to_pci_dev(dev);
878         struct pcie_link_state *link_state = pci_device->link_state;
879
880         return sprintf(buf, "%d\n", link_state->clkpm_enabled);
881 }
882
883 static ssize_t clk_ctl_store(struct device *dev,
884                 struct device_attribute *attr,
885                 const char *buf,
886                 size_t n)
887 {
888         struct pci_dev *pdev = to_pci_dev(dev);
889         bool state;
890
891         if (strtobool(buf, &state))
892                 return -EINVAL;
893
894         down_read(&pci_bus_sem);
895         mutex_lock(&aspm_lock);
896         pcie_set_clkpm_nocheck(pdev->link_state, state);
897         mutex_unlock(&aspm_lock);
898         up_read(&pci_bus_sem);
899
900         return n;
901 }
902
903 static DEVICE_ATTR_RW(link_state);
904 static DEVICE_ATTR_RW(clk_ctl);
905
906 static char power_group[] = "power";
907 void pcie_aspm_create_sysfs_dev_files(struct pci_dev *pdev)
908 {
909         struct pcie_link_state *link_state = pdev->link_state;
910
911         if (!link_state)
912                 return;
913
914         if (link_state->aspm_support)
915                 sysfs_add_file_to_group(&pdev->dev.kobj,
916                         &dev_attr_link_state.attr, power_group);
917         if (link_state->clkpm_capable)
918                 sysfs_add_file_to_group(&pdev->dev.kobj,
919                         &dev_attr_clk_ctl.attr, power_group);
920 }
921
922 void pcie_aspm_remove_sysfs_dev_files(struct pci_dev *pdev)
923 {
924         struct pcie_link_state *link_state = pdev->link_state;
925
926         if (!link_state)
927                 return;
928
929         if (link_state->aspm_support)
930                 sysfs_remove_file_from_group(&pdev->dev.kobj,
931                         &dev_attr_link_state.attr, power_group);
932         if (link_state->clkpm_capable)
933                 sysfs_remove_file_from_group(&pdev->dev.kobj,
934                         &dev_attr_clk_ctl.attr, power_group);
935 }
936 #endif
937
938 static int __init pcie_aspm_disable(char *str)
939 {
940         if (!strcmp(str, "off")) {
941                 aspm_policy = POLICY_DEFAULT;
942                 aspm_disabled = 1;
943                 aspm_support_enabled = false;
944                 printk(KERN_INFO "PCIe ASPM is disabled\n");
945         } else if (!strcmp(str, "force")) {
946                 aspm_force = 1;
947                 printk(KERN_INFO "PCIe ASPM is forcibly enabled\n");
948         }
949         return 1;
950 }
951
952 __setup("pcie_aspm=", pcie_aspm_disable);
953
954 void pcie_no_aspm(void)
955 {
956         /*
957          * Disabling ASPM is intended to prevent the kernel from modifying
958          * existing hardware state, not to clear existing state. To that end:
959          * (a) set policy to POLICY_DEFAULT in order to avoid changing state
960          * (b) prevent userspace from changing policy
961          */
962         if (!aspm_force) {
963                 aspm_policy = POLICY_DEFAULT;
964                 aspm_disabled = 1;
965         }
966 }
967
968 bool pcie_aspm_support_enabled(void)
969 {
970         return aspm_support_enabled;
971 }
972 EXPORT_SYMBOL(pcie_aspm_support_enabled);