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         /*
 504          * Some functions in a slot might not all be PCIe functions,
 505          * very strange. Disable ASPM for the whole slot
 506          */
 507         list_for_each_entry(child, &pdev->subordinate->devices, bus_list) {
 508                 pos = pci_pcie_cap(child);
 509                 if (!pos)
 510                         return -EINVAL;
 511
 512                 /*
 513                  * If ASPM is disabled then we're not going to change
 514                  * the BIOS state. It's safe to continue even if it's a
 515                  * pre-1.1 device
 516                  */
 517
 518                 if (aspm_disabled)
 519                         continue;
 520
 521                 /*
 522                  * Disable ASPM for pre-1.1 PCIe device, we follow MS to use
 523                  * RBER bit to determine if a function is 1.1 version device
 524                  */
 525                 pci_read_config_dword(child, pos + PCI_EXP_DEVCAP, &reg32);
 526                 if (!(reg32 & PCI_EXP_DEVCAP_RBER) && !aspm_force) {
 527                         dev_printk(KERN_INFO, &child->dev, "disabling ASPM"
 528                                 " on pre-1.1 PCIe device.  You can enable it"
 529                                 " with 'pcie_aspm=force'\n");
 530                         return -EINVAL;
 531                 }
 532         }
 533         return 0;
 534 }
 535
 536 static struct pcie_link_state *alloc_pcie_link_state(struct pci_dev *pdev)
 537 {
 538         struct pcie_link_state *link;
 539
 540         link = kzalloc(sizeof(*link), GFP_KERNEL);
 541         if (!link)
 542                 return NULL;
 543         INIT_LIST_HEAD(&link->sibling);
 544         INIT_LIST_HEAD(&link->children);
 545         INIT_LIST_HEAD(&link->link);
 546         link->pdev = pdev;
 547         if (pdev->pcie_type == PCI_EXP_TYPE_DOWNSTREAM) {
 548                 struct pcie_link_state *parent;
 549                 parent = pdev->bus->parent->self->link_state;
 550                 if (!parent) {
 551                         kfree(link);
 552                         return NULL;
 553                 }
 554                 link->parent = parent;
 555                 list_add(&link->link, &parent->children);
 556         }
 557         /* Setup a pointer to the root port link */
 558         if (!link->parent)
 559                 link->root = link;
 560         else
 561                 link->root = link->parent->root;
 562
 563         list_add(&link->sibling, &link_list);
 564         pdev->link_state = link;
 565         return link;
 566 }
 567
 568 /*
 569  * pcie_aspm_init_link_state: Initiate PCI express link state.
 570  * It is called after the pcie and its children devices are scaned.
 571  * @pdev: the root port or switch downstream port
 572  */
 573 void pcie_aspm_init_link_state(struct pci_dev *pdev)
 574 {
 575         struct pcie_link_state *link;
 576         int blacklist = !!pcie_aspm_sanity_check(pdev);
 577
 578         if (!pci_is_pcie(pdev) || pdev->link_state)
 579                 return;
 580         if (pdev->pcie_type != PCI_EXP_TYPE_ROOT_PORT &&
 581             pdev->pcie_type != PCI_EXP_TYPE_DOWNSTREAM)
 582                 return;
 583
 584         /* VIA has a strange chipset, root port is under a bridge */
 585         if (pdev->pcie_type == PCI_EXP_TYPE_ROOT_PORT &&
 586             pdev->bus->self)
 587                 return;
 588
 589         down_read(&pci_bus_sem);
 590         if (list_empty(&pdev->subordinate->devices))
 591                 goto out;
 592
 593         mutex_lock(&aspm_lock);
 594         link = alloc_pcie_link_state(pdev);
 595         if (!link)
 596                 goto unlock;
 597         /*
 598          * Setup initial ASPM state. Note that we need to configure
 599          * upstream links also because capable state of them can be
 600          * update through pcie_aspm_cap_init().
 601          */
 602         pcie_aspm_cap_init(link, blacklist);
 603
 604         /* Setup initial Clock PM state */
 605         pcie_clkpm_cap_init(link, blacklist);
 606
 607         /*
 608          * At this stage drivers haven't had an opportunity to change the
 609          * link policy setting. Enabling ASPM on broken hardware can cripple
 610          * it even before the driver has had a chance to disable ASPM, so
 611          * default to a safe level right now. If we're enabling ASPM beyond
 612          * the BIOS's expectation, we'll do so once pci_enable_device() is
 613          * called.
 614          */
 615         if (aspm_policy != POLICY_POWERSAVE) {
 616                 pcie_config_aspm_path(link);
 617                 pcie_set_clkpm(link, policy_to_clkpm_state(link));
 618         }
 619
 620 unlock:
 621         mutex_unlock(&aspm_lock);
 622 out:
 623         up_read(&pci_bus_sem);
 624 }
 625
 626 /* Recheck latencies and update aspm_capable for links under the root */
 627 static void pcie_update_aspm_capable(struct pcie_link_state *root)
 628 {
 629         struct pcie_link_state *link;
 630         BUG_ON(root->parent);
 631         list_for_each_entry(link, &link_list, sibling) {
 632                 if (link->root != root)
 633                         continue;
 634                 link->aspm_capable = link->aspm_support;
 635         }
 636         list_for_each_entry(link, &link_list, sibling) {
 637                 struct pci_dev *child;
 638                 struct pci_bus *linkbus = link->pdev->subordinate;
 639                 if (link->root != root)
 640                         continue;
 641                 list_for_each_entry(child, &linkbus->devices, bus_list) {
 642                         if ((child->pcie_type != PCI_EXP_TYPE_ENDPOINT) &&
 643                             (child->pcie_type != PCI_EXP_TYPE_LEG_END))
 644                                 continue;
 645                         pcie_aspm_check_latency(child);
 646                 }
 647         }
 648 }
 649
 650 /* @pdev: the endpoint device */
 651 void pcie_aspm_exit_link_state(struct pci_dev *pdev)
 652 {
 653         struct pci_dev *parent = pdev->bus->self;
 654         struct pcie_link_state *link, *root, *parent_link;
 655
 656         if (!pci_is_pcie(pdev) || !parent || !parent->link_state)
 657                 return;
 658         if ((parent->pcie_type != PCI_EXP_TYPE_ROOT_PORT) &&
 659             (parent->pcie_type != PCI_EXP_TYPE_DOWNSTREAM))
 660                 return;
 661
 662         down_read(&pci_bus_sem);
 663         mutex_lock(&aspm_lock);
 664         /*
 665          * All PCIe functions are in one slot, remove one function will remove
 666          * the whole slot, so just wait until we are the last function left.
 667          */
 668         if (!list_is_last(&pdev->bus_list, &parent->subordinate->devices))
 669                 goto out;
 670
 671         link = parent->link_state;
 672         root = link->root;
 673         parent_link = link->parent;
 674
 675         /* All functions are removed, so just disable ASPM for the link */
 676         pcie_config_aspm_link(link, 0);
 677         list_del(&link->sibling);
 678         list_del(&link->link);
 679         /* Clock PM is for endpoint device */
 680         free_link_state(link);
 681
 682         /* Recheck latencies and configure upstream links */
 683         if (parent_link) {
 684                 pcie_update_aspm_capable(root);
 685                 pcie_config_aspm_path(parent_link);
 686         }
 687 out:
 688         mutex_unlock(&aspm_lock);
 689         up_read(&pci_bus_sem);
 690 }
 691
 692 /* @pdev: the root port or switch downstream port */
 693 void pcie_aspm_pm_state_change(struct pci_dev *pdev)
 694 {
 695         struct pcie_link_state *link = pdev->link_state;
 696
 697         if (aspm_disabled || !pci_is_pcie(pdev) || !link)
 698                 return;
 699         if ((pdev->pcie_type != PCI_EXP_TYPE_ROOT_PORT) &&
 700             (pdev->pcie_type != PCI_EXP_TYPE_DOWNSTREAM))
 701                 return;
 702         /*
 703          * Devices changed PM state, we should recheck if latency
 704          * meets all functions' requirement
 705          */
 706         down_read(&pci_bus_sem);
 707         mutex_lock(&aspm_lock);
 708         pcie_update_aspm_capable(link->root);
 709         pcie_config_aspm_path(link);
 710         mutex_unlock(&aspm_lock);
 711         up_read(&pci_bus_sem);
 712 }
 713
 714 void pcie_aspm_powersave_config_link(struct pci_dev *pdev)
 715 {
 716         struct pcie_link_state *link = pdev->link_state;
 717
 718         if (aspm_disabled || !pci_is_pcie(pdev) || !link)
 719                 return;
 720
 721         if (aspm_policy != POLICY_POWERSAVE)
 722                 return;
 723
 724         if ((pdev->pcie_type != PCI_EXP_TYPE_ROOT_PORT) &&
 725             (pdev->pcie_type != PCI_EXP_TYPE_DOWNSTREAM))
 726                 return;
 727
 728         down_read(&pci_bus_sem);
 729         mutex_lock(&aspm_lock);
 730         pcie_config_aspm_path(link);
 731         pcie_set_clkpm(link, policy_to_clkpm_state(link));
 732         mutex_unlock(&aspm_lock);
 733         up_read(&pci_bus_sem);
 734 }
 735
 736 /*
 737  * pci_disable_link_state - disable pci device's link state, so the link will
 738  * never enter specific states
 739  */
 740 static void __pci_disable_link_state(struct pci_dev *pdev, int state, bool sem,
 741                                      bool force)
 742 {
 743         struct pci_dev *parent = pdev->bus->self;
 744         struct pcie_link_state *link;
 745
 746         if (aspm_disabled && !force)
 747                 return;
 748
 749         if (!pci_is_pcie(pdev))
 750                 return;
 751
 752         if (pdev->pcie_type == PCI_EXP_TYPE_ROOT_PORT ||
 753             pdev->pcie_type == PCI_EXP_TYPE_DOWNSTREAM)
 754                 parent = pdev;
 755         if (!parent || !parent->link_state)
 756                 return;
 757
 758         if (sem)
 759                 down_read(&pci_bus_sem);
 760         mutex_lock(&aspm_lock);
 761         link = parent->link_state;
 762         if (state & PCIE_LINK_STATE_L0S)
 763                 link->aspm_disable |= ASPM_STATE_L0S;
 764         if (state & PCIE_LINK_STATE_L1)
 765                 link->aspm_disable |= ASPM_STATE_L1;
 766         pcie_config_aspm_link(link, policy_to_aspm_state(link));
 767
 768         if (state & PCIE_LINK_STATE_CLKPM) {
 769                 link->clkpm_capable = 0;
 770                 pcie_set_clkpm(link, 0);
 771         }
 772         mutex_unlock(&aspm_lock);
 773         if (sem)
 774                 up_read(&pci_bus_sem);
 775 }
 776
 777 void pci_disable_link_state_locked(struct pci_dev *pdev, int state)
 778 {
 779         __pci_disable_link_state(pdev, state, false, false);
 780 }
 781 EXPORT_SYMBOL(pci_disable_link_state_locked);
 782
 783 void pci_disable_link_state(struct pci_dev *pdev, int state)
 784 {
 785         __pci_disable_link_state(pdev, state, true, false);
 786 }
 787 EXPORT_SYMBOL(pci_disable_link_state);
 788
 789 void pcie_clear_aspm(struct pci_bus *bus)
 790 {
 791         struct pci_dev *child;
 792
 793         /*
 794          * Clear any ASPM setup that the firmware has carried out on this bus
 795          */
 796         list_for_each_entry(child, &bus->devices, bus_list) {
 797                 __pci_disable_link_state(child, PCIE_LINK_STATE_L0S |
 798                                          PCIE_LINK_STATE_L1 |
 799                                          PCIE_LINK_STATE_CLKPM,
 800                                          false, true);
 801         }
 802 }
 803
 804 static int pcie_aspm_set_policy(const char *val, struct kernel_param *kp)
 805 {
 806         int i;
 807         struct pcie_link_state *link;
 808
 809         if (aspm_disabled)
 810                 return -EPERM;
 811         for (i = 0; i < ARRAY_SIZE(policy_str); i++)
 812                 if (!strncmp(val, policy_str[i], strlen(policy_str[i])))
 813                         break;
 814         if (i >= ARRAY_SIZE(policy_str))
 815                 return -EINVAL;
 816         if (i == aspm_policy)
 817                 return 0;
 818
 819         down_read(&pci_bus_sem);
 820         mutex_lock(&aspm_lock);
 821         aspm_policy = i;
 822         list_for_each_entry(link, &link_list, sibling) {
 823                 pcie_config_aspm_link(link, policy_to_aspm_state(link));
 824                 pcie_set_clkpm(link, policy_to_clkpm_state(link));
 825         }
 826         mutex_unlock(&aspm_lock);
 827         up_read(&pci_bus_sem);
 828         return 0;
 829 }
 830
 831 static int pcie_aspm_get_policy(char *buffer, struct kernel_param *kp)
 832 {
 833         int i, cnt = 0;
 834         for (i = 0; i < ARRAY_SIZE(policy_str); i++)
 835                 if (i == aspm_policy)
 836                         cnt += sprintf(buffer + cnt, "[%s] ", policy_str[i]);
 837                 else
 838                         cnt += sprintf(buffer + cnt, "%s ", policy_str[i]);
 839         return cnt;
 840 }
 841
 842 module_param_call(policy, pcie_aspm_set_policy, pcie_aspm_get_policy,
 843         NULL, 0644);
 844
 845 #ifdef CONFIG_PCIEASPM_DEBUG
 846 static ssize_t link_state_show(struct device *dev,
 847                 struct device_attribute *attr,
 848                 char *buf)
 849 {
 850         struct pci_dev *pci_device = to_pci_dev(dev);
 851         struct pcie_link_state *link_state = pci_device->link_state;
 852
 853         return sprintf(buf, "%d\n", link_state->aspm_enabled);
 854 }
 855
 856 static ssize_t link_state_store(struct device *dev,
 857                 struct device_attribute *attr,
 858                 const char *buf,
 859                 size_t n)
 860 {
 861         struct pci_dev *pdev = to_pci_dev(dev);
 862         struct pcie_link_state *link, *root = pdev->link_state->root;
 863         u32 val = buf[0] - '0', state = 0;
 864
 865         if (aspm_disabled)
 866                 return -EPERM;
 867         if (n < 1 || val > 3)
 868                 return -EINVAL;
 869
 870         /* Convert requested state to ASPM state */
 871         if (val & PCIE_LINK_STATE_L0S)
 872                 state |= ASPM_STATE_L0S;
 873         if (val & PCIE_LINK_STATE_L1)
 874                 state |= ASPM_STATE_L1;
 875
 876         down_read(&pci_bus_sem);
 877         mutex_lock(&aspm_lock);
 878         list_for_each_entry(link, &link_list, sibling) {
 879                 if (link->root != root)
 880                         continue;
 881                 pcie_config_aspm_link(link, state);
 882         }
 883         mutex_unlock(&aspm_lock);
 884         up_read(&pci_bus_sem);
 885         return n;
 886 }
 887
 888 static ssize_t clk_ctl_show(struct device *dev,
 889                 struct device_attribute *attr,
 890                 char *buf)
 891 {
 892         struct pci_dev *pci_device = to_pci_dev(dev);
 893         struct pcie_link_state *link_state = pci_device->link_state;
 894
 895         return sprintf(buf, "%d\n", link_state->clkpm_enabled);
 896 }
 897
 898 static ssize_t clk_ctl_store(struct device *dev,
 899                 struct device_attribute *attr,
 900                 const char *buf,
 901                 size_t n)
 902 {
 903         struct pci_dev *pdev = to_pci_dev(dev);
 904         int state;
 905
 906         if (n < 1)
 907                 return -EINVAL;
 908         state = buf[0]-'0';
 909
 910         down_read(&pci_bus_sem);
 911         mutex_lock(&aspm_lock);
 912         pcie_set_clkpm_nocheck(pdev->link_state, !!state);
 913         mutex_unlock(&aspm_lock);
 914         up_read(&pci_bus_sem);
 915
 916         return n;
 917 }
 918
 919 static DEVICE_ATTR(link_state, 0644, link_state_show, link_state_store);
 920 static DEVICE_ATTR(clk_ctl, 0644, clk_ctl_show, clk_ctl_store);
 921
 922 static char power_group[] = "power";
 923 void pcie_aspm_create_sysfs_dev_files(struct pci_dev *pdev)
 924 {
 925         struct pcie_link_state *link_state = pdev->link_state;
 926
 927         if (!pci_is_pcie(pdev) ||
 928             (pdev->pcie_type != PCI_EXP_TYPE_ROOT_PORT &&
 929              pdev->pcie_type != PCI_EXP_TYPE_DOWNSTREAM) || !link_state)
 930                 return;
 931
 932         if (link_state->aspm_support)
 933                 sysfs_add_file_to_group(&pdev->dev.kobj,
 934                         &dev_attr_link_state.attr, power_group);
 935         if (link_state->clkpm_capable)
 936                 sysfs_add_file_to_group(&pdev->dev.kobj,
 937                         &dev_attr_clk_ctl.attr, power_group);
 938 }
 939
 940 void pcie_aspm_remove_sysfs_dev_files(struct pci_dev *pdev)
 941 {
 942         struct pcie_link_state *link_state = pdev->link_state;
 943
 944         if (!pci_is_pcie(pdev) ||
 945             (pdev->pcie_type != PCI_EXP_TYPE_ROOT_PORT &&
 946              pdev->pcie_type != PCI_EXP_TYPE_DOWNSTREAM) || !link_state)
 947                 return;
 948
 949         if (link_state->aspm_support)
 950                 sysfs_remove_file_from_group(&pdev->dev.kobj,
 951                         &dev_attr_link_state.attr, power_group);
 952         if (link_state->clkpm_capable)
 953                 sysfs_remove_file_from_group(&pdev->dev.kobj,
 954                         &dev_attr_clk_ctl.attr, power_group);
 955 }
 956 #endif
 957
 958 static int __init pcie_aspm_disable(char *str)
 959 {
 960         if (!strcmp(str, "off")) {
 961                 aspm_policy = POLICY_DEFAULT;
 962                 aspm_disabled = 1;
 963                 aspm_support_enabled = false;
 964                 printk(KERN_INFO "PCIe ASPM is disabled\n");
 965         } else if (!strcmp(str, "force")) {
 966                 aspm_force = 1;
 967                 printk(KERN_INFO "PCIe ASPM is forcibly enabled\n");
 968         }
 969         return 1;
 970 }
 971
 972 __setup("pcie_aspm=", pcie_aspm_disable);
 973
 974 void pcie_no_aspm(void)
 975 {
 976         /*
 977          * Disabling ASPM is intended to prevent the kernel from modifying
 978          * existing hardware state, not to clear existing state. To that end:
 979          * (a) set policy to POLICY_DEFAULT in order to avoid changing state
 980          * (b) prevent userspace from changing policy
 981          */
 982         if (!aspm_force) {
 983                 aspm_policy = POLICY_DEFAULT;
 984                 aspm_disabled = 1;
 985         }
 986 }
 987
 988 /**
 989  * pcie_aspm_enabled - is PCIe ASPM enabled?
 990  *
 991  * Returns true if ASPM has not been disabled by the command-line option
 992  * pcie_aspm=off.
 993  **/
 994 int pcie_aspm_enabled(void)
 995 {
 996        return !aspm_disabled;
 997 }
 998 EXPORT_SYMBOL(pcie_aspm_enabled);
 999
1000 bool pcie_aspm_support_enabled(void)
1001 {
1002         return aspm_support_enabled;
1003 }
1004 EXPORT_SYMBOL(pcie_aspm_support_enabled);