PCI / PM: Simplify device wakeup settings code

After previous changes it is not necessary to distinguish between
device wakeup for run time and device wakeup from system sleep states
any more, so rework the PCI device wakeup settings code accordingly.

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/drivers/pci/pci-acpi.c b/drivers/pci/pci-acpi.c
index de255bc9736b8640625a6cc7e7926224c610de58..138a3c55d80e2344069eeeb2ae8887f47189f446 100644 (file)
--- a/drivers/pci/pci-acpi.c
+++ b/drivers/pci/pci-acpi.c
@@ -615,8 +615,7 @@ static const struct pci_platform_pm_ops acpi_pci_platform_pm = {
        .set_state = acpi_pci_set_power_state,
        .get_state = acpi_pci_get_power_state,
        .choose_state = acpi_pci_choose_state,
-       .sleep_wake = acpi_pci_wakeup,
-       .run_wake = acpi_pci_wakeup,
+       .set_wakeup = acpi_pci_wakeup,
        .need_resume = acpi_pci_need_resume,
 };
 

diff --git a/drivers/pci/pci-driver.c b/drivers/pci/pci-driver.c
index 192e7b681b96ad82be54625e70252ca859adfb5e..ffe7d54d93282aec5802cb5d427b90c78d4342a9 100644 (file)
--- a/drivers/pci/pci-driver.c
+++ b/drivers/pci/pci-driver.c
@@ -1216,7 +1216,7 @@ static int pci_pm_runtime_resume(struct device *dev)
 
        pci_restore_standard_config(pci_dev);
        pci_fixup_device(pci_fixup_resume_early, pci_dev);
-       __pci_enable_wake(pci_dev, PCI_D0, true, false);
+       pci_enable_wake(pci_dev, PCI_D0, false);
        pci_fixup_device(pci_fixup_resume, pci_dev);
 
        rc = pm->runtime_resume(dev);

diff --git a/drivers/pci/pci-mid.c b/drivers/pci/pci-mid.c
index 1c4af7227bcadbee2a1a286c0b3c6411b7a6f8fc..a4ac940c7696ab562063bb581a14615728aee72d 100644 (file)
--- a/drivers/pci/pci-mid.c
+++ b/drivers/pci/pci-mid.c
@@ -39,12 +39,7 @@ static pci_power_t mid_pci_choose_state(struct pci_dev *pdev)
        return PCI_D3hot;
 }
 
-static int mid_pci_sleep_wake(struct pci_dev *dev, bool enable)
-{
-       return 0;
-}
-
-static int mid_pci_run_wake(struct pci_dev *dev, bool enable)
+static int mid_pci_wakeup(struct pci_dev *dev, bool enable)
 {
        return 0;
 }
@@ -59,8 +54,7 @@ static const struct pci_platform_pm_ops mid_pci_platform_pm = {
        .set_state      = mid_pci_set_power_state,
        .get_state      = mid_pci_get_power_state,
        .choose_state   = mid_pci_choose_state,
-       .sleep_wake     = mid_pci_sleep_wake,
-       .run_wake       = mid_pci_run_wake,
+       .set_wakeup     = mid_pci_wakeup,
        .need_resume    = mid_pci_need_resume,
 };
 

diff --git a/drivers/pci/pci.c b/drivers/pci/pci.c
index 5641035e58fa320a40729b6c1a5811f6a850e9c1..d378262d30e392f3a4b14b568a3947f15926c191 100644 (file)
--- a/drivers/pci/pci.c
+++ b/drivers/pci/pci.c
@@ -574,8 +574,7 @@ static const struct pci_platform_pm_ops *pci_platform_pm;
 int pci_set_platform_pm(const struct pci_platform_pm_ops *ops)
 {
        if (!ops->is_manageable || !ops->set_state  || !ops->get_state ||
-           !ops->choose_state  || !ops->sleep_wake || !ops->run_wake  ||
-           !ops->need_resume)
+           !ops->choose_state  || !ops->set_wakeup || !ops->need_resume)
                return -EINVAL;
        pci_platform_pm = ops;
        return 0;
@@ -603,16 +602,10 @@ static inline pci_power_t platform_pci_choose_state(struct pci_dev *dev)
                        pci_platform_pm->choose_state(dev) : PCI_POWER_ERROR;
 }
 
-static inline int platform_pci_sleep_wake(struct pci_dev *dev, bool enable)
+static inline int platform_pci_set_wakeup(struct pci_dev *dev, bool enable)
 {
        return pci_platform_pm ?
-                       pci_platform_pm->sleep_wake(dev, enable) : -ENODEV;
-}
-
-static inline int platform_pci_run_wake(struct pci_dev *dev, bool enable)
-{
-       return pci_platform_pm ?
-                       pci_platform_pm->run_wake(dev, enable) : -ENODEV;
+                       pci_platform_pm->set_wakeup(dev, enable) : -ENODEV;
 }
 
 static inline bool platform_pci_need_resume(struct pci_dev *dev)
@@ -1889,10 +1882,9 @@ void pci_pme_active(struct pci_dev *dev, bool enable)
 EXPORT_SYMBOL(pci_pme_active);
 
 /**
- * __pci_enable_wake - enable PCI device as wakeup event source
+ * pci_enable_wake - enable PCI device as wakeup event source
  * @dev: PCI device affected
  * @state: PCI state from which device will issue wakeup events
- * @runtime: True if the events are to be generated at run time
  * @enable: True to enable event generation; false to disable
  *
  * This enables the device as a wakeup event source, or disables it.
@@ -1908,14 +1900,10 @@ EXPORT_SYMBOL(pci_pme_active);
  * Error code depending on the platform is returned if both the platform and
  * the native mechanism fail to enable the generation of wake-up events
  */
-int __pci_enable_wake(struct pci_dev *dev, pci_power_t state,
-                     bool runtime, bool enable)
+int pci_enable_wake(struct pci_dev *dev, pci_power_t state, bool enable)
 {
        int ret = 0;
 
-       if (enable && !runtime && !device_may_wakeup(&dev->dev))
-               return -EINVAL;
-
        /*
         * Don't do the same thing twice in a row for one device, but restore
         * PME Enable in case it has been updated by config space restoration.
@@ -1938,24 +1926,20 @@ int __pci_enable_wake(struct pci_dev *dev, pci_power_t state,
                        pci_pme_active(dev, true);
                else
                        ret = 1;
-               error = runtime ? platform_pci_run_wake(dev, true) :
-                                       platform_pci_sleep_wake(dev, true);
+               error = platform_pci_set_wakeup(dev, true);
                if (ret)
                        ret = error;
                if (!ret)
                        dev->wakeup_prepared = true;
        } else {
-               if (runtime)
-                       platform_pci_run_wake(dev, false);
-               else
-                       platform_pci_sleep_wake(dev, false);
+               platform_pci_set_wakeup(dev, false);
                pci_pme_active(dev, false);
                dev->wakeup_prepared = false;
        }
 
        return ret;
 }
-EXPORT_SYMBOL(__pci_enable_wake);
+EXPORT_SYMBOL(pci_enable_wake);
 
 /**
  * pci_wake_from_d3 - enable/disable device to wake up from D3_hot or D3_cold
@@ -2097,12 +2081,12 @@ int pci_finish_runtime_suspend(struct pci_dev *dev)
 
        dev->runtime_d3cold = target_state == PCI_D3cold;
 
-       __pci_enable_wake(dev, target_state, true, pci_dev_run_wake(dev));
+       pci_enable_wake(dev, target_state, pci_dev_run_wake(dev));
 
        error = pci_set_power_state(dev, target_state);
 
        if (error) {
-               __pci_enable_wake(dev, target_state, true, false);
+               pci_enable_wake(dev, target_state, false);
                dev->runtime_d3cold = false;
        }
 

diff --git a/drivers/pci/pci.h b/drivers/pci/pci.h
index f8113e5b98129026e6c100b7b8f803a74507a442..240b2c0fed4b998e27418f7323620db43897098c 100644 (file)
--- a/drivers/pci/pci.h
+++ b/drivers/pci/pci.h
@@ -47,11 +47,7 @@ int pci_probe_reset_function(struct pci_dev *dev);
  *                platform; to be used during system-wide transitions from a
  *                sleeping state to the working state and vice versa
  *
- * @sleep_wake: enables/disables the system wake up capability of given device
- *
- * @run_wake: enables/disables the platform to generate run-time wake-up events
- *             for given device (the device's wake-up capability has to be
- *             enabled by @sleep_wake for this feature to work)
+ * @set_wakeup: enables/disables wakeup capability for the device
  *
  * @need_resume: returns 'true' if the given device (which is currently
  *             suspended) needs to be resumed to be configured for system
@@ -65,8 +61,7 @@ struct pci_platform_pm_ops {
        int (*set_state)(struct pci_dev *dev, pci_power_t state);
        pci_power_t (*get_state)(struct pci_dev *dev);
        pci_power_t (*choose_state)(struct pci_dev *dev);
-       int (*sleep_wake)(struct pci_dev *dev, bool enable);
-       int (*run_wake)(struct pci_dev *dev, bool enable);
+       int (*set_wakeup)(struct pci_dev *dev, bool enable);
        bool (*need_resume)(struct pci_dev *dev);
 };
 

diff --git a/include/linux/pci.h b/include/linux/pci.h
index d3d5bca82b43b1e650ed5081f27ee4e7b35b8566..ff200c84240b35cec0150292a13e05c74a84c090 100644 (file)
--- a/include/linux/pci.h
+++ b/include/linux/pci.h
@@ -1097,8 +1097,7 @@ int pci_set_power_state(struct pci_dev *dev, pci_power_t state);
 pci_power_t pci_choose_state(struct pci_dev *dev, pm_message_t state);
 bool pci_pme_capable(struct pci_dev *dev, pci_power_t state);
 void pci_pme_active(struct pci_dev *dev, bool enable);
-int __pci_enable_wake(struct pci_dev *dev, pci_power_t state,
-                     bool runtime, bool enable);
+int pci_enable_wake(struct pci_dev *dev, pci_power_t state, bool enable);
 int pci_wake_from_d3(struct pci_dev *dev, bool enable);
 int pci_prepare_to_sleep(struct pci_dev *dev);
 int pci_back_from_sleep(struct pci_dev *dev);
@@ -1108,12 +1107,6 @@ void pci_pme_wakeup_bus(struct pci_bus *bus);
 void pci_d3cold_enable(struct pci_dev *dev);
 void pci_d3cold_disable(struct pci_dev *dev);
 
-static inline int pci_enable_wake(struct pci_dev *dev, pci_power_t state,
-                                 bool enable)
-{
-       return __pci_enable_wake(dev, state, false, enable);
-}
-
 /* PCI Virtual Channel */
 int pci_save_vc_state(struct pci_dev *dev);
 void pci_restore_vc_state(struct pci_dev *dev);