niansa-misc/linux
1
0
Fork 0
mirror of synced 2025-03-06 20:59:54 +01:00
Code Issues Projects Releases Packages Wiki Activity

PCI/PM: Avoid using device_may_wakeup() for runtime PM

Browse source 
pci_target_state() calls device_may_wakeup() which checks whether or not
the device may wake up the system from sleep states, but pci_target_state()
is used for runtime PM too.

Since runtime PM is expected to always enable remote wakeup if possible,
modify pci_target_state() to take additional argument indicating whether or
not it should look for a state from which the device can signal wakeup and
pass either the return value of device_can_wakeup(), or "false" (if the
device itself is not wakeup-capable) to it from the code related to runtime
PM.

While at it, fix the comment in pci_dev_run_wake() which is not about sleep
states.

Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
Signed-off-by: Bjorn Helgaas <bhelgaas@google.com>
Reviewed-by: Mika Westerberg <mika.westerberg@linux.intel.com>
This commit is contained in:
Rafael J. Wysocki 2017-06-23 14:58:11 +02:00 • committed by Bjorn Helgaas
parent 0bf3730bbc
commit 666ff6f83e
1 changed files with 13 additions and 9 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

22
drivers/pci/pci.c
View file

@ -1960,12 +1960,13 @@ EXPORT_SYMBOL(pci_wake_from_d3);
/** /**
* pci_target_state - find an appropriate low power state for a given PCI dev * pci_target_state - find an appropriate low power state for a given PCI dev
* @dev: PCI device * @dev: PCI device
* @wakeup: Whether or not wakeup functionality will be enabled for the device.
* *
* Use underlying platform code to find a supported low power state for @dev. * Use underlying platform code to find a supported low power state for @dev.
* If the platform can't manage @dev, return the deepest state from which it * If the platform can't manage @dev, return the deepest state from which it
* can generate wake events, based on any available PME info. * can generate wake events, based on any available PME info.
*/ */
static pci_power_t pci_target_state(struct pci_dev *dev) static pci_power_t pci_target_state(struct pci_dev *dev, bool wakeup)
{ {
pci_power_t target_state = PCI_D3hot; pci_power_t target_state = PCI_D3hot;
@ -2002,7 +2003,7 @@ static pci_power_t pci_target_state(struct pci_dev *dev)
if (dev->current_state == PCI_D3cold) if (dev->current_state == PCI_D3cold)
target_state = PCI_D3cold; target_state = PCI_D3cold;
if (device_may_wakeup(&dev->dev)) { if (wakeup) {
/* /*
* Find the deepest state from which the device can generate * Find the deepest state from which the device can generate
* wake-up events, make it the target state and enable device * wake-up events, make it the target state and enable device
@ -2028,13 +2029,14 @@ static pci_power_t pci_target_state(struct pci_dev *dev)
*/ */
int pci_prepare_to_sleep(struct pci_dev *dev) int pci_prepare_to_sleep(struct pci_dev *dev)
{ {
pci_power_t target_state = pci_target_state(dev); bool wakeup = device_may_wakeup(&dev->dev);
pci_power_t target_state = pci_target_state(dev, wakeup);
int error; int error;
if (target_state == PCI_POWER_ERROR) if (target_state == PCI_POWER_ERROR)
return -EIO; return -EIO;
pci_enable_wake(dev, target_state, device_may_wakeup(&dev->dev)); pci_enable_wake(dev, target_state, wakeup);
error = pci_set_power_state(dev, target_state); error = pci_set_power_state(dev, target_state);
@ -2067,9 +2069,10 @@ EXPORT_SYMBOL(pci_back_from_sleep);
*/ */
int pci_finish_runtime_suspend(struct pci_dev *dev) int pci_finish_runtime_suspend(struct pci_dev *dev)
{ {
pci_power_t target_state = pci_target_state(dev); pci_power_t target_state;
int error; int error;
target_state = pci_target_state(dev, device_can_wakeup(&dev->dev));
if (target_state == PCI_POWER_ERROR) if (target_state == PCI_POWER_ERROR)
return -EIO; return -EIO;
@ -2105,8 +2108,8 @@ bool pci_dev_run_wake(struct pci_dev *dev)
if (!dev->pme_support) if (!dev->pme_support)
return false; return false;
/* PME-capable in principle, but not from the intended sleep state */ /* PME-capable in principle, but not from the target power state */
if (!pci_pme_capable(dev, pci_target_state(dev))) if (!pci_pme_capable(dev, pci_target_state(dev, false)))
return false; return false;
while (bus->parent) { while (bus->parent) {
@ -2141,9 +2144,10 @@ EXPORT_SYMBOL_GPL(pci_dev_run_wake);
bool pci_dev_keep_suspended(struct pci_dev *pci_dev) bool pci_dev_keep_suspended(struct pci_dev *pci_dev)
{ {
struct device *dev = &pci_dev->dev; struct device *dev = &pci_dev->dev;
bool wakeup = device_may_wakeup(dev);
if (!pm_runtime_suspended(dev) if (!pm_runtime_suspended(dev)
|| pci_target_state(pci_dev) != pci_dev->current_state || pci_target_state(pci_dev, wakeup) != pci_dev->current_state
|| platform_pci_need_resume(pci_dev) || platform_pci_need_resume(pci_dev)
|| (pci_dev->dev_flags & PCI_DEV_FLAGS_NEEDS_RESUME)) || (pci_dev->dev_flags & PCI_DEV_FLAGS_NEEDS_RESUME))
return false; return false;
@ -2161,7 +2165,7 @@ bool pci_dev_keep_suspended(struct pci_dev *pci_dev)
spin_lock_irq(&dev->power.lock); spin_lock_irq(&dev->power.lock);
if (pm_runtime_suspended(dev) && pci_dev->current_state < PCI_D3cold && if (pm_runtime_suspended(dev) && pci_dev->current_state < PCI_D3cold &&
!device_may_wakeup(dev)) !wakeup)
__pci_pme_active(pci_dev, false); __pci_pme_active(pci_dev, false);
spin_unlock_irq(&dev->power.lock); spin_unlock_irq(&dev->power.lock);