PM: Remove redundant checks from core device resume routines

Since a separate list of devices is used to link devices that have
completed each stage of suspend (or resume), it is not necessary to
check dev->power.status in the core device resume routines any more.

Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>

diff --git a/drivers/base/power/main.c b/drivers/base/power/main.c
index b711867fa58e251b9910755df186768e0cb6a09a..bb5c8cb64174dad6cd49795df861c964a841ef85 100644 (file)
--- a/drivers/base/power/main.c
+++ b/drivers/base/power/main.c
@@ -485,22 +485,18 @@ void dpm_resume_noirq(pm_message_t state)
        transition_started = false;
        while (!list_empty(&dpm_noirq_list)) {
                struct device *dev = to_device(dpm_noirq_list.next);
+               int error;
 
                get_device(dev);
-               if (dev->power.status > DPM_OFF) {
-                       int error;
-
-                       dev->power.status = DPM_OFF;
-                       mutex_unlock(&dpm_list_mtx);
+               dev->power.status = DPM_OFF;
+               list_move_tail(&dev->power.entry, &dpm_suspended_list);
+               mutex_unlock(&dpm_list_mtx);
 
-                       error = device_resume_noirq(dev, state);
+               error = device_resume_noirq(dev, state);
+               if (error)
+                       pm_dev_err(dev, state, " early", error);
 
-                       mutex_lock(&dpm_list_mtx);
-                       if (error)
-                               pm_dev_err(dev, state, " early", error);
-               }
-               if (!list_empty(&dev->power.entry))
-                       list_move_tail(&dev->power.entry, &dpm_suspended_list);
+               mutex_lock(&dpm_list_mtx);
                put_device(dev);
        }
        mutex_unlock(&dpm_list_mtx);
@@ -619,9 +615,6 @@ static void dpm_resume(pm_message_t state)
        async_error = 0;
 
        list_for_each_entry(dev, &dpm_suspended_list, power.entry) {
-               if (dev->power.status < DPM_OFF)
-                       continue;
-
                INIT_COMPLETION(dev->power.completion);
                if (is_async(dev)) {
                        get_device(dev);
@@ -632,16 +625,16 @@ static void dpm_resume(pm_message_t state)
        while (!list_empty(&dpm_suspended_list)) {
                dev = to_device(dpm_suspended_list.next);
                get_device(dev);
-               if (dev->power.status >= DPM_OFF && !is_async(dev)) {
+               if (!is_async(dev)) {
                        int error;
 
                        mutex_unlock(&dpm_list_mtx);
 
                        error = device_resume(dev, state, false);
-
-                       mutex_lock(&dpm_list_mtx);
                        if (error)
                                pm_dev_err(dev, state, "", error);
+
+                       mutex_lock(&dpm_list_mtx);
                }
                if (!list_empty(&dev->power.entry))
                        list_move_tail(&dev->power.entry, &dpm_prepared_list);
@@ -697,17 +690,14 @@ static void dpm_complete(pm_message_t state)
                struct device *dev = to_device(dpm_prepared_list.prev);
 
                get_device(dev);
-               if (dev->power.status > DPM_ON) {
-                       dev->power.status = DPM_ON;
-                       mutex_unlock(&dpm_list_mtx);
+               dev->power.status = DPM_ON;
+               list_move(&dev->power.entry, &list);
+               mutex_unlock(&dpm_list_mtx);
 
-                       device_complete(dev, state);
-                       pm_runtime_put_sync(dev);
+               device_complete(dev, state);
+               pm_runtime_put_sync(dev);
 
-                       mutex_lock(&dpm_list_mtx);
-               }
-               if (!list_empty(&dev->power.entry))
-                       list_move(&dev->power.entry, &list);
+               mutex_lock(&dpm_list_mtx);
                put_device(dev);
        }
        list_splice(&list, &dpm_list);