2 files changed, 44 insertions, 12 deletions

diff --git a/Documentation/power/runtime_pm.txt b/Documentation/power/runtime_pm.txt
index 0ec3d610fc9a..d50dd1ab590d 100644
--- a/Documentation/power/runtime_pm.txt
+++ b/Documentation/power/runtime_pm.txt
@@ -583,6 +583,13 @@ this is:
         pm_runtime_set_active(dev);
         pm_runtime_enable(dev);
 
+The PM core always increments the run-time usage counter before calling the
+->suspend() callback and decrements it after calling the ->resume() callback.
+Hence disabling run-time PM temporarily like this will not cause any runtime
+suspend attempts to be permanently lost.  If the usage count goes to zero
+following the return of the ->resume() callback, the ->runtime_idle() callback
+will be invoked as usual.
+
 On some systems, however, system sleep is not entered through a global firmware
 or hardware operation.  Instead, all hardware components are put into low-power
 states directly by the kernel in a coordinated way.  Then, the system sleep
@@ -595,6 +602,20 @@ place (in particular, if the system is not waking up from hibernation), it may
 be more efficient to leave the devices that had been suspended before the system
 suspend began in the suspended state.
 
+The PM core does its best to reduce the probability of race conditions between
+the runtime PM and system suspend/resume (and hibernation) callbacks by carrying
+out the following operations:
+
+  * During system suspend it calls pm_runtime_get_noresume() and
+    pm_runtime_barrier() for every device right before executing the
+    subsystem-level .suspend() callback for it.  In addition to that it calls
+    pm_runtime_disable() for every device right after executing the
+    subsystem-level .suspend() callback for it.
+
+  * During system resume it calls pm_runtime_enable() and pm_runtime_put_sync()
+    for every device right before and right after executing the subsystem-level
+    .resume() callback for it, respectively.
+
 7. Generic subsystem callbacks
 
 Subsystems may wish to conserve code space by using the set of generic power
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);
-                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);
+                error = device_prepare(dev, state);
 
                 mutex_lock(&dpm_list_mtx);
                 if (error) {