2 files changed, 212 insertions, 3 deletions

diff --git a/include/linux/pm.h b/include/linux/pm.h
index b3f74764a586..2b6e20df0e52 100644
--- a/include/linux/pm.h
+++ b/include/linux/pm.h
@@ -22,6 +22,10 @@
 #define _LINUX_PM_H
 
 #include <linux/list.h>
+#include <linux/workqueue.h>
+#include <linux/spinlock.h>
+#include <linux/wait.h>
+#include <linux/timer.h>
 
 /*
  * Callbacks for platform drivers to implement.
@@ -165,6 +169,28 @@ typedef struct pm_message {
  * It is allowed to unregister devices while the above callbacks are being
  * executed.  However, it is not allowed to unregister a device from within any
  * of its own callbacks.
+ *
+ * There also are the following callbacks related to run-time power management
+ * of devices:
+ *
+ * @runtime_suspend: Prepare the device for a condition in which it won't be
+ *      able to communicate with the CPU(s) and RAM due to power management.
+ *      This need not mean that the device should be put into a low power state.
+ *      For example, if the device is behind a link which is about to be turned
+ *      off, the device may remain at full power.  If the device does go to low
+ *      power and if device_may_wakeup(dev) is true, remote wake-up (i.e., a
+ *      hardware mechanism allowing the device to request a change of its power
+ *      state, such as PCI PME) should be enabled for it.
+ *
+ * @runtime_resume: Put the device into the fully active state in response to a
+ *      wake-up event generated by hardware or at the request of software.  If
+ *      necessary, put the device into the full power state and restore its
+ *      registers, so that it is fully operational.
+ *
+ * @runtime_idle: Device appears to be inactive and it might be put into a low
+ *      power state if all of the necessary conditions are satisfied.  Check
+ *      these conditions and handle the device as appropriate, possibly queueing
+ *      a suspend request for it.  The return value is ignored by the PM core.
  */
 
 struct dev_pm_ops {
@@ -182,6 +208,9 @@ struct dev_pm_ops {
         int (*thaw_noirq)(struct device *dev);
         int (*poweroff_noirq)(struct device *dev);
         int (*restore_noirq)(struct device *dev);
+        int (*runtime_suspend)(struct device *dev);
+        int (*runtime_resume)(struct device *dev);
+        int (*runtime_idle)(struct device *dev);
 };
 
 /**
@@ -315,14 +344,80 @@ enum dpm_state {
         DPM_OFF_IRQ,
 };
 
+/**
+ * Device run-time power management status.
+ *
+ * These status labels are used internally by the PM core to indicate the
+ * current status of a device with respect to the PM core operations.  They do
+ * not reflect the actual power state of the device or its status as seen by the
+ * driver.
+ *
+ * RPM_ACTIVE           Device is fully operational.  Indicates that the device
+ *                      bus type's ->runtime_resume() callback has completed
+ *                      successfully.
+ *
+ * RPM_SUSPENDED        Device bus type's ->runtime_suspend() callback has
+ *                      completed successfully.  The device is regarded as
+ *                      suspended.
+ *
+ * RPM_RESUMING         Device bus type's ->runtime_resume() callback is being
+ *                      executed.
+ *
+ * RPM_SUSPENDING       Device bus type's ->runtime_suspend() callback is being
+ *                      executed.
+ */
+
+enum rpm_status {
+        RPM_ACTIVE = 0,
+        RPM_RESUMING,
+        RPM_SUSPENDED,
+        RPM_SUSPENDING,
+};
+
+/**
+ * Device run-time power management request types.
+ *
+ * RPM_REQ_NONE         Do nothing.
+ *
+ * RPM_REQ_IDLE         Run the device bus type's ->runtime_idle() callback
+ *
+ * RPM_REQ_SUSPEND      Run the device bus type's ->runtime_suspend() callback
+ *
+ * RPM_REQ_RESUME       Run the device bus type's ->runtime_resume() callback
+ */
+
+enum rpm_request {
+        RPM_REQ_NONE = 0,
+        RPM_REQ_IDLE,
+        RPM_REQ_SUSPEND,
+        RPM_REQ_RESUME,
+};
+
 struct dev_pm_info {
         pm_message_t            power_state;
-        unsigned                can_wakeup:1;
-        unsigned                should_wakeup:1;
+        unsigned int            can_wakeup:1;
+        unsigned int            should_wakeup:1;
         enum dpm_state          status;         /* Owned by the PM core */
-#ifdef  CONFIG_PM_SLEEP
+#ifdef CONFIG_PM_SLEEP
         struct list_head        entry;
 #endif
+#ifdef CONFIG_PM_RUNTIME
+        struct timer_list       suspend_timer;
+        unsigned long           timer_expires;
+        struct work_struct      work;
+        wait_queue_head_t       wait_queue;
+        spinlock_t              lock;
+        atomic_t                usage_count;
+        atomic_t                child_count;
+        unsigned int            disable_depth:3;
+        unsigned int            ignore_children:1;
+        unsigned int            idle_notification:1;
+        unsigned int            request_pending:1;
+        unsigned int            deferred_resume:1;
+        enum rpm_request        request;
+        enum rpm_status         runtime_status;
+        int                     runtime_error;
+#endif
 };
 
 /*
diff --git a/include/linux/pm_runtime.h b/include/linux/pm_runtime.h
new file mode 100644
index 000000000000..44087044910f
--- /dev/null
+++ b/include/linux/pm_runtime.h
@@ -0,0 +1,114 @@
+/*
+ * pm_runtime.h - Device run-time power management helper functions.
+ *
+ * Copyright (C) 2009 Rafael J. Wysocki <rjw@sisk.pl>
+ *
+ * This file is released under the GPLv2.
+ */
+
+#ifndef _LINUX_PM_RUNTIME_H
+#define _LINUX_PM_RUNTIME_H
+
+#include <linux/device.h>
+#include <linux/pm.h>
+
+#ifdef CONFIG_PM_RUNTIME
+
+extern struct workqueue_struct *pm_wq;
+
+extern int pm_runtime_idle(struct device *dev);
+extern int pm_runtime_suspend(struct device *dev);
+extern int pm_runtime_resume(struct device *dev);
+extern int pm_request_idle(struct device *dev);
+extern int pm_schedule_suspend(struct device *dev, unsigned int delay);
+extern int pm_request_resume(struct device *dev);
+extern int __pm_runtime_get(struct device *dev, bool sync);
+extern int __pm_runtime_put(struct device *dev, bool sync);
+extern int __pm_runtime_set_status(struct device *dev, unsigned int status);
+extern int pm_runtime_barrier(struct device *dev);
+extern void pm_runtime_enable(struct device *dev);
+extern void __pm_runtime_disable(struct device *dev, bool check_resume);
+
+static inline bool pm_children_suspended(struct device *dev)
+{
+        return dev->power.ignore_children
+                || !atomic_read(&dev->power.child_count);
+}
+
+static inline void pm_suspend_ignore_children(struct device *dev, bool enable)
+{
+        dev->power.ignore_children = enable;
+}
+
+static inline void pm_runtime_get_noresume(struct device *dev)
+{
+        atomic_inc(&dev->power.usage_count);
+}
+
+static inline void pm_runtime_put_noidle(struct device *dev)
+{
+        atomic_add_unless(&dev->power.usage_count, -1, 0);
+}
+
+#else /* !CONFIG_PM_RUNTIME */
+
+static inline int pm_runtime_idle(struct device *dev) { return -ENOSYS; }
+static inline int pm_runtime_suspend(struct device *dev) { return -ENOSYS; }
+static inline int pm_runtime_resume(struct device *dev) { return 0; }
+static inline int pm_request_idle(struct device *dev) { return -ENOSYS; }
+static inline int pm_schedule_suspend(struct device *dev, unsigned int delay)
+{
+        return -ENOSYS;
+}
+static inline int pm_request_resume(struct device *dev) { return 0; }
+static inline int __pm_runtime_get(struct device *dev, bool sync) { return 1; }
+static inline int __pm_runtime_put(struct device *dev, bool sync) { return 0; }
+static inline int __pm_runtime_set_status(struct device *dev,
+                                            unsigned int status) { return 0; }
+static inline int pm_runtime_barrier(struct device *dev) { return 0; }
+static inline void pm_runtime_enable(struct device *dev) {}
+static inline void __pm_runtime_disable(struct device *dev, bool c) {}
+
+static inline bool pm_children_suspended(struct device *dev) { return false; }
+static inline void pm_suspend_ignore_children(struct device *dev, bool en) {}
+static inline void pm_runtime_get_noresume(struct device *dev) {}
+static inline void pm_runtime_put_noidle(struct device *dev) {}
+
+#endif /* !CONFIG_PM_RUNTIME */
+
+static inline int pm_runtime_get(struct device *dev)
+{
+        return __pm_runtime_get(dev, false);
+}
+
+static inline int pm_runtime_get_sync(struct device *dev)
+{
+        return __pm_runtime_get(dev, true);
+}
+
+static inline int pm_runtime_put(struct device *dev)
+{
+        return __pm_runtime_put(dev, false);
+}
+
+static inline int pm_runtime_put_sync(struct device *dev)
+{
+        return __pm_runtime_put(dev, true);
+}
+
+static inline int pm_runtime_set_active(struct device *dev)
+{
+        return __pm_runtime_set_status(dev, RPM_ACTIVE);
+}
+
+static inline void pm_runtime_set_suspended(struct device *dev)
+{
+        __pm_runtime_set_status(dev, RPM_SUSPENDED);
+}
+
+static inline void pm_runtime_disable(struct device *dev)
+{
+        __pm_runtime_disable(dev, true);
+}
+
+#endif