1 files changed, 38 insertions, 27 deletions

diff --git a/drivers/base/power/main.c b/drivers/base/power/main.c
index 06f09bf89cb..a85459126bc 100644
--- a/drivers/base/power/main.c
+++ b/drivers/base/power/main.c
@@ -425,9 +425,9 @@ static int device_resume_noirq(struct device *dev, pm_message_t state)
         TRACE_DEVICE(dev);
         TRACE_RESUME(0);
 
-        if (dev->pwr_domain) {
+        if (dev->pm_domain) {
                 pm_dev_dbg(dev, state, "EARLY power domain ");
-                error = pm_noirq_op(dev, &dev->pwr_domain->ops, state);
+                error = pm_noirq_op(dev, &dev->pm_domain->ops, state);
         } else if (dev->type && dev->type->pm) {
                 pm_dev_dbg(dev, state, "EARLY type ");
                 error = pm_noirq_op(dev, dev->type->pm, state);
@@ -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,9 +522,12 @@ static int device_resume(struct device *dev, pm_message_t state, bool async)
         if (!dev->power.is_suspended)
                 goto Unlock;
 
-        if (dev->pwr_domain) {
+        pm_runtime_enable(dev);
+        put = true;
+
+        if (dev->pm_domain) {
                 pm_dev_dbg(dev, state, "power domain ");
-                error = pm_op(dev, &dev->pwr_domain->ops, state);
+                error = pm_op(dev, &dev->pm_domain->ops, state);
                 goto End;
         }
 
@@ -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;
 }
 
@@ -641,10 +649,10 @@ static void device_complete(struct device *dev, pm_message_t state)
 {
         device_lock(dev);
 
-        if (dev->pwr_domain) {
+        if (dev->pm_domain) {
                 pm_dev_dbg(dev, state, "completing power domain ");
-                if (dev->pwr_domain->ops.complete)
-                        dev->pwr_domain->ops.complete(dev);
+                if (dev->pm_domain->ops.complete)
+                        dev->pm_domain->ops.complete(dev);
         } else if (dev->type && dev->type->pm) {
                 pm_dev_dbg(dev, state, "completing type ");
                 if (dev->type->pm->complete)
@@ -744,9 +752,9 @@ static int device_suspend_noirq(struct device *dev, pm_message_t state)
 {
         int error;
 
-        if (dev->pwr_domain) {
+        if (dev->pm_domain) {
                 pm_dev_dbg(dev, state, "LATE power domain ");
-                error = pm_noirq_op(dev, &dev->pwr_domain->ops, state);
+                error = pm_noirq_op(dev, &dev->pm_domain->ops, state);
                 if (error)
                         return error;
         } else if (dev->type && dev->type->pm) {
@@ -843,19 +851,25 @@ 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;
         }
 
-        if (dev->pwr_domain) {
+        device_lock(dev);
+
+        if (dev->pm_domain) {
                 pm_dev_dbg(dev, state, "power domain ");
-                error = pm_op(dev, &dev->pwr_domain->ops, state);
+                error = pm_op(dev, &dev->pm_domain->ops, state);
                 goto End;
         }
 
@@ -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;
 }
@@ -982,11 +999,11 @@ static int device_prepare(struct device *dev, pm_message_t state)
 
         device_lock(dev);
 
-        if (dev->pwr_domain) {
+        if (dev->pm_domain) {
                 pm_dev_dbg(dev, state, "preparing power domain ");
-                if (dev->pwr_domain->ops.prepare)
-                        error = dev->pwr_domain->ops.prepare(dev);
-                suspend_report_result(dev->pwr_domain->ops.prepare, error);
+                if (dev->pm_domain->ops.prepare)
+                        error = dev->pm_domain->ops.prepare(dev);
+                suspend_report_result(dev->pm_domain->ops.prepare, error);
                 if (error)
                         goto End;
         } else if (dev->type && dev->type->pm) {
@@ -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) {