Merge branch 'pm-runtime' into for-linus

* pm-runtime: OMAP: PM: disable idle on suspend for GPIO and UART OMAP: PM: omap_device: add API to disable idle on suspend OMAP: PM: omap_device: add system PM methods for PM domain handling OMAP: PM: omap_device: conditionally use PM domain runtime helpers PM / Runtime: Add new helper function: pm_runtime_status_suspended() PM / Runtime: Consistent utilization of deferred_resume PM / Runtime: Prevent runtime_resume from racing with probe PM / Runtime: Replace "run-time" with "runtime" in documentation PM / Runtime: Improve documentation of enable, disable and barrier PM: Limit race conditions between runtime PM and system sleep (v2) PCI / PM: Detect early wakeup in pci_pm_prepare() PM / Runtime: Return special error code if runtime PM is disabled PM / Runtime: Update documentation of interactions with system sleep
author: Rafael J. Wysocki <rjw@sisk.pl> 2011-07-15 17:59:25 -0400
committer: Rafael J. Wysocki <rjw@sisk.pl> 2011-07-15 17:59:25 -0400
commit: 7ae033cc0dfce68d8e0c83aca60837cf2bf0d2e6 (patch)
tree: 91bb3b8ae2790c7fef06b1832a7df61ae496a77a /drivers
parent: ba1389d74f34c0c6e95cc135a332cd29c29d9c20 (diff)
parent: c8c9fda5069456eb9e0e403c19764b2e257802e1 (diff)
5 files changed, 88 insertions, 56 deletions
diff --git a/drivers/base/power/main.c b/drivers/base/power/main.c
index 85b591a5429a..a85459126bc6 100644
--- a/drivers/base/power/main.c
+++ b/drivers/base/power/main.c
@@ -505,6 +505,7 @@ static int legacy_resume(struct device *dev, int (*cb)(struct device *dev))
 static int device_resume(struct device *dev, pm_message_t state, bool async)
 {
        int error = 0;
+        bool put = false;
        TRACE_DEVICE(dev);
        TRACE_RESUME(0);
@@ -521,6 +522,9 @@ static int device_resume(struct device *dev, pm_message_t state, bool async)
        if (!dev->power.is_suspended)
                goto Unlock;
+        pm_runtime_enable(dev);
+        put = true;
        if (dev->pm_domain) {
                pm_dev_dbg(dev, state, "power domain ");
                error = pm_op(dev, &dev->pm_domain->ops, state);
@@ -563,6 +567,10 @@ static int device_resume(struct device *dev, pm_message_t state, bool async)
        complete_all(&dev->power.completion);
        TRACE_RESUME(error);
+        if (put)
+                pm_runtime_put_sync(dev);
        return error;
 }
@@ -843,16 +851,22 @@ static int __device_suspend(struct device *dev, pm_message_t state, bool async)
        int error = 0;
        dpm_wait_for_children(dev, async);
-        device_lock(dev);
        if (async_error)
-                goto Unlock;
+                return 0;
+        pm_runtime_get_noresume(dev);
+        if (pm_runtime_barrier(dev) && device_may_wakeup(dev))
+                pm_wakeup_event(dev, 0);
        if (pm_wakeup_pending()) {
+                pm_runtime_put_sync(dev);
                async_error = -EBUSY;
-                goto Unlock;
+                return 0;
        }
+        device_lock(dev);
        if (dev->pm_domain) {
                pm_dev_dbg(dev, state, "power domain ");
                error = pm_op(dev, &dev->pm_domain->ops, state);
@@ -890,12 +904,15 @@ static int __device_suspend(struct device *dev, pm_message_t state, bool async)
 End:
        dev->power.is_suspended = !error;
- Unlock:
        device_unlock(dev);
        complete_all(&dev->power.completion);
-        if (error)
+        if (error) {
+                pm_runtime_put_sync(dev);
                async_error = error;
+        } else if (dev->power.is_suspended) {
+                __pm_runtime_disable(dev, false);
+        }
        return error;
 }
@@ -1035,13 +1052,7 @@ int dpm_prepare(pm_message_t state)
                get_device(dev);
                mutex_unlock(&dpm_list_mtx);
-                pm_runtime_get_noresume(dev);
+                error = device_prepare(dev, state);
-                if (pm_runtime_barrier(dev) && device_may_wakeup(dev))
-                        pm_wakeup_event(dev, 0);
-                pm_runtime_put_sync(dev);
-                error = pm_wakeup_pending() ?
-                                -EBUSY : device_prepare(dev, state);
                mutex_lock(&dpm_list_mtx);
                if (error) {
diff --git a/drivers/base/power/runtime.c b/drivers/base/power/runtime.c
index 5f5c4236f006..8dc247c974af 100644
--- a/drivers/base/power/runtime.c
+++ b/drivers/base/power/runtime.c
@@ -1,5 +1,5 @@
 /*
- * drivers/base/power/runtime.c - Helper functions for device run-time PM
+ * drivers/base/power/runtime.c - Helper functions for device runtime PM
 *
 * Copyright (c) 2009 Rafael J. Wysocki <rjw@sisk.pl>, Novell Inc.
 * Copyright (C) 2010 Alan Stern <stern@rowland.harvard.edu>
@@ -135,8 +135,9 @@ static int rpm_check_suspend_allowed(struct device *dev)
        if (dev->power.runtime_error)
                retval = -EINVAL;
-        else if (atomic_read(&dev->power.usage_count) > 0
+        else if (dev->power.disable_depth > 0)
-            || dev->power.disable_depth > 0)
+                retval = -EACCES;
+        else if (atomic_read(&dev->power.usage_count) > 0)
                retval = -EAGAIN;
        else if (!pm_children_suspended(dev))
                retval = -EBUSY;
@@ -158,7 +159,7 @@ static int rpm_check_suspend_allowed(struct device *dev)
 * @dev: Device to notify the bus type about.
 * @rpmflags: Flag bits.
 *
- * Check if the device's run-time PM status allows it to be suspended.  If
+ * Check if the device's runtime PM status allows it to be suspended.  If
 * another idle notification has been started earlier, return immediately.  If
 * the RPM_ASYNC flag is set then queue an idle-notification request; otherwise
 * run the ->runtime_idle() callback directly.
@@ -262,15 +263,15 @@ static int rpm_callback(int (*cb)(struct device *), struct device *dev)
                spin_lock_irq(&dev->power.lock);
        }
        dev->power.runtime_error = retval;
-        return retval;
+        return retval != -EACCES ? retval : -EIO;
 }
 /**
- * rpm_suspend - Carry out run-time suspend of given device.
+ * rpm_suspend - Carry out runtime suspend of given device.
 * @dev: Device to suspend.
 * @rpmflags: Flag bits.
 *
- * Check if the device's run-time PM status allows it to be suspended.  If
+ * Check if the device's runtime PM status allows it to be suspended.  If
 * another suspend has been started earlier, either return immediately or wait
 * for it to finish, depending on the RPM_NOWAIT and RPM_ASYNC flags.  Cancel a
 * pending idle notification.  If the RPM_ASYNC flag is set then queue a
@@ -388,7 +389,7 @@ static int rpm_suspend(struct device *dev, int rpmflags)
        retval = rpm_callback(callback, dev);
        if (retval) {
                __update_runtime_status(dev, RPM_ACTIVE);
-                dev->power.deferred_resume = 0;
+                dev->power.deferred_resume = false;
                if (retval == -EAGAIN || retval == -EBUSY)
                        dev->power.runtime_error = 0;
                else
@@ -429,11 +430,11 @@ static int rpm_suspend(struct device *dev, int rpmflags)
 }
 /**
- * rpm_resume - Carry out run-time resume of given device.
+ * rpm_resume - Carry out runtime resume of given device.
 * @dev: Device to resume.
 * @rpmflags: Flag bits.
 *
- * Check if the device's run-time PM status allows it to be resumed.  Cancel
+ * Check if the device's runtime PM status allows it to be resumed.  Cancel
 * any scheduled or pending requests.  If another resume has been started
 * earlier, either return immediately or wait for it to finish, depending on the
 * RPM_NOWAIT and RPM_ASYNC flags.  Similarly, if there's a suspend running in
@@ -458,7 +459,7 @@ static int rpm_resume(struct device *dev, int rpmflags)
        if (dev->power.runtime_error)
                retval = -EINVAL;
        else if (dev->power.disable_depth > 0)
-                retval = -EAGAIN;
+                retval = -EACCES;
        if (retval)
                goto out;
@@ -550,7 +551,7 @@ static int rpm_resume(struct device *dev, int rpmflags)
                spin_lock(&parent->power.lock);
                /*
-                 * We can resume if the parent's run-time PM is disabled or it
+                 * We can resume if the parent's runtime PM is disabled or it
                 * is set to ignore children.
                 */
                if (!parent->power.disable_depth
@@ -614,11 +615,11 @@ static int rpm_resume(struct device *dev, int rpmflags)
 }
 /**
- * pm_runtime_work - Universal run-time PM work function.
+ * pm_runtime_work - Universal runtime PM work function.
 * @work: Work structure used for scheduling the execution of this function.
 *
 * Use @work to get the device object the work is to be done for, determine what
- * is to be done and execute the appropriate run-time PM function.
+ * is to be done and execute the appropriate runtime PM function.
 */
 static void pm_runtime_work(struct work_struct *work)
 {
@@ -717,7 +718,7 @@ int pm_schedule_suspend(struct device *dev, unsigned int delay)
 EXPORT_SYMBOL_GPL(pm_schedule_suspend);
 /**
- * __pm_runtime_idle - Entry point for run-time idle operations.
+ * __pm_runtime_idle - Entry point for runtime idle operations.
 * @dev: Device to send idle notification for.
 * @rpmflags: Flag bits.
 *
@@ -746,7 +747,7 @@ int __pm_runtime_idle(struct device *dev, int rpmflags)
 EXPORT_SYMBOL_GPL(__pm_runtime_idle);
 /**
- * __pm_runtime_suspend - Entry point for run-time put/suspend operations.
+ * __pm_runtime_suspend - Entry point for runtime put/suspend operations.
 * @dev: Device to suspend.
 * @rpmflags: Flag bits.
 *
@@ -775,7 +776,7 @@ int __pm_runtime_suspend(struct device *dev, int rpmflags)
 EXPORT_SYMBOL_GPL(__pm_runtime_suspend);
 /**
- * __pm_runtime_resume - Entry point for run-time resume operations.
+ * __pm_runtime_resume - Entry point for runtime resume operations.
 * @dev: Device to resume.
 * @rpmflags: Flag bits.
 *
@@ -801,11 +802,11 @@ int __pm_runtime_resume(struct device *dev, int rpmflags)
 EXPORT_SYMBOL_GPL(__pm_runtime_resume);
 /**
- * __pm_runtime_set_status - Set run-time PM status of a device.
+ * __pm_runtime_set_status - Set runtime PM status of a device.
 * @dev: Device to handle.
- * @status: New run-time PM status of the device.
+ * @status: New runtime PM status of the device.
 *
- * If run-time PM of the device is disabled or its power.runtime_error field is
+ * If runtime PM of the device is disabled or its power.runtime_error field is
 * different from zero, the status may be changed either to RPM_ACTIVE, or to
 * RPM_SUSPENDED, as long as that reflects the actual state of the device.
 * However, if the device has a parent and the parent is not active, and the
@@ -851,7 +852,7 @@ int __pm_runtime_set_status(struct device *dev, unsigned int status)
                /*
                 * It is invalid to put an active child under a parent that is
-                 * not active, has run-time PM enabled and the
+                 * not active, has runtime PM enabled and the
                 * 'power.ignore_children' flag unset.
                 */
                if (!parent->power.disable_depth
@@ -885,7 +886,7 @@ EXPORT_SYMBOL_GPL(__pm_runtime_set_status);
 * @dev: Device to handle.
 *
 * Flush all pending requests for the device from pm_wq and wait for all
- * run-time PM operations involving the device in progress to complete.
+ * runtime PM operations involving the device in progress to complete.
 *
 * Should be called under dev->power.lock with interrupts disabled.
 */
@@ -933,7 +934,7 @@ static void __pm_runtime_barrier(struct device *dev)
 * Prevent the device from being suspended by incrementing its usage counter and
 * if there's a pending resume request for the device, wake the device up.
 * Next, make sure that all pending requests for the device have been flushed
- * from pm_wq and wait for all run-time PM operations involving the device in
+ * from pm_wq and wait for all runtime PM operations involving the device in
 * progress to complete.
 *
 * Return value:
@@ -963,18 +964,18 @@ int pm_runtime_barrier(struct device *dev)
 EXPORT_SYMBOL_GPL(pm_runtime_barrier);
 /**
- * __pm_runtime_disable - Disable run-time PM of a device.
+ * __pm_runtime_disable - Disable runtime PM of a device.
 * @dev: Device to handle.
 * @check_resume: If set, check if there's a resume request for the device.
 *
 * Increment power.disable_depth for the device and if was zero previously,
- * cancel all pending run-time PM requests for the device and wait for all
+ * cancel all pending runtime PM requests for the device and wait for all
 * operations in progress to complete.  The device can be either active or
- * suspended after its run-time PM has been disabled.
+ * suspended after its runtime PM has been disabled.
 *
 * If @check_resume is set and there's a resume request pending when
 * __pm_runtime_disable() is called and power.disable_depth is zero, the
- * function will wake up the device before disabling its run-time PM.
+ * function will wake up the device before disabling its runtime PM.
 */
 void __pm_runtime_disable(struct device *dev, bool check_resume)
 {
@@ -987,7 +988,7 @@ void __pm_runtime_disable(struct device *dev, bool check_resume)
        /*
         * Wake up the device if there's a resume request pending, because that
-         * means there probably is some I/O to process and disabling run-time PM
+         * means there probably is some I/O to process and disabling runtime PM
         * shouldn't prevent the device from processing the I/O.
         */
        if (check_resume && dev->power.request_pending
@@ -1012,7 +1013,7 @@ void __pm_runtime_disable(struct device *dev, bool check_resume)
 EXPORT_SYMBOL_GPL(__pm_runtime_disable);
 /**
- * pm_runtime_enable - Enable run-time PM of a device.
+ * pm_runtime_enable - Enable runtime PM of a device.
 * @dev: Device to handle.
 */
 void pm_runtime_enable(struct device *dev)
@@ -1031,7 +1032,7 @@ void pm_runtime_enable(struct device *dev)
 EXPORT_SYMBOL_GPL(pm_runtime_enable);
 /**
- * pm_runtime_forbid - Block run-time PM of a device.
+ * pm_runtime_forbid - Block runtime PM of a device.
 * @dev: Device to handle.
 *
 * Increase the device's usage count and clear its power.runtime_auto flag,
@@ -1054,7 +1055,7 @@ void pm_runtime_forbid(struct device *dev)
 EXPORT_SYMBOL_GPL(pm_runtime_forbid);
 /**
- * pm_runtime_allow - Unblock run-time PM of a device.
+ * pm_runtime_allow - Unblock runtime PM of a device.
 * @dev: Device to handle.
 *
 * Decrease the device's usage count and set its power.runtime_auto flag.
@@ -1075,12 +1076,12 @@ void pm_runtime_allow(struct device *dev)
 EXPORT_SYMBOL_GPL(pm_runtime_allow);
 /**
- * pm_runtime_no_callbacks - Ignore run-time PM callbacks for a device.
+ * pm_runtime_no_callbacks - Ignore runtime PM callbacks for a device.
 * @dev: Device to handle.
 *
 * Set the power.no_callbacks flag, which tells the PM core that this
- * device is power-managed through its parent and has no run-time PM
+ * device is power-managed through its parent and has no runtime PM
- * callbacks of its own.  The run-time sysfs attributes will be removed.
+ * callbacks of its own.  The runtime sysfs attributes will be removed.
 */
 void pm_runtime_no_callbacks(struct device *dev)
 {
@@ -1156,8 +1157,8 @@ static void update_autosuspend(struct device *dev, int old_delay, int old_use)
 * @delay: Value of the new delay in milliseconds.
 *
 * Set the device's power.autosuspend_delay value.  If it changes to negative
- * and the power.use_autosuspend flag is set, prevent run-time suspends.  If it
+ * and the power.use_autosuspend flag is set, prevent runtime suspends.  If it
- * changes the other way, allow run-time suspends.
+ * changes the other way, allow runtime suspends.
 */
 void pm_runtime_set_autosuspend_delay(struct device *dev, int delay)
 {
@@ -1177,7 +1178,7 @@ EXPORT_SYMBOL_GPL(pm_runtime_set_autosuspend_delay);
 * @dev: Device to handle.
 * @use: New value for use_autosuspend.
 *
- * Set the device's power.use_autosuspend flag, and allow or prevent run-time
+ * Set the device's power.use_autosuspend flag, and allow or prevent runtime
 * suspends as needed.
 */
 void __pm_runtime_use_autosuspend(struct device *dev, bool use)
@@ -1194,7 +1195,7 @@ void __pm_runtime_use_autosuspend(struct device *dev, bool use)
 EXPORT_SYMBOL_GPL(__pm_runtime_use_autosuspend);
 /**
- * pm_runtime_init - Initialize run-time PM fields in given device object.
+ * pm_runtime_init - Initialize runtime PM fields in given device object.
 * @dev: Device object to initialize.
 */
 void pm_runtime_init(struct device *dev)
diff --git a/drivers/base/power/sysfs.c b/drivers/base/power/sysfs.c
index a9f5b8979611..942d6a7c9ae1 100644
--- a/drivers/base/power/sysfs.c
+++ b/drivers/base/power/sysfs.c
@@ -116,12 +116,14 @@ static ssize_t control_store(struct device * dev, struct device_attribute *attr,
        cp = memchr(buf, '\n', n);
        if (cp)
                len = cp - buf;
+        device_lock(dev);
        if (len == sizeof ctrl_auto - 1 && strncmp(buf, ctrl_auto, len) == 0)
                pm_runtime_allow(dev);
        else if (len == sizeof ctrl_on - 1 && strncmp(buf, ctrl_on, len) == 0)
                pm_runtime_forbid(dev);
        else
-                return -EINVAL;
+                n = -EINVAL;
+        device_unlock(dev);
        return n;
 }
@@ -205,7 +207,9 @@ static ssize_t autosuspend_delay_ms_store(struct device *dev,
        if (strict_strtol(buf, 10, &delay) != 0 || delay != (int) delay)
                return -EINVAL;
+        device_lock(dev);
        pm_runtime_set_autosuspend_delay(dev, delay);
+        device_unlock(dev);
        return n;
 }
diff --git a/drivers/pci/pci-driver.c b/drivers/pci/pci-driver.c
index 46767c53917a..12d1e81a8abe 100644
--- a/drivers/pci/pci-driver.c
+++ b/drivers/pci/pci-driver.c
@@ -18,6 +18,7 @@
 #include <linux/sched.h>
 #include <linux/cpu.h>
 #include <linux/pm_runtime.h>
+#include <linux/suspend.h>
 #include "pci.h"
 struct pci_dynid {
@@ -616,6 +617,21 @@ static int pci_pm_prepare(struct device *dev)
        int error = 0;
        /*
+         * If a PCI device configured to wake up the system from sleep states
+         * has been suspended at run time and there's a resume request pending
+         * for it, this is equivalent to the device signaling wakeup, so the
+         * system suspend operation should be aborted.
+         */
+        pm_runtime_get_noresume(dev);
+        if (pm_runtime_barrier(dev) && device_may_wakeup(dev))
+                pm_wakeup_event(dev, 0);
+        if (pm_wakeup_pending()) {
+                pm_runtime_put_sync(dev);
+                return -EBUSY;
+        }
+        /*
         * PCI devices suspended at run time need to be resumed at this
         * point, because in general it is necessary to reconfigure them for
         * system suspend.  Namely, if the device is supposed to wake up the
@@ -624,7 +640,7 @@ static int pci_pm_prepare(struct device *dev)
         * system from the sleep state, we'll have to prevent it from signaling
         * wake-up.
         */
-        pm_runtime_get_sync(dev);
+        pm_runtime_resume(dev);
        if (drv && drv->pm && drv->pm->prepare)
                error = drv->pm->prepare(dev);
diff --git a/drivers/scsi/scsi_pm.c b/drivers/scsi/scsi_pm.c
index d70e91ae60af..d82a023a9015 100644
--- a/drivers/scsi/scsi_pm.c
+++ b/drivers/scsi/scsi_pm.c
@@ -144,9 +144,9 @@ int scsi_autopm_get_device(struct scsi_device *sdev)
        int     err;
        err = pm_runtime_get_sync(&sdev->sdev_gendev);
-        if (err < 0)
+        if (err < 0 && err !=-EACCES)
                pm_runtime_put_sync(&sdev->sdev_gendev);
-        else if (err > 0)
+        else
                err = 0;
        return err;
 }
@@ -173,9 +173,9 @@ int scsi_autopm_get_host(struct Scsi_Host *shost)
        int     err;
        err = pm_runtime_get_sync(&shost->shost_gendev);
-        if (err < 0)
+        if (err < 0 && err !=-EACCES)
                pm_runtime_put_sync(&shost->shost_gendev);
-        else if (err > 0)
+        else
                err = 0;
        return err;
 }
author	Rafael J. Wysocki <rjw@sisk.pl>	2011-07-15 17:59:25 -0400
committer	Rafael J. Wysocki <rjw@sisk.pl>	2011-07-15 17:59:25 -0400
commit	7ae033cc0dfce68d8e0c83aca60837cf2bf0d2e6 (patch)
tree	91bb3b8ae2790c7fef06b1832a7df61ae496a77a /drivers
parent	ba1389d74f34c0c6e95cc135a332cd29c29d9c20 (diff)
parent	c8c9fda5069456eb9e0e403c19764b2e257802e1 (diff)