1 files changed, 64 insertions, 39 deletions

diff --git a/drivers/base/power/main.c b/drivers/base/power/main.c
index c99f8730de82..ea1732ed7a9d 100644
--- a/drivers/base/power/main.c
+++ b/drivers/base/power/main.c
@@ -418,8 +418,7 @@ static void pm_dev_err(struct device *dev, pm_message_t state, const char *info,
                 dev_name(dev), pm_verb(state.event), info, error);
 }
 
-#ifdef CONFIG_PM_DEBUG
-static void dpm_show_time(ktime_t starttime, pm_message_t state,
+static void dpm_show_time(ktime_t starttime, pm_message_t state, int error,
                           const char *info)
 {
         ktime_t calltime;
@@ -432,14 +431,12 @@ static void dpm_show_time(ktime_t starttime, pm_message_t state,
         usecs = usecs64;
         if (usecs == 0)
                 usecs = 1;
-        pr_info("PM: %s%s%s of devices complete after %ld.%03ld msecs\n",
-                info ?: "", info ? " " : "", pm_verb(state.event),
-                usecs / USEC_PER_MSEC, usecs % USEC_PER_MSEC);
+
+        pm_pr_dbg("%s%s%s of devices %s after %ld.%03ld msecs\n",
+                  info ?: "", info ? " " : "", pm_verb(state.event),
+                  error ? "aborted" : "complete",
+                  usecs / USEC_PER_MSEC, usecs % USEC_PER_MSEC);
 }
-#else
-static inline void dpm_show_time(ktime_t starttime, pm_message_t state,
-                                 const char *info) {}
-#endif /* CONFIG_PM_DEBUG */
 
 static int dpm_run_callback(pm_callback_t cb, struct device *dev,
                             pm_message_t state, const char *info)
@@ -602,14 +599,7 @@ static void async_resume_noirq(void *data, async_cookie_t cookie)
         put_device(dev);
 }
 
-/**
- * dpm_resume_noirq - Execute "noirq resume" callbacks for all devices.
- * @state: PM transition of the system being carried out.
- *
- * Call the "noirq" resume handlers for all devices in dpm_noirq_list and
- * enable device drivers to receive interrupts.
- */
-void dpm_resume_noirq(pm_message_t state)
+void dpm_noirq_resume_devices(pm_message_t state)
 {
         struct device *dev;
         ktime_t starttime = ktime_get();
@@ -654,11 +644,28 @@ void dpm_resume_noirq(pm_message_t state)
         }
         mutex_unlock(&dpm_list_mtx);
         async_synchronize_full();
-        dpm_show_time(starttime, state, "noirq");
+        dpm_show_time(starttime, state, 0, "noirq");
+        trace_suspend_resume(TPS("dpm_resume_noirq"), state.event, false);
+}
+
+void dpm_noirq_end(void)
+{
         resume_device_irqs();
         device_wakeup_disarm_wake_irqs();
         cpuidle_resume();
-        trace_suspend_resume(TPS("dpm_resume_noirq"), state.event, false);
+}
+
+/**
+ * dpm_resume_noirq - Execute "noirq resume" callbacks for all devices.
+ * @state: PM transition of the system being carried out.
+ *
+ * Invoke the "noirq" resume callbacks for all devices in dpm_noirq_list and
+ * allow device drivers' interrupt handlers to be called.
+ */
+void dpm_resume_noirq(pm_message_t state)
+{
+        dpm_noirq_resume_devices(state);
+        dpm_noirq_end();
 }
 
 /**
@@ -776,7 +783,7 @@ void dpm_resume_early(pm_message_t state)
         }
         mutex_unlock(&dpm_list_mtx);
         async_synchronize_full();
-        dpm_show_time(starttime, state, "early");
+        dpm_show_time(starttime, state, 0, "early");
         trace_suspend_resume(TPS("dpm_resume_early"), state.event, false);
 }
 
@@ -948,7 +955,7 @@ void dpm_resume(pm_message_t state)
         }
         mutex_unlock(&dpm_list_mtx);
         async_synchronize_full();
-        dpm_show_time(starttime, state, NULL);
+        dpm_show_time(starttime, state, 0, NULL);
 
         cpufreq_resume();
         trace_suspend_resume(TPS("dpm_resume"), state.event, false);
@@ -1098,6 +1105,11 @@ static int __device_suspend_noirq(struct device *dev, pm_message_t state, bool a
         if (async_error)
                 goto Complete;
 
+        if (pm_wakeup_pending()) {
+                async_error = -EBUSY;
+                goto Complete;
+        }
+
         if (dev->power.syscore || dev->power.direct_complete)
                 goto Complete;
 
@@ -1158,22 +1170,19 @@ static int device_suspend_noirq(struct device *dev)
         return __device_suspend_noirq(dev, pm_transition, false);
 }
 
-/**
- * dpm_suspend_noirq - Execute "noirq suspend" callbacks for all devices.
- * @state: PM transition of the system being carried out.
- *
- * Prevent device drivers from receiving interrupts and call the "noirq" suspend
- * handlers for all non-sysdev devices.
- */
-int dpm_suspend_noirq(pm_message_t state)
+void dpm_noirq_begin(void)
+{
+        cpuidle_pause();
+        device_wakeup_arm_wake_irqs();
+        suspend_device_irqs();
+}
+
+int dpm_noirq_suspend_devices(pm_message_t state)
 {
         ktime_t starttime = ktime_get();
         int error = 0;
 
         trace_suspend_resume(TPS("dpm_suspend_noirq"), state.event, true);
-        cpuidle_pause();
-        device_wakeup_arm_wake_irqs();
-        suspend_device_irqs();
         mutex_lock(&dpm_list_mtx);
         pm_transition = state;
         async_error = 0;
@@ -1208,15 +1217,32 @@ int dpm_suspend_noirq(pm_message_t state)
         if (error) {
                 suspend_stats.failed_suspend_noirq++;
                 dpm_save_failed_step(SUSPEND_SUSPEND_NOIRQ);
-                dpm_resume_noirq(resume_event(state));
-        } else {
-                dpm_show_time(starttime, state, "noirq");
         }
+        dpm_show_time(starttime, state, error, "noirq");
         trace_suspend_resume(TPS("dpm_suspend_noirq"), state.event, false);
         return error;
 }
 
 /**
+ * dpm_suspend_noirq - Execute "noirq suspend" callbacks for all devices.
+ * @state: PM transition of the system being carried out.
+ *
+ * Prevent device drivers' interrupt handlers from being called and invoke
+ * "noirq" suspend callbacks for all non-sysdev devices.
+ */
+int dpm_suspend_noirq(pm_message_t state)
+{
+        int ret;
+
+        dpm_noirq_begin();
+        ret = dpm_noirq_suspend_devices(state);
+        if (ret)
+                dpm_resume_noirq(resume_event(state));
+
+        return ret;
+}
+
+/**
  * device_suspend_late - Execute a "late suspend" callback for given device.
  * @dev: Device to handle.
  * @state: PM transition of the system being carried out.
@@ -1350,9 +1376,8 @@ int dpm_suspend_late(pm_message_t state)
                 suspend_stats.failed_suspend_late++;
                 dpm_save_failed_step(SUSPEND_SUSPEND_LATE);
                 dpm_resume_early(resume_event(state));
-        } else {
-                dpm_show_time(starttime, state, "late");
         }
+        dpm_show_time(starttime, state, error, "late");
         trace_suspend_resume(TPS("dpm_suspend_late"), state.event, false);
         return error;
 }
@@ -1618,8 +1643,8 @@ int dpm_suspend(pm_message_t state)
         if (error) {
                 suspend_stats.failed_suspend++;
                 dpm_save_failed_step(SUSPEND_SUSPEND);
-        } else
-                dpm_show_time(starttime, state, NULL);
+        }
+        dpm_show_time(starttime, state, error, NULL);
         trace_suspend_resume(TPS("dpm_suspend"), state.event, false);
         return error;
 }