4 files changed, 280 insertions, 14 deletions

diff --git a/drivers/base/power/main.c b/drivers/base/power/main.c
index a5142bddef41..0e26a6f6fd48 100644
--- a/drivers/base/power/main.c
+++ b/drivers/base/power/main.c
@@ -25,6 +25,7 @@
 #include <linux/resume-trace.h>
 #include <linux/interrupt.h>
 #include <linux/sched.h>
+#include <linux/async.h>
 
 #include "../base.h"
 #include "power.h"
@@ -42,6 +43,7 @@
 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);
@@ -188,6 +192,31 @@ static void initcall_debug_report(struct device *dev, ktime_t calltime,
 }
 
 /**
+ * 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.
  * @ops: PM operations to choose from.
@@ -271,8 +300,9 @@ static int pm_noirq_op(struct device *dev,
         ktime_t calltime, delta, rettime;
 
         if (initcall_debug) {
-                pr_info("calling  %s_i+ @ %i\n",
-                                dev_name(dev), task_pid_nr(current));
+                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();
         }
 
@@ -468,16 +498,20 @@ static int legacy_resume(struct device *dev, int (*cb)(struct device *dev))
  * 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);
 
+        dpm_wait(dev->parent, async);
         down(&dev->sem);
 
+        dev->power.status = DPM_RESUMING;
+
         if (dev->bus) {
                 if (dev->bus->pm) {
                         pm_dev_dbg(dev, state, "");
@@ -510,11 +544,29 @@ static int device_resume(struct device *dev, pm_message_t state)
         }
  End:
         up(&dev->sem);
+        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.
@@ -525,21 +577,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)
@@ -554,6 +618,7 @@ 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);
 }
 
@@ -731,17 +796,24 @@ static int legacy_suspend(struct device *dev, pm_message_t state,
         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;
 
+        dpm_wait_for_children(dev, async);
         down(&dev->sem);
 
+        if (async_error)
+                goto End;
+
         if (dev->class) {
                 if (dev->class->pm) {
                         pm_dev_dbg(dev, state, "class ");
@@ -772,12 +844,44 @@ static int device_suspend(struct device *dev, pm_message_t state)
                         error = legacy_suspend(dev, state, dev->bus->suspend);
                 }
         }
+
+        if (!error)
+                dev->power.status = DPM_OFF;
+
  End:
         up(&dev->sem);
+        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.
@@ -790,13 +894,15 @@ static int dpm_suspend(pm_message_t state)
 
         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) {
@@ -804,13 +910,17 @@ 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;
@@ -936,3 +1046,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);
diff --git a/drivers/base/power/power.h b/drivers/base/power/power.h
index b8fa1aa5225a..c0bd03c83b9c 100644
--- a/drivers/base/power/power.h
+++ b/drivers/base/power/power.h
@@ -12,10 +12,10 @@ static inline void pm_runtime_remove(struct device *dev) {}
 
 #ifdef CONFIG_PM_SLEEP
 
-/*
- * main.c
- */
+/* kernel/power/main.c */
+extern int pm_async_enabled;
 
+/* drivers/base/power/main.c */
 extern struct list_head dpm_list;       /* The active device list */
 
 static inline struct device *to_device(struct list_head *entry)
diff --git a/drivers/base/power/runtime.c b/drivers/base/power/runtime.c
index f8b044e8aef7..626dd147b75f 100644
--- a/drivers/base/power/runtime.c
+++ b/drivers/base/power/runtime.c
@@ -1011,6 +1011,50 @@ void pm_runtime_enable(struct device *dev)
 EXPORT_SYMBOL_GPL(pm_runtime_enable);
 
 /**
+ * pm_runtime_forbid - Block run-time PM of a device.
+ * @dev: Device to handle.
+ *
+ * Increase the device's usage count and clear its power.runtime_auto flag,
+ * so that it cannot be suspended at run time until pm_runtime_allow() is called
+ * for it.
+ */
+void pm_runtime_forbid(struct device *dev)
+{
+        spin_lock_irq(&dev->power.lock);
+        if (!dev->power.runtime_auto)
+                goto out;
+
+        dev->power.runtime_auto = false;
+        atomic_inc(&dev->power.usage_count);
+        __pm_runtime_resume(dev, false);
+
+ out:
+        spin_unlock_irq(&dev->power.lock);
+}
+EXPORT_SYMBOL_GPL(pm_runtime_forbid);
+
+/**
+ * pm_runtime_allow - Unblock run-time PM of a device.
+ * @dev: Device to handle.
+ *
+ * Decrease the device's usage count and set its power.runtime_auto flag.
+ */
+void pm_runtime_allow(struct device *dev)
+{
+        spin_lock_irq(&dev->power.lock);
+        if (dev->power.runtime_auto)
+                goto out;
+
+        dev->power.runtime_auto = true;
+        if (atomic_dec_and_test(&dev->power.usage_count))
+                __pm_runtime_idle(dev);
+
+ out:
+        spin_unlock_irq(&dev->power.lock);
+}
+EXPORT_SYMBOL_GPL(pm_runtime_allow);
+
+/**
  * pm_runtime_init - Initialize run-time PM fields in given device object.
  * @dev: Device object to initialize.
  */
@@ -1028,6 +1072,7 @@ void pm_runtime_init(struct device *dev)
 
         atomic_set(&dev->power.child_count, 0);
         pm_suspend_ignore_children(dev, false);
+        dev->power.runtime_auto = true;
 
         dev->power.request_pending = false;
         dev->power.request = RPM_REQ_NONE;
diff --git a/drivers/base/power/sysfs.c b/drivers/base/power/sysfs.c
index 596aeecfdffe..86fd9373447e 100644
--- a/drivers/base/power/sysfs.c
+++ b/drivers/base/power/sysfs.c
@@ -4,9 +4,25 @@
 
 #include <linux/device.h>
 #include <linux/string.h>
+#include <linux/pm_runtime.h>
 #include "power.h"
 
 /*
+ *      control - Report/change current runtime PM setting of the device
+ *
+ *      Runtime power management of a device can be blocked with the help of
+ *      this attribute.  All devices have one of the following two values for
+ *      the power/control file:
+ *
+ *       + "auto\n" to allow the device to be power managed at run time;
+ *       + "on\n" to prevent the device from being power managed at run time;
+ *
+ *      The default for all devices is "auto", which means that devices may be
+ *      subject to automatic power management, depending on their drivers.
+ *      Changing this attribute to "on" prevents the driver from power managing
+ *      the device at run time.  Doing that while the device is suspended causes
+ *      it to be woken up.
+ *
  *      wakeup - Report/change current wakeup option for device
  *
  *      Some devices support "wakeup" events, which are hardware signals
@@ -38,11 +54,61 @@
  *      wakeup events internally (unless they are disabled), keeping
  *      their hardware in low power modes whenever they're unused.  This
  *      saves runtime power, without requiring system-wide sleep states.
+ *
+ *      async - Report/change current async suspend setting for the device
+ *
+ *      Asynchronous suspend and resume of the device during system-wide power
+ *      state transitions can be enabled by writing "enabled" to this file.
+ *      Analogously, if "disabled" is written to this file, the device will be
+ *      suspended and resumed synchronously.
+ *
+ *      All devices have one of the following two values for power/async:
+ *
+ *       + "enabled\n" to permit the asynchronous suspend/resume of the device;
+ *       + "disabled\n" to forbid it;
+ *
+ *      NOTE: It generally is unsafe to permit the asynchronous suspend/resume
+ *      of a device unless it is certain that all of the PM dependencies of the
+ *      device are known to the PM core.  However, for some devices this
+ *      attribute is set to "enabled" by bus type code or device drivers and in
+ *      that cases it should be safe to leave the default value.
  */
 
 static const char enabled[] = "enabled";
 static const char disabled[] = "disabled";
 
+#ifdef CONFIG_PM_RUNTIME
+static const char ctrl_auto[] = "auto";
+static const char ctrl_on[] = "on";
+
+static ssize_t control_show(struct device *dev, struct device_attribute *attr,
+                            char *buf)
+{
+        return sprintf(buf, "%s\n",
+                                dev->power.runtime_auto ? ctrl_auto : ctrl_on);
+}
+
+static ssize_t control_store(struct device * dev, struct device_attribute *attr,
+                             const char * buf, size_t n)
+{
+        char *cp;
+        int len = n;
+
+        cp = memchr(buf, '\n', n);
+        if (cp)
+                len = cp - buf;
+        if (len == sizeof ctrl_auto - 1 && strncmp(buf, ctrl_auto, len) == 0)
+                pm_runtime_allow(dev);
+        else if (len == sizeof ctrl_on - 1 && strncmp(buf, ctrl_on, len) == 0)
+                pm_runtime_forbid(dev);
+        else
+                return -EINVAL;
+        return n;
+}
+
+static DEVICE_ATTR(control, 0644, control_show, control_store);
+#endif
+
 static ssize_t
 wake_show(struct device * dev, struct device_attribute *attr, char * buf)
 {
@@ -77,9 +143,43 @@ wake_store(struct device * dev, struct device_attribute *attr,
 
 static DEVICE_ATTR(wakeup, 0644, wake_show, wake_store);
 
+#ifdef CONFIG_PM_SLEEP_ADVANCED_DEBUG
+static ssize_t async_show(struct device *dev, struct device_attribute *attr,
+                          char *buf)
+{
+        return sprintf(buf, "%s\n",
+                        device_async_suspend_enabled(dev) ? enabled : disabled);
+}
+
+static ssize_t async_store(struct device *dev, struct device_attribute *attr,
+                           const char *buf, size_t n)
+{
+        char *cp;
+        int len = n;
+
+        cp = memchr(buf, '\n', n);
+        if (cp)
+                len = cp - buf;
+        if (len == sizeof enabled - 1 && strncmp(buf, enabled, len) == 0)
+                device_enable_async_suspend(dev);
+        else if (len == sizeof disabled - 1 && strncmp(buf, disabled, len) == 0)
+                device_disable_async_suspend(dev);
+        else
+                return -EINVAL;
+        return n;
+}
+
+static DEVICE_ATTR(async, 0644, async_show, async_store);
+#endif /* CONFIG_PM_SLEEP_ADVANCED_DEBUG */
 
 static struct attribute * power_attrs[] = {
+#ifdef CONFIG_PM_RUNTIME
+        &dev_attr_control.attr,
+#endif
         &dev_attr_wakeup.attr,
+#ifdef CONFIG_PM_SLEEP_ADVANCED_DEBUG
+        &dev_attr_async.attr,
+#endif
         NULL,
 };
 static struct attribute_group pm_attr_group = {