drivers/pci/pcie/aspm.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Enable 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/bitfield.h>
  11 #include <linux/kernel.h>
  12 #include <linux/limits.h>
  13 #include <linux/math.h>
  14 #include <linux/module.h>
  15 #include <linux/moduleparam.h>
  16 #include <linux/pci.h>
  17 #include <linux/pci_regs.h>
  18 #include <linux/errno.h>
  19 #include <linux/pm.h>
  20 #include <linux/init.h>
  21 #include <linux/printk.h>
  22 #include <linux/slab.h>
  23 #include <linux/time.h>
  24
  25 #include "../pci.h"
  26
  27 #ifdef MODULE_PARAM_PREFIX
  28 #undef MODULE_PARAM_PREFIX
  29 #endif
  30 #define MODULE_PARAM_PREFIX "pcie_aspm."
  31
  32 /* Note: those are not register definitions */
  33 #define ASPM_STATE_L0S_UP       (1)     /* Upstream direction L0s state */
  34 #define ASPM_STATE_L0S_DW       (2)     /* Downstream direction L0s state */
  35 #define ASPM_STATE_L1           (4)     /* L1 state */
  36 #define ASPM_STATE_L1_1         (8)     /* ASPM L1.1 state */
  37 #define ASPM_STATE_L1_2         (0x10)  /* ASPM L1.2 state */
  38 #define ASPM_STATE_L1_1_PCIPM   (0x20)  /* PCI PM L1.1 state */
  39 #define ASPM_STATE_L1_2_PCIPM   (0x40)  /* PCI PM L1.2 state */
  40 #define ASPM_STATE_L1_SS_PCIPM  (ASPM_STATE_L1_1_PCIPM | ASPM_STATE_L1_2_PCIPM)
  41 #define ASPM_STATE_L1_2_MASK    (ASPM_STATE_L1_2 | ASPM_STATE_L1_2_PCIPM)
  42 #define ASPM_STATE_L1SS         (ASPM_STATE_L1_1 | ASPM_STATE_L1_1_PCIPM |\
  43                                  ASPM_STATE_L1_2_MASK)
  44 #define ASPM_STATE_L0S          (ASPM_STATE_L0S_UP | ASPM_STATE_L0S_DW)
  45 #define ASPM_STATE_ALL          (ASPM_STATE_L0S | ASPM_STATE_L1 |       \
  46                                  ASPM_STATE_L1SS)
  47
  48 struct pcie_link_state {
  49         struct pci_dev *pdev;           /* Upstream component of the Link */
  50         struct pci_dev *downstream;     /* Downstream component, function 0 */
  51         struct pcie_link_state *root;   /* pointer to the root port link */
  52         struct pcie_link_state *parent; /* pointer to the parent Link state */
  53         struct list_head sibling;       /* node in link_list */
  54
  55         /* ASPM state */
  56         u32 aspm_support:7;             /* Supported ASPM state */
  57         u32 aspm_enabled:7;             /* Enabled ASPM state */
  58         u32 aspm_capable:7;             /* Capable ASPM state with latency */
  59         u32 aspm_default:7;             /* Default ASPM state by BIOS */
  60         u32 aspm_disable:7;             /* Disabled ASPM state */
  61
  62         /* Clock PM state */
  63         u32 clkpm_capable:1;            /* Clock PM capable? */
  64         u32 clkpm_enabled:1;            /* Current Clock PM state */
  65         u32 clkpm_default:1;            /* Default Clock PM state by BIOS */
  66         u32 clkpm_disable:1;            /* Clock PM disabled */
  67 };
  68
  69 static int aspm_disabled, aspm_force;
  70 static bool aspm_support_enabled = true;
  71 static DEFINE_MUTEX(aspm_lock);
  72 static LIST_HEAD(link_list);
  73
  74 #define POLICY_DEFAULT 0        /* BIOS default setting */
  75 #define POLICY_PERFORMANCE 1    /* high performance */
  76 #define POLICY_POWERSAVE 2      /* high power saving */
  77 #define POLICY_POWER_SUPERSAVE 3 /* possibly even more power saving */
  78
  79 #ifdef CONFIG_PCIEASPM_PERFORMANCE
  80 static int aspm_policy = POLICY_PERFORMANCE;
  81 #elif defined CONFIG_PCIEASPM_POWERSAVE
  82 static int aspm_policy = POLICY_POWERSAVE;
  83 #elif defined CONFIG_PCIEASPM_POWER_SUPERSAVE
  84 static int aspm_policy = POLICY_POWER_SUPERSAVE;
  85 #else
  86 static int aspm_policy;
  87 #endif
  88
  89 static const char *policy_str[] = {
  90         [POLICY_DEFAULT] = "default",
  91         [POLICY_PERFORMANCE] = "performance",
  92         [POLICY_POWERSAVE] = "powersave",
  93         [POLICY_POWER_SUPERSAVE] = "powersupersave"
  94 };
  95
  96 /*
  97  * The L1 PM substate capability is only implemented in function 0 in a
  98  * multi function device.
  99  */
 100 static struct pci_dev *pci_function_0(struct pci_bus *linkbus)
 101 {
 102         struct pci_dev *child;
 103
 104         list_for_each_entry(child, &linkbus->devices, bus_list)
 105                 if (PCI_FUNC(child->devfn) == 0)
 106                         return child;
 107         return NULL;
 108 }
 109
 110 static int policy_to_aspm_state(struct pcie_link_state *link)
 111 {
 112         switch (aspm_policy) {
 113         case POLICY_PERFORMANCE:
 114                 /* Disable ASPM and Clock PM */
 115                 return 0;
 116         case POLICY_POWERSAVE:
 117                 /* Enable ASPM L0s/L1 */
 118                 return (ASPM_STATE_L0S | ASPM_STATE_L1);
 119         case POLICY_POWER_SUPERSAVE:
 120                 /* Enable Everything */
 121                 return ASPM_STATE_ALL;
 122         case POLICY_DEFAULT:
 123                 return link->aspm_default;
 124         }
 125         return 0;
 126 }
 127
 128 static int policy_to_clkpm_state(struct pcie_link_state *link)
 129 {
 130         switch (aspm_policy) {
 131         case POLICY_PERFORMANCE:
 132                 /* Disable ASPM and Clock PM */
 133                 return 0;
 134         case POLICY_POWERSAVE:
 135         case POLICY_POWER_SUPERSAVE:
 136                 /* Enable Clock PM */
 137                 return 1;
 138         case POLICY_DEFAULT:
 139                 return link->clkpm_default;
 140         }
 141         return 0;
 142 }
 143
 144 static void pcie_set_clkpm_nocheck(struct pcie_link_state *link, int enable)
 145 {
 146         struct pci_dev *child;
 147         struct pci_bus *linkbus = link->pdev->subordinate;
 148         u32 val = enable ? PCI_EXP_LNKCTL_CLKREQ_EN : 0;
 149
 150         list_for_each_entry(child, &linkbus->devices, bus_list)
 151                 pcie_capability_clear_and_set_word(child, PCI_EXP_LNKCTL,
 152                                                    PCI_EXP_LNKCTL_CLKREQ_EN,
 153                                                    val);
 154         link->clkpm_enabled = !!enable;
 155 }
 156
 157 static void pcie_set_clkpm(struct pcie_link_state *link, int enable)
 158 {
 159         /*
 160          * Don't enable Clock PM if the link is not Clock PM capable
 161          * or Clock PM is disabled
 162          */
 163         if (!link->clkpm_capable || link->clkpm_disable)
 164                 enable = 0;
 165         /* Need nothing if the specified equals to current state */
 166         if (link->clkpm_enabled == enable)
 167                 return;
 168         pcie_set_clkpm_nocheck(link, enable);
 169 }
 170
 171 static void pcie_clkpm_cap_init(struct pcie_link_state *link, int blacklist)
 172 {
 173         int capable = 1, enabled = 1;
 174         u32 reg32;
 175         u16 reg16;
 176         struct pci_dev *child;
 177         struct pci_bus *linkbus = link->pdev->subordinate;
 178
 179         /* All functions should have the same cap and state, take the worst */
 180         list_for_each_entry(child, &linkbus->devices, bus_list) {
 181                 pcie_capability_read_dword(child, PCI_EXP_LNKCAP, &reg32);
 182                 if (!(reg32 & PCI_EXP_LNKCAP_CLKPM)) {
 183                         capable = 0;
 184                         enabled = 0;
 185                         break;
 186                 }
 187                 pcie_capability_read_word(child, PCI_EXP_LNKCTL, &reg16);
 188                 if (!(reg16 & PCI_EXP_LNKCTL_CLKREQ_EN))
 189                         enabled = 0;
 190         }
 191         link->clkpm_enabled = enabled;
 192         link->clkpm_default = enabled;
 193         link->clkpm_capable = capable;
 194         link->clkpm_disable = blacklist ? 1 : 0;
 195 }
 196
 197 /*
 198  * pcie_aspm_configure_common_clock: check if the 2 ends of a link
 199  *   could use common clock. If they are, configure them to use the
 200  *   common clock. That will reduce the ASPM state exit latency.
 201  */
 202 static void pcie_aspm_configure_common_clock(struct pcie_link_state *link)
 203 {
 204         int same_clock = 1;
 205         u16 reg16, ccc, parent_old_ccc, child_old_ccc[8];
 206         struct pci_dev *child, *parent = link->pdev;
 207         struct pci_bus *linkbus = parent->subordinate;
 208         /*
 209          * All functions of a slot should have the same Slot Clock
 210          * Configuration, so just check one function
 211          */
 212         child = list_entry(linkbus->devices.next, struct pci_dev, bus_list);
 213         BUG_ON(!pci_is_pcie(child));
 214
 215         /* Check downstream component if bit Slot Clock Configuration is 1 */
 216         pcie_capability_read_word(child, PCI_EXP_LNKSTA, &reg16);
 217         if (!(reg16 & PCI_EXP_LNKSTA_SLC))
 218                 same_clock = 0;
 219
 220         /* Check upstream component if bit Slot Clock Configuration is 1 */
 221         pcie_capability_read_word(parent, PCI_EXP_LNKSTA, &reg16);
 222         if (!(reg16 & PCI_EXP_LNKSTA_SLC))
 223                 same_clock = 0;
 224
 225         /* Port might be already in common clock mode */
 226         pcie_capability_read_word(parent, PCI_EXP_LNKCTL, &reg16);
 227         parent_old_ccc = reg16 & PCI_EXP_LNKCTL_CCC;
 228         if (same_clock && (reg16 & PCI_EXP_LNKCTL_CCC)) {
 229                 bool consistent = true;
 230
 231                 list_for_each_entry(child, &linkbus->devices, bus_list) {
 232                         pcie_capability_read_word(child, PCI_EXP_LNKCTL,
 233                                                   &reg16);
 234                         if (!(reg16 & PCI_EXP_LNKCTL_CCC)) {
 235                                 consistent = false;
 236                                 break;
 237                         }
 238                 }
 239                 if (consistent)
 240                         return;
 241                 pci_info(parent, "ASPM: current common clock configuration is inconsistent, reconfiguring\n");
 242         }
 243
 244         ccc = same_clock ? PCI_EXP_LNKCTL_CCC : 0;
 245         /* Configure downstream component, all functions */
 246         list_for_each_entry(child, &linkbus->devices, bus_list) {
 247                 pcie_capability_read_word(child, PCI_EXP_LNKCTL, &reg16);
 248                 child_old_ccc[PCI_FUNC(child->devfn)] = reg16 & PCI_EXP_LNKCTL_CCC;
 249                 pcie_capability_clear_and_set_word(child, PCI_EXP_LNKCTL,
 250                                                    PCI_EXP_LNKCTL_CCC, ccc);
 251         }
 252
 253         /* Configure upstream component */
 254         pcie_capability_clear_and_set_word(parent, PCI_EXP_LNKCTL,
 255                                            PCI_EXP_LNKCTL_CCC, ccc);
 256
 257         if (pcie_retrain_link(link->pdev, true)) {
 258
 259                 /* Training failed. Restore common clock configurations */
 260                 pci_err(parent, "ASPM: Could not configure common clock\n");
 261                 list_for_each_entry(child, &linkbus->devices, bus_list)
 262                         pcie_capability_clear_and_set_word(child, PCI_EXP_LNKCTL,
 263                                                            PCI_EXP_LNKCTL_CCC,
 264                                                            child_old_ccc[PCI_FUNC(child->devfn)]);
 265                 pcie_capability_clear_and_set_word(parent, PCI_EXP_LNKCTL,
 266                                                    PCI_EXP_LNKCTL_CCC, parent_old_ccc);
 267         }
 268 }
 269
 270 /* Convert L0s latency encoding to ns */
 271 static u32 calc_l0s_latency(u32 lnkcap)
 272 {
 273         u32 encoding = FIELD_GET(PCI_EXP_LNKCAP_L0SEL, lnkcap);
 274
 275         if (encoding == 0x7)
 276                 return 5 * NSEC_PER_USEC;       /* > 4us */
 277         return (64 << encoding);
 278 }
 279
 280 /* Convert L0s acceptable latency encoding to ns */
 281 static u32 calc_l0s_acceptable(u32 encoding)
 282 {
 283         if (encoding == 0x7)
 284                 return U32_MAX;
 285         return (64 << encoding);
 286 }
 287
 288 /* Convert L1 latency encoding to ns */
 289 static u32 calc_l1_latency(u32 lnkcap)
 290 {
 291         u32 encoding = FIELD_GET(PCI_EXP_LNKCAP_L1EL, lnkcap);
 292
 293         if (encoding == 0x7)
 294                 return 65 * NSEC_PER_USEC;      /* > 64us */
 295         return NSEC_PER_USEC << encoding;
 296 }
 297
 298 /* Convert L1 acceptable latency encoding to ns */
 299 static u32 calc_l1_acceptable(u32 encoding)
 300 {
 301         if (encoding == 0x7)
 302                 return U32_MAX;
 303         return NSEC_PER_USEC << encoding;
 304 }
 305
 306 /* Convert L1SS T_pwr encoding to usec */
 307 static u32 calc_l12_pwron(struct pci_dev *pdev, u32 scale, u32 val)
 308 {
 309         switch (scale) {
 310         case 0:
 311                 return val * 2;
 312         case 1:
 313                 return val * 10;
 314         case 2:
 315                 return val * 100;
 316         }
 317         pci_err(pdev, "%s: Invalid T_PwrOn scale: %u\n", __func__, scale);
 318         return 0;
 319 }
 320
 321 /*
 322  * Encode an LTR_L1.2_THRESHOLD value for the L1 PM Substates Control 1
 323  * register.  Ports enter L1.2 when the most recent LTR value is greater
 324  * than or equal to LTR_L1.2_THRESHOLD, so we round up to make sure we
 325  * don't enter L1.2 too aggressively.
 326  *
 327  * See PCIe r6.0, sec 5.5.1, 6.18, 7.8.3.3.
 328  */
 329 static void encode_l12_threshold(u32 threshold_us, u32 *scale, u32 *value)
 330 {
 331         u64 threshold_ns = (u64)threshold_us * NSEC_PER_USEC;
 332
 333         /*
 334          * LTR_L1.2_THRESHOLD_Value ("value") is a 10-bit field with max
 335          * value of 0x3ff.
 336          */
 337         if (threshold_ns <= 1 * FIELD_MAX(PCI_L1SS_CTL1_LTR_L12_TH_VALUE)) {
 338                 *scale = 0;             /* Value times 1ns */
 339                 *value = threshold_ns;
 340         } else if (threshold_ns <= 32 * FIELD_MAX(PCI_L1SS_CTL1_LTR_L12_TH_VALUE)) {
 341                 *scale = 1;             /* Value times 32ns */
 342                 *value = roundup(threshold_ns, 32) / 32;
 343         } else if (threshold_ns <= 1024 * FIELD_MAX(PCI_L1SS_CTL1_LTR_L12_TH_VALUE)) {
 344                 *scale = 2;             /* Value times 1024ns */
 345                 *value = roundup(threshold_ns, 1024) / 1024;
 346         } else if (threshold_ns <= 32768 * FIELD_MAX(PCI_L1SS_CTL1_LTR_L12_TH_VALUE)) {
 347                 *scale = 3;             /* Value times 32768ns */
 348                 *value = roundup(threshold_ns, 32768) / 32768;
 349         } else if (threshold_ns <= 1048576 * FIELD_MAX(PCI_L1SS_CTL1_LTR_L12_TH_VALUE)) {
 350                 *scale = 4;             /* Value times 1048576ns */
 351                 *value = roundup(threshold_ns, 1048576) / 1048576;
 352         } else if (threshold_ns <= (u64)33554432 * FIELD_MAX(PCI_L1SS_CTL1_LTR_L12_TH_VALUE)) {
 353                 *scale = 5;             /* Value times 33554432ns */
 354                 *value = roundup(threshold_ns, 33554432) / 33554432;
 355         } else {
 356                 *scale = 5;
 357                 *value = FIELD_MAX(PCI_L1SS_CTL1_LTR_L12_TH_VALUE);
 358         }
 359 }
 360
 361 static void pcie_aspm_check_latency(struct pci_dev *endpoint)
 362 {
 363         u32 latency, encoding, lnkcap_up, lnkcap_dw;
 364         u32 l1_switch_latency = 0, latency_up_l0s;
 365         u32 latency_up_l1, latency_dw_l0s, latency_dw_l1;
 366         u32 acceptable_l0s, acceptable_l1;
 367         struct pcie_link_state *link;
 368
 369         /* Device not in D0 doesn't need latency check */
 370         if ((endpoint->current_state != PCI_D0) &&
 371             (endpoint->current_state != PCI_UNKNOWN))
 372                 return;
 373
 374         link = endpoint->bus->self->link_state;
 375
 376         /* Calculate endpoint L0s acceptable latency */
 377         encoding = FIELD_GET(PCI_EXP_DEVCAP_L0S, endpoint->devcap);
 378         acceptable_l0s = calc_l0s_acceptable(encoding);
 379
 380         /* Calculate endpoint L1 acceptable latency */
 381         encoding = FIELD_GET(PCI_EXP_DEVCAP_L1, endpoint->devcap);
 382         acceptable_l1 = calc_l1_acceptable(encoding);
 383
 384         while (link) {
 385                 struct pci_dev *dev = pci_function_0(link->pdev->subordinate);
 386
 387                 /* Read direction exit latencies */
 388                 pcie_capability_read_dword(link->pdev, PCI_EXP_LNKCAP,
 389                                            &lnkcap_up);
 390                 pcie_capability_read_dword(dev, PCI_EXP_LNKCAP,
 391                                            &lnkcap_dw);
 392                 latency_up_l0s = calc_l0s_latency(lnkcap_up);
 393                 latency_up_l1 = calc_l1_latency(lnkcap_up);
 394                 latency_dw_l0s = calc_l0s_latency(lnkcap_dw);
 395                 latency_dw_l1 = calc_l1_latency(lnkcap_dw);
 396
 397                 /* Check upstream direction L0s latency */
 398                 if ((link->aspm_capable & ASPM_STATE_L0S_UP) &&
 399                     (latency_up_l0s > acceptable_l0s))
 400                         link->aspm_capable &= ~ASPM_STATE_L0S_UP;
 401
 402                 /* Check downstream direction L0s latency */
 403                 if ((link->aspm_capable & ASPM_STATE_L0S_DW) &&
 404                     (latency_dw_l0s > acceptable_l0s))
 405                         link->aspm_capable &= ~ASPM_STATE_L0S_DW;
 406                 /*
 407                  * Check L1 latency.
 408                  * Every switch on the path to root complex need 1
 409                  * more microsecond for L1. Spec doesn't mention L0s.
 410                  *
 411                  * The exit latencies for L1 substates are not advertised
 412                  * by a device.  Since the spec also doesn't mention a way
 413                  * to determine max latencies introduced by enabling L1
 414                  * substates on the components, it is not clear how to do
 415                  * a L1 substate exit latency check.  We assume that the
 416                  * L1 exit latencies advertised by a device include L1
 417                  * substate latencies (and hence do not do any check).
 418                  */
 419                 latency = max_t(u32, latency_up_l1, latency_dw_l1);
 420                 if ((link->aspm_capable & ASPM_STATE_L1) &&
 421                     (latency + l1_switch_latency > acceptable_l1))
 422                         link->aspm_capable &= ~ASPM_STATE_L1;
 423                 l1_switch_latency += NSEC_PER_USEC;
 424
 425                 link = link->parent;
 426         }
 427 }
 428
 429 static void pci_clear_and_set_dword(struct pci_dev *pdev, int pos,
 430                                     u32 clear, u32 set)
 431 {
 432         u32 val;
 433
 434         pci_read_config_dword(pdev, pos, &val);
 435         val &= ~clear;
 436         val |= set;
 437         pci_write_config_dword(pdev, pos, val);
 438 }
 439
 440 /* Calculate L1.2 PM substate timing parameters */
 441 static void aspm_calc_l12_info(struct pcie_link_state *link,
 442                                 u32 parent_l1ss_cap, u32 child_l1ss_cap)
 443 {
 444         struct pci_dev *child = link->downstream, *parent = link->pdev;
 445         u32 val1, val2, scale1, scale2;
 446         u32 t_common_mode, t_power_on, l1_2_threshold, scale, value;
 447         u32 ctl1 = 0, ctl2 = 0;
 448         u32 pctl1, pctl2, cctl1, cctl2;
 449         u32 pl1_2_enables, cl1_2_enables;
 450
 451         /* Choose the greater of the two Port Common_Mode_Restore_Times */
 452         val1 = FIELD_GET(PCI_L1SS_CAP_CM_RESTORE_TIME, parent_l1ss_cap);
 453         val2 = FIELD_GET(PCI_L1SS_CAP_CM_RESTORE_TIME, child_l1ss_cap);
 454         t_common_mode = max(val1, val2);
 455
 456         /* Choose the greater of the two Port T_POWER_ON times */
 457         val1   = FIELD_GET(PCI_L1SS_CAP_P_PWR_ON_VALUE, parent_l1ss_cap);
 458         scale1 = FIELD_GET(PCI_L1SS_CAP_P_PWR_ON_SCALE, parent_l1ss_cap);
 459         val2   = FIELD_GET(PCI_L1SS_CAP_P_PWR_ON_VALUE, child_l1ss_cap);
 460         scale2 = FIELD_GET(PCI_L1SS_CAP_P_PWR_ON_SCALE, child_l1ss_cap);
 461
 462         if (calc_l12_pwron(parent, scale1, val1) >
 463             calc_l12_pwron(child, scale2, val2)) {
 464                 ctl2 |= FIELD_PREP(PCI_L1SS_CTL2_T_PWR_ON_SCALE, scale1) |
 465                         FIELD_PREP(PCI_L1SS_CTL2_T_PWR_ON_VALUE, val1);
 466                 t_power_on = calc_l12_pwron(parent, scale1, val1);
 467         } else {
 468                 ctl2 |= FIELD_PREP(PCI_L1SS_CTL2_T_PWR_ON_SCALE, scale2) |
 469                         FIELD_PREP(PCI_L1SS_CTL2_T_PWR_ON_VALUE, val2);
 470                 t_power_on = calc_l12_pwron(child, scale2, val2);
 471         }
 472
 473         /*
 474          * Set LTR_L1.2_THRESHOLD to the time required to transition the
 475          * Link from L0 to L1.2 and back to L0 so we enter L1.2 only if
 476          * downstream devices report (via LTR) that they can tolerate at
 477          * least that much latency.
 478          *
 479          * Based on PCIe r3.1, sec 5.5.3.3.1, Figures 5-16 and 5-17, and
 480          * Table 5-11.  T(POWER_OFF) is at most 2us and T(L1.2) is at
 481          * least 4us.
 482          */
 483         l1_2_threshold = 2 + 4 + t_common_mode + t_power_on;
 484         encode_l12_threshold(l1_2_threshold, &scale, &value);
 485         ctl1 |= FIELD_PREP(PCI_L1SS_CTL1_CM_RESTORE_TIME, t_common_mode) |
 486                 FIELD_PREP(PCI_L1SS_CTL1_LTR_L12_TH_VALUE, value) |
 487                 FIELD_PREP(PCI_L1SS_CTL1_LTR_L12_TH_SCALE, scale);
 488
 489         /* Some broken devices only support dword access to L1 SS */
 490         pci_read_config_dword(parent, parent->l1ss + PCI_L1SS_CTL1, &pctl1);
 491         pci_read_config_dword(parent, parent->l1ss + PCI_L1SS_CTL2, &pctl2);
 492         pci_read_config_dword(child, child->l1ss + PCI_L1SS_CTL1, &cctl1);
 493         pci_read_config_dword(child, child->l1ss + PCI_L1SS_CTL2, &cctl2);
 494
 495         if (ctl1 == pctl1 && ctl1 == cctl1 &&
 496             ctl2 == pctl2 && ctl2 == cctl2)
 497                 return;
 498
 499         /* Disable L1.2 while updating.  See PCIe r5.0, sec 5.5.4, 7.8.3.3 */
 500         pl1_2_enables = pctl1 & PCI_L1SS_CTL1_L1_2_MASK;
 501         cl1_2_enables = cctl1 & PCI_L1SS_CTL1_L1_2_MASK;
 502
 503         if (pl1_2_enables || cl1_2_enables) {
 504                 pci_clear_and_set_dword(child, child->l1ss + PCI_L1SS_CTL1,
 505                                         PCI_L1SS_CTL1_L1_2_MASK, 0);
 506                 pci_clear_and_set_dword(parent, parent->l1ss + PCI_L1SS_CTL1,
 507                                         PCI_L1SS_CTL1_L1_2_MASK, 0);
 508         }
 509
 510         /* Program T_POWER_ON times in both ports */
 511         pci_write_config_dword(parent, parent->l1ss + PCI_L1SS_CTL2, ctl2);
 512         pci_write_config_dword(child, child->l1ss + PCI_L1SS_CTL2, ctl2);
 513
 514         /* Program Common_Mode_Restore_Time in upstream device */
 515         pci_clear_and_set_dword(parent, parent->l1ss + PCI_L1SS_CTL1,
 516                                 PCI_L1SS_CTL1_CM_RESTORE_TIME, ctl1);
 517
 518         /* Program LTR_L1.2_THRESHOLD time in both ports */
 519         pci_clear_and_set_dword(parent, parent->l1ss + PCI_L1SS_CTL1,
 520                                 PCI_L1SS_CTL1_LTR_L12_TH_VALUE |
 521                                 PCI_L1SS_CTL1_LTR_L12_TH_SCALE, ctl1);
 522         pci_clear_and_set_dword(child, child->l1ss + PCI_L1SS_CTL1,
 523                                 PCI_L1SS_CTL1_LTR_L12_TH_VALUE |
 524                                 PCI_L1SS_CTL1_LTR_L12_TH_SCALE, ctl1);
 525
 526         if (pl1_2_enables || cl1_2_enables) {
 527                 pci_clear_and_set_dword(parent, parent->l1ss + PCI_L1SS_CTL1, 0,
 528                                         pl1_2_enables);
 529                 pci_clear_and_set_dword(child, child->l1ss + PCI_L1SS_CTL1, 0,
 530                                         cl1_2_enables);
 531         }
 532 }
 533
 534 static void aspm_l1ss_init(struct pcie_link_state *link)
 535 {
 536         struct pci_dev *child = link->downstream, *parent = link->pdev;
 537         u32 parent_l1ss_cap, child_l1ss_cap;
 538         u32 parent_l1ss_ctl1 = 0, child_l1ss_ctl1 = 0;
 539
 540         if (!parent->l1ss || !child->l1ss)
 541                 return;
 542
 543         /* Setup L1 substate */
 544         pci_read_config_dword(parent, parent->l1ss + PCI_L1SS_CAP,
 545                               &parent_l1ss_cap);
 546         pci_read_config_dword(child, child->l1ss + PCI_L1SS_CAP,
 547                               &child_l1ss_cap);
 548
 549         if (!(parent_l1ss_cap & PCI_L1SS_CAP_L1_PM_SS))
 550                 parent_l1ss_cap = 0;
 551         if (!(child_l1ss_cap & PCI_L1SS_CAP_L1_PM_SS))
 552                 child_l1ss_cap = 0;
 553
 554         /*
 555          * If we don't have LTR for the entire path from the Root Complex
 556          * to this device, we can't use ASPM L1.2 because it relies on the
 557          * LTR_L1.2_THRESHOLD.  See PCIe r4.0, secs 5.5.4, 6.18.
 558          */
 559         if (!child->ltr_path)
 560                 child_l1ss_cap &= ~PCI_L1SS_CAP_ASPM_L1_2;
 561
 562         if (parent_l1ss_cap & child_l1ss_cap & PCI_L1SS_CAP_ASPM_L1_1)
 563                 link->aspm_support |= ASPM_STATE_L1_1;
 564         if (parent_l1ss_cap & child_l1ss_cap & PCI_L1SS_CAP_ASPM_L1_2)
 565                 link->aspm_support |= ASPM_STATE_L1_2;
 566         if (parent_l1ss_cap & child_l1ss_cap & PCI_L1SS_CAP_PCIPM_L1_1)
 567                 link->aspm_support |= ASPM_STATE_L1_1_PCIPM;
 568         if (parent_l1ss_cap & child_l1ss_cap & PCI_L1SS_CAP_PCIPM_L1_2)
 569                 link->aspm_support |= ASPM_STATE_L1_2_PCIPM;
 570
 571         if (parent_l1ss_cap)
 572                 pci_read_config_dword(parent, parent->l1ss + PCI_L1SS_CTL1,
 573                                       &parent_l1ss_ctl1);
 574         if (child_l1ss_cap)
 575                 pci_read_config_dword(child, child->l1ss + PCI_L1SS_CTL1,
 576                                       &child_l1ss_ctl1);
 577
 578         if (parent_l1ss_ctl1 & child_l1ss_ctl1 & PCI_L1SS_CTL1_ASPM_L1_1)
 579                 link->aspm_enabled |= ASPM_STATE_L1_1;
 580         if (parent_l1ss_ctl1 & child_l1ss_ctl1 & PCI_L1SS_CTL1_ASPM_L1_2)
 581                 link->aspm_enabled |= ASPM_STATE_L1_2;
 582         if (parent_l1ss_ctl1 & child_l1ss_ctl1 & PCI_L1SS_CTL1_PCIPM_L1_1)
 583                 link->aspm_enabled |= ASPM_STATE_L1_1_PCIPM;
 584         if (parent_l1ss_ctl1 & child_l1ss_ctl1 & PCI_L1SS_CTL1_PCIPM_L1_2)
 585                 link->aspm_enabled |= ASPM_STATE_L1_2_PCIPM;
 586
 587         if (link->aspm_support & ASPM_STATE_L1_2_MASK)
 588                 aspm_calc_l12_info(link, parent_l1ss_cap, child_l1ss_cap);
 589 }
 590
 591 static void pcie_aspm_cap_init(struct pcie_link_state *link, int blacklist)
 592 {
 593         struct pci_dev *child = link->downstream, *parent = link->pdev;
 594         u32 parent_lnkcap, child_lnkcap;
 595         u16 parent_lnkctl, child_lnkctl;
 596         struct pci_bus *linkbus = parent->subordinate;
 597
 598         if (blacklist) {
 599                 /* Set enabled/disable so that we will disable ASPM later */
 600                 link->aspm_enabled = ASPM_STATE_ALL;
 601                 link->aspm_disable = ASPM_STATE_ALL;
 602                 return;
 603         }
 604
 605         /*
 606          * If ASPM not supported, don't mess with the clocks and link,
 607          * bail out now.
 608          */
 609         pcie_capability_read_dword(parent, PCI_EXP_LNKCAP, &parent_lnkcap);
 610         pcie_capability_read_dword(child, PCI_EXP_LNKCAP, &child_lnkcap);
 611         if (!(parent_lnkcap & child_lnkcap & PCI_EXP_LNKCAP_ASPMS))
 612                 return;
 613
 614         /* Configure common clock before checking latencies */
 615         pcie_aspm_configure_common_clock(link);
 616
 617         /*
 618          * Re-read upstream/downstream components' register state after
 619          * clock configuration.  L0s & L1 exit latencies in the otherwise
 620          * read-only Link Capabilities may change depending on common clock
 621          * configuration (PCIe r5.0, sec 7.5.3.6).
 622          */
 623         pcie_capability_read_dword(parent, PCI_EXP_LNKCAP, &parent_lnkcap);
 624         pcie_capability_read_dword(child, PCI_EXP_LNKCAP, &child_lnkcap);
 625         pcie_capability_read_word(parent, PCI_EXP_LNKCTL, &parent_lnkctl);
 626         pcie_capability_read_word(child, PCI_EXP_LNKCTL, &child_lnkctl);
 627
 628         /*
 629          * Setup L0s state
 630          *
 631          * Note that we must not enable L0s in either direction on a
 632          * given link unless components on both sides of the link each
 633          * support L0s.
 634          */
 635         if (parent_lnkcap & child_lnkcap & PCI_EXP_LNKCAP_ASPM_L0S)
 636                 link->aspm_support |= ASPM_STATE_L0S;
 637
 638         if (child_lnkctl & PCI_EXP_LNKCTL_ASPM_L0S)
 639                 link->aspm_enabled |= ASPM_STATE_L0S_UP;
 640         if (parent_lnkctl & PCI_EXP_LNKCTL_ASPM_L0S)
 641                 link->aspm_enabled |= ASPM_STATE_L0S_DW;
 642
 643         /* Setup L1 state */
 644         if (parent_lnkcap & child_lnkcap & PCI_EXP_LNKCAP_ASPM_L1)
 645                 link->aspm_support |= ASPM_STATE_L1;
 646
 647         if (parent_lnkctl & child_lnkctl & PCI_EXP_LNKCTL_ASPM_L1)
 648                 link->aspm_enabled |= ASPM_STATE_L1;
 649
 650         aspm_l1ss_init(link);
 651
 652         /* Save default state */
 653         link->aspm_default = link->aspm_enabled;
 654
 655         /* Setup initial capable state. Will be updated later */
 656         link->aspm_capable = link->aspm_support;
 657
 658         /* Get and check endpoint acceptable latencies */
 659         list_for_each_entry(child, &linkbus->devices, bus_list) {
 660                 if (pci_pcie_type(child) != PCI_EXP_TYPE_ENDPOINT &&
 661                     pci_pcie_type(child) != PCI_EXP_TYPE_LEG_END)
 662                         continue;
 663
 664                 pcie_aspm_check_latency(child);
 665         }
 666 }
 667
 668 /* Configure the ASPM L1 substates */
 669 static void pcie_config_aspm_l1ss(struct pcie_link_state *link, u32 state)
 670 {
 671         u32 val, enable_req;
 672         struct pci_dev *child = link->downstream, *parent = link->pdev;
 673
 674         enable_req = (link->aspm_enabled ^ state) & state;
 675
 676         /*
 677          * Here are the rules specified in the PCIe spec for enabling L1SS:
 678          * - When enabling L1.x, enable bit at parent first, then at child
 679          * - When disabling L1.x, disable bit at child first, then at parent
 680          * - When enabling ASPM L1.x, need to disable L1
 681          *   (at child followed by parent).
 682          * - The ASPM/PCIPM L1.2 must be disabled while programming timing
 683          *   parameters
 684          *
 685          * To keep it simple, disable all L1SS bits first, and later enable
 686          * what is needed.
 687          */
 688
 689         /* Disable all L1 substates */
 690         pci_clear_and_set_dword(child, child->l1ss + PCI_L1SS_CTL1,
 691                                 PCI_L1SS_CTL1_L1SS_MASK, 0);
 692         pci_clear_and_set_dword(parent, parent->l1ss + PCI_L1SS_CTL1,
 693                                 PCI_L1SS_CTL1_L1SS_MASK, 0);
 694         /*
 695          * If needed, disable L1, and it gets enabled later
 696          * in pcie_config_aspm_link().
 697          */
 698         if (enable_req & (ASPM_STATE_L1_1 | ASPM_STATE_L1_2)) {
 699                 pcie_capability_clear_and_set_word(child, PCI_EXP_LNKCTL,
 700                                                    PCI_EXP_LNKCTL_ASPM_L1, 0);
 701                 pcie_capability_clear_and_set_word(parent, PCI_EXP_LNKCTL,
 702                                                    PCI_EXP_LNKCTL_ASPM_L1, 0);
 703         }
 704
 705         val = 0;
 706         if (state & ASPM_STATE_L1_1)
 707                 val |= PCI_L1SS_CTL1_ASPM_L1_1;
 708         if (state & ASPM_STATE_L1_2)
 709                 val |= PCI_L1SS_CTL1_ASPM_L1_2;
 710         if (state & ASPM_STATE_L1_1_PCIPM)
 711                 val |= PCI_L1SS_CTL1_PCIPM_L1_1;
 712         if (state & ASPM_STATE_L1_2_PCIPM)
 713                 val |= PCI_L1SS_CTL1_PCIPM_L1_2;
 714
 715         /* Enable what we need to enable */
 716         pci_clear_and_set_dword(parent, parent->l1ss + PCI_L1SS_CTL1,
 717                                 PCI_L1SS_CTL1_L1SS_MASK, val);
 718         pci_clear_and_set_dword(child, child->l1ss + PCI_L1SS_CTL1,
 719                                 PCI_L1SS_CTL1_L1SS_MASK, val);
 720 }
 721
 722 static void pcie_config_aspm_dev(struct pci_dev *pdev, u32 val)
 723 {
 724         pcie_capability_clear_and_set_word(pdev, PCI_EXP_LNKCTL,
 725                                            PCI_EXP_LNKCTL_ASPMC, val);
 726 }
 727
 728 static void pcie_config_aspm_link(struct pcie_link_state *link, u32 state)
 729 {
 730         u32 upstream = 0, dwstream = 0;
 731         struct pci_dev *child = link->downstream, *parent = link->pdev;
 732         struct pci_bus *linkbus = parent->subordinate;
 733
 734         /* Enable only the states that were not explicitly disabled */
 735         state &= (link->aspm_capable & ~link->aspm_disable);
 736
 737         /* Can't enable any substates if L1 is not enabled */
 738         if (!(state & ASPM_STATE_L1))
 739                 state &= ~ASPM_STATE_L1SS;
 740
 741         /* Spec says both ports must be in D0 before enabling PCI PM substates*/
 742         if (parent->current_state != PCI_D0 || child->current_state != PCI_D0) {
 743                 state &= ~ASPM_STATE_L1_SS_PCIPM;
 744                 state |= (link->aspm_enabled & ASPM_STATE_L1_SS_PCIPM);
 745         }
 746
 747         /* Nothing to do if the link is already in the requested state */
 748         if (link->aspm_enabled == state)
 749                 return;
 750         /* Convert ASPM state to upstream/downstream ASPM register state */
 751         if (state & ASPM_STATE_L0S_UP)
 752                 dwstream |= PCI_EXP_LNKCTL_ASPM_L0S;
 753         if (state & ASPM_STATE_L0S_DW)
 754                 upstream |= PCI_EXP_LNKCTL_ASPM_L0S;
 755         if (state & ASPM_STATE_L1) {
 756                 upstream |= PCI_EXP_LNKCTL_ASPM_L1;
 757                 dwstream |= PCI_EXP_LNKCTL_ASPM_L1;
 758         }
 759
 760         if (link->aspm_capable & ASPM_STATE_L1SS)
 761                 pcie_config_aspm_l1ss(link, state);
 762
 763         /*
 764          * Spec 2.0 suggests all functions should be configured the
 765          * same setting for ASPM. Enabling ASPM L1 should be done in
 766          * upstream component first and then downstream, and vice
 767          * versa for disabling ASPM L1. Spec doesn't mention L0S.
 768          */
 769         if (state & ASPM_STATE_L1)
 770                 pcie_config_aspm_dev(parent, upstream);
 771         list_for_each_entry(child, &linkbus->devices, bus_list)
 772                 pcie_config_aspm_dev(child, dwstream);
 773         if (!(state & ASPM_STATE_L1))
 774                 pcie_config_aspm_dev(parent, upstream);
 775
 776         link->aspm_enabled = state;
 777 }
 778
 779 static void pcie_config_aspm_path(struct pcie_link_state *link)
 780 {
 781         while (link) {
 782                 pcie_config_aspm_link(link, policy_to_aspm_state(link));
 783                 link = link->parent;
 784         }
 785 }
 786
 787 static void free_link_state(struct pcie_link_state *link)
 788 {
 789         link->pdev->link_state = NULL;
 790         kfree(link);
 791 }
 792
 793 static int pcie_aspm_sanity_check(struct pci_dev *pdev)
 794 {
 795         struct pci_dev *child;
 796         u32 reg32;
 797
 798         /*
 799          * Some functions in a slot might not all be PCIe functions,
 800          * very strange. Disable ASPM for the whole slot
 801          */
 802         list_for_each_entry(child, &pdev->subordinate->devices, bus_list) {
 803                 if (!pci_is_pcie(child))
 804                         return -EINVAL;
 805
 806                 /*
 807                  * If ASPM is disabled then we're not going to change
 808                  * the BIOS state. It's safe to continue even if it's a
 809                  * pre-1.1 device
 810                  */
 811
 812                 if (aspm_disabled)
 813                         continue;
 814
 815                 /*
 816                  * Disable ASPM for pre-1.1 PCIe device, we follow MS to use
 817                  * RBER bit to determine if a function is 1.1 version device
 818                  */
 819                 pcie_capability_read_dword(child, PCI_EXP_DEVCAP, &reg32);
 820                 if (!(reg32 & PCI_EXP_DEVCAP_RBER) && !aspm_force) {
 821                         pci_info(child, "disabling ASPM on pre-1.1 PCIe device.  You can enable it with 'pcie_aspm=force'\n");
 822                         return -EINVAL;
 823                 }
 824         }
 825         return 0;
 826 }
 827
 828 static struct pcie_link_state *alloc_pcie_link_state(struct pci_dev *pdev)
 829 {
 830         struct pcie_link_state *link;
 831
 832         link = kzalloc(sizeof(*link), GFP_KERNEL);
 833         if (!link)
 834                 return NULL;
 835
 836         INIT_LIST_HEAD(&link->sibling);
 837         link->pdev = pdev;
 838         link->downstream = pci_function_0(pdev->subordinate);
 839
 840         /*
 841          * Root Ports and PCI/PCI-X to PCIe Bridges are roots of PCIe
 842          * hierarchies.  Note that some PCIe host implementations omit
 843          * the root ports entirely, in which case a downstream port on
 844          * a switch may become the root of the link state chain for all
 845          * its subordinate endpoints.
 846          */
 847         if (pci_pcie_type(pdev) == PCI_EXP_TYPE_ROOT_PORT ||
 848             pci_pcie_type(pdev) == PCI_EXP_TYPE_PCIE_BRIDGE ||
 849             !pdev->bus->parent->self) {
 850                 link->root = link;
 851         } else {
 852                 struct pcie_link_state *parent;
 853
 854                 parent = pdev->bus->parent->self->link_state;
 855                 if (!parent) {
 856                         kfree(link);
 857                         return NULL;
 858                 }
 859
 860                 link->parent = parent;
 861                 link->root = link->parent->root;
 862         }
 863
 864         list_add(&link->sibling, &link_list);
 865         pdev->link_state = link;
 866         return link;
 867 }
 868
 869 static void pcie_aspm_update_sysfs_visibility(struct pci_dev *pdev)
 870 {
 871         struct pci_dev *child;
 872
 873         list_for_each_entry(child, &pdev->subordinate->devices, bus_list)
 874                 sysfs_update_group(&child->dev.kobj, &aspm_ctrl_attr_group);
 875 }
 876
 877 /*
 878  * pcie_aspm_init_link_state: Initiate PCI express link state.
 879  * It is called after the pcie and its children devices are scanned.
 880  * @pdev: the root port or switch downstream port
 881  */
 882 void pcie_aspm_init_link_state(struct pci_dev *pdev)
 883 {
 884         struct pcie_link_state *link;
 885         int blacklist = !!pcie_aspm_sanity_check(pdev);
 886
 887         if (!aspm_support_enabled)
 888                 return;
 889
 890         if (pdev->link_state)
 891                 return;
 892
 893         /*
 894          * We allocate pcie_link_state for the component on the upstream
 895          * end of a Link, so there's nothing to do unless this device is
 896          * downstream port.
 897          */
 898         if (!pcie_downstream_port(pdev))
 899                 return;
 900
 901         /* VIA has a strange chipset, root port is under a bridge */
 902         if (pci_pcie_type(pdev) == PCI_EXP_TYPE_ROOT_PORT &&
 903             pdev->bus->self)
 904                 return;
 905
 906         down_read(&pci_bus_sem);
 907         if (list_empty(&pdev->subordinate->devices))
 908                 goto out;
 909
 910         mutex_lock(&aspm_lock);
 911         link = alloc_pcie_link_state(pdev);
 912         if (!link)
 913                 goto unlock;
 914         /*
 915          * Setup initial ASPM state. Note that we need to configure
 916          * upstream links also because capable state of them can be
 917          * update through pcie_aspm_cap_init().
 918          */
 919         pcie_aspm_cap_init(link, blacklist);
 920
 921         /* Setup initial Clock PM state */
 922         pcie_clkpm_cap_init(link, blacklist);
 923
 924         /*
 925          * At this stage drivers haven't had an opportunity to change the
 926          * link policy setting. Enabling ASPM on broken hardware can cripple
 927          * it even before the driver has had a chance to disable ASPM, so
 928          * default to a safe level right now. If we're enabling ASPM beyond
 929          * the BIOS's expectation, we'll do so once pci_enable_device() is
 930          * called.
 931          */
 932         if (aspm_policy != POLICY_POWERSAVE &&
 933             aspm_policy != POLICY_POWER_SUPERSAVE) {
 934                 pcie_config_aspm_path(link);
 935                 pcie_set_clkpm(link, policy_to_clkpm_state(link));
 936         }
 937
 938         pcie_aspm_update_sysfs_visibility(pdev);
 939
 940 unlock:
 941         mutex_unlock(&aspm_lock);
 942 out:
 943         up_read(&pci_bus_sem);
 944 }
 945
 946 /* Recheck latencies and update aspm_capable for links under the root */
 947 static void pcie_update_aspm_capable(struct pcie_link_state *root)
 948 {
 949         struct pcie_link_state *link;
 950         BUG_ON(root->parent);
 951         list_for_each_entry(link, &link_list, sibling) {
 952                 if (link->root != root)
 953                         continue;
 954                 link->aspm_capable = link->aspm_support;
 955         }
 956         list_for_each_entry(link, &link_list, sibling) {
 957                 struct pci_dev *child;
 958                 struct pci_bus *linkbus = link->pdev->subordinate;
 959                 if (link->root != root)
 960                         continue;
 961                 list_for_each_entry(child, &linkbus->devices, bus_list) {
 962                         if ((pci_pcie_type(child) != PCI_EXP_TYPE_ENDPOINT) &&
 963                             (pci_pcie_type(child) != PCI_EXP_TYPE_LEG_END))
 964                                 continue;
 965                         pcie_aspm_check_latency(child);
 966                 }
 967         }
 968 }
 969
 970 /* @pdev: the endpoint device */
 971 void pcie_aspm_exit_link_state(struct pci_dev *pdev)
 972 {
 973         struct pci_dev *parent = pdev->bus->self;
 974         struct pcie_link_state *link, *root, *parent_link;
 975
 976         if (!parent || !parent->link_state)
 977                 return;
 978
 979         down_read(&pci_bus_sem);
 980         mutex_lock(&aspm_lock);
 981
 982         link = parent->link_state;
 983         root = link->root;
 984         parent_link = link->parent;
 985
 986         /*
 987          * link->downstream is a pointer to the pci_dev of function 0.  If
 988          * we remove that function, the pci_dev is about to be deallocated,
 989          * so we can't use link->downstream again.  Free the link state to
 990          * avoid this.
 991          *
 992          * If we're removing a non-0 function, it's possible we could
 993          * retain the link state, but PCIe r6.0, sec 7.5.3.7, recommends
 994          * programming the same ASPM Control value for all functions of
 995          * multi-function devices, so disable ASPM for all of them.
 996          */
 997         pcie_config_aspm_link(link, 0);
 998         list_del(&link->sibling);
 999         free_link_state(link);
1000
1001         /* Recheck latencies and configure upstream links */
1002         if (parent_link) {
1003                 pcie_update_aspm_capable(root);
1004                 pcie_config_aspm_path(parent_link);
1005         }
1006
1007         mutex_unlock(&aspm_lock);
1008         up_read(&pci_bus_sem);
1009 }
1010
1011 void pcie_aspm_powersave_config_link(struct pci_dev *pdev)
1012 {
1013         struct pcie_link_state *link = pdev->link_state;
1014
1015         if (aspm_disabled || !link)
1016                 return;
1017
1018         if (aspm_policy != POLICY_POWERSAVE &&
1019             aspm_policy != POLICY_POWER_SUPERSAVE)
1020                 return;
1021
1022         down_read(&pci_bus_sem);
1023         mutex_lock(&aspm_lock);
1024         pcie_config_aspm_path(link);
1025         pcie_set_clkpm(link, policy_to_clkpm_state(link));
1026         mutex_unlock(&aspm_lock);
1027         up_read(&pci_bus_sem);
1028 }
1029
1030 static struct pcie_link_state *pcie_aspm_get_link(struct pci_dev *pdev)
1031 {
1032         struct pci_dev *bridge;
1033
1034         if (!pci_is_pcie(pdev))
1035                 return NULL;
1036
1037         bridge = pci_upstream_bridge(pdev);
1038         if (!bridge || !pci_is_pcie(bridge))
1039                 return NULL;
1040
1041         return bridge->link_state;
1042 }
1043
1044 static int __pci_disable_link_state(struct pci_dev *pdev, int state, bool sem)
1045 {
1046         struct pcie_link_state *link = pcie_aspm_get_link(pdev);
1047
1048         if (!link)
1049                 return -EINVAL;
1050         /*
1051          * A driver requested that ASPM be disabled on this device, but
1052          * if we don't have permission to manage ASPM (e.g., on ACPI
1053          * systems we have to observe the FADT ACPI_FADT_NO_ASPM bit and
1054          * the _OSC method), we can't honor that request.  Windows has
1055          * a similar mechanism using "PciASPMOptOut", which is also
1056          * ignored in this situation.
1057          */
1058         if (aspm_disabled) {
1059                 pci_warn(pdev, "can't disable ASPM; OS doesn't have ASPM control\n");
1060                 return -EPERM;
1061         }
1062
1063         if (sem)
1064                 down_read(&pci_bus_sem);
1065         mutex_lock(&aspm_lock);
1066         if (state & PCIE_LINK_STATE_L0S)
1067                 link->aspm_disable |= ASPM_STATE_L0S;
1068         if (state & PCIE_LINK_STATE_L1)
1069                 /* L1 PM substates require L1 */
1070                 link->aspm_disable |= ASPM_STATE_L1 | ASPM_STATE_L1SS;
1071         if (state & PCIE_LINK_STATE_L1_1)
1072                 link->aspm_disable |= ASPM_STATE_L1_1;
1073         if (state & PCIE_LINK_STATE_L1_2)
1074                 link->aspm_disable |= ASPM_STATE_L1_2;
1075         if (state & PCIE_LINK_STATE_L1_1_PCIPM)
1076                 link->aspm_disable |= ASPM_STATE_L1_1_PCIPM;
1077         if (state & PCIE_LINK_STATE_L1_2_PCIPM)
1078                 link->aspm_disable |= ASPM_STATE_L1_2_PCIPM;
1079         pcie_config_aspm_link(link, policy_to_aspm_state(link));
1080
1081         if (state & PCIE_LINK_STATE_CLKPM)
1082                 link->clkpm_disable = 1;
1083         pcie_set_clkpm(link, policy_to_clkpm_state(link));
1084         mutex_unlock(&aspm_lock);
1085         if (sem)
1086                 up_read(&pci_bus_sem);
1087
1088         return 0;
1089 }
1090
1091 int pci_disable_link_state_locked(struct pci_dev *pdev, int state)
1092 {
1093         return __pci_disable_link_state(pdev, state, false);
1094 }
1095 EXPORT_SYMBOL(pci_disable_link_state_locked);
1096
1097 /**
1098  * pci_disable_link_state - Disable device's link state, so the link will
1099  * never enter specific states.  Note that if the BIOS didn't grant ASPM
1100  * control to the OS, this does nothing because we can't touch the LNKCTL
1101  * register. Returns 0 or a negative errno.
1102  *
1103  * @pdev: PCI device
1104  * @state: ASPM link state to disable
1105  */
1106 int pci_disable_link_state(struct pci_dev *pdev, int state)
1107 {
1108         return __pci_disable_link_state(pdev, state, true);
1109 }
1110 EXPORT_SYMBOL(pci_disable_link_state);
1111
1112 /**
1113  * pci_enable_link_state - Clear and set the default device link state so that
1114  * the link may be allowed to enter the specified states. Note that if the
1115  * BIOS didn't grant ASPM control to the OS, this does nothing because we can't
1116  * touch the LNKCTL register. Also note that this does not enable states
1117  * disabled by pci_disable_link_state(). Return 0 or a negative errno.
1118  *
1119  * @pdev: PCI device
1120  * @state: Mask of ASPM link states to enable
1121  */
1122 int pci_enable_link_state(struct pci_dev *pdev, int state)
1123 {
1124         struct pcie_link_state *link = pcie_aspm_get_link(pdev);
1125
1126         if (!link)
1127                 return -EINVAL;
1128         /*
1129          * A driver requested that ASPM be enabled on this device, but
1130          * if we don't have permission to manage ASPM (e.g., on ACPI
1131          * systems we have to observe the FADT ACPI_FADT_NO_ASPM bit and
1132          * the _OSC method), we can't honor that request.
1133          */
1134         if (aspm_disabled) {
1135                 pci_warn(pdev, "can't override BIOS ASPM; OS doesn't have ASPM control\n");
1136                 return -EPERM;
1137         }
1138
1139         down_read(&pci_bus_sem);
1140         mutex_lock(&aspm_lock);
1141         link->aspm_default = 0;
1142         if (state & PCIE_LINK_STATE_L0S)
1143                 link->aspm_default |= ASPM_STATE_L0S;
1144         if (state & PCIE_LINK_STATE_L1)
1145                 link->aspm_default |= ASPM_STATE_L1;
1146         /* L1 PM substates require L1 */
1147         if (state & PCIE_LINK_STATE_L1_1)
1148                 link->aspm_default |= ASPM_STATE_L1_1 | ASPM_STATE_L1;
1149         if (state & PCIE_LINK_STATE_L1_2)
1150                 link->aspm_default |= ASPM_STATE_L1_2 | ASPM_STATE_L1;
1151         if (state & PCIE_LINK_STATE_L1_1_PCIPM)
1152                 link->aspm_default |= ASPM_STATE_L1_1_PCIPM | ASPM_STATE_L1;
1153         if (state & PCIE_LINK_STATE_L1_2_PCIPM)
1154                 link->aspm_default |= ASPM_STATE_L1_2_PCIPM | ASPM_STATE_L1;
1155         pcie_config_aspm_link(link, policy_to_aspm_state(link));
1156
1157         link->clkpm_default = (state & PCIE_LINK_STATE_CLKPM) ? 1 : 0;
1158         pcie_set_clkpm(link, policy_to_clkpm_state(link));
1159         mutex_unlock(&aspm_lock);
1160         up_read(&pci_bus_sem);
1161
1162         return 0;
1163 }
1164 EXPORT_SYMBOL(pci_enable_link_state);
1165
1166 static int pcie_aspm_set_policy(const char *val,
1167                                 const struct kernel_param *kp)
1168 {
1169         int i;
1170         struct pcie_link_state *link;
1171
1172         if (aspm_disabled)
1173                 return -EPERM;
1174         i = sysfs_match_string(policy_str, val);
1175         if (i < 0)
1176                 return i;
1177         if (i == aspm_policy)
1178                 return 0;
1179
1180         down_read(&pci_bus_sem);
1181         mutex_lock(&aspm_lock);
1182         aspm_policy = i;
1183         list_for_each_entry(link, &link_list, sibling) {
1184                 pcie_config_aspm_link(link, policy_to_aspm_state(link));
1185                 pcie_set_clkpm(link, policy_to_clkpm_state(link));
1186         }
1187         mutex_unlock(&aspm_lock);
1188         up_read(&pci_bus_sem);
1189         return 0;
1190 }
1191
1192 static int pcie_aspm_get_policy(char *buffer, const struct kernel_param *kp)
1193 {
1194         int i, cnt = 0;
1195         for (i = 0; i < ARRAY_SIZE(policy_str); i++)
1196                 if (i == aspm_policy)
1197                         cnt += sprintf(buffer + cnt, "[%s] ", policy_str[i]);
1198                 else
1199                         cnt += sprintf(buffer + cnt, "%s ", policy_str[i]);
1200         cnt += sprintf(buffer + cnt, "\n");
1201         return cnt;
1202 }
1203
1204 module_param_call(policy, pcie_aspm_set_policy, pcie_aspm_get_policy,
1205         NULL, 0644);
1206
1207 /**
1208  * pcie_aspm_enabled - Check if PCIe ASPM has been enabled for a device.
1209  * @pdev: Target device.
1210  *
1211  * Relies on the upstream bridge's link_state being valid.  The link_state
1212  * is deallocated only when the last child of the bridge (i.e., @pdev or a
1213  * sibling) is removed, and the caller should be holding a reference to
1214  * @pdev, so this should be safe.
1215  */
1216 bool pcie_aspm_enabled(struct pci_dev *pdev)
1217 {
1218         struct pcie_link_state *link = pcie_aspm_get_link(pdev);
1219
1220         if (!link)
1221                 return false;
1222
1223         return link->aspm_enabled;
1224 }
1225 EXPORT_SYMBOL_GPL(pcie_aspm_enabled);
1226
1227 static ssize_t aspm_attr_show_common(struct device *dev,
1228                                      struct device_attribute *attr,
1229                                      char *buf, u8 state)
1230 {
1231         struct pci_dev *pdev = to_pci_dev(dev);
1232         struct pcie_link_state *link = pcie_aspm_get_link(pdev);
1233
1234         return sysfs_emit(buf, "%d\n", (link->aspm_enabled & state) ? 1 : 0);
1235 }
1236
1237 static ssize_t aspm_attr_store_common(struct device *dev,
1238                                       struct device_attribute *attr,
1239                                       const char *buf, size_t len, u8 state)
1240 {
1241         struct pci_dev *pdev = to_pci_dev(dev);
1242         struct pcie_link_state *link = pcie_aspm_get_link(pdev);
1243         bool state_enable;
1244
1245         if (kstrtobool(buf, &state_enable) < 0)
1246                 return -EINVAL;
1247
1248         down_read(&pci_bus_sem);
1249         mutex_lock(&aspm_lock);
1250
1251         if (state_enable) {
1252                 link->aspm_disable &= ~state;
1253                 /* need to enable L1 for substates */
1254                 if (state & ASPM_STATE_L1SS)
1255                         link->aspm_disable &= ~ASPM_STATE_L1;
1256         } else {
1257                 link->aspm_disable |= state;
1258         }
1259
1260         pcie_config_aspm_link(link, policy_to_aspm_state(link));
1261
1262         mutex_unlock(&aspm_lock);
1263         up_read(&pci_bus_sem);
1264
1265         return len;
1266 }
1267
1268 #define ASPM_ATTR(_f, _s)                                               \
1269 static ssize_t _f##_show(struct device *dev,                            \
1270                          struct device_attribute *attr, char *buf)      \
1271 { return aspm_attr_show_common(dev, attr, buf, ASPM_STATE_##_s); }      \
1272                                                                         \
1273 static ssize_t _f##_store(struct device *dev,                           \
1274                           struct device_attribute *attr,                \
1275                           const char *buf, size_t len)                  \
1276 { return aspm_attr_store_common(dev, attr, buf, len, ASPM_STATE_##_s); }
1277
1278 ASPM_ATTR(l0s_aspm, L0S)
1279 ASPM_ATTR(l1_aspm, L1)
1280 ASPM_ATTR(l1_1_aspm, L1_1)
1281 ASPM_ATTR(l1_2_aspm, L1_2)
1282 ASPM_ATTR(l1_1_pcipm, L1_1_PCIPM)
1283 ASPM_ATTR(l1_2_pcipm, L1_2_PCIPM)
1284
1285 static ssize_t clkpm_show(struct device *dev,
1286                           struct device_attribute *attr, char *buf)
1287 {
1288         struct pci_dev *pdev = to_pci_dev(dev);
1289         struct pcie_link_state *link = pcie_aspm_get_link(pdev);
1290
1291         return sysfs_emit(buf, "%d\n", link->clkpm_enabled);
1292 }
1293
1294 static ssize_t clkpm_store(struct device *dev,
1295                            struct device_attribute *attr,
1296                            const char *buf, size_t len)
1297 {
1298         struct pci_dev *pdev = to_pci_dev(dev);
1299         struct pcie_link_state *link = pcie_aspm_get_link(pdev);
1300         bool state_enable;
1301
1302         if (kstrtobool(buf, &state_enable) < 0)
1303                 return -EINVAL;
1304
1305         down_read(&pci_bus_sem);
1306         mutex_lock(&aspm_lock);
1307
1308         link->clkpm_disable = !state_enable;
1309         pcie_set_clkpm(link, policy_to_clkpm_state(link));
1310
1311         mutex_unlock(&aspm_lock);
1312         up_read(&pci_bus_sem);
1313
1314         return len;
1315 }
1316
1317 static DEVICE_ATTR_RW(clkpm);
1318 static DEVICE_ATTR_RW(l0s_aspm);
1319 static DEVICE_ATTR_RW(l1_aspm);
1320 static DEVICE_ATTR_RW(l1_1_aspm);
1321 static DEVICE_ATTR_RW(l1_2_aspm);
1322 static DEVICE_ATTR_RW(l1_1_pcipm);
1323 static DEVICE_ATTR_RW(l1_2_pcipm);
1324
1325 static struct attribute *aspm_ctrl_attrs[] = {
1326         &dev_attr_clkpm.attr,
1327         &dev_attr_l0s_aspm.attr,
1328         &dev_attr_l1_aspm.attr,
1329         &dev_attr_l1_1_aspm.attr,
1330         &dev_attr_l1_2_aspm.attr,
1331         &dev_attr_l1_1_pcipm.attr,
1332         &dev_attr_l1_2_pcipm.attr,
1333         NULL
1334 };
1335
1336 static umode_t aspm_ctrl_attrs_are_visible(struct kobject *kobj,
1337                                            struct attribute *a, int n)
1338 {
1339         struct device *dev = kobj_to_dev(kobj);
1340         struct pci_dev *pdev = to_pci_dev(dev);
1341         struct pcie_link_state *link = pcie_aspm_get_link(pdev);
1342         static const u8 aspm_state_map[] = {
1343                 ASPM_STATE_L0S,
1344                 ASPM_STATE_L1,
1345                 ASPM_STATE_L1_1,
1346                 ASPM_STATE_L1_2,
1347                 ASPM_STATE_L1_1_PCIPM,
1348                 ASPM_STATE_L1_2_PCIPM,
1349         };
1350
1351         if (aspm_disabled || !link)
1352                 return 0;
1353
1354         if (n == 0)
1355                 return link->clkpm_capable ? a->mode : 0;
1356
1357         return link->aspm_capable & aspm_state_map[n - 1] ? a->mode : 0;
1358 }
1359
1360 const struct attribute_group aspm_ctrl_attr_group = {
1361         .name = "link",
1362         .attrs = aspm_ctrl_attrs,
1363         .is_visible = aspm_ctrl_attrs_are_visible,
1364 };
1365
1366 static int __init pcie_aspm_disable(char *str)
1367 {
1368         if (!strcmp(str, "off")) {
1369                 aspm_policy = POLICY_DEFAULT;
1370                 aspm_disabled = 1;
1371                 aspm_support_enabled = false;
1372                 pr_info("PCIe ASPM is disabled\n");
1373         } else if (!strcmp(str, "force")) {
1374                 aspm_force = 1;
1375                 pr_info("PCIe ASPM is forcibly enabled\n");
1376         }
1377         return 1;
1378 }
1379
1380 __setup("pcie_aspm=", pcie_aspm_disable);
1381
1382 void pcie_no_aspm(void)
1383 {
1384         /*
1385          * Disabling ASPM is intended to prevent the kernel from modifying
1386          * existing hardware state, not to clear existing state. To that end:
1387          * (a) set policy to POLICY_DEFAULT in order to avoid changing state
1388          * (b) prevent userspace from changing policy
1389          */
1390         if (!aspm_force) {
1391                 aspm_policy = POLICY_DEFAULT;
1392                 aspm_disabled = 1;
1393         }
1394 }
1395
1396 bool pcie_aspm_support_enabled(void)
1397 {
1398         return aspm_support_enabled;
1399 }