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);
+}