Merge branch 'cpuidle/3.18' of https://git.linaro.org/people/daniel.lezcano/linux into pm-cpuidle

Pull ARM cpuidle changes for v3.18 from Daniel Lezcano:

"this pull request contains the following changes:

 * Lorenzo Pieralisi implemented a framework to initialize the ARM
   cpuidle drivers with the DT. As an example, it provided a couple of
   drivers using it: arm64 and big little. The former one is a new
   driver while the latter is a change. There was also a patch for
   Exynos allowing to use this framework but as it depends on a change
   in Samsung's tree, I postponed this patch until the change is visible
   after the merge. The set of changes depends on some other changes
   made in the ARM64 tree, for this reason a shared branch is used. This
   is why there is a merge from arm64 in my pull request. I believe we
   already used this procedure.

 * Kevin Hilman added the compatible string for the exynos 5800 in the DT"

* 'cpuidle/3.18' of https://git.linaro.org/people/daniel.lezcano/linux:
  drivers: cpuidle: initialize big.LITTLE driver through DT
  drivers: cpuidle: CPU idle ARM64 driver
  drivers: cpuidle: implement DT based idle states infrastructure
  cpuidle: big.LITTLE: add Exynos5800 compatible string
  arm64: add PSCI CPU_SUSPEND based cpu_suspend support
  arm64: kernel: introduce cpu_init_idle CPU operation
  arm64: kernel: refactor the CPU suspend API for retention states
  Documentation: arm: define DT idle states bindings

8 files changed, 401 insertions, 0 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 38cff69ffe06..e339c7f2c2b7 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