6 files changed, 138 insertions, 61 deletions

diff --git a/include/linux/devfreq.h b/include/linux/devfreq.h
index 98ce8124b1cc..281c72a3b9d5 100644
--- a/include/linux/devfreq.h
+++ b/include/linux/devfreq.h
@@ -44,6 +44,14 @@ struct devfreq_dev_status {
         void *private_data;
 };
 
+/*
+ * The resulting frequency should be at most this. (this bound is the
+ * least upper bound; thus, the resulting freq should be lower or same)
+ * If the flag is not set, the resulting frequency should be at most the
+ * bound (greatest lower bound)
+ */
+#define DEVFREQ_FLAG_LEAST_UPPER_BOUND          0x1
+
 /**
  * struct devfreq_dev_profile - Devfreq's user device profile
  * @initial_freq        The operating frequency when devfreq_add_device() is
@@ -54,6 +62,8 @@ struct devfreq_dev_status {
  *                      higher than any operable frequency, set maximum.
  *                      Before returning, target function should set
  *                      freq at the current frequency.
+ *                      The "flags" parameter's possible values are
+ *                      explained above with "DEVFREQ_FLAG_*" macros.
  * @get_dev_status      The device should provide the current performance
  *                      status to devfreq, which is used by governors.
  * @exit                An optional callback that is called when devfreq
@@ -66,7 +76,7 @@ struct devfreq_dev_profile {
         unsigned long initial_freq;
         unsigned int polling_ms;
 
-        int (*target)(struct device *dev, unsigned long *freq);
+        int (*target)(struct device *dev, unsigned long *freq, u32 flags);
         int (*get_dev_status)(struct device *dev,
                               struct devfreq_dev_status *stat);
         void (*exit)(struct device *dev);
@@ -124,6 +134,8 @@ struct devfreq_governor {
  *              touch this.
  * @being_removed       a flag to mark that this object is being removed in
  *                      order to prevent trying to remove the object multiple times.
+ * @min_freq    Limit minimum frequency requested by user (0: none)
+ * @max_freq    Limit maximum frequency requested by user (0: none)
  *
  * This structure stores the devfreq information for a give device.
  *
@@ -149,6 +161,9 @@ struct devfreq {
         void *data; /* private data for governors */
 
         bool being_removed;
+
+        unsigned long min_freq;
+        unsigned long max_freq;
 };
 
 #if defined(CONFIG_PM_DEVFREQ)
@@ -160,7 +175,7 @@ extern int devfreq_remove_device(struct devfreq *devfreq);
 
 /* Helper functions for devfreq user device driver with OPP. */
 extern struct opp *devfreq_recommended_opp(struct device *dev,
-                                           unsigned long *freq);
+                                           unsigned long *freq, u32 flags);
 extern int devfreq_register_opp_notifier(struct device *dev,
                                          struct devfreq *devfreq);
 extern int devfreq_unregister_opp_notifier(struct device *dev,
@@ -200,18 +215,18 @@ struct devfreq_simple_ondemand_data {
 static struct devfreq *devfreq_add_device(struct device *dev,
                                           struct devfreq_dev_profile *profile,
                                           struct devfreq_governor *governor,
-                                          void *data);
+                                          void *data)
 {
         return NULL;
 }
 
-static int devfreq_remove_device(struct devfreq *devfreq);
+static int devfreq_remove_device(struct devfreq *devfreq)
 {
         return 0;
 }
 
 static struct opp *devfreq_recommended_opp(struct device *dev,
-                                           unsigned long *freq)
+                                           unsigned long *freq, u32 flags)
 {
         return -EINVAL;
 }
diff --git a/include/linux/pm.h b/include/linux/pm.h
index e4982ac3fbbc..715305e05123 100644
--- a/include/linux/pm.h
+++ b/include/linux/pm.h
@@ -110,6 +110,10 @@ typedef struct pm_message {
  *      Subsystem-level @suspend() is executed for all devices after invoking
  *      subsystem-level @prepare() for all of them.
  *
+ * @suspend_late: Continue operations started by @suspend().  For a number of
+ *      devices @suspend_late() may point to the same callback routine as the
+ *      runtime suspend callback.
+ *
  * @resume: Executed after waking the system up from a sleep state in which the
  *      contents of main memory were preserved.  The exact action to perform
  *      depends on the device's subsystem, but generally the driver is expected
@@ -122,6 +126,10 @@ typedef struct pm_message {
  *      Subsystem-level @resume() is executed for all devices after invoking
  *      subsystem-level @resume_noirq() for all of them.
  *
+ * @resume_early: Prepare to execute @resume().  For a number of devices
+ *      @resume_early() may point to the same callback routine as the runtime
+ *      resume callback.
+ *
  * @freeze: Hibernation-specific, executed before creating a hibernation image.
  *      Analogous to @suspend(), but it should not enable the device to signal
  *      wakeup events or change its power state.  The majority of subsystems
@@ -131,6 +139,10 @@ typedef struct pm_message {
  *      Subsystem-level @freeze() is executed for all devices after invoking
  *      subsystem-level @prepare() for all of them.
  *
+ * @freeze_late: Continue operations started by @freeze().  Analogous to
+ *      @suspend_late(), but it should not enable the device to signal wakeup
+ *      events or change its power state.
+ *
  * @thaw: Hibernation-specific, executed after creating a hibernation image OR
  *      if the creation of an image has failed.  Also executed after a failing
  *      attempt to restore the contents of main memory from such an image.
@@ -140,15 +152,23 @@ typedef struct pm_message {
  *      subsystem-level @thaw_noirq() for all of them.  It also may be executed
  *      directly after @freeze() in case of a transition error.
  *
+ * @thaw_early: Prepare to execute @thaw().  Undo the changes made by the
+ *      preceding @freeze_late().
+ *
  * @poweroff: Hibernation-specific, executed after saving a hibernation image.
  *      Analogous to @suspend(), but it need not save the device's settings in
  *      memory.
  *      Subsystem-level @poweroff() is executed for all devices after invoking
  *      subsystem-level @prepare() for all of them.
  *
+ * @poweroff_late: Continue operations started by @poweroff().  Analogous to
+ *      @suspend_late(), but it need not save the device's settings in memory.
+ *
  * @restore: Hibernation-specific, executed after restoring the contents of main
  *      memory from a hibernation image, analogous to @resume().
  *
+ * @restore_early: Prepare to execute @restore(), analogous to @resume_early().
+ *
  * @suspend_noirq: Complete the actions started by @suspend().  Carry out any
  *      additional operations required for suspending the device that might be
  *      racing with its driver's interrupt handler, which is guaranteed not to
@@ -158,9 +178,10 @@ typedef struct pm_message {
  *      @suspend_noirq() has returned successfully.  If the device can generate
  *      system wakeup signals and is enabled to wake up the system, it should be
  *      configured to do so at that time.  However, depending on the platform
- *      and device's subsystem, @suspend() may be allowed to put the device into
- *      the low-power state and configure it to generate wakeup signals, in
- *      which case it generally is not necessary to define @suspend_noirq().
+ *      and device's subsystem, @suspend() or @suspend_late() may be allowed to
+ *      put the device into the low-power state and configure it to generate
+ *      wakeup signals, in which case it generally is not necessary to define
+ *      @suspend_noirq().
  *
  * @resume_noirq: Prepare for the execution of @resume() by carrying out any
  *      operations required for resuming the device that might be racing with
@@ -171,9 +192,9 @@ typedef struct pm_message {
  *      additional operations required for freezing the device that might be
  *      racing with its driver's interrupt handler, which is guaranteed not to
  *      run while @freeze_noirq() is being executed.
- *      The power state of the device should not be changed by either @freeze()
- *      or @freeze_noirq() and it should not be configured to signal system
- *      wakeup by any of these callbacks.
+ *      The power state of the device should not be changed by either @freeze(),
+ *      or @freeze_late(), or @freeze_noirq() and it should not be configured to
+ *      signal system wakeup by any of these callbacks.
  *
  * @thaw_noirq: Prepare for the execution of @thaw() by carrying out any
  *      operations required for thawing the device that might be racing with its
@@ -249,6 +270,12 @@ struct dev_pm_ops {
         int (*thaw)(struct device *dev);
         int (*poweroff)(struct device *dev);
         int (*restore)(struct device *dev);
+        int (*suspend_late)(struct device *dev);
+        int (*resume_early)(struct device *dev);
+        int (*freeze_late)(struct device *dev);
+        int (*thaw_early)(struct device *dev);
+        int (*poweroff_late)(struct device *dev);
+        int (*restore_early)(struct device *dev);
         int (*suspend_noirq)(struct device *dev);
         int (*resume_noirq)(struct device *dev);
         int (*freeze_noirq)(struct device *dev);
@@ -293,6 +320,15 @@ const struct dev_pm_ops name = { \
 /*
  * Use this for defining a set of PM operations to be used in all situations
  * (sustem suspend, hibernation or runtime PM).
+ * NOTE: In general, system suspend callbacks, .suspend() and .resume(), should
+ * be different from the corresponding runtime PM callbacks, .runtime_suspend(),
+ * and .runtime_resume(), because .runtime_suspend() always works on an already
+ * quiescent device, while .suspend() should assume that the device may be doing
+ * something when it is called (it should ensure that the device will be
+ * quiescent after it has returned).  Therefore it's better to point the "late"
+ * suspend and "early" resume callback pointers, .suspend_late() and
+ * .resume_early(), to the same routines as .runtime_suspend() and
+ * .runtime_resume(), respectively (and analogously for hibernation).
  */
 #define UNIVERSAL_DEV_PM_OPS(name, suspend_fn, resume_fn, idle_fn) \
 const struct dev_pm_ops name = { \
@@ -510,6 +546,7 @@ struct dev_pm_info {
         unsigned long           accounting_timestamp;
         ktime_t                 suspend_time;
         s64                     max_time_suspended_ns;
+        struct dev_pm_qos_request *pq_req;
 #endif
         struct pm_subsys_data   *subsys_data;  /* Owned by the subsystem. */
         struct pm_qos_constraints *constraints;
@@ -584,13 +621,13 @@ struct dev_pm_domain {
 
 #ifdef CONFIG_PM_SLEEP
 extern void device_pm_lock(void);
-extern void dpm_resume_noirq(pm_message_t state);
+extern void dpm_resume_start(pm_message_t state);
 extern void dpm_resume_end(pm_message_t state);
 extern void dpm_resume(pm_message_t state);
 extern void dpm_complete(pm_message_t state);
 
 extern void device_pm_unlock(void);
-extern int dpm_suspend_noirq(pm_message_t state);
+extern int dpm_suspend_end(pm_message_t state);
 extern int dpm_suspend_start(pm_message_t state);
 extern int dpm_suspend(pm_message_t state);
 extern int dpm_prepare(pm_message_t state);
@@ -605,17 +642,23 @@ extern void __suspend_report_result(const char *function, void *fn, int ret);
 extern int device_pm_wait_for_dev(struct device *sub, struct device *dev);
 
 extern int pm_generic_prepare(struct device *dev);
+extern int pm_generic_suspend_late(struct device *dev);
 extern int pm_generic_suspend_noirq(struct device *dev);
 extern int pm_generic_suspend(struct device *dev);
+extern int pm_generic_resume_early(struct device *dev);
 extern int pm_generic_resume_noirq(struct device *dev);
 extern int pm_generic_resume(struct device *dev);
 extern int pm_generic_freeze_noirq(struct device *dev);
+extern int pm_generic_freeze_late(struct device *dev);
 extern int pm_generic_freeze(struct device *dev);
 extern int pm_generic_thaw_noirq(struct device *dev);
+extern int pm_generic_thaw_early(struct device *dev);
 extern int pm_generic_thaw(struct device *dev);
 extern int pm_generic_restore_noirq(struct device *dev);
+extern int pm_generic_restore_early(struct device *dev);
 extern int pm_generic_restore(struct device *dev);
 extern int pm_generic_poweroff_noirq(struct device *dev);
+extern int pm_generic_poweroff_late(struct device *dev);
 extern int pm_generic_poweroff(struct device *dev);
 extern void pm_generic_complete(struct device *dev);
 
diff --git a/include/linux/pm_domain.h b/include/linux/pm_domain.h
index a03a0ad998b8..1236d262b3e8 100644
--- a/include/linux/pm_domain.h
+++ b/include/linux/pm_domain.h
@@ -11,6 +11,7 @@
 
 #include <linux/device.h>
 #include <linux/err.h>
+#include <linux/of.h>
 
 enum gpd_status {
         GPD_STATE_ACTIVE = 0,   /* PM domain is active */
@@ -70,6 +71,7 @@ struct generic_pm_domain {
         s64 break_even_ns;      /* Power break even for the entire domain. */
         s64 max_off_time_ns;    /* Maximum allowed "suspended" time. */
         ktime_t power_off_time;
+        struct device_node *of_node; /* Node in device tree */
 };
 
 static inline struct generic_pm_domain *pd_to_genpd(struct dev_pm_domain *pd)
@@ -97,14 +99,15 @@ struct generic_pm_domain_data {
         struct gpd_dev_ops ops;
         struct gpd_timing_data td;
         bool need_restore;
+        bool always_on;
 };
 
+#ifdef CONFIG_PM_GENERIC_DOMAINS
 static inline struct generic_pm_domain_data *to_gpd_data(struct pm_domain_data *pdd)
 {
         return container_of(pdd, struct generic_pm_domain_data, base);
 }
 
-#ifdef CONFIG_PM_GENERIC_DOMAINS
 static inline struct generic_pm_domain_data *dev_gpd_data(struct device *dev)
 {
         return to_gpd_data(dev->power.subsys_data->domain_data);
@@ -117,14 +120,25 @@ extern int __pm_genpd_add_device(struct generic_pm_domain *genpd,
                                  struct device *dev,
                                  struct gpd_timing_data *td);
 
+extern int __pm_genpd_of_add_device(struct device_node *genpd_node,
+                                    struct device *dev,
+                                    struct gpd_timing_data *td);
+
 static inline int pm_genpd_add_device(struct generic_pm_domain *genpd,
                                       struct device *dev)
 {
         return __pm_genpd_add_device(genpd, dev, NULL);
 }
 
+static inline int pm_genpd_of_add_device(struct device_node *genpd_node,
+                                         struct device *dev)
+{
+        return __pm_genpd_of_add_device(genpd_node, dev, NULL);
+}
+
 extern int pm_genpd_remove_device(struct generic_pm_domain *genpd,
                                   struct device *dev);
+extern void pm_genpd_dev_always_on(struct device *dev, bool val);
 extern int pm_genpd_add_subdomain(struct generic_pm_domain *genpd,
                                   struct generic_pm_domain *new_subdomain);
 extern int pm_genpd_remove_subdomain(struct generic_pm_domain *genpd,
@@ -143,6 +157,10 @@ extern bool default_stop_ok(struct device *dev);
 extern struct dev_power_governor pm_domain_always_on_gov;
 #else
 
+static inline struct generic_pm_domain_data *dev_gpd_data(struct device *dev)
+{
+        return ERR_PTR(-ENOSYS);
+}
 static inline struct generic_pm_domain *dev_to_genpd(struct device *dev)
 {
         return ERR_PTR(-ENOSYS);
@@ -163,6 +181,7 @@ static inline int pm_genpd_remove_device(struct generic_pm_domain *genpd,
 {
         return -ENOSYS;
 }
+static inline void pm_genpd_dev_always_on(struct device *dev, bool val) {}
 static inline int pm_genpd_add_subdomain(struct generic_pm_domain *genpd,
                                          struct generic_pm_domain *new_sd)
 {
@@ -183,7 +202,8 @@ static inline int __pm_genpd_remove_callbacks(struct device *dev, bool clear_td)
 {
         return -ENOSYS;
 }
-static inline void pm_genpd_init(struct generic_pm_domain *genpd, bool is_off)
+static inline void pm_genpd_init(struct generic_pm_domain *genpd,
+                                 struct dev_power_governor *gov, bool is_off)
 {
 }
 static inline int pm_genpd_poweron(struct generic_pm_domain *genpd)
@@ -194,6 +214,7 @@ static inline bool default_stop_ok(struct device *dev)
 {
         return false;
 }
+#define simple_qos_governor NULL
 #define pm_domain_always_on_gov NULL
 #endif
 
diff --git a/include/linux/pm_qos.h b/include/linux/pm_qos.h
index 4d99e4e6ef83..2e9191a712f3 100644
--- a/include/linux/pm_qos.h
+++ b/include/linux/pm_qos.h
@@ -9,12 +9,16 @@
 #include <linux/miscdevice.h>
 #include <linux/device.h>
 
-#define PM_QOS_RESERVED 0
-#define PM_QOS_CPU_DMA_LATENCY 1
-#define PM_QOS_NETWORK_LATENCY 2
-#define PM_QOS_NETWORK_THROUGHPUT 3
+enum {
+        PM_QOS_RESERVED = 0,
+        PM_QOS_CPU_DMA_LATENCY,
+        PM_QOS_NETWORK_LATENCY,
+        PM_QOS_NETWORK_THROUGHPUT,
+
+        /* insert new class ID */
+        PM_QOS_NUM_CLASSES,
+};
 
-#define PM_QOS_NUM_CLASSES 4
 #define PM_QOS_DEFAULT_VALUE -1
 
 #define PM_QOS_CPU_DMA_LAT_DEFAULT_VALUE        (2000 * USEC_PER_SEC)
@@ -63,7 +67,6 @@ static inline int dev_pm_qos_request_active(struct dev_pm_qos_request *req)
         return req->dev != 0;
 }
 
-#ifdef CONFIG_PM
 int pm_qos_update_target(struct pm_qos_constraints *c, struct plist_node *node,
                          enum pm_qos_req_action action, int value);
 void pm_qos_add_request(struct pm_qos_request *req, int pm_qos_class,
@@ -78,6 +81,7 @@ int pm_qos_remove_notifier(int pm_qos_class, struct notifier_block *notifier);
 int pm_qos_request_active(struct pm_qos_request *req);
 s32 pm_qos_read_value(struct pm_qos_constraints *c);
 
+#ifdef CONFIG_PM
 s32 __dev_pm_qos_read_value(struct device *dev);
 s32 dev_pm_qos_read_value(struct device *dev);
 int dev_pm_qos_add_request(struct device *dev, struct dev_pm_qos_request *req,
@@ -95,45 +99,6 @@ void dev_pm_qos_constraints_destroy(struct device *dev);
 int dev_pm_qos_add_ancestor_request(struct device *dev,
                                     struct dev_pm_qos_request *req, s32 value);
 #else
-static inline int pm_qos_update_target(struct pm_qos_constraints *c,
-                                       struct plist_node *node,
-                                       enum pm_qos_req_action action,
-                                       int value)
-                        { return 0; }
-static inline void pm_qos_add_request(struct pm_qos_request *req,
-                                      int pm_qos_class, s32 value)
-                        { return; }
-static inline void pm_qos_update_request(struct pm_qos_request *req,
-                                         s32 new_value)
-                        { return; }
-static inline void pm_qos_remove_request(struct pm_qos_request *req)
-                        { return; }
-
-static inline int pm_qos_request(int pm_qos_class)
-{
-        switch (pm_qos_class) {
-        case PM_QOS_CPU_DMA_LATENCY:
-                return PM_QOS_CPU_DMA_LAT_DEFAULT_VALUE;
-        case PM_QOS_NETWORK_LATENCY:
-                return PM_QOS_NETWORK_LAT_DEFAULT_VALUE;
-        case PM_QOS_NETWORK_THROUGHPUT:
-                return PM_QOS_NETWORK_THROUGHPUT_DEFAULT_VALUE;
-        default:
-                return PM_QOS_DEFAULT_VALUE;
-        }
-}
-
-static inline int pm_qos_add_notifier(int pm_qos_class,
-                                      struct notifier_block *notifier)
-                        { return 0; }
-static inline int pm_qos_remove_notifier(int pm_qos_class,
-                                         struct notifier_block *notifier)
-                        { return 0; }
-static inline int pm_qos_request_active(struct pm_qos_request *req)
-                        { return 0; }
-static inline s32 pm_qos_read_value(struct pm_qos_constraints *c)
-                        { return 0; }
-
 static inline s32 __dev_pm_qos_read_value(struct device *dev)
                         { return 0; }
 static inline s32 dev_pm_qos_read_value(struct device *dev)
@@ -172,4 +137,13 @@ static inline int dev_pm_qos_add_ancestor_request(struct device *dev,
                         { return 0; }
 #endif
 
+#ifdef CONFIG_PM_RUNTIME
+int dev_pm_qos_expose_latency_limit(struct device *dev, s32 value);
+void dev_pm_qos_hide_latency_limit(struct device *dev);
+#else
+static inline int dev_pm_qos_expose_latency_limit(struct device *dev, s32 value)
+                        { return 0; }
+static inline void dev_pm_qos_hide_latency_limit(struct device *dev) {}
+#endif
+
 #endif
diff --git a/include/linux/pm_wakeup.h b/include/linux/pm_wakeup.h
index a32da962d693..d9f05113e5fb 100644
--- a/include/linux/pm_wakeup.h
+++ b/include/linux/pm_wakeup.h
@@ -41,7 +41,7 @@
  * @active: Status of the wakeup source.
  */
 struct wakeup_source {
-        char                    *name;
+        const char              *name;
         struct list_head        entry;
         spinlock_t              lock;
         struct timer_list       timer;
@@ -73,7 +73,9 @@ static inline bool device_may_wakeup(struct device *dev)
 }
 
 /* drivers/base/power/wakeup.c */
+extern void wakeup_source_prepare(struct wakeup_source *ws, const char *name);
 extern struct wakeup_source *wakeup_source_create(const char *name);
+extern void wakeup_source_drop(struct wakeup_source *ws);
 extern void wakeup_source_destroy(struct wakeup_source *ws);
 extern void wakeup_source_add(struct wakeup_source *ws);
 extern void wakeup_source_remove(struct wakeup_source *ws);
@@ -103,11 +105,16 @@ static inline bool device_can_wakeup(struct device *dev)
         return dev->power.can_wakeup;
 }
 
+static inline void wakeup_source_prepare(struct wakeup_source *ws,
+                                         const char *name) {}
+
 static inline struct wakeup_source *wakeup_source_create(const char *name)
 {
         return NULL;
 }
 
+static inline void wakeup_source_drop(struct wakeup_source *ws) {}
+
 static inline void wakeup_source_destroy(struct wakeup_source *ws) {}
 
 static inline void wakeup_source_add(struct wakeup_source *ws) {}
@@ -165,4 +172,17 @@ static inline void pm_wakeup_event(struct device *dev, unsigned int msec) {}
 
 #endif /* !CONFIG_PM_SLEEP */
 
+static inline void wakeup_source_init(struct wakeup_source *ws,
+                                      const char *name)
+{
+        wakeup_source_prepare(ws, name);
+        wakeup_source_add(ws);
+}
+
+static inline void wakeup_source_trash(struct wakeup_source *ws)
+{
+        wakeup_source_remove(ws);
+        wakeup_source_drop(ws);
+}
+
 #endif /* _LINUX_PM_WAKEUP_H */
diff --git a/include/linux/suspend.h b/include/linux/suspend.h
index 91784a4f8608..ac1c114c499d 100644
--- a/include/linux/suspend.h
+++ b/include/linux/suspend.h
@@ -42,8 +42,10 @@ enum suspend_stat_step {
         SUSPEND_FREEZE = 1,
         SUSPEND_PREPARE,
         SUSPEND_SUSPEND,
+        SUSPEND_SUSPEND_LATE,
         SUSPEND_SUSPEND_NOIRQ,
         SUSPEND_RESUME_NOIRQ,
+        SUSPEND_RESUME_EARLY,
         SUSPEND_RESUME
 };
 
@@ -53,8 +55,10 @@ struct suspend_stats {
         int     failed_freeze;
         int     failed_prepare;
         int     failed_suspend;
+        int     failed_suspend_late;
         int     failed_suspend_noirq;
         int     failed_resume;
+        int     failed_resume_early;
         int     failed_resume_noirq;
 #define REC_FAILED_NUM  2
         int     last_failed_dev;