PM / core: Drop run_wake flag from struct dev_pm_info

The run_wake flag in struct dev_pm_info is used to indicate whether
or not the device is capable of generating remote wakeup signals at
run time (or in the system working state), but the distinction
between runtime remote wakeup and system wakeup signaling has always
been rather artificial.  The only practical reason for it to exist
at the core level was that ACPI and PCI treated those two cases
differently, but that's not the case any more after recent changes.

For this reason, get rid of the run_wake flag and, when applicable,
use device_set_wakeup_capable() and device_can_wakeup() instead of
device_set_run_wake() and device_run_wake(), respectively.

Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
Reviewed-by: Mika Westerberg <mika.westerberg@linux.intel.com>
Acked-by: Bjorn Helgaas <bhelgaas@google.com>

diff --git a/Documentation/power/runtime_pm.txt b/Documentation/power/runtime_pm.txt
index ee69d753217274780f9c66df9d178ac3385ae3fa..0fde3dcf077a302eb24ea6d8fd8df65c4b252d8e 100644 (file)
--- a/Documentation/power/runtime_pm.txt
+++ b/Documentation/power/runtime_pm.txt
@@ -105,9 +105,9 @@ knows what to do to handle the device).
 
 In particular, if the driver requires remote wakeup capability (i.e. hardware
 mechanism allowing the device to request a change of its power state, such as
-PCI PME) for proper functioning and device_run_wake() returns 'false' for the
+PCI PME) for proper functioning and device_can_wakeup() returns 'false' for the
 device, then ->runtime_suspend() should return -EBUSY.  On the other hand, if
-device_run_wake() returns 'true' for the device and the device is put into a
+device_can_wakeup() returns 'true' for the device and the device is put into a
 low-power state during the execution of the suspend callback, it is expected
 that remote wakeup will be enabled for the device.  Generally, remote wakeup
 should be enabled for all input devices put into low-power states at run time.
@@ -253,9 +253,6 @@ defined in include/linux/pm.h:
       being executed for that device and it is not practical to wait for the
       suspend to complete; means "start a resume as soon as you've suspended"
 
-  unsigned int run_wake;
-    - set if the device is capable of generating runtime wake-up events
-
   enum rpm_status runtime_status;
     - the runtime PM status of the device; this field's initial value is
       RPM_SUSPENDED, which means that each device is initially regarded by the

diff --git a/drivers/acpi/pci_root.c b/drivers/acpi/pci_root.c
index 783acbe255208f4ae607a3e0908832879b00320e..0d34e622a8b5a4bbf81dc6049b2c9dc507c41813 100644 (file)
--- a/drivers/acpi/pci_root.c
+++ b/drivers/acpi/pci_root.c
@@ -608,8 +608,7 @@ static int acpi_pci_root_add(struct acpi_device *device,
                pcie_no_aspm();
 
        pci_acpi_add_bus_pm_notifier(device);
-       if (device->wakeup.flags.valid)
-               device_set_run_wake(root->bus->bridge, true);
+       device_set_wakeup_capable(root->bus->bridge, device->wakeup.flags.valid);
 
        if (hotadd) {
                pcibios_resource_survey_bus(root->bus);
@@ -649,7 +648,7 @@ static void acpi_pci_root_remove(struct acpi_device *device)
        pci_stop_root_bus(root->bus);
 
        pci_ioapic_remove(root);
-       device_set_run_wake(root->bus->bridge, false);
+       device_set_wakeup_capable(root->bus->bridge, false);
        pci_acpi_remove_bus_pm_notifier(device);
 
        pci_remove_root_bus(root->bus);

diff --git a/drivers/pci/pci-acpi.c b/drivers/pci/pci-acpi.c
index 138a3c55d80e2344069eeeb2ae8887f47189f446..e70c1c7ba1bf550422cd2b54bbf9801bb716a771 100644 (file)
--- a/drivers/pci/pci-acpi.c
+++ b/drivers/pci/pci-acpi.c
@@ -738,7 +738,6 @@ static void pci_acpi_setup(struct device *dev)
                return;
 
        device_set_wakeup_capable(dev, true);
-       device_set_run_wake(dev, true);
        acpi_pci_wakeup(pci_dev, false);
 }
 
@@ -750,10 +749,8 @@ static void pci_acpi_cleanup(struct device *dev)
                return;
 
        pci_acpi_remove_pm_notifier(adev);
-       if (adev->wakeup.flags.valid) {
+       if (adev->wakeup.flags.valid)
                device_set_wakeup_capable(dev, false);
-               device_set_run_wake(dev, false);
-       }
 }
 
 static bool pci_acpi_bus_match(struct device *dev)

diff --git a/drivers/pci/pci.c b/drivers/pci/pci.c
index d378262d30e392f3a4b14b568a3947f15926c191..0b5302a9fdaef5e1a92d0ac521e1478eab096ec5 100644 (file)
--- a/drivers/pci/pci.c
+++ b/drivers/pci/pci.c
@@ -2105,7 +2105,7 @@ bool pci_dev_run_wake(struct pci_dev *dev)
 {
        struct pci_bus *bus = dev->bus;
 
-       if (device_run_wake(&dev->dev))
+       if (device_can_wakeup(&dev->dev))
                return true;
 
        if (!dev->pme_support)
@@ -2118,7 +2118,7 @@ bool pci_dev_run_wake(struct pci_dev *dev)
        while (bus->parent) {
                struct pci_dev *bridge = bus->self;
 
-               if (device_run_wake(&bridge->dev))
+               if (device_can_wakeup(&bridge->dev))
                        return true;
 
                bus = bus->parent;
@@ -2126,7 +2126,7 @@ bool pci_dev_run_wake(struct pci_dev *dev)
 
        /* We have reached the root bus. */
        if (bus->bridge)
-               return device_run_wake(bus->bridge);
+               return device_can_wakeup(bus->bridge);
 
        return false;
 }

diff --git a/drivers/pci/pcie/pme.c b/drivers/pci/pcie/pme.c
index 1db1615838ac74e5f62789a83ff82e446548e9b4..80e58d25006d04b86e6efe82f581db80c81fe85c 100644 (file)
--- a/drivers/pci/pcie/pme.c
+++ b/drivers/pci/pcie/pme.c
@@ -300,7 +300,7 @@ static irqreturn_t pcie_pme_irq(int irq, void *context)
  */
 static int pcie_pme_can_wakeup(struct pci_dev *dev, void *ign)
 {
-       device_set_run_wake(&dev->dev, true);
+       device_set_wakeup_capable(&dev->dev, true);
        return 0;
 }
 

diff --git a/drivers/usb/dwc3/dwc3-pci.c b/drivers/usb/dwc3/dwc3-pci.c
index fe851544d7fbaad82d3fdadc397da734d0a5bf4b..7e995df7a797b4353ba18e17ed701c3bc2096c4e 100644 (file)
--- a/drivers/usb/dwc3/dwc3-pci.c
+++ b/drivers/usb/dwc3/dwc3-pci.c
@@ -230,7 +230,6 @@ static int dwc3_pci_probe(struct pci_dev *pci,
        }
 
        device_init_wakeup(dev, true);
-       device_set_run_wake(dev, true);
        pci_set_drvdata(pci, dwc);
        pm_runtime_put(dev);
 
@@ -310,7 +309,7 @@ static int dwc3_pci_runtime_suspend(struct device *dev)
 {
        struct dwc3_pci         *dwc = dev_get_drvdata(dev);
 
-       if (device_run_wake(dev))
+       if (device_can_wakeup(dev))
                return dwc3_pci_dsm(dwc, PCI_INTEL_BXT_STATE_D3);
 
        return -EBUSY;

diff --git a/drivers/usb/host/uhci-pci.c b/drivers/usb/host/uhci-pci.c
index 02260cfdedb135c92d219a2e5531775355973188..49effdc0d8579c2c69d1424bdeb46e9f128f0ea9 100644 (file)
--- a/drivers/usb/host/uhci-pci.c
+++ b/drivers/usb/host/uhci-pci.c
@@ -131,7 +131,7 @@ static int uhci_pci_init(struct usb_hcd *hcd)
 
        /* Intel controllers use non-PME wakeup signalling */
        if (to_pci_dev(uhci_dev(uhci))->vendor == PCI_VENDOR_ID_INTEL)
-               device_set_run_wake(uhci_dev(uhci), 1);
+               device_set_wakeup_capable(uhci_dev(uhci), true);
 
        /* Set up pointers to PCI-specific functions */
        uhci->reset_hc = uhci_pci_reset_hc;

diff --git a/include/linux/pm.h b/include/linux/pm.h
index a0894bc52bb4560180f18d823e167e75b968c3db..b8b4df09fd8f5ed3eb3ce5c0f47e4068ba702ca2 100644 (file)
--- a/include/linux/pm.h
+++ b/include/linux/pm.h
@@ -584,7 +584,6 @@ struct dev_pm_info {
        unsigned int            idle_notification:1;
        unsigned int            request_pending:1;
        unsigned int            deferred_resume:1;
-       unsigned int            run_wake:1;
        unsigned int            runtime_auto:1;
        bool                    ignore_children:1;
        unsigned int            no_callbacks:1;

diff --git a/include/linux/pm_runtime.h b/include/linux/pm_runtime.h
index ca4823e675e28e2edc81fe6e48160464c4d25dcb..2efb08a60e638f3b0c043ce6485c54ebc031d5e9 100644 (file)
--- a/include/linux/pm_runtime.h
+++ b/include/linux/pm_runtime.h
@@ -76,16 +76,6 @@ static inline void pm_runtime_put_noidle(struct device *dev)
        atomic_add_unless(&dev->power.usage_count, -1, 0);
 }
 
-static inline bool device_run_wake(struct device *dev)
-{
-       return dev->power.run_wake;
-}
-
-static inline void device_set_run_wake(struct device *dev, bool enable)
-{
-       dev->power.run_wake = enable;
-}
-
 static inline bool pm_runtime_suspended(struct device *dev)
 {
        return dev->power.runtime_status == RPM_SUSPENDED
@@ -163,8 +153,6 @@ static inline void pm_runtime_forbid(struct device *dev) {}
 static inline void pm_suspend_ignore_children(struct device *dev, bool enable) {}
 static inline void pm_runtime_get_noresume(struct device *dev) {}
 static inline void pm_runtime_put_noidle(struct device *dev) {}
-static inline bool device_run_wake(struct device *dev) { return false; }
-static inline void device_set_run_wake(struct device *dev, bool enable) {}
 static inline bool pm_runtime_suspended(struct device *dev) { return false; }
 static inline bool pm_runtime_active(struct device *dev) { return true; }
 static inline bool pm_runtime_status_suspended(struct device *dev) { return false; }