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