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