Merge branch 'pm-sleep' into acpi-battery

6 files changed, 122 insertions, 87 deletions

diff --git a/kernel/power/hibernate.c b/kernel/power/hibernate.c
index f4f2073711d3..df88d55dc436 100644
--- a/kernel/power/hibernate.c
+++ b/kernel/power/hibernate.c
@@ -35,7 +35,7 @@
 static int nocompress;
 static int noresume;
 static int resume_wait;
-static int resume_delay;
+static unsigned int resume_delay;
 static char resume_file[256] = CONFIG_PM_STD_PARTITION;
 dev_t swsusp_resume_device;
 sector_t swsusp_resume_block;
@@ -228,19 +228,23 @@ static void platform_recover(int platform_mode)
 void swsusp_show_speed(struct timeval *start, struct timeval *stop,
                         unsigned nr_pages, char *msg)
 {
-        s64 elapsed_centisecs64;
-        int centisecs;
-        int k;
-        int kps;
+        u64 elapsed_centisecs64;
+        unsigned int centisecs;
+        unsigned int k;
+        unsigned int kps;
 
         elapsed_centisecs64 = timeval_to_ns(stop) - timeval_to_ns(start);
+        /*
+         * If "(s64)elapsed_centisecs64 < 0", it will print long elapsed time,
+         * it is obvious enough for what went wrong.
+         */
         do_div(elapsed_centisecs64, NSEC_PER_SEC / 100);
         centisecs = elapsed_centisecs64;
         if (centisecs == 0)
                 centisecs = 1;  /* avoid div-by-zero */
         k = nr_pages * (PAGE_SIZE / 1024);
         kps = (k * 100) / centisecs;
-        printk(KERN_INFO "PM: %s %d kbytes in %d.%02d seconds (%d.%02d MB/s)\n",
+        printk(KERN_INFO "PM: %s %u kbytes in %u.%02u seconds (%u.%02u MB/s)\n",
                         msg, k,
                         centisecs / 100, centisecs % 100,
                         kps / 1000, (kps % 1000) / 10);
@@ -595,7 +599,8 @@ static void power_down(void)
         case HIBERNATION_PLATFORM:
                 hibernation_platform_enter();
         case HIBERNATION_SHUTDOWN:
-                kernel_power_off();
+                if (pm_power_off)
+                        kernel_power_off();
                 break;
 #ifdef CONFIG_SUSPEND
         case HIBERNATION_SUSPEND:
@@ -623,7 +628,8 @@ static void power_down(void)
          * corruption after resume.
          */
         printk(KERN_CRIT "PM: Please power down manually\n");
-        while(1);
+        while (1)
+                cpu_relax();
 }
 
 /**
@@ -1109,7 +1115,10 @@ static int __init resumewait_setup(char *str)
 
 static int __init resumedelay_setup(char *str)
 {
-        resume_delay = simple_strtoul(str, NULL, 0);
+        int rc = kstrtouint(str, 0, &resume_delay);
+
+        if (rc)
+                return rc;
         return 1;
 }
 
diff --git a/kernel/power/main.c b/kernel/power/main.c
index 6271bc4073ef..573410d6647e 100644
--- a/kernel/power/main.c
+++ b/kernel/power/main.c
@@ -279,26 +279,26 @@ static inline void pm_print_times_init(void) {}
 struct kobject *power_kobj;
 
 /**
- *      state - control system power state.
+ * state - control system sleep states.
  *
- *      show() returns what states are supported, which is hard-coded to
- *      'freeze' (Low-Power Idle), 'standby' (Power-On Suspend),
- *      'mem' (Suspend-to-RAM), and 'disk' (Suspend-to-Disk).
+ * show() returns available sleep state labels, which may be "mem", "standby",
+ * "freeze" and "disk" (hibernation).  See Documentation/power/states.txt for a
+ * description of what they mean.
  *
- *      store() accepts one of those strings, translates it into the
- *      proper enumerated value, and initiates a suspend transition.
+ * store() accepts one of those strings, translates it into the proper
+ * enumerated value, and initiates a suspend transition.
  */
 static ssize_t state_show(struct kobject *kobj, struct kobj_attribute *attr,
                           char *buf)
 {
         char *s = buf;
 #ifdef CONFIG_SUSPEND
-        int i;
+        suspend_state_t i;
+
+        for (i = PM_SUSPEND_MIN; i < PM_SUSPEND_MAX; i++)
+                if (pm_states[i].state)
+                        s += sprintf(s,"%s ", pm_states[i].label);
 
-        for (i = 0; i < PM_SUSPEND_MAX; i++) {
-                if (pm_states[i] && valid_state(i))
-                        s += sprintf(s,"%s ", pm_states[i]);
-        }
 #endif
 #ifdef CONFIG_HIBERNATION
         s += sprintf(s, "%s\n", "disk");
@@ -314,7 +314,7 @@ static suspend_state_t decode_state(const char *buf, size_t n)
 {
 #ifdef CONFIG_SUSPEND
         suspend_state_t state = PM_SUSPEND_MIN;
-        const char * const *s;
+        struct pm_sleep_state *s;
 #endif
         char *p;
         int len;
@@ -328,8 +328,9 @@ static suspend_state_t decode_state(const char *buf, size_t n)
 
 #ifdef CONFIG_SUSPEND
         for (s = &pm_states[state]; state < PM_SUSPEND_MAX; s++, state++)
-                if (*s && len == strlen(*s) && !strncmp(buf, *s, len))
-                        return state;
+                if (s->state && len == strlen(s->label)
+                    && !strncmp(buf, s->label, len))
+                        return s->state;
 #endif
 
         return PM_SUSPEND_ON;
@@ -447,8 +448,8 @@ static ssize_t autosleep_show(struct kobject *kobj,
 
 #ifdef CONFIG_SUSPEND
         if (state < PM_SUSPEND_MAX)
-                return sprintf(buf, "%s\n", valid_state(state) ?
-                                                pm_states[state] : "error");
+                return sprintf(buf, "%s\n", pm_states[state].state ?
+                                        pm_states[state].label : "error");
 #endif
 #ifdef CONFIG_HIBERNATION
         return sprintf(buf, "disk\n");
diff --git a/kernel/power/power.h b/kernel/power/power.h
index 15f37ea08719..c60f13b5270a 100644
--- a/kernel/power/power.h
+++ b/kernel/power/power.h
@@ -178,17 +178,20 @@ extern void swsusp_show_speed(struct timeval *, struct timeval *,
                                 unsigned int, char *);
 
 #ifdef CONFIG_SUSPEND
+struct pm_sleep_state {
+        const char *label;
+        suspend_state_t state;
+};
+
 /* kernel/power/suspend.c */
-extern const char *const pm_states[];
+extern struct pm_sleep_state pm_states[];
 
-extern bool valid_state(suspend_state_t state);
 extern int suspend_devices_and_enter(suspend_state_t state);
 #else /* !CONFIG_SUSPEND */
 static inline int suspend_devices_and_enter(suspend_state_t state)
 {
         return -ENOSYS;
 }
-static inline bool valid_state(suspend_state_t state) { return false; }
 #endif /* !CONFIG_SUSPEND */
 
 #ifdef CONFIG_PM_TEST_SUSPEND
diff --git a/kernel/power/suspend.c b/kernel/power/suspend.c
index 8233cd4047d7..338a6f147974 100644
--- a/kernel/power/suspend.c
+++ b/kernel/power/suspend.c
@@ -31,10 +31,10 @@
 
 #include "power.h"
 
-const char *const pm_states[PM_SUSPEND_MAX] = {
-        [PM_SUSPEND_FREEZE]     = "freeze",
-        [PM_SUSPEND_STANDBY]    = "standby",
-        [PM_SUSPEND_MEM]        = "mem",
+struct pm_sleep_state pm_states[PM_SUSPEND_MAX] = {
+        [PM_SUSPEND_FREEZE] = { .label = "freeze", .state = PM_SUSPEND_FREEZE },
+        [PM_SUSPEND_STANDBY] = { .label = "standby", },
+        [PM_SUSPEND_MEM] = { .label = "mem", },
 };
 
 static const struct platform_suspend_ops *suspend_ops;
@@ -54,9 +54,11 @@ static void freeze_begin(void)
 
 static void freeze_enter(void)
 {
+        cpuidle_use_deepest_state(true);
         cpuidle_resume();
         wait_event(suspend_freeze_wait_head, suspend_freeze_wake);
         cpuidle_pause();
+        cpuidle_use_deepest_state(false);
 }
 
 void freeze_wake(void)
@@ -66,42 +68,62 @@ void freeze_wake(void)
 }
 EXPORT_SYMBOL_GPL(freeze_wake);
 
+static bool valid_state(suspend_state_t state)
+{
+        /*
+         * PM_SUSPEND_STANDBY and PM_SUSPEND_MEM states need low level
+         * support and need to be valid to the low level
+         * implementation, no valid callback implies that none are valid.
+         */
+        return suspend_ops && suspend_ops->valid && suspend_ops->valid(state);
+}
+
+/*
+ * If this is set, the "mem" label always corresponds to the deepest sleep state
+ * available, the "standby" label corresponds to the second deepest sleep state
+ * available (if any), and the "freeze" label corresponds to the remaining
+ * available sleep state (if there is one).
+ */
+static bool relative_states;
+
+static int __init sleep_states_setup(char *str)
+{
+        relative_states = !strncmp(str, "1", 1);
+        if (relative_states) {
+                pm_states[PM_SUSPEND_MEM].state = PM_SUSPEND_FREEZE;
+                pm_states[PM_SUSPEND_FREEZE].state = 0;
+        }
+        return 1;
+}
+
+__setup("relative_sleep_states=", sleep_states_setup);
+
 /**
  * suspend_set_ops - Set the global suspend method table.
  * @ops: Suspend operations to use.
  */
 void suspend_set_ops(const struct platform_suspend_ops *ops)
 {
+        suspend_state_t i;
+        int j = PM_SUSPEND_MAX - 1;
+
         lock_system_sleep();
+
         suspend_ops = ops;
+        for (i = PM_SUSPEND_MEM; i >= PM_SUSPEND_STANDBY; i--)
+                if (valid_state(i))
+                        pm_states[j--].state = i;
+                else if (!relative_states)
+                        pm_states[j--].state = 0;
+
+        pm_states[j--].state = PM_SUSPEND_FREEZE;
+        while (j >= PM_SUSPEND_MIN)
+                pm_states[j--].state = 0;
+
         unlock_system_sleep();
 }
 EXPORT_SYMBOL_GPL(suspend_set_ops);
 
-bool valid_state(suspend_state_t state)
-{
-        if (state == PM_SUSPEND_FREEZE) {
-#ifdef CONFIG_PM_DEBUG
-                if (pm_test_level != TEST_NONE &&
-                    pm_test_level != TEST_FREEZER &&
-                    pm_test_level != TEST_DEVICES &&
-                    pm_test_level != TEST_PLATFORM) {
-                        printk(KERN_WARNING "Unsupported pm_test mode for "
-                                        "freeze state, please choose "
-                                        "none/freezer/devices/platform.\n");
-                        return false;
-                }
-#endif
-                        return true;
-        }
-        /*
-         * PM_SUSPEND_STANDBY and PM_SUSPEND_MEMORY states need lowlevel
-         * support and need to be valid to the lowlevel
-         * implementation, no valid callback implies that none are valid.
-         */
-        return suspend_ops && suspend_ops->valid && suspend_ops->valid(state);
-}
-
 /**
  * suspend_valid_only_mem - Generic memory-only valid callback.
  *
@@ -328,9 +350,17 @@ static int enter_state(suspend_state_t state)
 {
         int error;
 
-        if (!valid_state(state))
-                return -ENODEV;
-
+        if (state == PM_SUSPEND_FREEZE) {
+#ifdef CONFIG_PM_DEBUG
+                if (pm_test_level != TEST_NONE && pm_test_level <= TEST_CPUS) {
+                        pr_warning("PM: Unsupported test mode for freeze state,"
+                                   "please choose none/freezer/devices/platform.\n");
+                        return -EAGAIN;
+                }
+#endif
+        } else if (!valid_state(state)) {
+                return -EINVAL;
+        }
         if (!mutex_trylock(&pm_mutex))
                 return -EBUSY;
 
@@ -341,7 +371,7 @@ static int enter_state(suspend_state_t state)
         sys_sync();
         printk("done.\n");
 
-        pr_debug("PM: Preparing system for %s sleep\n", pm_states[state]);
+        pr_debug("PM: Preparing system for %s sleep\n", pm_states[state].label);
         error = suspend_prepare(state);
         if (error)
                 goto Unlock;
@@ -349,7 +379,7 @@ static int enter_state(suspend_state_t state)
         if (suspend_test(TEST_FREEZER))
                 goto Finish;
 
-        pr_debug("PM: Entering %s sleep\n", pm_states[state]);
+        pr_debug("PM: Entering %s sleep\n", pm_states[state].label);
         pm_restrict_gfp_mask();
         error = suspend_devices_and_enter(state);
         pm_restore_gfp_mask();
diff --git a/kernel/power/suspend_test.c b/kernel/power/suspend_test.c
index 9b2a1d58558d..269b097e78ea 100644
--- a/kernel/power/suspend_test.c
+++ b/kernel/power/suspend_test.c
@@ -92,13 +92,13 @@ static void __init test_wakealarm(struct rtc_device *rtc, suspend_state_t state)
         }
 
         if (state == PM_SUSPEND_MEM) {
-                printk(info_test, pm_states[state]);
+                printk(info_test, pm_states[state].label);
                 status = pm_suspend(state);
                 if (status == -ENODEV)
                         state = PM_SUSPEND_STANDBY;
         }
         if (state == PM_SUSPEND_STANDBY) {
-                printk(info_test, pm_states[state]);
+                printk(info_test, pm_states[state].label);
                 status = pm_suspend(state);
         }
         if (status < 0)
@@ -136,18 +136,16 @@ static char warn_bad_state[] __initdata =
 
 static int __init setup_test_suspend(char *value)
 {
-        unsigned i;
+        suspend_state_t i;
 
         /* "=mem" ==> "mem" */
         value++;
-        for (i = 0; i < PM_SUSPEND_MAX; i++) {
-                if (!pm_states[i])
-                        continue;
-                if (strcmp(pm_states[i], value) != 0)
-                        continue;
-                test_state = (__force suspend_state_t) i;
-                return 0;
-        }
+        for (i = PM_SUSPEND_MIN; i < PM_SUSPEND_MAX; i++)
+                if (!strcmp(pm_states[i].label, value)) {
+                        test_state = pm_states[i].state;
+                        return 0;
+                }
+
         printk(warn_bad_state, value);
         return 0;
 }
@@ -164,8 +162,8 @@ static int __init test_suspend(void)
         /* PM is initialized by now; is that state testable? */
         if (test_state == PM_SUSPEND_ON)
                 goto done;
-        if (!valid_state(test_state)) {
-                printk(warn_bad_state, pm_states[test_state]);
+        if (!pm_states[test_state].state) {
+                printk(warn_bad_state, pm_states[test_state].label);
                 goto done;
         }
 
diff --git a/kernel/sched/idle.c b/kernel/sched/idle.c
index 8f4390a079c7..a8f12247ce7c 100644
--- a/kernel/sched/idle.c
+++ b/kernel/sched/idle.c
@@ -101,19 +101,13 @@ static int cpuidle_idle_call(void)
         rcu_idle_enter();
 
         /*
-         * Check if the cpuidle framework is ready, otherwise fallback
-         * to the default arch specific idle method
+         * Ask the cpuidle framework to choose a convenient idle state.
+         * Fall back to the default arch specific idle method on errors.
          */
-        ret = cpuidle_enabled(drv, dev);
-
-        if (!ret) {
-                /*
-                 * Ask the governor to choose an idle state it thinks
-                 * it is convenient to go to. There is *always* a
-                 * convenient idle state
-                 */
-                next_state = cpuidle_select(drv, dev);
+        next_state = cpuidle_select(drv, dev);
 
+        ret = next_state;
+        if (ret >= 0) {
                 /*
                  * The idle task must be scheduled, it is pointless to
                  * go to idle, just update no idle residency and get
@@ -140,7 +134,7 @@ static int cpuidle_idle_call(void)
                                         CLOCK_EVT_NOTIFY_BROADCAST_ENTER,
                                         &dev->cpu);
 
-                        if (!ret) {
+                        if (ret >= 0) {
                                 trace_cpu_idle_rcuidle(next_state, dev->cpu);
 
                                 /*
@@ -175,7 +169,7 @@ static int cpuidle_idle_call(void)
          * We can't use the cpuidle framework, let's use the default
          * idle routine
          */
-        if (ret)
+        if (ret < 0)
                 arch_cpu_idle();
 
         __current_set_polling();