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