Merge tag 'pm+acpi-3.16-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm into next

Pull ACPI and power management updates from Rafael Wysocki:
 "ACPICA is the leader this time (63 commits), followed by cpufreq (28
  commits), devfreq (15 commits), system suspend/hibernation (12
  commits), ACPI video and ACPI device enumeration (10 commits each).

  We have no major new features this time, but there are a few
  significant changes of how things work.  The most visible one will
  probably be that we are now going to create platform devices rather
  than PNP devices by default for ACPI device objects with _HID.  That
  was long overdue and will be really necessary to be able to use the
  same drivers for the same hardware blocks on ACPI and DT-based systems
  going forward.  We're not expecting fallout from this one (as usual),
  but it's something to watch nevertheless.

  The second change having a chance to be visible is that ACPI video
  will now default to using native backlight rather than the ACPI
  backlight interface which should generally help systems with broken
  Win8 BIOSes.  We're hoping that all problems with the native backlight
  handling that we had previously have been addressed and we are in a
  good enough shape to flip the default, but this change should be easy
  enough to revert if need be.

  In addition to that, the system suspend core has a new mechanism to
  allow runtime-suspended devices to stay suspended throughout system
  suspend/resume transitions if some extra conditions are met
  (generally, they are related to coordination within device hierarchy).
  However, enabling this feature requires cooperation from the bus type
  layer and for now it has only been implemented for the ACPI PM domain
  (used by ACPI-enumerated platform devices mostly today).

  Also, the acpidump utility that was previously shipped as a separate
  tool will now be provided by the upstream ACPICA along with the rest
  of ACPICA code, which will allow it to be more up to date and better
  supported, and we have one new cpuidle driver (ARM clps711x).

  The rest is improvements related to certain specific use cases,
  cleanups and fixes all over the place.

  Specifics:

   - ACPICA update to upstream version 20140424.  That includes a number
     of fixes and improvements related to things like GPE handling,
     table loading, headers, memory mapping and unmapping, DSDT/SSDT
     overriding, and the Unload() operator.  The acpidump utility from
     upstream ACPICA is included too.  From Bob Moore, Lv Zheng, David
     Box, David Binderman, and Colin Ian King.

   - Fixes and cleanups related to ACPI video and backlight interfaces
     from Hans de Goede.  That includes blacklist entries for some new
     machines and using native backlight by default.

   - ACPI device enumeration changes to create platform devices rather
     than PNP devices for ACPI device objects with _HID by default.  PNP
     devices will still be created for the ACPI device object with
     device IDs corresponding to real PNP devices, so that change should
     not break things left and right, and we're expecting to see more
     and more ACPI-enumerated platform devices in the future.  From
     Zhang Rui and Rafael J Wysocki.

   - Updates for the ACPI LPSS (Low-Power Subsystem) driver allowing it
     to handle system suspend/resume on Asus T100 correctly.  From
     Heikki Krogerus and Rafael J Wysocki.

   - PM core update introducing a mechanism to allow runtime-suspended
     devices to stay suspended over system suspend/resume transitions if
     certain additional conditions related to coordination within device
     hierarchy are met.  Related PM documentation update and ACPI PM
     domain support for the new feature.  From Rafael J Wysocki.

   - Fixes and improvements related to the "freeze" sleep state.  They
     affect several places including cpuidle, PM core, ACPI core, and
     the ACPI battery driver.  From Rafael J Wysocki and Zhang Rui.

   - Miscellaneous fixes and updates of the ACPI core from Aaron Lu,
     Bjørn Mork, Hanjun Guo, Lan Tianyu, and Rafael J Wysocki.

   - Fixes and cleanups for the ACPI processor and ACPI PAD (Processor
     Aggregator Device) drivers from Baoquan He, Manuel Schölling, Tony
     Camuso, and Toshi Kani.

   - System suspend/resume optimization in the ACPI battery driver from
     Lan Tianyu.

   - OPP (Operating Performance Points) subsystem updates from Chander
     Kashyap, Mark Brown, and Nishanth Menon.

   - cpufreq core fixes, updates and cleanups from Srivatsa S Bhat,
     Stratos Karafotis, and Viresh Kumar.

   - Updates, fixes and cleanups for the Tegra, powernow-k8, imx6q,
     s5pv210, nforce2, and powernv cpufreq drivers from Brian Norris,
     Jingoo Han, Paul Bolle, Philipp Zabel, Stratos Karafotis, and
     Viresh Kumar.

   - intel_pstate driver fixes and cleanups from Dirk Brandewie, Doug
     Smythies, and Stratos Karafotis.

   - Enabling the big.LITTLE cpufreq driver on arm64 from Mark Brown.

   - Fix for the cpuidle menu governor from Chander Kashyap.

   - New ARM clps711x cpuidle driver from Alexander Shiyan.

   - Hibernate core fixes and cleanups from Chen Gang, Dan Carpenter,
     Fabian Frederick, Pali Rohár, and Sebastian Capella.

   - Intel RAPL (Running Average Power Limit) driver updates from Jacob
     Pan.

   - PNP subsystem updates from Bjorn Helgaas and Fabian Frederick.

   - devfreq core updates from Chanwoo Choi and Paul Bolle.

   - devfreq updates for exynos4 and exynos5 from Chanwoo Choi and
     Bartlomiej Zolnierkiewicz.

   - turbostat tool fix from Jean Delvare.

   - cpupower tool updates from Prarit Bhargava, Ramkumar Ramachandra
     and Thomas Renninger.

   - New ACPI ec_access.c tool for poking at the EC in a safe way from
     Thomas Renninger"

* tag 'pm+acpi-3.16-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm: (187 commits)
  ACPICA: Namespace: Remove _PRP method support.
  intel_pstate: Improve initial busy calculation
  intel_pstate: add sample time scaling
  intel_pstate: Correct rounding in busy calculation
  intel_pstate: Remove C0 tracking
  PM / hibernate: fixed typo in comment
  ACPI: Fix x86 regression related to early mapping size limitation
  ACPICA: Tables: Add mechanism to control early table checksum verification.
  ACPI / scan: use platform bus type by default for _HID enumeration
  ACPI / scan: always register ACPI LPSS scan handler
  ACPI / scan: always register memory hotplug scan handler
  ACPI / scan: always register container scan handler
  ACPI / scan: Change the meaning of missing .attach() in scan handlers
  ACPI / scan: introduce platform_id device PNP type flag
  ACPI / scan: drop unsupported serial IDs from PNP ACPI scan handler ID list
  ACPI / scan: drop IDs that do not comply with the ACPI PNP ID rule
  ACPI / PNP: use device ID list for PNPACPI device enumeration
  ACPI / scan: .match() callback for ACPI scan handlers
  ACPI / battery: wakeup the system only when necessary
  power_supply: allow power supply devices registered w/o wakeup source
  ...

7 files changed, 130 insertions, 77 deletions

diff --git a/kernel/power/Kconfig b/kernel/power/Kconfig
index 2fac9cc79b3d..9a83d780facd 100644
--- a/kernel/power/Kconfig
+++ b/kernel/power/Kconfig
@@ -257,8 +257,7 @@ config ARCH_HAS_OPP
         bool
 
 config PM_OPP
-        bool "Operating Performance Point (OPP) Layer library"
-        depends on ARCH_HAS_OPP
+        bool
         ---help---
           SOCs have a standard set of tuples consisting of frequency and
           voltage pairs that the device will support per voltage domain. This
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 155721f7f909..963e6d0f050b 100644
--- a/kernel/power/suspend.c
+++ b/kernel/power/suspend.c
@@ -31,13 +31,14 @@
 
 #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;
+static const struct platform_freeze_ops *freeze_ops;
 
 static bool need_suspend_ops(suspend_state_t state)
 {
@@ -47,6 +48,13 @@ static bool need_suspend_ops(suspend_state_t state)
 static DECLARE_WAIT_QUEUE_HEAD(suspend_freeze_wait_head);
 static bool suspend_freeze_wake;
 
+void freeze_set_ops(const struct platform_freeze_ops *ops)
+{
+        lock_system_sleep();
+        freeze_ops = ops;
+        unlock_system_sleep();
+}
+
 static void freeze_begin(void)
 {
         suspend_freeze_wake = false;
@@ -68,42 +76,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.
  *
@@ -271,6 +299,10 @@ int suspend_devices_and_enter(suspend_state_t state)
                 error = suspend_ops->begin(state);
                 if (error)
                         goto Close;
+        } else if (state == PM_SUSPEND_FREEZE && freeze_ops->begin) {
+                error = freeze_ops->begin();
+                if (error)
+                        goto Close;
         }
         suspend_console();
         suspend_test_start();
@@ -296,6 +328,9 @@ int suspend_devices_and_enter(suspend_state_t state)
  Close:
         if (need_suspend_ops(state) && suspend_ops->end)
                 suspend_ops->end();
+        else if (state == PM_SUSPEND_FREEZE && freeze_ops->end)
+                freeze_ops->end();
+
         trace_machine_suspend(PWR_EVENT_EXIT);
         return error;
 
@@ -330,9 +365,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;
 
@@ -343,7 +386,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;
@@ -351,7 +394,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/power/swap.c b/kernel/power/swap.c
index 8c9a4819f798..aaa3261dea5d 100644
--- a/kernel/power/swap.c
+++ b/kernel/power/swap.c
@@ -567,7 +567,7 @@ static int lzo_compress_threadfn(void *data)
 
 /**
  * save_image_lzo - Save the suspend image data compressed with LZO.
- * @handle: Swap mam handle to use for saving the image.
+ * @handle: Swap map handle to use for saving the image.
  * @snapshot: Image to read data from.
  * @nr_to_write: Number of pages to save.
  */