| Message ID | a0a39450-1f23-f5a0-d669-3d722e5b71dd@gmail.com |
|---|---|
| State | Superseded |
| Delegated to: | Bjorn Helgaas |
| Headers | show |
| Series | PCI/ASPM: add sysfs attribute for controlling ASPM | expand |
On Sat, Apr 13, 2019 at 11:12:41AM +0200, Heiner Kallweit wrote: > Background of this extension is a problem with the r8169 network driver. > Several combinations of board chipsets and network chip versions have > problems if ASPM is enabled, therefore we have to disable ASPM per > default. However especially on notebooks ASPM can provide significant > power-saving, therefore we want to give users the option to enable > ASPM. With the new sysfs attribute users can control which ASPM > link-states are disabled. > +void pcie_aspm_create_sysfs_dev_files(struct pci_dev *pdev); > +void pcie_aspm_remove_sysfs_dev_files(struct pci_dev *pdev); > #else > static inline void pcie_aspm_init_link_state(struct pci_dev *pdev) { } > static inline void pcie_aspm_exit_link_state(struct pci_dev *pdev) { } > static inline void pcie_aspm_pm_state_change(struct pci_dev *pdev) { } > static inline void pcie_aspm_powersave_config_link(struct pci_dev *pdev) { } > -#endif > - > -#ifdef CONFIG_PCIEASPM_DEBUG > -void pcie_aspm_create_sysfs_dev_files(struct pci_dev *pdev); > -void pcie_aspm_remove_sysfs_dev_files(struct pci_dev *pdev); > -#else I like the idea of exposing these sysfs control files all the time, instead of only when CONFIG_PCIEASPM_DEBUG=y, but I think when we do that, we should put the files at the downstream end of the link (e.g., an endpoint) instead of at the upstream end (e.g., a root port or switch downstream port). We had some conversation about this here: https://lore.kernel.org/lkml/20180727202619.GD173328@bhelgaas-glaptop.roam.corp.google.com Doing it at the downstream end would require more changes, of course, and probably raises some locking issues, but I think we have a small window of opportunity here where we can tweak the sysfs structure before we're committed to supporting something forever. Bjorn
On 30.04.2019 19:53, Bjorn Helgaas wrote: > On Sat, Apr 13, 2019 at 11:12:41AM +0200, Heiner Kallweit wrote: >> Background of this extension is a problem with the r8169 network driver. >> Several combinations of board chipsets and network chip versions have >> problems if ASPM is enabled, therefore we have to disable ASPM per >> default. However especially on notebooks ASPM can provide significant >> power-saving, therefore we want to give users the option to enable >> ASPM. With the new sysfs attribute users can control which ASPM >> link-states are disabled. > >> +void pcie_aspm_create_sysfs_dev_files(struct pci_dev *pdev); >> +void pcie_aspm_remove_sysfs_dev_files(struct pci_dev *pdev); >> #else >> static inline void pcie_aspm_init_link_state(struct pci_dev *pdev) { } >> static inline void pcie_aspm_exit_link_state(struct pci_dev *pdev) { } >> static inline void pcie_aspm_pm_state_change(struct pci_dev *pdev) { } >> static inline void pcie_aspm_powersave_config_link(struct pci_dev *pdev) { } >> -#endif >> - >> -#ifdef CONFIG_PCIEASPM_DEBUG >> -void pcie_aspm_create_sysfs_dev_files(struct pci_dev *pdev); >> -void pcie_aspm_remove_sysfs_dev_files(struct pci_dev *pdev); >> -#else > > I like the idea of exposing these sysfs control files all the time, > instead of only when CONFIG_PCIEASPM_DEBUG=y, but I think when we do > that, we should put the files at the downstream end of the link (e.g., > an endpoint) instead of at the upstream end (e.g., a root port or > switch downstream port). We had some conversation about this here: > > https://lore.kernel.org/lkml/20180727202619.GD173328@bhelgaas-glaptop.roam.corp.google.com > > Doing it at the downstream end would require more changes, of course, > and probably raises some locking issues, but I think we have a small > window of opportunity here where we can tweak the sysfs structure > before we're committed to supporting something forever. > Thanks for the feedback. I'll check the mentioned conversation and try to get the control moved to the endpoint. > Bjorn > Heiner
On 30.04.2019 19:53, Bjorn Helgaas wrote: > On Sat, Apr 13, 2019 at 11:12:41AM +0200, Heiner Kallweit wrote: >> Background of this extension is a problem with the r8169 network driver. >> Several combinations of board chipsets and network chip versions have >> problems if ASPM is enabled, therefore we have to disable ASPM per >> default. However especially on notebooks ASPM can provide significant >> power-saving, therefore we want to give users the option to enable >> ASPM. With the new sysfs attribute users can control which ASPM >> link-states are disabled. > >> +void pcie_aspm_create_sysfs_dev_files(struct pci_dev *pdev); >> +void pcie_aspm_remove_sysfs_dev_files(struct pci_dev *pdev); >> #else >> static inline void pcie_aspm_init_link_state(struct pci_dev *pdev) { } >> static inline void pcie_aspm_exit_link_state(struct pci_dev *pdev) { } >> static inline void pcie_aspm_pm_state_change(struct pci_dev *pdev) { } >> static inline void pcie_aspm_powersave_config_link(struct pci_dev *pdev) { } >> -#endif >> - >> -#ifdef CONFIG_PCIEASPM_DEBUG >> -void pcie_aspm_create_sysfs_dev_files(struct pci_dev *pdev); >> -void pcie_aspm_remove_sysfs_dev_files(struct pci_dev *pdev); >> -#else > > I like the idea of exposing these sysfs control files all the time, > instead of only when CONFIG_PCIEASPM_DEBUG=y, but I think when we do > that, we should put the files at the downstream end of the link (e.g., > an endpoint) instead of at the upstream end (e.g., a root port or > switch downstream port). We had some conversation about this here: > > https://lore.kernel.org/lkml/20180727202619.GD173328@bhelgaas-glaptop.roam.corp.google.com > > Doing it at the downstream end would require more changes, of course, > and probably raises some locking issues, but I think we have a small This isn't obvious to me as I'm not that familiar with the PCIe subsystem. - Why do we need more changes on the downstream end? - Which locking is affected? > window of opportunity here where we can tweak the sysfs structure > before we're committed to supporting something forever. > > Bjorn > Heiner
On 30.04.2019 19:53, Bjorn Helgaas wrote: > On Sat, Apr 13, 2019 at 11:12:41AM +0200, Heiner Kallweit wrote: >> Background of this extension is a problem with the r8169 network driver. >> Several combinations of board chipsets and network chip versions have >> problems if ASPM is enabled, therefore we have to disable ASPM per >> default. However especially on notebooks ASPM can provide significant >> power-saving, therefore we want to give users the option to enable >> ASPM. With the new sysfs attribute users can control which ASPM >> link-states are disabled. > >> +void pcie_aspm_create_sysfs_dev_files(struct pci_dev *pdev); >> +void pcie_aspm_remove_sysfs_dev_files(struct pci_dev *pdev); >> #else >> static inline void pcie_aspm_init_link_state(struct pci_dev *pdev) { } >> static inline void pcie_aspm_exit_link_state(struct pci_dev *pdev) { } >> static inline void pcie_aspm_pm_state_change(struct pci_dev *pdev) { } >> static inline void pcie_aspm_powersave_config_link(struct pci_dev *pdev) { } >> -#endif >> - >> -#ifdef CONFIG_PCIEASPM_DEBUG >> -void pcie_aspm_create_sysfs_dev_files(struct pci_dev *pdev); >> -void pcie_aspm_remove_sysfs_dev_files(struct pci_dev *pdev); >> -#else > > I like the idea of exposing these sysfs control files all the time, > instead of only when CONFIG_PCIEASPM_DEBUG=y, but I think when we do > that, we should put the files at the downstream end of the link (e.g., > an endpoint) instead of at the upstream end (e.g., a root port or > switch downstream port). We had some conversation about this here: > > https://lore.kernel.org/lkml/20180727202619.GD173328@bhelgaas-glaptop.roam.corp.google.com > > Doing it at the downstream end would require more changes, of course, > and probably raises some locking issues, but I think we have a small > window of opportunity here where we can tweak the sysfs structure > before we're committed to supporting something forever. > > Bjorn > Here comes an updated version of patch 3. Unfortunately my test systems don't allow OS ASPM control. At least the sysfs files are created for the right devices (endpoints), and the attribute can be properly controlled. --- drivers/pci/pci.h | 8 +- drivers/pci/pcie/aspm.c | 171 +++++++++++++++++++++++++++++++++++++++- 2 files changed, 171 insertions(+), 8 deletions(-) diff --git a/drivers/pci/pci.h b/drivers/pci/pci.h index 9cb99380c..06642b7de 100644 --- a/drivers/pci/pci.h +++ b/drivers/pci/pci.h @@ -499,17 +499,13 @@ void pcie_aspm_init_link_state(struct pci_dev *pdev); void pcie_aspm_exit_link_state(struct pci_dev *pdev); void pcie_aspm_pm_state_change(struct pci_dev *pdev); void pcie_aspm_powersave_config_link(struct pci_dev *pdev); +void pcie_aspm_create_sysfs_dev_files(struct pci_dev *pdev); +void pcie_aspm_remove_sysfs_dev_files(struct pci_dev *pdev); #else static inline void pcie_aspm_init_link_state(struct pci_dev *pdev) { } static inline void pcie_aspm_exit_link_state(struct pci_dev *pdev) { } static inline void pcie_aspm_pm_state_change(struct pci_dev *pdev) { } static inline void pcie_aspm_powersave_config_link(struct pci_dev *pdev) { } -#endif - -#ifdef CONFIG_PCIEASPM_DEBUG -void pcie_aspm_create_sysfs_dev_files(struct pci_dev *pdev); -void pcie_aspm_remove_sysfs_dev_files(struct pci_dev *pdev); -#else static inline void pcie_aspm_create_sysfs_dev_files(struct pci_dev *pdev) { } static inline void pcie_aspm_remove_sysfs_dev_files(struct pci_dev *pdev) { } #endif diff --git a/drivers/pci/pcie/aspm.c b/drivers/pci/pcie/aspm.c index 7847be38e..f73539e5b 100644 --- a/drivers/pci/pcie/aspm.c +++ b/drivers/pci/pcie/aspm.c @@ -42,6 +42,8 @@ #define ASPM_STATE_ALL (ASPM_STATE_L0S | ASPM_STATE_L1 | \ ASPM_STATE_L1SS) +static const char power_group[] = "power"; + struct aspm_latency { u32 l0s; /* L0s latency (nsec) */ u32 l1; /* L1 latency (nsec) */ @@ -1251,38 +1253,203 @@ static ssize_t clk_ctl_store(struct device *dev, static DEVICE_ATTR_RW(link_state); static DEVICE_ATTR_RW(clk_ctl); +#endif + +struct aspm_sysfs_state { + const char *name; + int disable_mask; +}; + +static const struct aspm_sysfs_state aspm_sysfs_states[] = { + { "L0S", ASPM_STATE_L0S }, + { "L1", ASPM_STATE_L1 }, + { "L1.1", ASPM_STATE_L1_1_MASK }, + { "L1.2", ASPM_STATE_L1_2_MASK }, +}; + +static struct pcie_link_state *aspm_get_parent_link(struct pci_dev *pdev) +{ + struct pci_dev *parent = pdev->bus->self; + + if (pdev->has_secondary_link) + parent = pdev; + + return parent ? parent->link_state : NULL; +} + +static ssize_t aspm_disable_link_state_show(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct pci_dev *pdev = to_pci_dev(dev); + struct pcie_link_state *link; + int len = 0, i; + + link = aspm_get_parent_link(pdev); + if (!link) + return -EOPNOTSUPP; + + mutex_lock(&aspm_lock); + + for (i = 0; i < ARRAY_SIZE(aspm_sysfs_states); i++) { + const struct aspm_sysfs_state *st = aspm_sysfs_states + i; + + if (link->aspm_disable & st->disable_mask) + len += scnprintf(buf + len, PAGE_SIZE - len, "[%s] ", + st->name); + else + len += scnprintf(buf + len, PAGE_SIZE - len, "%s ", + st->name); + } + + if (link->clkpm_disable) + len += scnprintf(buf + len, PAGE_SIZE - len, "[CLKPM] "); + else + len += scnprintf(buf + len, PAGE_SIZE - len, "CLKPM "); + + mutex_unlock(&aspm_lock); + + len += scnprintf(buf + len, PAGE_SIZE - len, "\n"); + + return len; +} + +static ssize_t aspm_disable_link_state_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t len) +{ + struct pci_dev *pdev = to_pci_dev(dev); + struct pcie_link_state *link; + char *buftmp = (char *)buf, *tok; + unsigned int disable_aspm, disable_clkpm; + bool first = true, add; + int err = 0, i; + + if (aspm_disabled) + return -EPERM; + + link = aspm_get_parent_link(pdev); + if (!link) + return -EOPNOTSUPP; + + down_read(&pci_bus_sem); + mutex_lock(&aspm_lock); + + disable_aspm = link->aspm_disable; + disable_clkpm = link->clkpm_disable; + + while ((tok = strsep(&buftmp, " \n")) != NULL) { + bool found = false; + + if (!*tok) + continue; + + if (first) { + if (!strcasecmp(tok, "none")) { + disable_aspm = 0; + disable_clkpm = 0; + break; + } + if (!strcasecmp(tok, "all")) { + disable_aspm = ASPM_STATE_ALL; + disable_clkpm = 1; + break; + } + first = false; + } + + if (*tok != '+' && *tok != '-') { + err = -EINVAL; + goto out; + } + + add = *tok++ == '+'; + + for (i = 0; i < ARRAY_SIZE(aspm_sysfs_states); i++) { + const struct aspm_sysfs_state *st = + aspm_sysfs_states + i; + + if (!strcasecmp(tok, st->name)) { + if (add) + disable_aspm |= st->disable_mask; + else + disable_aspm &= ~st->disable_mask; + found = true; + break; + } + } + + if (!found && !strcasecmp(tok, "clkpm")) { + disable_clkpm = add ? 1 : 0; + found = true; + } + + if (!found) { + err = -EINVAL; + goto out; + } + } + + if (disable_aspm & ASPM_STATE_L1) + disable_aspm |= ASPM_STATE_L1SS; + + link->aspm_disable = disable_aspm; + link->clkpm_disable = disable_clkpm; + + pcie_config_aspm_link(link, policy_to_aspm_state(link)); + pcie_set_clkpm(link, policy_to_clkpm_state(link)); +out: + mutex_unlock(&aspm_lock); + up_read(&pci_bus_sem); + + return err ?: len; +} + +static DEVICE_ATTR_RW(aspm_disable_link_state); -static char power_group[] = "power"; void pcie_aspm_create_sysfs_dev_files(struct pci_dev *pdev) { struct pcie_link_state *link_state = pdev->link_state; + if (pci_pcie_type(pdev) == PCI_EXP_TYPE_ENDPOINT && + aspm_get_parent_link(pdev)) + sysfs_add_file_to_group(&pdev->dev.kobj, + &dev_attr_aspm_disable_link_state.attr, power_group); + if (!link_state) return; +#ifdef CONFIG_PCIEASPM_DEBUG if (link_state->aspm_support) sysfs_add_file_to_group(&pdev->dev.kobj, &dev_attr_link_state.attr, power_group); if (link_state->clkpm_capable) sysfs_add_file_to_group(&pdev->dev.kobj, &dev_attr_clk_ctl.attr, power_group); +#endif } void pcie_aspm_remove_sysfs_dev_files(struct pci_dev *pdev) { struct pcie_link_state *link_state = pdev->link_state; + if (pci_pcie_type(pdev) == PCI_EXP_TYPE_ENDPOINT && + aspm_get_parent_link(pdev)) + sysfs_remove_file_from_group(&pdev->dev.kobj, + &dev_attr_aspm_disable_link_state.attr, power_group); + if (!link_state) return; +#ifdef CONFIG_PCIEASPM_DEBUG if (link_state->aspm_support) sysfs_remove_file_from_group(&pdev->dev.kobj, &dev_attr_link_state.attr, power_group); if (link_state->clkpm_capable) sysfs_remove_file_from_group(&pdev->dev.kobj, &dev_attr_clk_ctl.attr, power_group); -} #endif +} static int __init pcie_aspm_disable(char *str) {
On Sat, May 04, 2019 at 05:31:04PM +0200, Heiner Kallweit wrote: > On 30.04.2019 19:53, Bjorn Helgaas wrote: > > On Sat, Apr 13, 2019 at 11:12:41AM +0200, Heiner Kallweit wrote: > > I like the idea of exposing these sysfs control files all the time, > > instead of only when CONFIG_PCIEASPM_DEBUG=y, but I think when we do > > that, we should put the files at the downstream end of the link (e.g., > > an endpoint) instead of at the upstream end (e.g., a root port or > > switch downstream port). We had some conversation about this here: > > > > https://lore.kernel.org/lkml/20180727202619.GD173328@bhelgaas-glaptop.roam.corp.google.com > > > > Doing it at the downstream end would require more changes, of course, > > and probably raises some locking issues, but I think we have a small > > This isn't obvious to me as I'm not that familiar with the PCIe subsystem. > - Why do we need more changes on the downstream end? I just meant that it might be a little more complicated because the existing PCIEASPM_DEBUG code works at the upstream end so you can't use it directly. > - Which locking is affected? Normally if we operate on device X, we only touch registers in device X. Here we need to also touch things in the bridge upstream from X, so it's outside the usual model. We've had locking issues in the device enable path where we sometimes have to enable the upstream bridge before enabling the device itself. I don't know if there are similar issues here or not, so I mentioned it as a possibility. > > window of opportunity here where we can tweak the sysfs structure > > before we're committed to supporting something forever. > > > > Bjorn > > > Heiner
diff --git a/drivers/pci/pci.h b/drivers/pci/pci.h index d994839a3..6d4e5fc24 100644 --- a/drivers/pci/pci.h +++ b/drivers/pci/pci.h @@ -499,17 +499,13 @@ void pcie_aspm_init_link_state(struct pci_dev *pdev); void pcie_aspm_exit_link_state(struct pci_dev *pdev); void pcie_aspm_pm_state_change(struct pci_dev *pdev); void pcie_aspm_powersave_config_link(struct pci_dev *pdev); +void pcie_aspm_create_sysfs_dev_files(struct pci_dev *pdev); +void pcie_aspm_remove_sysfs_dev_files(struct pci_dev *pdev); #else static inline void pcie_aspm_init_link_state(struct pci_dev *pdev) { } static inline void pcie_aspm_exit_link_state(struct pci_dev *pdev) { } static inline void pcie_aspm_pm_state_change(struct pci_dev *pdev) { } static inline void pcie_aspm_powersave_config_link(struct pci_dev *pdev) { } -#endif - -#ifdef CONFIG_PCIEASPM_DEBUG -void pcie_aspm_create_sysfs_dev_files(struct pci_dev *pdev); -void pcie_aspm_remove_sysfs_dev_files(struct pci_dev *pdev); -#else static inline void pcie_aspm_create_sysfs_dev_files(struct pci_dev *pdev) { } static inline void pcie_aspm_remove_sysfs_dev_files(struct pci_dev *pdev) { } #endif diff --git a/drivers/pci/pcie/aspm.c b/drivers/pci/pcie/aspm.c index 7847be38e..bfbfd9134 100644 --- a/drivers/pci/pcie/aspm.c +++ b/drivers/pci/pcie/aspm.c @@ -42,6 +42,8 @@ #define ASPM_STATE_ALL (ASPM_STATE_L0S | ASPM_STATE_L1 | \ ASPM_STATE_L1SS) +static const char power_group[] = "power"; + struct aspm_latency { u32 l0s; /* L0s latency (nsec) */ u32 l1; /* L1 latency (nsec) */ @@ -1251,8 +1253,164 @@ static ssize_t clk_ctl_store(struct device *dev, static DEVICE_ATTR_RW(link_state); static DEVICE_ATTR_RW(clk_ctl); +#endif + +struct aspm_sysfs_state { + const char *name; + int disable_mask; +}; + +static const struct aspm_sysfs_state aspm_sysfs_states[] = { + { "L0S", ASPM_STATE_L0S }, + { "L1", ASPM_STATE_L1 }, + { "L1.1", ASPM_STATE_L1_1_MASK }, + { "L1.2", ASPM_STATE_L1_2_MASK }, +}; + +static struct pci_dev *aspm_get_parent(struct pci_dev *pdev) +{ + struct pci_dev *parent = pdev->bus->self; + + if (pdev->has_secondary_link) + parent = pdev; + + return parent && parent->link_state ? parent : NULL; +} + +static ssize_t aspm_disable_link_state_show(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct pci_dev *parent, *pdev = to_pci_dev(dev); + struct pcie_link_state *link; + int len = 0, i; + + parent = aspm_get_parent(pdev); + if (!parent) + return -EOPNOTSUPP; + + link = parent->link_state; + + mutex_lock(&aspm_lock); + + for (i = 0; i < ARRAY_SIZE(aspm_sysfs_states); i++) { + const struct aspm_sysfs_state *st = aspm_sysfs_states + i; + + if (link->aspm_disable & st->disable_mask) + len += scnprintf(buf + len, PAGE_SIZE - len, "[%s] ", + st->name); + else + len += scnprintf(buf + len, PAGE_SIZE - len, "%s ", + st->name); + } + + if (link->clkpm_disable) + len += scnprintf(buf + len, PAGE_SIZE - len, "[CLKPM] "); + else + len += scnprintf(buf + len, PAGE_SIZE - len, "CLKPM "); + + mutex_unlock(&aspm_lock); + + len += scnprintf(buf + len, PAGE_SIZE - len, "\n"); + + return len; +} + +static ssize_t aspm_disable_link_state_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t len) +{ + struct pci_dev *parent, *pdev = to_pci_dev(dev); + struct pcie_link_state *link; + char *buftmp = (char *)buf, *tok; + unsigned int disable_aspm, disable_clkpm; + bool first = true, add; + int err = 0, i; + + if (aspm_disabled) + return -EPERM; + + parent = aspm_get_parent(pdev); + if (!parent) + return -EOPNOTSUPP; + + link = parent->link_state; + + down_read(&pci_bus_sem); + mutex_lock(&aspm_lock); + + disable_aspm = link->aspm_disable; + disable_clkpm = link->clkpm_disable; + + while ((tok = strsep(&buftmp, " \n")) != NULL) { + bool found = false; + + if (!*tok) + continue; + + if (first) { + if (!strcasecmp(tok, "none")) { + disable_aspm = 0; + disable_clkpm = 0; + break; + } + if (!strcasecmp(tok, "all")) { + disable_aspm = ASPM_STATE_ALL; + disable_clkpm = 1; + break; + } + first = false; + } + + if (*tok != '+' && *tok != '-') { + err = -EINVAL; + goto out; + } + + add = *tok++ == '+'; + + for (i = 0; i < ARRAY_SIZE(aspm_sysfs_states); i++) { + const struct aspm_sysfs_state *st = + aspm_sysfs_states + i; + + if (!strcasecmp(tok, st->name)) { + if (add) + disable_aspm |= st->disable_mask; + else + disable_aspm &= ~st->disable_mask; + found = true; + break; + } + } + + if (!found && !strcasecmp(tok, "clkpm")) { + disable_clkpm = add ? 1 : 0; + found = true; + } + + if (!found) { + err = -EINVAL; + goto out; + } + } + + if (disable_aspm & ASPM_STATE_L1) + disable_aspm |= ASPM_STATE_L1SS; + + link->aspm_disable = disable_aspm; + link->clkpm_disable = disable_clkpm; + + pcie_config_aspm_link(link, policy_to_aspm_state(link)); + pcie_set_clkpm(link, policy_to_clkpm_state(link)); +out: + mutex_unlock(&aspm_lock); + up_read(&pci_bus_sem); + + return err ?: len; +} + +static DEVICE_ATTR_RW(aspm_disable_link_state); -static char power_group[] = "power"; void pcie_aspm_create_sysfs_dev_files(struct pci_dev *pdev) { struct pcie_link_state *link_state = pdev->link_state; @@ -1260,12 +1418,18 @@ void pcie_aspm_create_sysfs_dev_files(struct pci_dev *pdev) if (!link_state) return; + if (link_state->aspm_support) + sysfs_add_file_to_group(&pdev->dev.kobj, + &dev_attr_aspm_disable_link_state.attr, power_group); + +#ifdef CONFIG_PCIEASPM_DEBUG if (link_state->aspm_support) sysfs_add_file_to_group(&pdev->dev.kobj, &dev_attr_link_state.attr, power_group); if (link_state->clkpm_capable) sysfs_add_file_to_group(&pdev->dev.kobj, &dev_attr_clk_ctl.attr, power_group); +#endif } void pcie_aspm_remove_sysfs_dev_files(struct pci_dev *pdev) @@ -1275,14 +1439,19 @@ void pcie_aspm_remove_sysfs_dev_files(struct pci_dev *pdev) if (!link_state) return; + if (link_state->aspm_support) + sysfs_remove_file_from_group(&pdev->dev.kobj, + &dev_attr_aspm_disable_link_state.attr, power_group); + +#ifdef CONFIG_PCIEASPM_DEBUG if (link_state->aspm_support) sysfs_remove_file_from_group(&pdev->dev.kobj, &dev_attr_link_state.attr, power_group); if (link_state->clkpm_capable) sysfs_remove_file_from_group(&pdev->dev.kobj, &dev_attr_clk_ctl.attr, power_group); -} #endif +} static int __init pcie_aspm_disable(char *str) {
Background of this extension is a problem with the r8169 network driver. Several combinations of board chipsets and network chip versions have problems if ASPM is enabled, therefore we have to disable ASPM per default. However especially on notebooks ASPM can provide significant power-saving, therefore we want to give users the option to enable ASPM. With the new sysfs attribute users can control which ASPM link-states are disabled. This is a first RFC version, therefore documentation of attribute is still missing. The attribute handling was inspired by the protocol attribute handling in drivers/media/rc/rc-main.c. Attribute syntax in a few words: none: allow all supported ASPM states all: disable all ASPM states +<state>: add state to list of disabled ASPM states -<state>: re-enable ASPM state if supported Signed-off-by: Heiner Kallweit <hkallweit1@gmail.com> --- drivers/pci/pci.h | 8 +- drivers/pci/pcie/aspm.c | 173 +++++++++++++++++++++++++++++++++++++++- 2 files changed, 173 insertions(+), 8 deletions(-)