Merge branch 'pm-cpuidle'

* pm-cpuidle:
  cpuidle: Fix ARCH_NEEDS_CPU_IDLE_COUPLED dependency warning
  cpuidle: Comment the driver's framework code
  cpuidle: simplify multiple driver support
  ARM: zynq: Add cpuidle support
  cpuidle: improve governor Kconfig options

5 files changed, 307 insertions, 132 deletions

diff --git a/drivers/cpuidle/Kconfig b/drivers/cpuidle/Kconfig
index c4cc27e5c8a5..81de5d96749b 100644
--- a/drivers/cpuidle/Kconfig
+++ b/drivers/cpuidle/Kconfig
@@ -1,7 +1,9 @@
 
-config CPU_IDLE
+menuconfig CPU_IDLE
         bool "CPU idle PM support"
         default y if ACPI || PPC_PSERIES
+        select CPU_IDLE_GOV_LADDER if (!NO_HZ && !NO_HZ_IDLE)
+        select CPU_IDLE_GOV_MENU if (NO_HZ || NO_HZ_IDLE)
         help
           CPU idle is a generic framework for supporting software-controlled
           idle processor power management.  It includes modular cross-platform
@@ -9,9 +11,10 @@ config CPU_IDLE
 
           If you're using an ACPI-enabled platform, you should say Y here.
 
+if CPU_IDLE
+
 config CPU_IDLE_MULTIPLE_DRIVERS
         bool "Support multiple cpuidle drivers"
-        depends on CPU_IDLE
         default n
         help
          Allows the cpuidle framework to use different drivers for each CPU.
@@ -19,24 +22,26 @@ config CPU_IDLE_MULTIPLE_DRIVERS
          states. If unsure say N.
 
 config CPU_IDLE_GOV_LADDER
-        bool
-        depends on CPU_IDLE
+        bool "Ladder governor (for periodic timer tick)"
         default y
 
 config CPU_IDLE_GOV_MENU
-        bool
-        depends on CPU_IDLE && NO_HZ
+        bool "Menu governor (for tickless system)"
         default y
 
-config ARCH_NEEDS_CPU_IDLE_COUPLED
-        def_bool n
-
-if CPU_IDLE
-
 config CPU_IDLE_CALXEDA
         bool "CPU Idle Driver for Calxeda processors"
         depends on ARCH_HIGHBANK
         help
           Select this to enable cpuidle on Calxeda processors.
 
+config CPU_IDLE_ZYNQ
+        bool "CPU Idle Driver for Xilinx Zynq processors"
+        depends on ARCH_ZYNQ
+        help
+          Select this to enable cpuidle on Xilinx Zynq processors.
+
 endif
+
+config ARCH_NEEDS_CPU_IDLE_COUPLED
+        def_bool n
diff --git a/drivers/cpuidle/Makefile b/drivers/cpuidle/Makefile
index 0d8bd55e776f..8767a7b3eb91 100644
--- a/drivers/cpuidle/Makefile
+++ b/drivers/cpuidle/Makefile
@@ -7,3 +7,4 @@ obj-$(CONFIG_ARCH_NEEDS_CPU_IDLE_COUPLED) += coupled.o
 
 obj-$(CONFIG_CPU_IDLE_CALXEDA) += cpuidle-calxeda.o
 obj-$(CONFIG_ARCH_KIRKWOOD) += cpuidle-kirkwood.o
+obj-$(CONFIG_CPU_IDLE_ZYNQ) += cpuidle-zynq.o
diff --git a/drivers/cpuidle/cpuidle-zynq.c b/drivers/cpuidle/cpuidle-zynq.c
new file mode 100644
index 000000000000..38e03a183591
--- /dev/null
+++ b/drivers/cpuidle/cpuidle-zynq.c
@@ -0,0 +1,83 @@
+/*
+ * Copyright (C) 2012-2013 Xilinx
+ *
+ * CPU idle support for Xilinx Zynq
+ *
+ * based on arch/arm/mach-at91/cpuidle.c
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * The cpu idle uses wait-for-interrupt and RAM self refresh in order
+ * to implement two idle states -
+ * #1 wait-for-interrupt
+ * #2 wait-for-interrupt and RAM self refresh
+ *
+ * Maintainer: Michal Simek <michal.simek@xilinx.com>
+ */
+
+#include <linux/init.h>
+#include <linux/cpu_pm.h>
+#include <linux/cpuidle.h>
+#include <linux/of.h>
+#include <asm/proc-fns.h>
+#include <asm/cpuidle.h>
+
+#define ZYNQ_MAX_STATES         2
+
+/* Actual code that puts the SoC in different idle states */
+static int zynq_enter_idle(struct cpuidle_device *dev,
+                           struct cpuidle_driver *drv, int index)
+{
+        /* Devices must be stopped here */
+        cpu_pm_enter();
+
+        /* Add code for DDR self refresh start */
+        cpu_do_idle();
+
+        /* Add code for DDR self refresh stop */
+        cpu_pm_exit();
+
+        return index;
+}
+
+static struct cpuidle_driver zynq_idle_driver = {
+        .name = "zynq_idle",
+        .owner = THIS_MODULE,
+        .states = {
+                ARM_CPUIDLE_WFI_STATE,
+                {
+                        .enter                  = zynq_enter_idle,
+                        .exit_latency           = 10,
+                        .target_residency       = 10000,
+                        .flags                  = CPUIDLE_FLAG_TIME_VALID |
+                                                  CPUIDLE_FLAG_TIMER_STOP,
+                        .name                   = "RAM_SR",
+                        .desc                   = "WFI and RAM Self Refresh",
+                },
+        },
+        .safe_state_index = 0,
+        .state_count = ZYNQ_MAX_STATES,
+};
+
+/* Initialize CPU idle by registering the idle states */
+static int __init zynq_cpuidle_init(void)
+{
+        if (!of_machine_is_compatible("xlnx,zynq-7000"))
+                return -ENODEV;
+
+        pr_info("Xilinx Zynq CpuIdle Driver started\n");
+
+        return cpuidle_register(&zynq_idle_driver, NULL);
+}
+
+device_initcall(zynq_cpuidle_init);
diff --git a/drivers/cpuidle/cpuidle.c b/drivers/cpuidle/cpuidle.c
index c3a93fece819..fdc432f18022 100644
--- a/drivers/cpuidle/cpuidle.c
+++ b/drivers/cpuidle/cpuidle.c
@@ -466,7 +466,7 @@ void cpuidle_unregister(struct cpuidle_driver *drv)
         int cpu;
         struct cpuidle_device *device;
 
-        for_each_possible_cpu(cpu) {
+        for_each_cpu(cpu, drv->cpumask) {
                 device = &per_cpu(cpuidle_dev, cpu);
                 cpuidle_unregister_device(device);
         }
@@ -498,7 +498,7 @@ int cpuidle_register(struct cpuidle_driver *drv,
                 return ret;
         }
 
-        for_each_possible_cpu(cpu) {
+        for_each_cpu(cpu, drv->cpumask) {
                 device = &per_cpu(cpuidle_dev, cpu);
                 device->cpu = cpu;
 
diff --git a/drivers/cpuidle/driver.c b/drivers/cpuidle/driver.c
index 8dfaaae94444..3ac499d5a207 100644
--- a/drivers/cpuidle/driver.c
+++ b/drivers/cpuidle/driver.c
@@ -18,182 +18,249 @@
 
 DEFINE_SPINLOCK(cpuidle_driver_lock);
 
-static void __cpuidle_set_cpu_driver(struct cpuidle_driver *drv, int cpu);
-static struct cpuidle_driver * __cpuidle_get_cpu_driver(int cpu);
+#ifdef CONFIG_CPU_IDLE_MULTIPLE_DRIVERS
 
-static void cpuidle_setup_broadcast_timer(void *arg)
+static DEFINE_PER_CPU(struct cpuidle_driver *, cpuidle_drivers);
+
+/**
+ * __cpuidle_get_cpu_driver - return the cpuidle driver tied to a CPU.
+ * @cpu: the CPU handled by the driver
+ *
+ * Returns a pointer to struct cpuidle_driver or NULL if no driver has been
+ * registered for @cpu.
+ */
+static struct cpuidle_driver *__cpuidle_get_cpu_driver(int cpu)
 {
-        int cpu = smp_processor_id();
-        clockevents_notify((long)(arg), &cpu);
+        return per_cpu(cpuidle_drivers, cpu);
 }
 
-static void __cpuidle_driver_init(struct cpuidle_driver *drv, int cpu)
+/**
+ * __cpuidle_unset_driver - unset per CPU driver variables.
+ * @drv: a valid pointer to a struct cpuidle_driver
+ *
+ * For each CPU in the driver's CPU mask, unset the registered driver per CPU
+ * variable. If @drv is different from the registered driver, the corresponding
+ * variable is not cleared.
+ */
+static inline void __cpuidle_unset_driver(struct cpuidle_driver *drv)
 {
-        int i;
-
-        drv->refcnt = 0;
+        int cpu;
 
-        for (i = drv->state_count - 1; i >= 0 ; i--) {
+        for_each_cpu(cpu, drv->cpumask) {
 
-                if (!(drv->states[i].flags & CPUIDLE_FLAG_TIMER_STOP))
+                if (drv != __cpuidle_get_cpu_driver(cpu))
                         continue;
 
-                drv->bctimer = 1;
-                on_each_cpu_mask(get_cpu_mask(cpu), cpuidle_setup_broadcast_timer,
-                                 (void *)CLOCK_EVT_NOTIFY_BROADCAST_ON, 1);
-                break;
+                per_cpu(cpuidle_drivers, cpu) = NULL;
         }
 }
 
-static int __cpuidle_register_driver(struct cpuidle_driver *drv, int cpu)
+/**
+ * __cpuidle_set_driver - set per CPU driver variables the the given driver.
+ * @drv: a valid pointer to a struct cpuidle_driver
+ *
+ * For each CPU in the driver's cpumask, unset the registered driver per CPU
+ * to @drv.
+ *
+ * Returns 0 on success, -EBUSY if the CPUs have driver(s) already.
+ */
+static inline int __cpuidle_set_driver(struct cpuidle_driver *drv)
 {
-        if (!drv || !drv->state_count)
-                return -EINVAL;
-
-        if (cpuidle_disabled())
-                return -ENODEV;
+        int cpu;
 
-        if (__cpuidle_get_cpu_driver(cpu))
-                return -EBUSY;
+        for_each_cpu(cpu, drv->cpumask) {
 
-        __cpuidle_driver_init(drv, cpu);
+                if (__cpuidle_get_cpu_driver(cpu)) {
+                        __cpuidle_unset_driver(drv);
+                        return -EBUSY;
+                }
 
-        __cpuidle_set_cpu_driver(drv, cpu);
+                per_cpu(cpuidle_drivers, cpu) = drv;
+        }
 
         return 0;
 }
 
-static void __cpuidle_unregister_driver(struct cpuidle_driver *drv, int cpu)
-{
-        if (drv != __cpuidle_get_cpu_driver(cpu))
-                return;
+#else
 
-        if (!WARN_ON(drv->refcnt > 0))
-                __cpuidle_set_cpu_driver(NULL, cpu);
+static struct cpuidle_driver *cpuidle_curr_driver;
 
-        if (drv->bctimer) {
-                drv->bctimer = 0;
-                on_each_cpu_mask(get_cpu_mask(cpu), cpuidle_setup_broadcast_timer,
-                                 (void *)CLOCK_EVT_NOTIFY_BROADCAST_OFF, 1);
-        }
+/**
+ * __cpuidle_get_cpu_driver - return the global cpuidle driver pointer.
+ * @cpu: ignored without the multiple driver support
+ *
+ * Return a pointer to a struct cpuidle_driver object or NULL if no driver was
+ * previously registered.
+ */
+static inline struct cpuidle_driver *__cpuidle_get_cpu_driver(int cpu)
+{
+        return cpuidle_curr_driver;
 }
 
-#ifdef CONFIG_CPU_IDLE_MULTIPLE_DRIVERS
+/**
+ * __cpuidle_set_driver - assign the global cpuidle driver variable.
+ * @drv: pointer to a struct cpuidle_driver object
+ *
+ * Returns 0 on success, -EBUSY if the driver is already registered.
+ */
+static inline int __cpuidle_set_driver(struct cpuidle_driver *drv)
+{
+        if (cpuidle_curr_driver)
+                return -EBUSY;
 
-static DEFINE_PER_CPU(struct cpuidle_driver *, cpuidle_drivers);
+        cpuidle_curr_driver = drv;
 
-static void __cpuidle_set_cpu_driver(struct cpuidle_driver *drv, int cpu)
-{
-        per_cpu(cpuidle_drivers, cpu) = drv;
+        return 0;
 }
 
-static struct cpuidle_driver *__cpuidle_get_cpu_driver(int cpu)
+/**
+ * __cpuidle_unset_driver - unset the global cpuidle driver variable.
+ * @drv: a pointer to a struct cpuidle_driver
+ *
+ * Reset the global cpuidle variable to NULL.  If @drv does not match the
+ * registered driver, do nothing.
+ */
+static inline void __cpuidle_unset_driver(struct cpuidle_driver *drv)
 {
-        return per_cpu(cpuidle_drivers, cpu);
+        if (drv == cpuidle_curr_driver)
+                cpuidle_curr_driver = NULL;
 }
 
-static void __cpuidle_unregister_all_cpu_driver(struct cpuidle_driver *drv)
+#endif
+
+/**
+ * cpuidle_setup_broadcast_timer - enable/disable the broadcast timer
+ * @arg: a void pointer used to match the SMP cross call API
+ *
+ * @arg is used as a value of type 'long' with on of the two values:
+ * - CLOCK_EVT_NOTIFY_BROADCAST_ON
+ * - CLOCK_EVT_NOTIFY_BROADCAST_OFF
+ *
+ * Set the broadcast timer notification for the current CPU.  This function
+ * is executed per CPU by an SMP cross call.  It not supposed to be called
+ * directly.
+ */
+static void cpuidle_setup_broadcast_timer(void *arg)
 {
-        int cpu;
-        for_each_present_cpu(cpu)
-                __cpuidle_unregister_driver(drv, cpu);
+        int cpu = smp_processor_id();
+        clockevents_notify((long)(arg), &cpu);
 }
 
-static int __cpuidle_register_all_cpu_driver(struct cpuidle_driver *drv)
+/**
+ * __cpuidle_driver_init - initialize the driver's internal data
+ * @drv: a valid pointer to a struct cpuidle_driver
+ *
+ * Returns 0 on success, a negative error code otherwise.
+ */
+static int __cpuidle_driver_init(struct cpuidle_driver *drv)
 {
-        int ret = 0;
-        int i, cpu;
+        int i;
 
-        for_each_present_cpu(cpu) {
-                ret = __cpuidle_register_driver(drv, cpu);
-                if (ret)
-                        break;
-        }
+        drv->refcnt = 0;
 
-        if (ret)
-                for_each_present_cpu(i) {
-                        if (i == cpu)
-                                break;
-                        __cpuidle_unregister_driver(drv, i);
-                }
+        /*
+         * Use all possible CPUs as the default, because if the kernel boots
+         * with some CPUs offline and then we online one of them, the CPU
+         * notifier has to know which driver to assign.
+         */
+        if (!drv->cpumask)
+                drv->cpumask = (struct cpumask *)cpu_possible_mask;
+
+        /*
+         * Look for the timer stop flag in the different states, so that we know
+         * if the broadcast timer has to be set up.  The loop is in the reverse
+         * order, because usually on of the the deeper states has this flag set.
+         */
+        for (i = drv->state_count - 1; i >= 0 ; i--) {
 
+                if (!(drv->states[i].flags & CPUIDLE_FLAG_TIMER_STOP))
+                        continue;
 
-        return ret;
+                drv->bctimer = 1;
+                break;
+        }
+
+        return 0;
 }
 
-int cpuidle_register_cpu_driver(struct cpuidle_driver *drv, int cpu)
+/**
+ * __cpuidle_register_driver: register the driver
+ * @drv: a valid pointer to a struct cpuidle_driver
+ *
+ * Do some sanity checks, initialize the driver, assign the driver to the
+ * global cpuidle driver variable(s) and set up the broadcast timer if the
+ * cpuidle driver has some states that shut down the local timer.
+ *
+ * Returns 0 on success, a negative error code otherwise:
+ *  * -EINVAL if the driver pointer is NULL or no idle states are available
+ *  * -ENODEV if the cpuidle framework is disabled
+ *  * -EBUSY if the driver is already assigned to the global variable(s)
+ */
+static int __cpuidle_register_driver(struct cpuidle_driver *drv)
 {
         int ret;
 
-        spin_lock(&cpuidle_driver_lock);
-        ret = __cpuidle_register_driver(drv, cpu);
-        spin_unlock(&cpuidle_driver_lock);
+        if (!drv || !drv->state_count)
+                return -EINVAL;
 
-        return ret;
-}
+        if (cpuidle_disabled())
+                return -ENODEV;
 
-void cpuidle_unregister_cpu_driver(struct cpuidle_driver *drv, int cpu)
-{
-        spin_lock(&cpuidle_driver_lock);
-        __cpuidle_unregister_driver(drv, cpu);
-        spin_unlock(&cpuidle_driver_lock);
-}
+        ret = __cpuidle_driver_init(drv);
+        if (ret)
+                return ret;
 
-/**
- * cpuidle_register_driver - registers a driver
- * @drv: the driver
- */
-int cpuidle_register_driver(struct cpuidle_driver *drv)
-{
-        int ret;
+        ret = __cpuidle_set_driver(drv);
+        if (ret)
+                return ret;
 
-        spin_lock(&cpuidle_driver_lock);
-        ret = __cpuidle_register_all_cpu_driver(drv);
-        spin_unlock(&cpuidle_driver_lock);
+        if (drv->bctimer)
+                on_each_cpu_mask(drv->cpumask, cpuidle_setup_broadcast_timer,
+                                 (void *)CLOCK_EVT_NOTIFY_BROADCAST_ON, 1);
 
-        return ret;
+        return 0;
 }
-EXPORT_SYMBOL_GPL(cpuidle_register_driver);
 
 /**
- * cpuidle_unregister_driver - unregisters a driver
- * @drv: the driver
+ * __cpuidle_unregister_driver - unregister the driver
+ * @drv: a valid pointer to a struct cpuidle_driver
+ *
+ * Check if the driver is no longer in use, reset the global cpuidle driver
+ * variable(s) and disable the timer broadcast notification mechanism if it was
+ * in use.
+ *
  */
-void cpuidle_unregister_driver(struct cpuidle_driver *drv)
+static void __cpuidle_unregister_driver(struct cpuidle_driver *drv)
 {
-        spin_lock(&cpuidle_driver_lock);
-        __cpuidle_unregister_all_cpu_driver(drv);
-        spin_unlock(&cpuidle_driver_lock);
-}
-EXPORT_SYMBOL_GPL(cpuidle_unregister_driver);
-
-#else
-
-static struct cpuidle_driver *cpuidle_curr_driver;
+        if (WARN_ON(drv->refcnt > 0))
+                return;
 
-static inline void __cpuidle_set_cpu_driver(struct cpuidle_driver *drv, int cpu)
-{
-        cpuidle_curr_driver = drv;
-}
+        if (drv->bctimer) {
+                drv->bctimer = 0;
+                on_each_cpu_mask(drv->cpumask, cpuidle_setup_broadcast_timer,
+                                 (void *)CLOCK_EVT_NOTIFY_BROADCAST_OFF, 1);
+        }
 
-static inline struct cpuidle_driver *__cpuidle_get_cpu_driver(int cpu)
-{
-        return cpuidle_curr_driver;
+        __cpuidle_unset_driver(drv);
 }
 
 /**
  * cpuidle_register_driver - registers a driver
- * @drv: the driver
+ * @drv: a pointer to a valid struct cpuidle_driver
+ *
+ * Register the driver under a lock to prevent concurrent attempts to
+ * [un]register the driver from occuring at the same time.
+ *
+ * Returns 0 on success, a negative error code (returned by
+ * __cpuidle_register_driver()) otherwise.
  */
 int cpuidle_register_driver(struct cpuidle_driver *drv)
 {
-        int ret, cpu;
+        int ret;
 
-        cpu = get_cpu();
         spin_lock(&cpuidle_driver_lock);
-        ret = __cpuidle_register_driver(drv, cpu);
+        ret = __cpuidle_register_driver(drv);
         spin_unlock(&cpuidle_driver_lock);
-        put_cpu();
 
         return ret;
 }
@@ -201,23 +268,24 @@ EXPORT_SYMBOL_GPL(cpuidle_register_driver);
 
 /**
  * cpuidle_unregister_driver - unregisters a driver
- * @drv: the driver
+ * @drv: a pointer to a valid struct cpuidle_driver
+ *
+ * Unregisters the cpuidle driver under a lock to prevent concurrent attempts
+ * to [un]register the driver from occuring at the same time.  @drv has to
+ * match the currently registered driver.
  */
 void cpuidle_unregister_driver(struct cpuidle_driver *drv)
 {
-        int cpu;
-
-        cpu = get_cpu();
         spin_lock(&cpuidle_driver_lock);
-        __cpuidle_unregister_driver(drv, cpu);
+        __cpuidle_unregister_driver(drv);
         spin_unlock(&cpuidle_driver_lock);
-        put_cpu();
 }
 EXPORT_SYMBOL_GPL(cpuidle_unregister_driver);
-#endif
 
 /**
- * cpuidle_get_driver - return the current driver
+ * cpuidle_get_driver - return the driver tied to the current CPU.
+ *
+ * Returns a struct cpuidle_driver pointer, or NULL if no driver is registered.
  */
 struct cpuidle_driver *cpuidle_get_driver(void)
 {
@@ -233,7 +301,11 @@ struct cpuidle_driver *cpuidle_get_driver(void)
 EXPORT_SYMBOL_GPL(cpuidle_get_driver);
 
 /**
- * cpuidle_get_cpu_driver - return the driver tied with a cpu
+ * cpuidle_get_cpu_driver - return the driver registered for a CPU.
+ * @dev: a valid pointer to a struct cpuidle_device
+ *
+ * Returns a struct cpuidle_driver pointer, or NULL if no driver is registered
+ * for the CPU associated with @dev.
  */
 struct cpuidle_driver *cpuidle_get_cpu_driver(struct cpuidle_device *dev)
 {
@@ -244,6 +316,14 @@ struct cpuidle_driver *cpuidle_get_cpu_driver(struct cpuidle_device *dev)
 }
 EXPORT_SYMBOL_GPL(cpuidle_get_cpu_driver);
 
+/**
+ * cpuidle_driver_ref - get a reference to the driver.
+ *
+ * Increment the reference counter of the cpuidle driver associated with
+ * the current CPU.
+ *
+ * Returns a pointer to the driver, or NULL if the current CPU has no driver.
+ */
 struct cpuidle_driver *cpuidle_driver_ref(void)
 {
         struct cpuidle_driver *drv;
@@ -257,6 +337,12 @@ struct cpuidle_driver *cpuidle_driver_ref(void)
         return drv;
 }
 
+/**
+ * cpuidle_driver_unref - puts down the refcount for the driver
+ *
+ * Decrement the reference counter of the cpuidle driver associated with
+ * the current CPU.
+ */
 void cpuidle_driver_unref(void)
 {
         struct cpuidle_driver *drv = cpuidle_get_driver();