1 files changed, 297 insertions, 36 deletions

diff --git a/drivers/base/power/main.c b/drivers/base/power/main.c
index 8aa2443182d5..941fcb87e52a 100644
--- a/drivers/base/power/main.c
+++ b/drivers/base/power/main.c
@@ -23,8 +23,9 @@
 #include <linux/pm.h>
 #include <linux/pm_runtime.h>
 #include <linux/resume-trace.h>
-#include <linux/rwsem.h>
 #include <linux/interrupt.h>
+#include <linux/sched.h>
+#include <linux/async.h>
 
 #include "../base.h"
 #include "power.h"
@@ -34,14 +35,15 @@
  * because children are guaranteed to be discovered after parents, and
  * are inserted at the back of the list on discovery.
  *
- * Since device_pm_add() may be called with a device semaphore held,
- * we must never try to acquire a device semaphore while holding
+ * Since device_pm_add() may be called with a device lock held,
+ * we must never try to acquire a device lock while holding
  * dpm_list_mutex.
  */
 
 LIST_HEAD(dpm_list);
 
 static DEFINE_MUTEX(dpm_list_mtx);
+static pm_message_t pm_transition;
 
 /*
  * Set once the preparation of devices for a PM transition has started, reset
@@ -56,6 +58,7 @@ static bool transition_started;
 void device_pm_init(struct device *dev)
 {
         dev->power.status = DPM_ON;
+        init_completion(&dev->power.completion);
         pm_runtime_init(dev);
 }
 
@@ -111,6 +114,7 @@ void device_pm_remove(struct device *dev)
         pr_debug("PM: Removing info for %s:%s\n",
                  dev->bus ? dev->bus->name : "No Bus",
                  kobject_name(&dev->kobj));
+        complete_all(&dev->power.completion);
         mutex_lock(&dpm_list_mtx);
         list_del_init(&dev->power.entry);
         mutex_unlock(&dpm_list_mtx);
@@ -161,6 +165,57 @@ void device_pm_move_last(struct device *dev)
         list_move_tail(&dev->power.entry, &dpm_list);
 }
 
+static ktime_t initcall_debug_start(struct device *dev)
+{
+        ktime_t calltime = ktime_set(0, 0);
+
+        if (initcall_debug) {
+                pr_info("calling  %s+ @ %i\n",
+                                dev_name(dev), task_pid_nr(current));
+                calltime = ktime_get();
+        }
+
+        return calltime;
+}
+
+static void initcall_debug_report(struct device *dev, ktime_t calltime,
+                                  int error)
+{
+        ktime_t delta, rettime;
+
+        if (initcall_debug) {
+                rettime = ktime_get();
+                delta = ktime_sub(rettime, calltime);
+                pr_info("call %s+ returned %d after %Ld usecs\n", dev_name(dev),
+                        error, (unsigned long long)ktime_to_ns(delta) >> 10);
+        }
+}
+
+/**
+ * dpm_wait - Wait for a PM operation to complete.
+ * @dev: Device to wait for.
+ * @async: If unset, wait only if the device's power.async_suspend flag is set.
+ */
+static void dpm_wait(struct device *dev, bool async)
+{
+        if (!dev)
+                return;
+
+        if (async || (pm_async_enabled && dev->power.async_suspend))
+                wait_for_completion(&dev->power.completion);
+}
+
+static int dpm_wait_fn(struct device *dev, void *async_ptr)
+{
+        dpm_wait(dev, *((bool *)async_ptr));
+        return 0;
+}
+
+static void dpm_wait_for_children(struct device *dev, bool async)
+{
+       device_for_each_child(dev, &async, dpm_wait_fn);
+}
+
 /**
  * pm_op - Execute the PM operation appropriate for given PM event.
  * @dev: Device to handle.
@@ -172,6 +227,9 @@ static int pm_op(struct device *dev,
                  pm_message_t state)
 {
         int error = 0;
+        ktime_t calltime;
+
+        calltime = initcall_debug_start(dev);
 
         switch (state.event) {
 #ifdef CONFIG_SUSPEND
@@ -219,6 +277,9 @@ static int pm_op(struct device *dev,
         default:
                 error = -EINVAL;
         }
+
+        initcall_debug_report(dev, calltime, error);
+
         return error;
 }
 
@@ -236,6 +297,14 @@ static int pm_noirq_op(struct device *dev,
                         pm_message_t state)
 {
         int error = 0;
+        ktime_t calltime, delta, rettime;
+
+        if (initcall_debug) {
+                pr_info("calling  %s+ @ %i, parent: %s\n",
+                                dev_name(dev), task_pid_nr(current),
+                                dev->parent ? dev_name(dev->parent) : "none");
+                calltime = ktime_get();
+        }
 
         switch (state.event) {
 #ifdef CONFIG_SUSPEND
@@ -283,6 +352,15 @@ static int pm_noirq_op(struct device *dev,
         default:
                 error = -EINVAL;
         }
+
+        if (initcall_debug) {
+                rettime = ktime_get();
+                delta = ktime_sub(rettime, calltime);
+                printk("initcall %s_i+ returned %d after %Ld usecs\n",
+                        dev_name(dev), error,
+                        (unsigned long long)ktime_to_ns(delta) >> 10);
+        }
+
         return error;
 }
 
@@ -324,6 +402,23 @@ static void pm_dev_err(struct device *dev, pm_message_t state, char *info,
                 kobject_name(&dev->kobj), pm_verb(state.event), info, error);
 }
 
+static void dpm_show_time(ktime_t starttime, pm_message_t state, char *info)
+{
+        ktime_t calltime;
+        s64 usecs64;
+        int usecs;
+
+        calltime = ktime_get();
+        usecs64 = ktime_to_ns(ktime_sub(calltime, starttime));
+        do_div(usecs64, NSEC_PER_USEC);
+        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);
+}
+
 /*------------------------- Resume routines -------------------------*/
 
 /**
@@ -341,14 +436,26 @@ static int device_resume_noirq(struct device *dev, pm_message_t state)
         TRACE_DEVICE(dev);
         TRACE_RESUME(0);
 
-        if (!dev->bus)
-                goto End;
-
-        if (dev->bus->pm) {
+        if (dev->bus && dev->bus->pm) {
                 pm_dev_dbg(dev, state, "EARLY ");
                 error = pm_noirq_op(dev, dev->bus->pm, state);
+                if (error)
+                        goto End;
         }
- End:
+
+        if (dev->type && dev->type->pm) {
+                pm_dev_dbg(dev, state, "EARLY type ");
+                error = pm_noirq_op(dev, dev->type->pm, state);
+                if (error)
+                        goto End;
+        }
+
+        if (dev->class && dev->class->pm) {
+                pm_dev_dbg(dev, state, "EARLY class ");
+                error = pm_noirq_op(dev, dev->class->pm, state);
+        }
+
+End:
         TRACE_RESUME(error);
         return error;
 }
@@ -363,6 +470,7 @@ static int device_resume_noirq(struct device *dev, pm_message_t state)
 void dpm_resume_noirq(pm_message_t state)
 {
         struct device *dev;
+        ktime_t starttime = ktime_get();
 
         mutex_lock(&dpm_list_mtx);
         transition_started = false;
@@ -376,23 +484,48 @@ void dpm_resume_noirq(pm_message_t state)
                                 pm_dev_err(dev, state, " early", error);
                 }
         mutex_unlock(&dpm_list_mtx);
+        dpm_show_time(starttime, state, "early");
         resume_device_irqs();
 }
 EXPORT_SYMBOL_GPL(dpm_resume_noirq);
 
 /**
+ * legacy_resume - Execute a legacy (bus or class) resume callback for device.
+ * @dev: Device to resume.
+ * @cb: Resume callback to execute.
+ */
+static int legacy_resume(struct device *dev, int (*cb)(struct device *dev))
+{
+        int error;
+        ktime_t calltime;
+
+        calltime = initcall_debug_start(dev);
+
+        error = cb(dev);
+        suspend_report_result(cb, error);
+
+        initcall_debug_report(dev, calltime, error);
+
+        return error;
+}
+
+/**
  * device_resume - Execute "resume" callbacks for given device.
  * @dev: Device to handle.
  * @state: PM transition of the system being carried out.
+ * @async: If true, the device is being resumed asynchronously.
  */
-static int device_resume(struct device *dev, pm_message_t state)
+static int device_resume(struct device *dev, pm_message_t state, bool async)
 {
         int error = 0;
 
         TRACE_DEVICE(dev);
         TRACE_RESUME(0);
 
-        down(&dev->sem);
+        dpm_wait(dev->parent, async);
+        device_lock(dev);
+
+        dev->power.status = DPM_RESUMING;
 
         if (dev->bus) {
                 if (dev->bus->pm) {
@@ -400,7 +533,7 @@ static int device_resume(struct device *dev, pm_message_t state)
                         error = pm_op(dev, dev->bus->pm, state);
                 } else if (dev->bus->resume) {
                         pm_dev_dbg(dev, state, "legacy ");
-                        error = dev->bus->resume(dev);
+                        error = legacy_resume(dev, dev->bus->resume);
                 }
                 if (error)
                         goto End;
@@ -421,16 +554,34 @@ static int device_resume(struct device *dev, pm_message_t state)
                         error = pm_op(dev, dev->class->pm, state);
                 } else if (dev->class->resume) {
                         pm_dev_dbg(dev, state, "legacy class ");
-                        error = dev->class->resume(dev);
+                        error = legacy_resume(dev, dev->class->resume);
                 }
         }
  End:
-        up(&dev->sem);
+        device_unlock(dev);
+        complete_all(&dev->power.completion);
 
         TRACE_RESUME(error);
         return error;
 }
 
+static void async_resume(void *data, async_cookie_t cookie)
+{
+        struct device *dev = (struct device *)data;
+        int error;
+
+        error = device_resume(dev, pm_transition, true);
+        if (error)
+                pm_dev_err(dev, pm_transition, " async", error);
+        put_device(dev);
+}
+
+static bool is_async(struct device *dev)
+{
+        return dev->power.async_suspend && pm_async_enabled
+                && !pm_trace_is_enabled();
+}
+
 /**
  * dpm_resume - Execute "resume" callbacks for non-sysdev devices.
  * @state: PM transition of the system being carried out.
@@ -441,20 +592,33 @@ static int device_resume(struct device *dev, pm_message_t state)
 static void dpm_resume(pm_message_t state)
 {
         struct list_head list;
+        struct device *dev;
+        ktime_t starttime = ktime_get();
 
         INIT_LIST_HEAD(&list);
         mutex_lock(&dpm_list_mtx);
-        while (!list_empty(&dpm_list)) {
-                struct device *dev = to_device(dpm_list.next);
+        pm_transition = state;
+
+        list_for_each_entry(dev, &dpm_list, power.entry) {
+                if (dev->power.status < DPM_OFF)
+                        continue;
+
+                INIT_COMPLETION(dev->power.completion);
+                if (is_async(dev)) {
+                        get_device(dev);
+                        async_schedule(async_resume, dev);
+                }
+        }
 
+        while (!list_empty(&dpm_list)) {
+                dev = to_device(dpm_list.next);
                 get_device(dev);
-                if (dev->power.status >= DPM_OFF) {
+                if (dev->power.status >= DPM_OFF && !is_async(dev)) {
                         int error;
 
-                        dev->power.status = DPM_RESUMING;
                         mutex_unlock(&dpm_list_mtx);
 
-                        error = device_resume(dev, state);
+                        error = device_resume(dev, state, false);
 
                         mutex_lock(&dpm_list_mtx);
                         if (error)
@@ -469,6 +633,8 @@ static void dpm_resume(pm_message_t state)
         }
         list_splice(&list, &dpm_list);
         mutex_unlock(&dpm_list_mtx);
+        async_synchronize_full();
+        dpm_show_time(starttime, state, NULL);
 }
 
 /**
@@ -478,7 +644,7 @@ static void dpm_resume(pm_message_t state)
  */
 static void device_complete(struct device *dev, pm_message_t state)
 {
-        down(&dev->sem);
+        device_lock(dev);
 
         if (dev->class && dev->class->pm && dev->class->pm->complete) {
                 pm_dev_dbg(dev, state, "completing class ");
@@ -495,7 +661,7 @@ static void device_complete(struct device *dev, pm_message_t state)
                 dev->bus->pm->complete(dev);
         }
 
-        up(&dev->sem);
+        device_unlock(dev);
 }
 
 /**
@@ -521,7 +687,7 @@ static void dpm_complete(pm_message_t state)
                         mutex_unlock(&dpm_list_mtx);
 
                         device_complete(dev, state);
-                        pm_runtime_put_noidle(dev);
+                        pm_runtime_put_sync(dev);
 
                         mutex_lock(&dpm_list_mtx);
                 }
@@ -584,13 +750,26 @@ static int device_suspend_noirq(struct device *dev, pm_message_t state)
 {
         int error = 0;
 
-        if (!dev->bus)
-                return 0;
+        if (dev->class && dev->class->pm) {
+                pm_dev_dbg(dev, state, "LATE class ");
+                error = pm_noirq_op(dev, dev->class->pm, state);
+                if (error)
+                        goto End;
+        }
 
-        if (dev->bus->pm) {
+        if (dev->type && dev->type->pm) {
+                pm_dev_dbg(dev, state, "LATE type ");
+                error = pm_noirq_op(dev, dev->type->pm, state);
+                if (error)
+                        goto End;
+        }
+
+        if (dev->bus && dev->bus->pm) {
                 pm_dev_dbg(dev, state, "LATE ");
                 error = pm_noirq_op(dev, dev->bus->pm, state);
         }
+
+End:
         return error;
 }
 
@@ -604,6 +783,7 @@ static int device_suspend_noirq(struct device *dev, pm_message_t state)
 int dpm_suspend_noirq(pm_message_t state)
 {
         struct device *dev;
+        ktime_t starttime = ktime_get();
         int error = 0;
 
         suspend_device_irqs();
@@ -619,20 +799,51 @@ int dpm_suspend_noirq(pm_message_t state)
         mutex_unlock(&dpm_list_mtx);
         if (error)
                 dpm_resume_noirq(resume_event(state));
+        else
+                dpm_show_time(starttime, state, "late");
         return error;
 }
 EXPORT_SYMBOL_GPL(dpm_suspend_noirq);
 
 /**
+ * legacy_suspend - Execute a legacy (bus or class) suspend callback for device.
+ * @dev: Device to suspend.
+ * @state: PM transition of the system being carried out.
+ * @cb: Suspend callback to execute.
+ */
+static int legacy_suspend(struct device *dev, pm_message_t state,
+                          int (*cb)(struct device *dev, pm_message_t state))
+{
+        int error;
+        ktime_t calltime;
+
+        calltime = initcall_debug_start(dev);
+
+        error = cb(dev, state);
+        suspend_report_result(cb, error);
+
+        initcall_debug_report(dev, calltime, error);
+
+        return error;
+}
+
+static int async_error;
+
+/**
  * device_suspend - Execute "suspend" callbacks for given device.
  * @dev: Device to handle.
  * @state: PM transition of the system being carried out.
+ * @async: If true, the device is being suspended asynchronously.
  */
-static int device_suspend(struct device *dev, pm_message_t state)
+static int __device_suspend(struct device *dev, pm_message_t state, bool async)
 {
         int error = 0;
 
-        down(&dev->sem);
+        dpm_wait_for_children(dev, async);
+        device_lock(dev);
+
+        if (async_error)
+                goto End;
 
         if (dev->class) {
                 if (dev->class->pm) {
@@ -640,8 +851,7 @@ static int device_suspend(struct device *dev, pm_message_t state)
                         error = pm_op(dev, dev->class->pm, state);
                 } else if (dev->class->suspend) {
                         pm_dev_dbg(dev, state, "legacy class ");
-                        error = dev->class->suspend(dev, state);
-                        suspend_report_result(dev->class->suspend, error);
+                        error = legacy_suspend(dev, state, dev->class->suspend);
                 }
                 if (error)
                         goto End;
@@ -662,16 +872,47 @@ static int device_suspend(struct device *dev, pm_message_t state)
                         error = pm_op(dev, dev->bus->pm, state);
                 } else if (dev->bus->suspend) {
                         pm_dev_dbg(dev, state, "legacy ");
-                        error = dev->bus->suspend(dev, state);
-                        suspend_report_result(dev->bus->suspend, error);
+                        error = legacy_suspend(dev, state, dev->bus->suspend);
                 }
         }
+
+        if (!error)
+                dev->power.status = DPM_OFF;
+
  End:
-        up(&dev->sem);
+        device_unlock(dev);
+        complete_all(&dev->power.completion);
 
         return error;
 }
 
+static void async_suspend(void *data, async_cookie_t cookie)
+{
+        struct device *dev = (struct device *)data;
+        int error;
+
+        error = __device_suspend(dev, pm_transition, true);
+        if (error) {
+                pm_dev_err(dev, pm_transition, " async", error);
+                async_error = error;
+        }
+
+        put_device(dev);
+}
+
+static int device_suspend(struct device *dev)
+{
+        INIT_COMPLETION(dev->power.completion);
+
+        if (pm_async_enabled && dev->power.async_suspend) {
+                get_device(dev);
+                async_schedule(async_suspend, dev);
+                return 0;
+        }
+
+        return __device_suspend(dev, pm_transition, false);
+}
+
 /**
  * dpm_suspend - Execute "suspend" callbacks for all non-sysdev devices.
  * @state: PM transition of the system being carried out.
@@ -679,17 +920,20 @@ static int device_suspend(struct device *dev, pm_message_t state)
 static int dpm_suspend(pm_message_t state)
 {
         struct list_head list;
+        ktime_t starttime = ktime_get();
         int error = 0;
 
         INIT_LIST_HEAD(&list);
         mutex_lock(&dpm_list_mtx);
+        pm_transition = state;
+        async_error = 0;
         while (!list_empty(&dpm_list)) {
                 struct device *dev = to_device(dpm_list.prev);
 
                 get_device(dev);
                 mutex_unlock(&dpm_list_mtx);
 
-                error = device_suspend(dev, state);
+                error = device_suspend(dev);
 
                 mutex_lock(&dpm_list_mtx);
                 if (error) {
@@ -697,13 +941,19 @@ static int dpm_suspend(pm_message_t state)
                         put_device(dev);
                         break;
                 }
-                dev->power.status = DPM_OFF;
                 if (!list_empty(&dev->power.entry))
                         list_move(&dev->power.entry, &list);
                 put_device(dev);
+                if (async_error)
+                        break;
         }
         list_splice(&list, dpm_list.prev);
         mutex_unlock(&dpm_list_mtx);
+        async_synchronize_full();
+        if (!error)
+                error = async_error;
+        if (!error)
+                dpm_show_time(starttime, state, NULL);
         return error;
 }
 
@@ -719,7 +969,7 @@ static int device_prepare(struct device *dev, pm_message_t state)
 {
         int error = 0;
 
-        down(&dev->sem);
+        device_lock(dev);
 
         if (dev->bus && dev->bus->pm && dev->bus->pm->prepare) {
                 pm_dev_dbg(dev, state, "preparing ");
@@ -743,7 +993,7 @@ static int device_prepare(struct device *dev, pm_message_t state)
                 suspend_report_result(dev->class->pm->prepare, error);
         }
  End:
-        up(&dev->sem);
+        device_unlock(dev);
 
         return error;
 }
@@ -772,7 +1022,7 @@ static int dpm_prepare(pm_message_t state)
                 pm_runtime_get_noresume(dev);
                 if (pm_runtime_barrier(dev) && device_may_wakeup(dev)) {
                         /* Wake-up requested during system sleep transition. */
-                        pm_runtime_put_noidle(dev);
+                        pm_runtime_put_sync(dev);
                         error = -EBUSY;
                 } else {
                         error = device_prepare(dev, state);
@@ -827,3 +1077,14 @@ void __suspend_report_result(const char *function, void *fn, int ret)
                 printk(KERN_ERR "%s(): %pF returns %d\n", function, fn, ret);
 }
 EXPORT_SYMBOL_GPL(__suspend_report_result);
+
+/**
+ * device_pm_wait_for_dev - Wait for suspend/resume of a device to complete.
+ * @dev: Device to wait for.
+ * @subordinate: Device that needs to wait for @dev.
+ */
+void device_pm_wait_for_dev(struct device *subordinate, struct device *dev)
+{
+        dpm_wait(dev, subordinate->power.async_suspend);
+}
+EXPORT_SYMBOL_GPL(device_pm_wait_for_dev);