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