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

Pull ACPI and power management updates from Rafael Wysocki:
 "Features-wise, to me the most important this time is a rework of
  wakeup interrupts handling in the core that makes them work
  consistently across all of the available sleep states, including
  suspend-to-idle.  Many thanks to Thomas Gleixner for his help with
  this work.

  Second is an update of the generic PM domains code that has been in
  need of some care for quite a while.  Unused code is being removed, DT
  support is being added and domains are now going to be attached to
  devices in bus type code in analogy with the ACPI PM domain.  The
  majority of work here was done by Ulf Hansson who also has been the
  most active developer this time.

  Apart from this we have a traditional ACPICA update, this time to
  upstream version 20140828 and a few ACPI wakeup interrupts handling
  patches on top of the general rework mentioned above.  There also are
  several cpufreq commits including renaming the cpufreq-cpu0 driver to
  cpufreq-dt, as this is what implements generic DT-based cpufreq
  support, and a new DT-based idle states infrastructure for cpuidle.

  In addition to that, the ACPI LPSS driver is updated, ACPI support for
  Apple machines is improved, a few bugs are fixed and a few cleanups
  are made all over.

  Finally, the Adaptive Voltage Scaling (AVS) subsystem now has a tree
  maintained by Kevin Hilman that will be merged through the PM tree.

  Numbers-wise, the generic PM domains update takes the lead this time
  with 32 non-merge commits, second is cpufreq (15 commits) and the 3rd
  place goes to the wakeup interrupts handling rework (13 commits).

  Specifics:

   - Rework the handling of wakeup IRQs by the IRQ core such that all of
     them will be switched over to "wakeup" mode in suspend_device_irqs()
     and in that mode the first interrupt will abort system suspend in
     progress or wake up the system if already in suspend-to-idle (or
     equivalent) without executing any interrupt handlers.  Among other
     things that eliminates the wakeup-related motivation to use the
     IRQF_NO_SUSPEND interrupt flag with interrupts which don't really
     need it and should not use it (Thomas Gleixner and Rafael Wysocki)

   - Switch over ACPI to handling wakeup interrupts with the help of the
     new mechanism introduced by the above IRQ core rework (Rafael Wysocki)

   - Rework the core generic PM domains code to eliminate code that's
     not used, add DT support and add a generic mechanism by which
     devices can be added to PM domains automatically during enumeration
     (Ulf Hansson, Geert Uytterhoeven and Tomasz Figa).

   - Add debugfs-based mechanics for debugging generic PM domains
     (Maciej Matraszek).

   - ACPICA update to upstream version 20140828.  Included are updates
     related to the SRAT and GTDT tables and the _PSx methods are in the
     METHOD_NAME list now (Bob Moore and Hanjun Guo).

   - Add _OSI("Darwin") support to the ACPI core (unfortunately, that
     can't really be done in a straightforward way) to prevent
     Thunderbolt from being turned off on Apple systems after boot (or
     after resume from system suspend) and rework the ACPI Smart Battery
     Subsystem (SBS) driver to work correctly with Apple platforms
     (Matthew Garrett and Andreas Noever).

   - ACPI LPSS (Low-Power Subsystem) driver update cleaning up the code,
     adding support for 133MHz I2C source clock on Intel Baytrail to it
     and making it avoid using UART RTS override with Auto Flow Control
     (Heikki Krogerus).

   - ACPI backlight updates removing the video_set_use_native_backlight
     quirk which is not necessary any more, making the code check the
     list of output devices returned by the _DOD method to avoid
     creating acpi_video interfaces that won't work and adding a quirk
     for Lenovo Ideapad Z570 (Hans de Goede, Aaron Lu and Stepan Bujnak)

   - New Win8 ACPI OSI quirks for some Dell laptops (Edward Lin)

   - Assorted ACPI code cleanups (Fabian Frederick, Rasmus Villemoes,
     Sudip Mukherjee, Yijing Wang, and Zhang Rui)

   - cpufreq core updates and cleanups (Viresh Kumar, Preeti U Murthy,
     Rasmus Villemoes)

   - cpufreq driver updates: cpufreq-cpu0/cpufreq-dt (driver name change
     among other things), ppc-corenet, powernv (Viresh Kumar, Preeti U
     Murthy, Shilpasri G Bhat, Lucas Stach)

   - cpuidle support for DT-based idle states infrastructure, new ARM64
     cpuidle driver, cpuidle core cleanups (Lorenzo Pieralisi, Rasmus
     Villemoes)

   - ARM big.LITTLE cpuidle driver updates: support for DT-based
     initialization and Exynos5800 compatible string (Lorenzo Pieralisi,
     Kevin Hilman)

   - Rework of the test_suspend kernel command line argument and a new
     trace event for console resume (Srinivas Pandruvada, Todd E Brandt)

   - Second attempt to optimize swsusp_free() (hibernation core) to make
     it avoid going through all PFNs which may be way too slow on some
     systems (Joerg Roedel)

   - devfreq updates (Paul Bolle, Punit Agrawal, Ãrjan Eide).

   - rockchip-io Adaptive Voltage Scaling (AVS) driver and AVS entry
     update in MAINTAINERS (Heiko Stübner, Kevin Hilman)

   - PM core fix related to clock management (Geert Uytterhoeven)

   - PM core's sysfs code cleanup (Johannes Berg)"

* tag 'pm+acpi-3.18-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm: (105 commits)
  ACPI / fan: printk replacement
  PM / clk: Fix crash in clocks management code if !CONFIG_PM_RUNTIME
  PM / Domains: Rename cpu_data to cpuidle_data
  cpufreq: cpufreq-dt: fix potential double put of cpu OF node
  cpufreq: cpu0: rename driver and internals to 'cpufreq_dt'
  PM / hibernate: Iterate over set bits instead of PFNs in swsusp_free()
  cpufreq: ppc-corenet: remove duplicate update of cpu_data
  ACPI / sleep: Rework the handling of ACPI GPE wakeup from suspend-to-idle
  PM / sleep: Rename platform suspend/resume functions in suspend.c
  PM / sleep: Export dpm_suspend_late/noirq() and dpm_resume_early/noirq()
  ACPICA: Introduce acpi_enable_all_wakeup_gpes()
  ACPICA: Clear all non-wakeup GPEs in acpi_hw_enable_wakeup_gpe_block()
  ACPI / video: check _DOD list when creating backlight devices
  PM / Domains: Move dev_pm_domain_attach|detach() to pm_domain.h
  cpufreq: Replace strnicmp with strncasecmp
  cpufreq: powernv: Set the cpus to nominal frequency during reboot/kexec
  cpufreq: powernv: Set the pstate of the last hotplugged out cpu in policy->cpus to minimum
  cpufreq: Allow stop CPU callback to be used by all cpufreq drivers
  PM / devfreq: exynos: Enable building exynos PPMU as module
  PM / devfreq: Export helper functions for drivers
  ...

9 files changed, 402 insertions, 1 deletions

diff --git a/drivers/cpuidle/Kconfig b/drivers/cpuidle/Kconfig
index 32748c36c477..c5029c1209b4 100644
--- a/drivers/cpuidle/Kconfig
+++ b/drivers/cpuidle/Kconfig
@@ -25,11 +25,19 @@ config CPU_IDLE_GOV_MENU
         bool "Menu governor (for tickless system)"
         default y
 
+config DT_IDLE_STATES
+        bool
+
 menu "ARM CPU Idle Drivers"
 depends on ARM
 source "drivers/cpuidle/Kconfig.arm"
 endmenu
 
+menu "ARM64 CPU Idle Drivers"
+depends on ARM64
+source "drivers/cpuidle/Kconfig.arm64"
+endmenu
+
 menu "MIPS CPU Idle Drivers"
 depends on MIPS
 source "drivers/cpuidle/Kconfig.mips"
diff --git a/drivers/cpuidle/Kconfig.arm b/drivers/cpuidle/Kconfig.arm
index 58bcd0d166ec..8c16ab20fb15 100644
--- a/drivers/cpuidle/Kconfig.arm
+++ b/drivers/cpuidle/Kconfig.arm
@@ -7,6 +7,7 @@ config ARM_BIG_LITTLE_CPUIDLE
         depends on MCPM
         select ARM_CPU_SUSPEND
         select CPU_IDLE_MULTIPLE_DRIVERS
+        select DT_IDLE_STATES
         help
           Select this option to enable CPU idle driver for big.LITTLE based
           ARM systems. Driver manages CPUs coordination through MCPM and
diff --git a/drivers/cpuidle/Kconfig.arm64 b/drivers/cpuidle/Kconfig.arm64
new file mode 100644
index 000000000000..d0a08ed1b2ee
--- /dev/null
+++ b/drivers/cpuidle/Kconfig.arm64
@@ -0,0 +1,14 @@
+#
+# ARM64 CPU Idle drivers
+#
+
+config ARM64_CPUIDLE
+        bool "Generic ARM64 CPU idle Driver"
+        select ARM64_CPU_SUSPEND
+        select DT_IDLE_STATES
+        help
+          Select this to enable generic cpuidle driver for ARM64.
+          It provides a generic idle driver whose idle states are configured
+          at run-time through DT nodes. The CPUidle suspend backend is
+          initialized by calling the CPU operations init idle hook
+          provided by architecture code.
diff --git a/drivers/cpuidle/Makefile b/drivers/cpuidle/Makefile
index 11edb31c55e9..4d177b916f75 100644
--- a/drivers/cpuidle/Makefile
+++ b/drivers/cpuidle/Makefile
@@ -4,6 +4,7 @@
 
 obj-y += cpuidle.o driver.o governor.o sysfs.o governors/
 obj-$(CONFIG_ARCH_NEEDS_CPU_IDLE_COUPLED) += coupled.o
+obj-$(CONFIG_DT_IDLE_STATES)              += dt_idle_states.o
 
 ##################################################################################
 # ARM SoC drivers
@@ -22,6 +23,10 @@ obj-$(CONFIG_ARM_EXYNOS_CPUIDLE)        += cpuidle-exynos.o
 obj-$(CONFIG_MIPS_CPS_CPUIDLE)          += cpuidle-cps.o
 
 ###############################################################################
+# ARM64 drivers
+obj-$(CONFIG_ARM64_CPUIDLE)             += cpuidle-arm64.o
+
+###############################################################################
 # POWERPC drivers
 obj-$(CONFIG_PSERIES_CPUIDLE)           += cpuidle-pseries.o
 obj-$(CONFIG_POWERNV_CPUIDLE)           += cpuidle-powernv.o
diff --git a/drivers/cpuidle/cpuidle-arm64.c b/drivers/cpuidle/cpuidle-arm64.c
new file mode 100644
index 000000000000..50997ea942fc
--- /dev/null
+++ b/drivers/cpuidle/cpuidle-arm64.c
@@ -0,0 +1,133 @@
+/*
+ * ARM64 generic CPU idle driver.
+ *
+ * Copyright (C) 2014 ARM Ltd.
+ * Author: Lorenzo Pieralisi <lorenzo.pieralisi@arm.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#define pr_fmt(fmt) "CPUidle arm64: " fmt
+
+#include <linux/cpuidle.h>
+#include <linux/cpumask.h>
+#include <linux/cpu_pm.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/of.h>
+
+#include <asm/cpuidle.h>
+#include <asm/suspend.h>
+
+#include "dt_idle_states.h"
+
+/*
+ * arm64_enter_idle_state - Programs CPU to enter the specified state
+ *
+ * dev: cpuidle device
+ * drv: cpuidle driver
+ * idx: state index
+ *
+ * Called from the CPUidle framework to program the device to the
+ * specified target state selected by the governor.
+ */
+static int arm64_enter_idle_state(struct cpuidle_device *dev,
+                                  struct cpuidle_driver *drv, int idx)
+{
+        int ret;
+
+        if (!idx) {
+                cpu_do_idle();
+                return idx;
+        }
+
+        ret = cpu_pm_enter();
+        if (!ret) {
+                /*
+                 * Pass idle state index to cpu_suspend which in turn will
+                 * call the CPU ops suspend protocol with idle index as a
+                 * parameter.
+                 */
+                ret = cpu_suspend(idx);
+
+                cpu_pm_exit();
+        }
+
+        return ret ? -1 : idx;
+}
+
+static struct cpuidle_driver arm64_idle_driver = {
+        .name = "arm64_idle",
+        .owner = THIS_MODULE,
+        /*
+         * State at index 0 is standby wfi and considered standard
+         * on all ARM platforms. If in some platforms simple wfi
+         * can't be used as "state 0", DT bindings must be implemented
+         * to work around this issue and allow installing a special
+         * handler for idle state index 0.
+         */
+        .states[0] = {
+                .enter                  = arm64_enter_idle_state,
+                .exit_latency           = 1,
+                .target_residency       = 1,
+                .power_usage            = UINT_MAX,
+                .flags                  = CPUIDLE_FLAG_TIME_VALID,
+                .name                   = "WFI",
+                .desc                   = "ARM64 WFI",
+        }
+};
+
+static const struct of_device_id arm64_idle_state_match[] __initconst = {
+        { .compatible = "arm,idle-state",
+          .data = arm64_enter_idle_state },
+        { },
+};
+
+/*
+ * arm64_idle_init
+ *
+ * Registers the arm64 specific cpuidle driver with the cpuidle
+ * framework. It relies on core code to parse the idle states
+ * and initialize them using driver data structures accordingly.
+ */
+static int __init arm64_idle_init(void)
+{
+        int cpu, ret;
+        struct cpuidle_driver *drv = &arm64_idle_driver;
+
+        /*
+         * Initialize idle states data, starting at index 1.
+         * This driver is DT only, if no DT idle states are detected (ret == 0)
+         * let the driver initialization fail accordingly since there is no
+         * reason to initialize the idle driver if only wfi is supported.
+         */
+        ret = dt_init_idle_driver(drv, arm64_idle_state_match, 1);
+        if (ret <= 0) {
+                if (ret)
+                        pr_err("failed to initialize idle states\n");
+                return ret ? : -ENODEV;
+        }
+
+        /*
+         * Call arch CPU operations in order to initialize
+         * idle states suspend back-end specific data
+         */
+        for_each_possible_cpu(cpu) {
+                ret = cpu_init_idle(cpu);
+                if (ret) {
+                        pr_err("CPU %d failed to init idle CPU ops\n", cpu);
+                        return ret;
+                }
+        }
+
+        ret = cpuidle_register(drv, NULL);
+        if (ret) {
+                pr_err("failed to register cpuidle driver\n");
+                return ret;
+        }
+
+        return 0;
+}
+device_initcall(arm64_idle_init);
diff --git a/drivers/cpuidle/cpuidle-big_little.c b/drivers/cpuidle/cpuidle-big_little.c
index ef94c3b81f18..fbc00a1d3c48 100644
--- a/drivers/cpuidle/cpuidle-big_little.c
+++ b/drivers/cpuidle/cpuidle-big_little.c
@@ -24,6 +24,8 @@
 #include <asm/smp_plat.h>
 #include <asm/suspend.h>
 
+#include "dt_idle_states.h"
+
 static int bl_enter_powerdown(struct cpuidle_device *dev,
                               struct cpuidle_driver *drv, int idx);
 
@@ -73,6 +75,12 @@ static struct cpuidle_driver bl_idle_little_driver = {
         .state_count = 2,
 };
 
+static const struct of_device_id bl_idle_state_match[] __initconst = {
+        { .compatible = "arm,idle-state",
+          .data = bl_enter_powerdown },
+        { },
+};
+
 static struct cpuidle_driver bl_idle_big_driver = {
         .name = "big_idle",
         .owner = THIS_MODULE,
@@ -159,6 +167,7 @@ static int __init bl_idle_driver_init(struct cpuidle_driver *drv, int part_id)
 static const struct of_device_id compatible_machine_match[] = {
         { .compatible = "arm,vexpress,v2p-ca15_a7" },
         { .compatible = "samsung,exynos5420" },
+        { .compatible = "samsung,exynos5800" },
         {},
 };
 
@@ -190,6 +199,17 @@ static int __init bl_idle_init(void)
         if (ret)
                 goto out_uninit_little;
 
+        /* Start at index 1, index 0 standard WFI */
+        ret = dt_init_idle_driver(&bl_idle_big_driver, bl_idle_state_match, 1);
+        if (ret < 0)
+                goto out_uninit_big;
+
+        /* Start at index 1, index 0 standard WFI */
+        ret = dt_init_idle_driver(&bl_idle_little_driver,
+                                  bl_idle_state_match, 1);
+        if (ret < 0)
+                goto out_uninit_big;
+
         ret = cpuidle_register(&bl_idle_little_driver, NULL);
         if (ret)
                 goto out_uninit_big;
diff --git a/drivers/cpuidle/dt_idle_states.c b/drivers/cpuidle/dt_idle_states.c
new file mode 100644
index 000000000000..52f4d11bbf3f
--- /dev/null
+++ b/drivers/cpuidle/dt_idle_states.c
@@ -0,0 +1,213 @@
+/*
+ * DT idle states parsing code.
+ *
+ * Copyright (C) 2014 ARM Ltd.
+ * Author: Lorenzo Pieralisi <lorenzo.pieralisi@arm.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#define pr_fmt(fmt) "DT idle-states: " fmt
+
+#include <linux/cpuidle.h>
+#include <linux/cpumask.h>
+#include <linux/errno.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/of_device.h>
+
+#include "dt_idle_states.h"
+
+static int init_state_node(struct cpuidle_state *idle_state,
+                           const struct of_device_id *matches,
+                           struct device_node *state_node)
+{
+        int err;
+        const struct of_device_id *match_id;
+
+        match_id = of_match_node(matches, state_node);
+        if (!match_id)
+                return -ENODEV;
+        /*
+         * CPUidle drivers are expected to initialize the const void *data
+         * pointer of the passed in struct of_device_id array to the idle
+         * state enter function.
+         */
+        idle_state->enter = match_id->data;
+
+        err = of_property_read_u32(state_node, "wakeup-latency-us",
+                                   &idle_state->exit_latency);
+        if (err) {
+                u32 entry_latency, exit_latency;
+
+                err = of_property_read_u32(state_node, "entry-latency-us",
+                                           &entry_latency);
+                if (err) {
+                        pr_debug(" * %s missing entry-latency-us property\n",
+                                 state_node->full_name);
+                        return -EINVAL;
+                }
+
+                err = of_property_read_u32(state_node, "exit-latency-us",
+                                           &exit_latency);
+                if (err) {
+                        pr_debug(" * %s missing exit-latency-us property\n",
+                                 state_node->full_name);
+                        return -EINVAL;
+                }
+                /*
+                 * If wakeup-latency-us is missing, default to entry+exit
+                 * latencies as defined in idle states bindings
+                 */
+                idle_state->exit_latency = entry_latency + exit_latency;
+        }
+
+        err = of_property_read_u32(state_node, "min-residency-us",
+                                   &idle_state->target_residency);
+        if (err) {
+                pr_debug(" * %s missing min-residency-us property\n",
+                             state_node->full_name);
+                return -EINVAL;
+        }
+
+        idle_state->flags = CPUIDLE_FLAG_TIME_VALID;
+        if (of_property_read_bool(state_node, "local-timer-stop"))
+                idle_state->flags |= CPUIDLE_FLAG_TIMER_STOP;
+        /*
+         * TODO:
+         *      replace with kstrdup and pointer assignment when name
+         *      and desc become string pointers
+         */
+        strncpy(idle_state->name, state_node->name, CPUIDLE_NAME_LEN - 1);
+        strncpy(idle_state->desc, state_node->name, CPUIDLE_DESC_LEN - 1);
+        return 0;
+}
+
+/*
+ * Check that the idle state is uniform across all CPUs in the CPUidle driver
+ * cpumask
+ */
+static bool idle_state_valid(struct device_node *state_node, unsigned int idx,
+                             const cpumask_t *cpumask)
+{
+        int cpu;
+        struct device_node *cpu_node, *curr_state_node;
+        bool valid = true;
+
+        /*
+         * Compare idle state phandles for index idx on all CPUs in the
+         * CPUidle driver cpumask. Start from next logical cpu following
+         * cpumask_first(cpumask) since that's the CPU state_node was
+         * retrieved from. If a mismatch is found bail out straight
+         * away since we certainly hit a firmware misconfiguration.
+         */
+        for (cpu = cpumask_next(cpumask_first(cpumask), cpumask);
+             cpu < nr_cpu_ids; cpu = cpumask_next(cpu, cpumask)) {
+                cpu_node = of_cpu_device_node_get(cpu);
+                curr_state_node = of_parse_phandle(cpu_node, "cpu-idle-states",
+                                                   idx);
+                if (state_node != curr_state_node)
+                        valid = false;
+
+                of_node_put(curr_state_node);
+                of_node_put(cpu_node);
+                if (!valid)
+                        break;
+        }
+
+        return valid;
+}
+
+/**
+ * dt_init_idle_driver() - Parse the DT idle states and initialize the
+ *                         idle driver states array
+ * @drv:          Pointer to CPU idle driver to be initialized
+ * @matches:      Array of of_device_id match structures to search in for
+ *                compatible idle state nodes. The data pointer for each valid
+ *                struct of_device_id entry in the matches array must point to
+ *                a function with the following signature, that corresponds to
+ *                the CPUidle state enter function signature:
+ *
+ *                int (*)(struct cpuidle_device *dev,
+ *                        struct cpuidle_driver *drv,
+ *                        int index);
+ *
+ * @start_idx:    First idle state index to be initialized
+ *
+ * If DT idle states are detected and are valid the state count and states
+ * array entries in the cpuidle driver are initialized accordingly starting
+ * from index start_idx.
+ *
+ * Return: number of valid DT idle states parsed, <0 on failure
+ */
+int dt_init_idle_driver(struct cpuidle_driver *drv,
+                        const struct of_device_id *matches,
+                        unsigned int start_idx)
+{
+        struct cpuidle_state *idle_state;
+        struct device_node *state_node, *cpu_node;
+        int i, err = 0;
+        const cpumask_t *cpumask;
+        unsigned int state_idx = start_idx;
+
+        if (state_idx >= CPUIDLE_STATE_MAX)
+                return -EINVAL;
+        /*
+         * We get the idle states for the first logical cpu in the
+         * driver mask (or cpu_possible_mask if the driver cpumask is not set)
+         * and we check through idle_state_valid() if they are uniform
+         * across CPUs, otherwise we hit a firmware misconfiguration.
+         */
+        cpumask = drv->cpumask ? : cpu_possible_mask;
+        cpu_node = of_cpu_device_node_get(cpumask_first(cpumask));
+
+        for (i = 0; ; i++) {
+                state_node = of_parse_phandle(cpu_node, "cpu-idle-states", i);
+                if (!state_node)
+                        break;
+
+                if (!idle_state_valid(state_node, i, cpumask)) {
+                        pr_warn("%s idle state not valid, bailing out\n",
+                                state_node->full_name);
+                        err = -EINVAL;
+                        break;
+                }
+
+                if (state_idx == CPUIDLE_STATE_MAX) {
+                        pr_warn("State index reached static CPU idle driver states array size\n");
+                        break;
+                }
+
+                idle_state = &drv->states[state_idx++];
+                err = init_state_node(idle_state, matches, state_node);
+                if (err) {
+                        pr_err("Parsing idle state node %s failed with err %d\n",
+                               state_node->full_name, err);
+                        err = -EINVAL;
+                        break;
+                }
+                of_node_put(state_node);
+        }
+
+        of_node_put(state_node);
+        of_node_put(cpu_node);
+        if (err)
+                return err;
+        /*
+         * Update the driver state count only if some valid DT idle states
+         * were detected
+         */
+        if (i)
+                drv->state_count = state_idx;
+
+        /*
+         * Return the number of present and valid DT idle states, which can
+         * also be 0 on platforms with missing DT idle states or legacy DT
+         * configuration predating the DT idle states bindings.
+         */
+        return i;
+}
+EXPORT_SYMBOL_GPL(dt_init_idle_driver);
diff --git a/drivers/cpuidle/dt_idle_states.h b/drivers/cpuidle/dt_idle_states.h
new file mode 100644
index 000000000000..4818134bc65b
--- /dev/null
+++ b/drivers/cpuidle/dt_idle_states.h
@@ -0,0 +1,7 @@
+#ifndef __DT_IDLE_STATES
+#define __DT_IDLE_STATES
+
+int dt_init_idle_driver(struct cpuidle_driver *drv,
+                        const struct of_device_id *matches,
+                        unsigned int start_idx);
+#endif
diff --git a/drivers/cpuidle/governor.c b/drivers/cpuidle/governor.c
index ca89412f5122..fb9f511cca23 100644
--- a/drivers/cpuidle/governor.c
+++ b/drivers/cpuidle/governor.c
@@ -28,7 +28,7 @@ static struct cpuidle_governor * __cpuidle_find_governor(const char *str)
         struct cpuidle_governor *gov;
 
         list_for_each_entry(gov, &cpuidle_governors, governor_list)
-                if (!strnicmp(str, gov->name, CPUIDLE_NAME_LEN))
+                if (!strncasecmp(str, gov->name, CPUIDLE_NAME_LEN))
                         return gov;
 
         return NULL;