PM: Introduce core framework for run-time PM of I/O devices (rev. 17)

Introduce a core framework for run-time power management of I/O
devices.  Add device run-time PM fields to 'struct dev_pm_info'
and device run-time PM callbacks to 'struct dev_pm_ops'.  Introduce
a run-time PM workqueue and define some device run-time PM helper
functions at the core level.  Document all these things.

Special thanks to Alan Stern for his help with the design and
multiple detailed reviews of the pereceding versions of this patch
and to Magnus Damm for testing feedback.

Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Acked-by: Magnus Damm <damm@igel.co.jp>

5 files changed, 1068 insertions, 8 deletions

diff --git a/drivers/base/dd.c b/drivers/base/dd.c
index f0106875f01d..7b34b3a48f67 100644
--- a/drivers/base/dd.c
+++ b/drivers/base/dd.c
@@ -23,6 +23,7 @@
 #include <linux/kthread.h>
 #include <linux/wait.h>
 #include <linux/async.h>
+#include <linux/pm_runtime.h>
 
 #include "base.h"
 #include "power/power.h"
@@ -202,7 +203,10 @@ int driver_probe_device(struct device_driver *drv, struct device *dev)
         pr_debug("bus: '%s': %s: matched device %s with driver %s\n",
                  drv->bus->name, __func__, dev_name(dev), drv->name);
 
+        pm_runtime_get_noresume(dev);
+        pm_runtime_barrier(dev);
         ret = really_probe(dev, drv);
+        pm_runtime_put_sync(dev);
 
         return ret;
 }
@@ -245,7 +249,9 @@ int device_attach(struct device *dev)
                         ret = 0;
                 }
         } else {
+                pm_runtime_get_noresume(dev);
                 ret = bus_for_each_drv(dev->bus, NULL, dev, __device_attach);
+                pm_runtime_put_sync(dev);
         }
         up(&dev->sem);
         return ret;
@@ -306,6 +312,9 @@ static void __device_release_driver(struct device *dev)
 
         drv = dev->driver;
         if (drv) {
+                pm_runtime_get_noresume(dev);
+                pm_runtime_barrier(dev);
+
                 driver_sysfs_remove(dev);
 
                 if (dev->bus)
@@ -324,6 +333,8 @@ static void __device_release_driver(struct device *dev)
                         blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
                                                      BUS_NOTIFY_UNBOUND_DRIVER,
                                                      dev);
+
+                pm_runtime_put_sync(dev);
         }
 }
 
diff --git a/drivers/base/power/Makefile b/drivers/base/power/Makefile
index 911208b89259..3ce3519e8f30 100644
--- a/drivers/base/power/Makefile
+++ b/drivers/base/power/Makefile
@@ -1,5 +1,6 @@
 obj-$(CONFIG_PM)        += sysfs.o
 obj-$(CONFIG_PM_SLEEP)  += main.o
+obj-$(CONFIG_PM_RUNTIME)        += runtime.o
 obj-$(CONFIG_PM_TRACE_RTC)      += trace.o
 
 ccflags-$(CONFIG_DEBUG_DRIVER) := -DDEBUG
diff --git a/drivers/base/power/main.c b/drivers/base/power/main.c
index 1b1a786b7dec..86990011277b 100644
--- a/drivers/base/power/main.c
+++ b/drivers/base/power/main.c
@@ -21,6 +21,7 @@
 #include <linux/kallsyms.h>
 #include <linux/mutex.h>
 #include <linux/pm.h>
+#include <linux/pm_runtime.h>
 #include <linux/resume-trace.h>
 #include <linux/rwsem.h>
 #include <linux/interrupt.h>
@@ -49,6 +50,16 @@ static DEFINE_MUTEX(dpm_list_mtx);
 static bool transition_started;
 
 /**
+ * device_pm_init - Initialize the PM-related part of a device object
+ * @dev: Device object being initialized.
+ */
+void device_pm_init(struct device *dev)
+{
+        dev->power.status = DPM_ON;
+        pm_runtime_init(dev);
+}
+
+/**
  *      device_pm_lock - lock the list of active devices used by the PM core
  */
 void device_pm_lock(void)
@@ -105,6 +116,7 @@ void device_pm_remove(struct device *dev)
         mutex_lock(&dpm_list_mtx);
         list_del_init(&dev->power.entry);
         mutex_unlock(&dpm_list_mtx);
+        pm_runtime_remove(dev);
 }
 
 /**
@@ -512,6 +524,7 @@ static void dpm_complete(pm_message_t state)
                         mutex_unlock(&dpm_list_mtx);
 
                         device_complete(dev, state);
+                        pm_runtime_put_noidle(dev);
 
                         mutex_lock(&dpm_list_mtx);
                 }
@@ -757,7 +770,14 @@ static int dpm_prepare(pm_message_t state)
                 dev->power.status = DPM_PREPARING;
                 mutex_unlock(&dpm_list_mtx);
 
-                error = device_prepare(dev, 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);
+                        error = -EBUSY;
+                } else {
+                        error = device_prepare(dev, state);
+                }
 
                 mutex_lock(&dpm_list_mtx);
                 if (error) {
diff --git a/drivers/base/power/power.h b/drivers/base/power/power.h
index c7cb4fc3735c..b8fa1aa5225a 100644
--- a/drivers/base/power/power.h
+++ b/drivers/base/power/power.h
@@ -1,7 +1,14 @@
-static inline void device_pm_init(struct device *dev)
-{
-        dev->power.status = DPM_ON;
-}
+#ifdef CONFIG_PM_RUNTIME
+
+extern void pm_runtime_init(struct device *dev);
+extern void pm_runtime_remove(struct device *dev);
+
+#else /* !CONFIG_PM_RUNTIME */
+
+static inline void pm_runtime_init(struct device *dev) {}
+static inline void pm_runtime_remove(struct device *dev) {}
+
+#endif /* !CONFIG_PM_RUNTIME */
 
 #ifdef CONFIG_PM_SLEEP
 
@@ -16,23 +23,33 @@ static inline struct device *to_device(struct list_head *entry)
         return container_of(entry, struct device, power.entry);
 }
 
+extern void device_pm_init(struct device *dev);
 extern void device_pm_add(struct device *);
 extern void device_pm_remove(struct device *);
 extern void device_pm_move_before(struct device *, struct device *);
 extern void device_pm_move_after(struct device *, struct device *);
 extern void device_pm_move_last(struct device *);
 
-#else /* CONFIG_PM_SLEEP */
+#else /* !CONFIG_PM_SLEEP */
+
+static inline void device_pm_init(struct device *dev)
+{
+        pm_runtime_init(dev);
+}
+
+static inline void device_pm_remove(struct device *dev)
+{
+        pm_runtime_remove(dev);
+}
 
 static inline void device_pm_add(struct device *dev) {}
-static inline void device_pm_remove(struct device *dev) {}
 static inline void device_pm_move_before(struct device *deva,
                                          struct device *devb) {}
 static inline void device_pm_move_after(struct device *deva,
                                         struct device *devb) {}
 static inline void device_pm_move_last(struct device *dev) {}
 
-#endif
+#endif /* !CONFIG_PM_SLEEP */
 
 #ifdef CONFIG_PM
 
diff --git a/drivers/base/power/runtime.c b/drivers/base/power/runtime.c
new file mode 100644
index 000000000000..38556f6cc22d
--- /dev/null
+++ b/drivers/base/power/runtime.c
@@ -0,0 +1,1011 @@
+/*
+ * drivers/base/power/runtime.c - Helper functions for device run-time PM
+ *
+ * Copyright (c) 2009 Rafael J. Wysocki <rjw@sisk.pl>, Novell Inc.
+ *
+ * This file is released under the GPLv2.
+ */
+
+#include <linux/sched.h>
+#include <linux/pm_runtime.h>
+#include <linux/jiffies.h>
+
+static int __pm_runtime_resume(struct device *dev, bool from_wq);
+static int __pm_request_idle(struct device *dev);
+static int __pm_request_resume(struct device *dev);
+
+/**
+ * pm_runtime_deactivate_timer - Deactivate given device's suspend timer.
+ * @dev: Device to handle.
+ */
+static void pm_runtime_deactivate_timer(struct device *dev)
+{
+        if (dev->power.timer_expires > 0) {
+                del_timer(&dev->power.suspend_timer);
+                dev->power.timer_expires = 0;
+        }
+}
+
+/**
+ * pm_runtime_cancel_pending - Deactivate suspend timer and cancel requests.
+ * @dev: Device to handle.
+ */
+static void pm_runtime_cancel_pending(struct device *dev)
+{
+        pm_runtime_deactivate_timer(dev);
+        /*
+         * In case there's a request pending, make sure its work function will
+         * return without doing anything.
+         */
+        dev->power.request = RPM_REQ_NONE;
+}
+
+/**
+ * __pm_runtime_idle - Notify device bus type if the device can be suspended.
+ * @dev: Device to notify the bus type about.
+ *
+ * This function must be called under dev->power.lock with interrupts disabled.
+ */
+static int __pm_runtime_idle(struct device *dev)
+        __releases(&dev->power.lock) __acquires(&dev->power.lock)
+{
+        int retval = 0;
+
+        dev_dbg(dev, "__pm_runtime_idle()!\n");
+
+        if (dev->power.runtime_error)
+                retval = -EINVAL;
+        else if (dev->power.idle_notification)
+                retval = -EINPROGRESS;
+        else if (atomic_read(&dev->power.usage_count) > 0
+            || dev->power.disable_depth > 0
+            || dev->power.runtime_status != RPM_ACTIVE)
+                retval = -EAGAIN;
+        else if (!pm_children_suspended(dev))
+                retval = -EBUSY;
+        if (retval)
+                goto out;
+
+        if (dev->power.request_pending) {
+                /*
+                 * If an idle notification request is pending, cancel it.  Any
+                 * other pending request takes precedence over us.
+                 */
+                if (dev->power.request == RPM_REQ_IDLE) {
+                        dev->power.request = RPM_REQ_NONE;
+                } else if (dev->power.request != RPM_REQ_NONE) {
+                        retval = -EAGAIN;
+                        goto out;
+                }
+        }
+
+        dev->power.idle_notification = true;
+
+        if (dev->bus && dev->bus->pm && dev->bus->pm->runtime_idle) {
+                spin_unlock_irq(&dev->power.lock);
+
+                dev->bus->pm->runtime_idle(dev);
+
+                spin_lock_irq(&dev->power.lock);
+        }
+
+        dev->power.idle_notification = false;
+        wake_up_all(&dev->power.wait_queue);
+
+ out:
+        dev_dbg(dev, "__pm_runtime_idle() returns %d!\n", retval);
+
+        return retval;
+}
+
+/**
+ * pm_runtime_idle - Notify device bus type if the device can be suspended.
+ * @dev: Device to notify the bus type about.
+ */
+int pm_runtime_idle(struct device *dev)
+{
+        int retval;
+
+        spin_lock_irq(&dev->power.lock);
+        retval = __pm_runtime_idle(dev);
+        spin_unlock_irq(&dev->power.lock);
+
+        return retval;
+}
+EXPORT_SYMBOL_GPL(pm_runtime_idle);
+
+/**
+ * __pm_runtime_suspend - Carry out run-time suspend of given device.
+ * @dev: Device to suspend.
+ * @from_wq: If set, the function has been called via pm_wq.
+ *
+ * Check if the device can be suspended and run the ->runtime_suspend() callback
+ * provided by its bus type.  If another suspend has been started earlier, wait
+ * for it to finish.  If an idle notification or suspend request is pending or
+ * scheduled, cancel it.
+ *
+ * This function must be called under dev->power.lock with interrupts disabled.
+ */
+int __pm_runtime_suspend(struct device *dev, bool from_wq)
+        __releases(&dev->power.lock) __acquires(&dev->power.lock)
+{
+        struct device *parent = NULL;
+        bool notify = false;
+        int retval = 0;
+
+        dev_dbg(dev, "__pm_runtime_suspend()%s!\n",
+                from_wq ? " from workqueue" : "");
+
+ repeat:
+        if (dev->power.runtime_error) {
+                retval = -EINVAL;
+                goto out;
+        }
+
+        /* Pending resume requests take precedence over us. */
+        if (dev->power.request_pending
+            && dev->power.request == RPM_REQ_RESUME) {
+                retval = -EAGAIN;
+                goto out;
+        }
+
+        /* Other scheduled or pending requests need to be canceled. */
+        pm_runtime_cancel_pending(dev);
+
+        if (dev->power.runtime_status == RPM_SUSPENDED)
+                retval = 1;
+        else if (dev->power.runtime_status == RPM_RESUMING
+            || dev->power.disable_depth > 0
+            || atomic_read(&dev->power.usage_count) > 0)
+                retval = -EAGAIN;
+        else if (!pm_children_suspended(dev))
+                retval = -EBUSY;
+        if (retval)
+                goto out;
+
+        if (dev->power.runtime_status == RPM_SUSPENDING) {
+                DEFINE_WAIT(wait);
+
+                if (from_wq) {
+                        retval = -EINPROGRESS;
+                        goto out;
+                }
+
+                /* Wait for the other suspend running in parallel with us. */
+                for (;;) {
+                        prepare_to_wait(&dev->power.wait_queue, &wait,
+                                        TASK_UNINTERRUPTIBLE);
+                        if (dev->power.runtime_status != RPM_SUSPENDING)
+                                break;
+
+                        spin_unlock_irq(&dev->power.lock);
+
+                        schedule();
+
+                        spin_lock_irq(&dev->power.lock);
+                }
+                finish_wait(&dev->power.wait_queue, &wait);
+                goto repeat;
+        }
+
+        dev->power.runtime_status = RPM_SUSPENDING;
+
+        if (dev->bus && dev->bus->pm && dev->bus->pm->runtime_suspend) {
+                spin_unlock_irq(&dev->power.lock);
+
+                retval = dev->bus->pm->runtime_suspend(dev);
+
+                spin_lock_irq(&dev->power.lock);
+                dev->power.runtime_error = retval;
+        } else {
+                retval = -ENOSYS;
+        }
+
+        if (retval) {
+                dev->power.runtime_status = RPM_ACTIVE;
+                pm_runtime_cancel_pending(dev);
+                dev->power.deferred_resume = false;
+
+                if (retval == -EAGAIN || retval == -EBUSY) {
+                        notify = true;
+                        dev->power.runtime_error = 0;
+                }
+        } else {
+                dev->power.runtime_status = RPM_SUSPENDED;
+
+                if (dev->parent) {
+                        parent = dev->parent;
+                        atomic_add_unless(&parent->power.child_count, -1, 0);
+                }
+        }
+        wake_up_all(&dev->power.wait_queue);
+
+        if (dev->power.deferred_resume) {
+                dev->power.deferred_resume = false;
+                __pm_runtime_resume(dev, false);
+                retval = -EAGAIN;
+                goto out;
+        }
+
+        if (notify)
+                __pm_runtime_idle(dev);
+
+        if (parent && !parent->power.ignore_children) {
+                spin_unlock_irq(&dev->power.lock);
+
+                pm_request_idle(parent);
+
+                spin_lock_irq(&dev->power.lock);
+        }
+
+ out:
+        dev_dbg(dev, "__pm_runtime_suspend() returns %d!\n", retval);
+
+        return retval;
+}
+
+/**
+ * pm_runtime_suspend - Carry out run-time suspend of given device.
+ * @dev: Device to suspend.
+ */
+int pm_runtime_suspend(struct device *dev)
+{
+        int retval;
+
+        spin_lock_irq(&dev->power.lock);
+        retval = __pm_runtime_suspend(dev, false);
+        spin_unlock_irq(&dev->power.lock);
+
+        return retval;
+}
+EXPORT_SYMBOL_GPL(pm_runtime_suspend);
+
+/**
+ * __pm_runtime_resume - Carry out run-time resume of given device.
+ * @dev: Device to resume.
+ * @from_wq: If set, the function has been called via pm_wq.
+ *
+ * Check if the device can be woken up and run the ->runtime_resume() callback
+ * provided by its bus type.  If another resume has been started earlier, wait
+ * for it to finish.  If there's a suspend running in parallel with this
+ * function, wait for it to finish and resume the device.  Cancel any scheduled
+ * or pending requests.
+ *
+ * This function must be called under dev->power.lock with interrupts disabled.
+ */
+int __pm_runtime_resume(struct device *dev, bool from_wq)
+        __releases(&dev->power.lock) __acquires(&dev->power.lock)
+{
+        struct device *parent = NULL;
+        int retval = 0;
+
+        dev_dbg(dev, "__pm_runtime_resume()%s!\n",
+                from_wq ? " from workqueue" : "");
+
+ repeat:
+        if (dev->power.runtime_error) {
+                retval = -EINVAL;
+                goto out;
+        }
+
+        pm_runtime_cancel_pending(dev);
+
+        if (dev->power.runtime_status == RPM_ACTIVE)
+                retval = 1;
+        else if (dev->power.disable_depth > 0)
+                retval = -EAGAIN;
+        if (retval)
+                goto out;
+
+        if (dev->power.runtime_status == RPM_RESUMING
+            || dev->power.runtime_status == RPM_SUSPENDING) {
+                DEFINE_WAIT(wait);
+
+                if (from_wq) {
+                        if (dev->power.runtime_status == RPM_SUSPENDING)
+                                dev->power.deferred_resume = true;
+                        retval = -EINPROGRESS;
+                        goto out;
+                }
+
+                /* Wait for the operation carried out in parallel with us. */
+                for (;;) {
+                        prepare_to_wait(&dev->power.wait_queue, &wait,
+                                        TASK_UNINTERRUPTIBLE);
+                        if (dev->power.runtime_status != RPM_RESUMING
+                            && dev->power.runtime_status != RPM_SUSPENDING)
+                                break;
+
+                        spin_unlock_irq(&dev->power.lock);
+
+                        schedule();
+
+                        spin_lock_irq(&dev->power.lock);
+                }
+                finish_wait(&dev->power.wait_queue, &wait);
+                goto repeat;
+        }
+
+        if (!parent && dev->parent) {
+                /*
+                 * Increment the parent's resume counter and resume it if
+                 * necessary.
+                 */
+                parent = dev->parent;
+                spin_unlock_irq(&dev->power.lock);
+
+                pm_runtime_get_noresume(parent);
+
+                spin_lock_irq(&parent->power.lock);
+                /*
+                 * We can resume if the parent's run-time PM is disabled or it
+                 * is set to ignore children.
+                 */
+                if (!parent->power.disable_depth
+                    && !parent->power.ignore_children) {
+                        __pm_runtime_resume(parent, false);
+                        if (parent->power.runtime_status != RPM_ACTIVE)
+                                retval = -EBUSY;
+                }
+                spin_unlock_irq(&parent->power.lock);
+
+                spin_lock_irq(&dev->power.lock);
+                if (retval)
+                        goto out;
+                goto repeat;
+        }
+
+        dev->power.runtime_status = RPM_RESUMING;
+
+        if (dev->bus && dev->bus->pm && dev->bus->pm->runtime_resume) {
+                spin_unlock_irq(&dev->power.lock);
+
+                retval = dev->bus->pm->runtime_resume(dev);
+
+                spin_lock_irq(&dev->power.lock);
+                dev->power.runtime_error = retval;
+        } else {
+                retval = -ENOSYS;
+        }
+
+        if (retval) {
+                dev->power.runtime_status = RPM_SUSPENDED;
+                pm_runtime_cancel_pending(dev);
+        } else {
+                dev->power.runtime_status = RPM_ACTIVE;
+                if (parent)
+                        atomic_inc(&parent->power.child_count);
+        }
+        wake_up_all(&dev->power.wait_queue);
+
+        if (!retval)
+                __pm_request_idle(dev);
+
+ out:
+        if (parent) {
+                spin_unlock_irq(&dev->power.lock);
+
+                pm_runtime_put(parent);
+
+                spin_lock_irq(&dev->power.lock);
+        }
+
+        dev_dbg(dev, "__pm_runtime_resume() returns %d!\n", retval);
+
+        return retval;
+}
+
+/**
+ * pm_runtime_resume - Carry out run-time resume of given device.
+ * @dev: Device to suspend.
+ */
+int pm_runtime_resume(struct device *dev)
+{
+        int retval;
+
+        spin_lock_irq(&dev->power.lock);
+        retval = __pm_runtime_resume(dev, false);
+        spin_unlock_irq(&dev->power.lock);
+
+        return retval;
+}
+EXPORT_SYMBOL_GPL(pm_runtime_resume);
+
+/**
+ * pm_runtime_work - Universal run-time PM work function.
+ * @work: Work structure used for scheduling the execution of this function.
+ *
+ * Use @work to get the device object the work is to be done for, determine what
+ * is to be done and execute the appropriate run-time PM function.
+ */
+static void pm_runtime_work(struct work_struct *work)
+{
+        struct device *dev = container_of(work, struct device, power.work);
+        enum rpm_request req;
+
+        spin_lock_irq(&dev->power.lock);
+
+        if (!dev->power.request_pending)
+                goto out;
+
+        req = dev->power.request;
+        dev->power.request = RPM_REQ_NONE;
+        dev->power.request_pending = false;
+
+        switch (req) {
+        case RPM_REQ_NONE:
+                break;
+        case RPM_REQ_IDLE:
+                __pm_runtime_idle(dev);
+                break;
+        case RPM_REQ_SUSPEND:
+                __pm_runtime_suspend(dev, true);
+                break;
+        case RPM_REQ_RESUME:
+                __pm_runtime_resume(dev, true);
+                break;
+        }
+
+ out:
+        spin_unlock_irq(&dev->power.lock);
+}
+
+/**
+ * __pm_request_idle - Submit an idle notification request for given device.
+ * @dev: Device to handle.
+ *
+ * Check if the device's run-time PM status is correct for suspending the device
+ * and queue up a request to run __pm_runtime_idle() for it.
+ *
+ * This function must be called under dev->power.lock with interrupts disabled.
+ */
+static int __pm_request_idle(struct device *dev)
+{
+        int retval = 0;
+
+        if (dev->power.runtime_error)
+                retval = -EINVAL;
+        else if (atomic_read(&dev->power.usage_count) > 0
+            || dev->power.disable_depth > 0
+            || dev->power.runtime_status == RPM_SUSPENDED
+            || dev->power.runtime_status == RPM_SUSPENDING)
+                retval = -EAGAIN;
+        else if (!pm_children_suspended(dev))
+                retval = -EBUSY;
+        if (retval)
+                return retval;
+
+        if (dev->power.request_pending) {
+                /* Any requests other then RPM_REQ_IDLE take precedence. */
+                if (dev->power.request == RPM_REQ_NONE)
+                        dev->power.request = RPM_REQ_IDLE;
+                else if (dev->power.request != RPM_REQ_IDLE)
+                        retval = -EAGAIN;
+                return retval;
+        }
+
+        dev->power.request = RPM_REQ_IDLE;
+        dev->power.request_pending = true;
+        queue_work(pm_wq, &dev->power.work);
+
+        return retval;
+}
+
+/**
+ * pm_request_idle - Submit an idle notification request for given device.
+ * @dev: Device to handle.
+ */
+int pm_request_idle(struct device *dev)
+{
+        unsigned long flags;
+        int retval;
+
+        spin_lock_irqsave(&dev->power.lock, flags);
+        retval = __pm_request_idle(dev);
+        spin_unlock_irqrestore(&dev->power.lock, flags);
+
+        return retval;
+}
+EXPORT_SYMBOL_GPL(pm_request_idle);
+
+/**
+ * __pm_request_suspend - Submit a suspend request for given device.
+ * @dev: Device to suspend.
+ *
+ * This function must be called under dev->power.lock with interrupts disabled.
+ */
+static int __pm_request_suspend(struct device *dev)
+{
+        int retval = 0;
+
+        if (dev->power.runtime_error)
+                return -EINVAL;
+
+        if (dev->power.runtime_status == RPM_SUSPENDED)
+                retval = 1;
+        else if (atomic_read(&dev->power.usage_count) > 0
+            || dev->power.disable_depth > 0)
+                retval = -EAGAIN;
+        else if (dev->power.runtime_status == RPM_SUSPENDING)
+                retval = -EINPROGRESS;
+        else if (!pm_children_suspended(dev))
+                retval = -EBUSY;
+        if (retval < 0)
+                return retval;
+
+        pm_runtime_deactivate_timer(dev);
+
+        if (dev->power.request_pending) {
+                /*
+                 * Pending resume requests take precedence over us, but we can
+                 * overtake any other pending request.
+                 */
+                if (dev->power.request == RPM_REQ_RESUME)
+                        retval = -EAGAIN;
+                else if (dev->power.request != RPM_REQ_SUSPEND)
+                        dev->power.request = retval ?
+                                                RPM_REQ_NONE : RPM_REQ_SUSPEND;
+                return retval;
+        } else if (retval) {
+                return retval;
+        }
+
+        dev->power.request = RPM_REQ_SUSPEND;
+        dev->power.request_pending = true;
+        queue_work(pm_wq, &dev->power.work);
+
+        return 0;
+}
+
+/**
+ * pm_suspend_timer_fn - Timer function for pm_schedule_suspend().
+ * @data: Device pointer passed by pm_schedule_suspend().
+ *
+ * Check if the time is right and execute __pm_request_suspend() in that case.
+ */
+static void pm_suspend_timer_fn(unsigned long data)
+{
+        struct device *dev = (struct device *)data;
+        unsigned long flags;
+        unsigned long expires;
+
+        spin_lock_irqsave(&dev->power.lock, flags);
+
+        expires = dev->power.timer_expires;
+        /* If 'expire' is after 'jiffies' we've been called too early. */
+        if (expires > 0 && !time_after(expires, jiffies)) {
+                dev->power.timer_expires = 0;
+                __pm_request_suspend(dev);
+        }
+
+        spin_unlock_irqrestore(&dev->power.lock, flags);
+}
+
+/**
+ * pm_schedule_suspend - Set up a timer to submit a suspend request in future.
+ * @dev: Device to suspend.
+ * @delay: Time to wait before submitting a suspend request, in milliseconds.
+ */
+int pm_schedule_suspend(struct device *dev, unsigned int delay)
+{
+        unsigned long flags;
+        int retval = 0;
+
+        spin_lock_irqsave(&dev->power.lock, flags);
+
+        if (dev->power.runtime_error) {
+                retval = -EINVAL;
+                goto out;
+        }
+
+        if (!delay) {
+                retval = __pm_request_suspend(dev);
+                goto out;
+        }
+
+        pm_runtime_deactivate_timer(dev);
+
+        if (dev->power.request_pending) {
+                /*
+                 * Pending resume requests take precedence over us, but any
+                 * other pending requests have to be canceled.
+                 */
+                if (dev->power.request == RPM_REQ_RESUME) {
+                        retval = -EAGAIN;
+                        goto out;
+                }
+                dev->power.request = RPM_REQ_NONE;
+        }
+
+        if (dev->power.runtime_status == RPM_SUSPENDED)
+                retval = 1;
+        else if (dev->power.runtime_status == RPM_SUSPENDING)
+                retval = -EINPROGRESS;
+        else if (atomic_read(&dev->power.usage_count) > 0
+            || dev->power.disable_depth > 0)
+                retval = -EAGAIN;
+        else if (!pm_children_suspended(dev))
+                retval = -EBUSY;
+        if (retval)
+                goto out;
+
+        dev->power.timer_expires = jiffies + msecs_to_jiffies(delay);
+        mod_timer(&dev->power.suspend_timer, dev->power.timer_expires);
+
+ out:
+        spin_unlock_irqrestore(&dev->power.lock, flags);
+
+        return retval;
+}
+EXPORT_SYMBOL_GPL(pm_schedule_suspend);
+
+/**
+ * pm_request_resume - Submit a resume request for given device.
+ * @dev: Device to resume.
+ *
+ * This function must be called under dev->power.lock with interrupts disabled.
+ */
+static int __pm_request_resume(struct device *dev)
+{
+        int retval = 0;
+
+        if (dev->power.runtime_error)
+                return -EINVAL;
+
+        if (dev->power.runtime_status == RPM_ACTIVE)
+                retval = 1;
+        else if (dev->power.runtime_status == RPM_RESUMING)
+                retval = -EINPROGRESS;
+        else if (dev->power.disable_depth > 0)
+                retval = -EAGAIN;
+        if (retval < 0)
+                return retval;
+
+        pm_runtime_deactivate_timer(dev);
+
+        if (dev->power.request_pending) {
+                /* If non-resume request is pending, we can overtake it. */
+                dev->power.request = retval ? RPM_REQ_NONE : RPM_REQ_RESUME;
+                return retval;
+        } else if (retval) {
+                return retval;
+        }
+
+        dev->power.request = RPM_REQ_RESUME;
+        dev->power.request_pending = true;
+        queue_work(pm_wq, &dev->power.work);
+
+        return retval;
+}
+
+/**
+ * pm_request_resume - Submit a resume request for given device.
+ * @dev: Device to resume.
+ */
+int pm_request_resume(struct device *dev)
+{
+        unsigned long flags;
+        int retval;
+
+        spin_lock_irqsave(&dev->power.lock, flags);
+        retval = __pm_request_resume(dev);
+        spin_unlock_irqrestore(&dev->power.lock, flags);
+
+        return retval;
+}
+EXPORT_SYMBOL_GPL(pm_request_resume);
+
+/**
+ * __pm_runtime_get - Reference count a device and wake it up, if necessary.
+ * @dev: Device to handle.
+ * @sync: If set and the device is suspended, resume it synchronously.
+ *
+ * Increment the usage count of the device and if it was zero previously,
+ * resume it or submit a resume request for it, depending on the value of @sync.
+ */
+int __pm_runtime_get(struct device *dev, bool sync)
+{
+        int retval = 1;
+
+        if (atomic_add_return(1, &dev->power.usage_count) == 1)
+                retval = sync ? pm_runtime_resume(dev) : pm_request_resume(dev);
+
+        return retval;
+}
+EXPORT_SYMBOL_GPL(__pm_runtime_get);
+
+/**
+ * __pm_runtime_put - Decrement the device's usage counter and notify its bus.
+ * @dev: Device to handle.
+ * @sync: If the device's bus type is to be notified, do that synchronously.
+ *
+ * Decrement the usage count of the device and if it reaches zero, carry out a
+ * synchronous idle notification or submit an idle notification request for it,
+ * depending on the value of @sync.
+ */
+int __pm_runtime_put(struct device *dev, bool sync)
+{
+        int retval = 0;
+
+        if (atomic_dec_and_test(&dev->power.usage_count))
+                retval = sync ? pm_runtime_idle(dev) : pm_request_idle(dev);
+
+        return retval;
+}
+EXPORT_SYMBOL_GPL(__pm_runtime_put);
+
+/**
+ * __pm_runtime_set_status - Set run-time PM status of a device.
+ * @dev: Device to handle.
+ * @status: New run-time PM status of the device.
+ *
+ * If run-time PM of the device is disabled or its power.runtime_error field is
+ * different from zero, the status may be changed either to RPM_ACTIVE, or to
+ * RPM_SUSPENDED, as long as that reflects the actual state of the device.
+ * However, if the device has a parent and the parent is not active, and the
+ * parent's power.ignore_children flag is unset, the device's status cannot be
+ * set to RPM_ACTIVE, so -EBUSY is returned in that case.
+ *
+ * If successful, __pm_runtime_set_status() clears the power.runtime_error field
+ * and the device parent's counter of unsuspended children is modified to
+ * reflect the new status.  If the new status is RPM_SUSPENDED, an idle
+ * notification request for the parent is submitted.
+ */
+int __pm_runtime_set_status(struct device *dev, unsigned int status)
+{
+        struct device *parent = dev->parent;
+        unsigned long flags;
+        bool notify_parent = false;
+        int error = 0;
+
+        if (status != RPM_ACTIVE && status != RPM_SUSPENDED)
+                return -EINVAL;
+
+        spin_lock_irqsave(&dev->power.lock, flags);
+
+        if (!dev->power.runtime_error && !dev->power.disable_depth) {
+                error = -EAGAIN;
+                goto out;
+        }
+
+        if (dev->power.runtime_status == status)
+                goto out_set;
+
+        if (status == RPM_SUSPENDED) {
+                /* It always is possible to set the status to 'suspended'. */
+                if (parent) {
+                        atomic_add_unless(&parent->power.child_count, -1, 0);
+                        notify_parent = !parent->power.ignore_children;
+                }
+                goto out_set;
+        }
+
+        if (parent) {
+                spin_lock_irq(&parent->power.lock);
+
+                /*
+                 * It is invalid to put an active child under a parent that is
+                 * not active, has run-time PM enabled and the
+                 * 'power.ignore_children' flag unset.
+                 */
+                if (!parent->power.disable_depth
+                    && !parent->power.ignore_children
+                    && parent->power.runtime_status != RPM_ACTIVE) {
+                        error = -EBUSY;
+                } else {
+                        if (dev->power.runtime_status == RPM_SUSPENDED)
+                                atomic_inc(&parent->power.child_count);
+                }
+
+                spin_unlock_irq(&parent->power.lock);
+
+                if (error)
+                        goto out;
+        }
+
+ out_set:
+        dev->power.runtime_status = status;
+        dev->power.runtime_error = 0;
+ out:
+        spin_unlock_irqrestore(&dev->power.lock, flags);
+
+        if (notify_parent)
+                pm_request_idle(parent);
+
+        return error;
+}
+EXPORT_SYMBOL_GPL(__pm_runtime_set_status);
+
+/**
+ * __pm_runtime_barrier - Cancel pending requests and wait for completions.
+ * @dev: Device to handle.
+ *
+ * Flush all pending requests for the device from pm_wq and wait for all
+ * run-time PM operations involving the device in progress to complete.
+ *
+ * Should be called under dev->power.lock with interrupts disabled.
+ */
+static void __pm_runtime_barrier(struct device *dev)
+{
+        pm_runtime_deactivate_timer(dev);
+
+        if (dev->power.request_pending) {
+                dev->power.request = RPM_REQ_NONE;
+                spin_unlock_irq(&dev->power.lock);
+
+                cancel_work_sync(&dev->power.work);
+
+                spin_lock_irq(&dev->power.lock);
+                dev->power.request_pending = false;
+        }
+
+        if (dev->power.runtime_status == RPM_SUSPENDING
+            || dev->power.runtime_status == RPM_RESUMING
+            || dev->power.idle_notification) {
+                DEFINE_WAIT(wait);
+
+                /* Suspend, wake-up or idle notification in progress. */
+                for (;;) {
+                        prepare_to_wait(&dev->power.wait_queue, &wait,
+                                        TASK_UNINTERRUPTIBLE);
+                        if (dev->power.runtime_status != RPM_SUSPENDING
+                            && dev->power.runtime_status != RPM_RESUMING
+                            && !dev->power.idle_notification)
+                                break;
+                        spin_unlock_irq(&dev->power.lock);
+
+                        schedule();
+
+                        spin_lock_irq(&dev->power.lock);
+                }
+                finish_wait(&dev->power.wait_queue, &wait);
+        }
+}
+
+/**
+ * pm_runtime_barrier - Flush pending requests and wait for completions.
+ * @dev: Device to handle.
+ *
+ * Prevent the device from being suspended by incrementing its usage counter and
+ * if there's a pending resume request for the device, wake the device up.
+ * Next, make sure that all pending requests for the device have been flushed
+ * from pm_wq and wait for all run-time PM operations involving the device in
+ * progress to complete.
+ *
+ * Return value:
+ * 1, if there was a resume request pending and the device had to be woken up,
+ * 0, otherwise
+ */
+int pm_runtime_barrier(struct device *dev)
+{
+        int retval = 0;
+
+        pm_runtime_get_noresume(dev);
+        spin_lock_irq(&dev->power.lock);
+
+        if (dev->power.request_pending
+            && dev->power.request == RPM_REQ_RESUME) {
+                __pm_runtime_resume(dev, false);
+                retval = 1;
+        }
+
+        __pm_runtime_barrier(dev);
+
+        spin_unlock_irq(&dev->power.lock);
+        pm_runtime_put_noidle(dev);
+
+        return retval;
+}
+EXPORT_SYMBOL_GPL(pm_runtime_barrier);
+
+/**
+ * __pm_runtime_disable - Disable run-time PM of a device.
+ * @dev: Device to handle.
+ * @check_resume: If set, check if there's a resume request for the device.
+ *
+ * Increment power.disable_depth for the device and if was zero previously,
+ * cancel all pending run-time PM requests for the device and wait for all
+ * operations in progress to complete.  The device can be either active or
+ * suspended after its run-time PM has been disabled.
+ *
+ * If @check_resume is set and there's a resume request pending when
+ * __pm_runtime_disable() is called and power.disable_depth is zero, the
+ * function will wake up the device before disabling its run-time PM.
+ */
+void __pm_runtime_disable(struct device *dev, bool check_resume)
+{
+        spin_lock_irq(&dev->power.lock);
+
+        if (dev->power.disable_depth > 0) {
+                dev->power.disable_depth++;
+                goto out;
+        }
+
+        /*
+         * Wake up the device if there's a resume request pending, because that
+         * means there probably is some I/O to process and disabling run-time PM
+         * shouldn't prevent the device from processing the I/O.
+         */
+        if (check_resume && dev->power.request_pending
+            && dev->power.request == RPM_REQ_RESUME) {
+                /*
+                 * Prevent suspends and idle notifications from being carried
+                 * out after we have woken up the device.
+                 */
+                pm_runtime_get_noresume(dev);
+
+                __pm_runtime_resume(dev, false);
+
+                pm_runtime_put_noidle(dev);
+        }
+
+        if (!dev->power.disable_depth++)
+                __pm_runtime_barrier(dev);
+
+ out:
+        spin_unlock_irq(&dev->power.lock);
+}
+EXPORT_SYMBOL_GPL(__pm_runtime_disable);
+
+/**
+ * pm_runtime_enable - Enable run-time PM of a device.
+ * @dev: Device to handle.
+ */
+void pm_runtime_enable(struct device *dev)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&dev->power.lock, flags);
+
+        if (dev->power.disable_depth > 0)
+                dev->power.disable_depth--;
+        else
+                dev_warn(dev, "Unbalanced %s!\n", __func__);
+
+        spin_unlock_irqrestore(&dev->power.lock, flags);
+}
+EXPORT_SYMBOL_GPL(pm_runtime_enable);
+
+/**
+ * pm_runtime_init - Initialize run-time PM fields in given device object.
+ * @dev: Device object to initialize.
+ */
+void pm_runtime_init(struct device *dev)
+{
+        spin_lock_init(&dev->power.lock);
+
+        dev->power.runtime_status = RPM_SUSPENDED;
+        dev->power.idle_notification = false;
+
+        dev->power.disable_depth = 1;
+        atomic_set(&dev->power.usage_count, 0);
+
+        dev->power.runtime_error = 0;
+
+        atomic_set(&dev->power.child_count, 0);
+        pm_suspend_ignore_children(dev, false);
+
+        dev->power.request_pending = false;
+        dev->power.request = RPM_REQ_NONE;
+        dev->power.deferred_resume = false;
+        INIT_WORK(&dev->power.work, pm_runtime_work);
+
+        dev->power.timer_expires = 0;
+        setup_timer(&dev->power.suspend_timer, pm_suspend_timer_fn,
+                        (unsigned long)dev);
+
+        init_waitqueue_head(&dev->power.wait_queue);
+}
+
+/**
+ * pm_runtime_remove - Prepare for removing a device from device hierarchy.
+ * @dev: Device object being removed from device hierarchy.
+ */
+void pm_runtime_remove(struct device *dev)
+{
+        __pm_runtime_disable(dev, false);
+
+        /* Change the status back to 'suspended' to match the initial status. */
+        if (dev->power.runtime_status == RPM_ACTIVE)
+                pm_runtime_set_suspended(dev);
+}