ARM: cpuidle: Unify the ARM64/ARM DT approach

The current state of the different cpuidle drivers is the different PM operations are passed via the platform_data using the platform driver paradigm.

This approach allowed to split the low level PM code from the arch specific and the generic cpuidle code.

Unfortunately there are complaints about this approach as, in the context of the single kernel image, we have multiple drivers loaded in memory for nothing and the platform driver is not adequate for cpuidle.

This patch provides a common interface via cpuidle ops for all new cpuidle driver and a definition for the device tree.

It will allow with the next patches to a have a common definition with ARM64 and share the same cpuidle driver.

The code is optimized to use the __init section intensively in order to reduce the memory footprint after the driver is initialized and unify the function names with ARM64.

Signed-off-by Daniel Lezcano <[email protected]>

Acked-by Kevin Hilman <[email protected]>

Acked-by Rob Herring <[email protected]>

With this change the cpuidle-arm64.c file calls the same function name for both ARM and ARM64.

Signed-off-by Daniel Lezcano <[email protected]>

Acked-by Kevin Hilman <[email protected]>

Acked-by Rob Herring <[email protected]>

---
 arch/arm64/include/asm/cpuidle.h | 4 ++--
 arch/arm64/kernel/cpuidle.c      | 2 +-
 drivers/cpuidle/cpuidle-arm64.c  | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

arch/arm64/include/asm/cpuidle.h +2 -2

index 460a38b..141b2fc 100644
@@ -4,10 +4,10 @@
 #include <asm/proc-fns.h>
 
 #ifdef CONFIG_CPU_IDLE
-extern int cpu_init_idle(unsigned int cpu);
+extern int arm_cpuidle_init(unsigned int cpu);
 extern int cpu_suspend(unsigned long arg);
 #else
-static inline int cpu_init_idle(unsigned int cpu)
+static inline int arm_cpuidle_init(unsigned int cpu)
 {
 	return -EOPNOTSUPP;
 }

arch/arm64/kernel/cpuidle.c +1 -1

index 5c08966..a78143a 100644
@@ -15,7 +15,7 @@
 #include <asm/cpuidle.h>
 #include <asm/cpu_ops.h>
 
-int cpu_init_idle(unsigned int cpu)
+int arm_cpuidle_init(unsigned int cpu)
 {
 	int ret = -EOPNOTSUPP;
 	struct device_node *cpu_node = of_cpu_device_node_get(cpu);

drivers/cpuidle/cpuidle-arm64.c +1 -1

index 0cea244..6ef291c7 100644
@@ -110,7 +110,7 @@ static int __init arm64_idle_init(void)
 	 * idle states suspend back-end specific data
 	 */
 	for_each_possible_cpu(cpu) {
-		ret = cpu_init_idle(cpu);
+		ret = arm_cpuidle_init(cpu);
 		if (ret) {
 			pr_err("CPU %d failed to init idle CPU ops\n", cpu);
 			return ret;

Signature · 1 line

1.9.1

In the next patch, this driver will be common across ARM/ARM64. Remove all refs to ARM64 as it will be shared with ARM32.

Signed-off-by Daniel Lezcano <[email protected]>

Acked-by Kevin Hilman <[email protected]>

Acked-by Rob Herring <[email protected]>

---
 drivers/cpuidle/cpuidle-arm64.c | 34 +++++++++++++++++-----------------
 1 file changed, 17 insertions(+), 17 deletions(-)

drivers/cpuidle/cpuidle-arm64.c +17 -17

index 6ef291c7..1c94b88 100644
@@ -1,5 +1,5 @@
 /*
- * ARM64 generic CPU idle driver.
+ * ARM/ARM64 generic CPU idle driver.
  *
  * Copyright (C) 2014 ARM Ltd.
  * Author: Lorenzo Pieralisi <[email protected]>

@@ -9,7 +9,7 @@
  * published by the Free Software Foundation.
  */
 
-#define pr_fmt(fmt) "CPUidle arm64: " fmt
+#define pr_fmt(fmt) "CPUidle arm: " fmt
 
 #include <linux/cpuidle.h>
 #include <linux/cpumask.h>

@@ -23,7 +23,7 @@
 #include "dt_idle_states.h"
 
 /*
- * arm64_enter_idle_state - Programs CPU to enter the specified state
+ * arm_enter_idle_state - Programs CPU to enter the specified state
  *
  * dev: cpuidle device
  * drv: cpuidle driver

@@ -32,8 +32,8 @@
  * 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)
+static int arm_enter_idle_state(struct cpuidle_device *dev,
+				struct cpuidle_driver *drv, int idx)
 {
 	int ret;
 

@@ -57,8 +57,8 @@ static int arm64_enter_idle_state(struct cpuidle_device *dev,
 	return ret ? -1 : idx;
 }
 
-static struct cpuidle_driver arm64_idle_driver = {
-	.name = "arm64_idle",
+static struct cpuidle_driver arm_idle_driver = {
+	.name = "arm_idle",
 	.owner = THIS_MODULE,
 	/*
 	 * State at index 0 is standby wfi and considered standard

@@ -68,32 +68,32 @@ static struct cpuidle_driver arm64_idle_driver = {
 	 * handler for idle state index 0.
 	 */
 	.states[0] = {
-		.enter                  = arm64_enter_idle_state,
+		.enter                  = arm_enter_idle_state,
 		.exit_latency           = 1,
 		.target_residency       = 1,
 		.power_usage		= UINT_MAX,
 		.name                   = "WFI",
-		.desc                   = "ARM64 WFI",
+		.desc                   = "ARM WFI",
 	}
 };
 
-static const struct of_device_id arm64_idle_state_match[] __initconst = {
+static const struct of_device_id arm_idle_state_match[] __initconst = {
 	{ .compatible = "arm,idle-state",
-	  .data = arm64_enter_idle_state },
+	  .data = arm_enter_idle_state },
 	{ },
 };
 
 /*
- * arm64_idle_init
+ * arm_idle_init
  *
- * Registers the arm64 specific cpuidle driver with the cpuidle
+ * Registers the arm 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)
+static int __init arm_idle_init(void)
 {
 	int cpu, ret;
-	struct cpuidle_driver *drv = &arm64_idle_driver;
+	struct cpuidle_driver *drv = &arm_idle_driver;
 
 	/*
 	 * Initialize idle states data, starting at index 1.

@@ -101,7 +101,7 @@ static int __init arm64_idle_init(void)
 	 * 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);
+	ret = dt_init_idle_driver(drv, arm_idle_state_match, 1);
 	if (ret <= 0)
 		return ret ? : -ENODEV;
 

@@ -119,4 +119,4 @@ static int __init arm64_idle_init(void)
 
 	return cpuidle_register(drv, NULL);
 }
-device_initcall(arm64_idle_init);
+device_initcall(arm_idle_init);

Signature · 1 line

1.9.1

ARM32 and ARM64 have the same DT definitions and the same approaches.

The generic ARM cpuidle driver can be put in common for those two architectures.

Signed-off-by Daniel Lezcano <[email protected]>

Acked-by Kevin Hilman <[email protected]>

Acked-by Rob Herring <[email protected]>

---
 drivers/cpuidle/Kconfig                            |  7 +------
 drivers/cpuidle/Kconfig.arm                        | 12 +++++++++++-
 drivers/cpuidle/Kconfig.arm64                      | 13 -------------
 drivers/cpuidle/Makefile                           |  5 +----
 drivers/cpuidle/{cpuidle-arm64.c => cpuidle-arm.c} |  0
 5 files changed, 13 insertions(+), 24 deletions(-)
 delete mode 100644 drivers/cpuidle/Kconfig.arm64
 rename drivers/cpuidle/{cpuidle-arm64.c => cpuidle-arm.c} (100%)

drivers/cpuidle/Kconfig +0 -0

index c5029c1..8c7930b 100644

drivers/cpuidle/Kconfig +0 -5

 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"

drivers/cpuidle/Kconfig.arm +0 -0

index 8e07c94..1f067bd 100644

drivers/cpuidle/Kconfig.arm +0 -0

 	select ARCH_NEEDS_CPU_IDLE_COUPLED if SMP
 	help
 	  Select this to enable cpuidle for Exynos processors

drivers/cpuidle/Kconfig.arm64 deleted +0 -13

deleted file mode 100644
index 6effb36..0000000
@@ -1,13 +0,0 @@
-#
-# ARM64 CPU Idle drivers
-#
-
-config ARM64_CPUIDLE
-	bool "Generic ARM64 CPU idle Driver"
-	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.

drivers/cpuidle/Makefile +1 -4

index 4d177b9..3ba81b1 100644
@@ -17,16 +17,13 @@ obj-$(CONFIG_ARM_ZYNQ_CPUIDLE)		+= cpuidle-zynq.o
 obj-$(CONFIG_ARM_U8500_CPUIDLE)         += cpuidle-ux500.o
 obj-$(CONFIG_ARM_AT91_CPUIDLE)          += cpuidle-at91.o
 obj-$(CONFIG_ARM_EXYNOS_CPUIDLE)        += cpuidle-exynos.o
+obj-$(CONFIG_ARM_CPUIDLE)		+= cpuidle-arm.o
 
 ###############################################################################
 # MIPS drivers
 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

drivers/cpuidle/cpuidle-arm.c renamed from drivers/cpuidle/cpuidle-arm64.c +0 -0

similarity index 100%
rename from drivers/cpuidle/cpuidle-arm64.c
rename to drivers/cpuidle/cpuidle-arm.c

Signature · 1 line

1.9.1

Some architectures have some cpus which does not support idle states.

Let the underlying low level code to return -ENXIO when it is not possible to set an idle state.

Signed-off-by Daniel Lezcano <[email protected]>

---
 drivers/cpuidle/cpuidle-arm.c | 42 ++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 40 insertions(+), 2 deletions(-)

drivers/cpuidle/cpuidle-arm.c +6 -0

index 1c94b88..e4a6eba 100644
@@ -17,6 +17,7 @@
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/of.h>
+#include <linux/slab.h>
 
 #include <asm/cpuidle.h>
 

@@ -94,6 +95,7 @@ static int __init arm_idle_init(void)
 {
 	int cpu, ret;
 	struct cpuidle_driver *drv = &arm_idle_driver;
+	struct cpuidle_device *dev;
 
 	/*
 	 * Initialize idle states data, starting at index 1.

@@ -105,18 +107,54 @@ static int __init arm_idle_init(void)
 	if (ret <= 0)
 		return ret ? : -ENODEV;
 
+	ret = cpuidle_register_driver(drv);
+	if (ret) {
+		pr_err("Failed to register cpuidle driver\n");
+		return ret;

drivers/cpuidle/cpuidle-arm.c +30 -2

+		if (ret == -ENXIO)
+			continue;
+
 		if (ret) {
 			pr_err("CPU %d failed to init idle CPU ops\n", cpu);
-			return ret;
+			goto out_fail;
+		}
+
+		dev = kzalloc(sizeof(*dev), GFP_KERNEL);
+		if (!dev) {
+			pr_err("Failed to allocate cpuidle device\n");
+			goto out_fail;
+		}
+		dev->cpu = cpu;
+
+		ret = cpuidle_register_device(dev);
+		if (ret) {
+			pr_err("Failed to register cpuidle device for CPU %d\n",
+			       cpu);
+			kfree(dev);
+			goto out_fail;
 		}
 	}
 
-	return cpuidle_register(drv, NULL);
+	return 0;
+out_fail:
+	while (--cpu >= 0) {
+		dev = per_cpu(cpuidle_devices, cpu);
+		cpuidle_unregister_device(dev);
+		kfree(dev);
+	}
+
+	cpuidle_unregister_driver(drv);
+
+	return ret;
 }
 device_initcall(arm_idle_init);

Signature · 1 line

1.9.1

Quoted 4 lines · Daniel Lezcano

Some architectures have some cpus which does not support idle states.

Let the underlying low level code to return -ENXIO when it is not possible to set an idle state.

Well, this is getting interesting. We are parsing possible CPUs to detect if they have common idle states in DT. If a CPU does not support idle states, the cpu node for that CPU should not define any idle state.

The approach above will work with my heterogenous system patch, since the respective CPUidle driver mask will be created by parsing the DT idle states.

http://www.spinics.net/lists/arm-kernel/msg403190.html

In current approach if a "possible " CPU does not have idle states, we do not init CPUidle at all.

So, to cut a long story short, what does "a cpu does not support idle states" mean ?

Does it mean that firmware defines idle states for that CPU in DT but initializing them fail ?

I am fine with this patch, but we need to define -ENXIO return properly.

Quoted 4 lines · Daniel Lezcano

Some architectures have some cpus which does not support idle states.

Let the underlying low level code to return -ENXIO when it is not possible to set an idle state.

Well, this is getting interesting. We are parsing possible CPUs to detect if they have common idle states in DT. If a CPU does not support idle states, the cpu node for that CPU should not define any idle state.

The approach above will work with my heterogenous system patch, since the respective CPUidle driver mask will be created by parsing the DT idle states.

http://www.spinics.net/lists/arm-kernel/msg403190.html

In current approach if a "possible " CPU does not have idle states, we do not init CPUidle at all.

So, to cut a long story short, what does "a cpu does not support idle states" mean ?

Does it mean that firmware defines idle states for that CPU in DT but initializing them fail ?

I am fine with this patch, but we need to define -ENXIO return properly.

Quoted 33 lines

Signed-off-by Daniel Lezcano <[email protected]>

---
  drivers/cpuidle/cpuidle-arm.c | 42 ++++++++++++++++++++++++++++++++++++++++--
  1 file changed, 40 insertions(+), 2 deletions(-)

drivers/cpuidle/cpuidle-arm.c +6 -0

index 1c94b88..e4a6eba 100644
@@ -17,6 +17,7 @@
  #include <linux/kernel.h>
  #include <linux/module.h>
  #include <linux/of.h>
+#include <linux/slab.h>
 
  #include <asm/cpuidle.h>
 

@@ -94,6 +95,7 @@ static int __init arm_idle_init(void)
  {
  	int cpu, ret;
  	struct cpuidle_driver *drv = &arm_idle_driver;
+	struct cpuidle_device *dev;
 
  	/*
  	 * Initialize idle states data, starting at index 1.

@@ -105,18 +107,54 @@ static int __init arm_idle_init(void)
  	if (ret <= 0)
  		return ret ? : -ENODEV;
 
+	ret = cpuidle_register_driver(drv);
+	if (ret) {
+		pr_err("Failed to register cpuidle driver\n");
+		return ret;

drivers/cpuidle/cpuidle-arm.c static int __init arm_idle_init(void) · line 123

Quoted 10 lines

drivers/cpuidle/cpuidle-arm.c +4 -0

+	}
+
  	/*
  	 * Call arch CPU operations in order to initialize
  	 * idle states suspend back-end specific data
  	 */
  	for_each_possible_cpu(cpu) {
  		ret = arm_cpuidle_init(cpu);
+
+		/* This cpu does not support any idle states */

We need to define what this means. If it means a cpu with no idle states in its cpu node the parsing would not even get here since to init the driver all possible cpus have to have the *same* idle states to function at present.

Lorenzo

Quoted 43 lines

drivers/cpuidle/cpuidle-arm.c +30 -3

+		if (ret == -ENXIO)
+			continue;
+
  		if (ret) {
  			pr_err("CPU %d failed to init idle CPU ops\n", cpu);
-			return ret;
+			goto out_fail;
+		}
+
+		dev = kzalloc(sizeof(*dev), GFP_KERNEL);
+		if (!dev) {
+			pr_err("Failed to allocate cpuidle device\n");
+			goto out_fail;
+		}
+		dev->cpu = cpu;
+
+		ret = cpuidle_register_device(dev);
+		if (ret) {
+			pr_err("Failed to register cpuidle device for CPU %d\n",
+			       cpu);
+			kfree(dev);
+			goto out_fail;
  		}
  	}
 
-	return cpuidle_register(drv, NULL);
+	return 0;
+out_fail:
+	while (--cpu >= 0) {
+		dev = per_cpu(cpuidle_devices, cpu);
+		cpuidle_unregister_device(dev);
+		kfree(dev);
+	}
+
+	cpuidle_unregister_driver(drv);
+
+	return ret;
  }
  device_initcall(arm_idle_init);
--

1.9.1

Quoted 20 lines · Lorenzo Pieralisi

Quoted 4 lines · Daniel Lezcano

Some architectures have some cpus which does not support idle states.

Let the underlying low level code to return -ENXIO when it is not possible to set an idle state.

Well, this is getting interesting. We are parsing possible CPUs to detect if they have common idle states in DT. If a CPU does not support idle states, the cpu node for that CPU should not define any idle state.

The approach above will work with my heterogenous system patch, since the respective CPUidle driver mask will be created by parsing the DT idle states.

http://www.spinics.net/lists/arm-kernel/msg403190.html

In current approach if a "possible " CPU does not have idle states, we do not init CPUidle at all.

Quoted 7 lines

So, to cut a long story short, what does "a cpu does not support idle states" mean ?

Does it mean that firmware defines idle states for that CPU in DT but initializing them fail ?

I am fine with this patch, but we need to define -ENXIO return properly.

Ok, so after discussing with Lina, it appears my change log is not correct.

In Qcom's platform, each core has a SPM. The device associated with this SPM is initialized before the cpuidle framework. If there is an error in the initialization (eg. error in the DT), the system continues to boot but in degraded mode as some SPM may not be correctly initialized. In this case, the EXNIO tells the cpuidle driver to not initialize the cpuidle device as the associated SPM is not operational. That prevents the system to crash and allows to handle the error gracefully.

Quoted 94 lines

Quoted 33 lines

Signed-off-by Daniel Lezcano <[email protected]>

---
  drivers/cpuidle/cpuidle-arm.c | 42 ++++++++++++++++++++++++++++++++++++++++--
  1 file changed, 40 insertions(+), 2 deletions(-)

drivers/cpuidle/cpuidle-arm.c +6 -0

index 1c94b88..e4a6eba 100644
@@ -17,6 +17,7 @@
  #include <linux/kernel.h>
  #include <linux/module.h>
  #include <linux/of.h>
+#include <linux/slab.h>
 
  #include <asm/cpuidle.h>
 

@@ -94,6 +95,7 @@ static int __init arm_idle_init(void)
  {
  	int cpu, ret;
  	struct cpuidle_driver *drv = &arm_idle_driver;
+	struct cpuidle_device *dev;
 
  	/*
  	 * Initialize idle states data, starting at index 1.

@@ -105,18 +107,54 @@ static int __init arm_idle_init(void)
  	if (ret <= 0)
  		return ret ? : -ENODEV;
 
+	ret = cpuidle_register_driver(drv);
+	if (ret) {
+		pr_err("Failed to register cpuidle driver\n");
+		return ret;

drivers/cpuidle/cpuidle-arm.c static int __init arm_idle_init(void) · line 123

Quoted 10 lines

drivers/cpuidle/cpuidle-arm.c +4 -0

+	}
+
  	/*
  	 * Call arch CPU operations in order to initialize
  	 * idle states suspend back-end specific data
  	 */
  	for_each_possible_cpu(cpu) {
  		ret = arm_cpuidle_init(cpu);
+
+		/* This cpu does not support any idle states */

We need to define what this means. If it means a cpu with no idle states in its cpu node the parsing would not even get here since to init the driver all possible cpus have to have the *same* idle states to function at present.

Lorenzo

Quoted 43 lines

drivers/cpuidle/cpuidle-arm.c +30 -3

+		if (ret == -ENXIO)
+			continue;
+
  		if (ret) {
  			pr_err("CPU %d failed to init idle CPU ops\n", cpu);
-			return ret;
+			goto out_fail;
+		}
+
+		dev = kzalloc(sizeof(*dev), GFP_KERNEL);
+		if (!dev) {
+			pr_err("Failed to allocate cpuidle device\n");
+			goto out_fail;
+		}
+		dev->cpu = cpu;
+
+		ret = cpuidle_register_device(dev);
+		if (ret) {
+			pr_err("Failed to register cpuidle device for CPU %d\n",
+			       cpu);
+			kfree(dev);
+			goto out_fail;
  		}
  	}
 
-	return cpuidle_register(drv, NULL);
+	return 0;
+out_fail:
+	while (--cpu >= 0) {
+		dev = per_cpu(cpuidle_devices, cpu);
+		cpuidle_unregister_device(dev);
+		kfree(dev);
+	}
+
+	cpuidle_unregister_driver(drv);
+
+	return ret;
  }
  device_initcall(arm_idle_init);
--

1.9.1

Signature · 5 lines

  <http://www.linaro.org/> Linaro.org │ Open source software for ARM SoCs

Follow Linaro:  <http://www.facebook.com/pages/Linaro> Facebook |
<http://twitter.com/#!/linaroorg> Twitter |
<http://www.linaro.org/linaro-blog/> Blog

On some platforms, the low level PM code may not be initialized correctly for a specific cpu. In this case, the EXNIO tells the cpuidle driver to not

initialize the cpuidle device as the associated low level PM is not operational.

That prevents the system to crash and allows to handle the error gracefully.

For example, on Qcom's platform, each core has a SPM. The device associated with this SPM is initialized before the cpuidle framework. If there is an error in the initialization (eg. error in the DT), the system continues to boot but in degraded mode as some SPM may not be correctly initialized.

Signed-off-by Daniel Lezcano <[email protected]>

---
 drivers/cpuidle/cpuidle-arm.c | 46 +++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 44 insertions(+), 2 deletions(-)

drivers/cpuidle/cpuidle-arm.c +8 -0

index 1c94b88..a7a01ce 100644
@@ -17,6 +17,7 @@
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/of.h>
+#include <linux/slab.h>
 
 #include <asm/cpuidle.h>
 

@@ -94,6 +95,7 @@ static int __init arm_idle_init(void)
 {
 	int cpu, ret;
 	struct cpuidle_driver *drv = &arm_idle_driver;
+	struct cpuidle_device *dev;
 
 	/*
 	 * Initialize idle states data, starting at index 1.

@@ -105,18 +107,58 @@ static int __init arm_idle_init(void)
 	if (ret <= 0)
 		return ret ? : -ENODEV;
 
+	ret = cpuidle_register_driver(drv);
+	if (ret) {
+		pr_err("Failed to register cpuidle driver\n");
+		return ret;
+	}
+
 	/*

drivers/cpuidle/cpuidle-arm.c +23 -2

+		 */
+		if (ret == -ENXIO)
+			continue;
+
 		if (ret) {
 			pr_err("CPU %d failed to init idle CPU ops\n", cpu);
-			return ret;
+			goto out_fail;
+		}
+
+		dev = kzalloc(sizeof(*dev), GFP_KERNEL);
+		if (!dev) {
+			pr_err("Failed to allocate cpuidle device\n");
+			goto out_fail;
+		}
+		dev->cpu = cpu;
+
+		ret = cpuidle_register_device(dev);
+		if (ret) {
+			pr_err("Failed to register cpuidle device for CPU %d\n",
+			       cpu);
+			kfree(dev);
+			goto out_fail;
 		}
 	}
 
-	return cpuidle_register(drv, NULL);
+	return 0;
+out_fail:
+	while (--cpu >= 0) {

Add kernel-doc format documentation in the code.

Signed-off-by Daniel Lezcano <[email protected]>

---
 arch/arm/kernel/cpuidle.c | 58 +++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 58 insertions(+)

arch/arm/kernel/cpuidle.c +0 -0

index 2b0dae3..9219613 100644

arch/arm/kernel/cpuidle.c +29 -0

+ * arm_cpuidle_simple_enter() - a wrapper to cpu_do_idle()
+ * @dev: not used
+ * @drv: not used
+ * @index: not used
+ *
+ * A trivial wrapper to allow the cpu_do_idle function to be assigned as a
+ * cpuidle callback by matching the function signature.
+ *
+ * Returns the index passed as parameter
+ */
 int arm_cpuidle_simple_enter(struct cpuidle_device *dev,
 		struct cpuidle_driver *drv, int index)
 {

@@ -29,6 +40,16 @@ int arm_cpuidle_simple_enter(struct cpuidle_device *dev,
 	return index;
 }
 
+/*
+ * arm_cpuidle_suspend() - function to enter low power idle states
+ * @index: an integer used as an identifier for the low level PM callbacks
+ *
+ * This function calls the underlying arch specific low level PM code as
+ * registered at the init time.
+ *
+ * Returns -EOPNOTSUPP if no suspend callback is defined, the result of the
+ * callback otherwise.
+ */
 int arm_cpuidle_suspend(int index)
 {
 	int ret = -EOPNOTSUPP;

@@ -40,6 +61,15 @@ int arm_cpuidle_suspend(int index)
 	return ret;
 }
 
+/*
+ * arm_cpuidle_get_ops() - find a registered cpuidle_ops by name
+ * @method: the method name
+ *
+ * Search in the __cpuidle_method_of_table array the cpuidle ops matching the
+ * method name.
+ *
+ * Returns a struct cpuidle_ops pointer, NULL if not found.
+ */
 static struct cpuidle_ops *__init arm_cpuidle_get_ops(const char *method)
 {
 	struct of_cpuidle_method *m = __cpuidle_method_of_table;

arch/arm/kernel/cpuidle.c +13 -0

+ * @cpu: the cpu identifier
+ *
+ * Get the method name defined in the 'enabled-method' property, retrieve the
+ * associated cpuidle_ops and do a struct copy. This copy is needed because all
+ * cpuidle_ops are tagged __initdata and will be unloaded after the init
+ * process.
+ *
+ * Return 0 on sucess, -ENOENT if no enabled-method is defined, -EOPNOTSUPP if
+ * no cpuidle_ops is registered for the enabled-method.
+ */
 static int __init arm_cpuidle_read_ops(struct device_node *dn, int cpu)
 {
 	const char *enable_method;

@@ -75,6 +118,21 @@ static int __init arm_cpuidle_read_ops(struct device_node *dn, int cpu)
 	return 0;
 }
 
+/*
+ * arm_cpuidle_init() - Initialize cpuidle_ops for a specific cpu
+ * @cpu: the cpu to be initialized

arch/arm/kernel/cpuidle.c +1 -0

+ */
 int __init arm_cpuidle_init(int cpu)
 {
 	struct device_node *cpu_node = of_cpu_device_node_get(cpu);

Signature · 1 line

1.9.1

On Tue, Mar 24, 2015 at 09:54:02AM +0000, Daniel Lezcano wrote:

Quoted 9 lines

+/*
+ * arm_cpuidle_init() - Initialize cpuidle_ops for a specific cpu
+ * @cpu: the cpu to be initialized
+ *
+ * Initialize the cpuidle ops with the device for the cpu and then call
+ * the cpu's idle initialization callback. This may fail if the underlying HW
+ * is not operational.
+ *
+ * Returns:

Quoted 4 lines

+ *  0 on success,
+ *  -ENODEV if it fails to find the cpu node in the device tree,
+ *  -EOPNOTSUPP if it does not find a registered cpuidle_ops for this cpu,
+ *  -ENOENT if it fails to find a enabled-method property,

Ultra-nit: "an enabled-method"

Quoted 4 lines · Daniel Lezcano

Add kernel-doc format documentation in the code.

Signed-off-by Daniel Lezcano <[email protected]>

---

Quoted 5 lines

+ * Returns:

+ *  0 on success,
+ *  -ENODEV if it fails to find the cpu node in the device tree,
+ *  -EOPNOTSUPP if it does not find a registered cpuidle_ops for this cpu,
+ *  -ENOENT if it fails to find a enabled-method property,

Ultra-nit: "an enabled-method"

Quoted 1 line

+ * -ENXIO if the HW reports a failure or a misconfiguration

-ENOMEM is missing.

Apart from these ultraminor changes (and thanks for putting it together):

Acked-by Lorenzo Pieralisi <[email protected]>

If the cpuidle init cpu operation returns -ENXIO, therefore reporting HW failure or misconfiguration, the CPUidle driver skips the respective cpuidle device initialization because the associated platform back-end HW is not operational.

That prevents the system to crash and allows to handle the error gracefully.

For example, on Qcom's platform, each core has a SPM. The device associated with this SPM is initialized before the cpuidle framework. If there is an error in the initialization (eg. error in the DT), the system continues to boot but in degraded mode as some SPM may not be correctly initialized.

Signed-off-by Daniel Lezcano <[email protected]>

---
 drivers/cpuidle/cpuidle-arm.c | 45 +++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 43 insertions(+), 2 deletions(-)

drivers/cpuidle/cpuidle-arm.c +43 -2

index 1c94b88..545069d 100644
@@ -17,6 +17,7 @@
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/of.h>
+#include <linux/slab.h>
 
 #include <asm/cpuidle.h>
 

@@ -94,6 +95,7 @@ static int __init arm_idle_init(void)
 {
 	int cpu, ret;
 	struct cpuidle_driver *drv = &arm_idle_driver;
+	struct cpuidle_device *dev;
 
 	/*
 	 * Initialize idle states data, starting at index 1.

@@ -105,18 +107,57 @@ static int __init arm_idle_init(void)
 	if (ret <= 0)
 		return ret ? : -ENODEV;
 
+	ret = cpuidle_register_driver(drv);
+	if (ret) {
+		pr_err("Failed to register cpuidle driver\n");
+		return ret;
+	}
+
 	/*
 	 * Call arch CPU operations in order to initialize
 	 * idle states suspend back-end specific data
 	 */
 	for_each_possible_cpu(cpu) {
 		ret = arm_cpuidle_init(cpu);
+
+		/*
+		 * Skip the cpuidle device initialization if the reported
+		 * failure is a HW misconfiguration/breakage (-ENXIO).
+		 */
+		if (ret == -ENXIO)
+			continue;
+
 		if (ret) {
 			pr_err("CPU %d failed to init idle CPU ops\n", cpu);
-			return ret;
+			goto out_fail;
+		}
+
+		dev = kzalloc(sizeof(*dev), GFP_KERNEL);
+		if (!dev) {
+			pr_err("Failed to allocate cpuidle device\n");
+			goto out_fail;
+		}
+		dev->cpu = cpu;
+
+		ret = cpuidle_register_device(dev);
+		if (ret) {
+			pr_err("Failed to register cpuidle device for CPU %d\n",
+			       cpu);
+			kfree(dev);
+			goto out_fail;
 		}
 	}
 
-	return cpuidle_register(drv, NULL);
+	return 0;
+out_fail:
+	while (--cpu >= 0) {
+		dev = per_cpu(cpuidle_devices, cpu);
+		cpuidle_unregister_device(dev);
+		kfree(dev);
+	}
+
+	cpuidle_unregister_driver(drv);
+
+	return ret;
 }
 device_initcall(arm_idle_init);

Signature · 1 line

1.9.1

Change the functions name:
arm_cpuidle_suspend => arm_idle
arm_cpuidle_init => arm_idle_cpu_init

Signed-off-by Daniel Lezcano <[email protected]>

---
 arch/arm/include/asm/cpuidle.h   | 4 ++--
 arch/arm/kernel/cpuidle.c        | 4 ++--
 arch/arm64/include/asm/cpuidle.h | 6 +++---
 arch/arm64/kernel/cpuidle.c      | 2 +-
 drivers/cpuidle/cpuidle-arm.c    | 4 ++--
 5 files changed, 10 insertions(+), 10 deletions(-)

arch/arm/include/asm/cpuidle.h +2 -2

index 0f84249..5f547c0 100644
@@ -44,8 +44,8 @@ struct of_cpuidle_method {
 	__used __section(__cpuidle_method_of_table)			\
 	= { .method = _method, .ops = _ops }
 
-extern int arm_cpuidle_suspend(int index);
+extern int arm_idle(int index);
 
-extern int arm_cpuidle_init(int cpu);
+extern int arm_idle_cpu_init(int cpu);
 
 #endif

arch/arm/kernel/cpuidle.c +2 -2

index 7b42a40..05a2c3e 100644
@@ -29,7 +29,7 @@ int arm_cpuidle_simple_enter(struct cpuidle_device *dev,
 	return index;
 }
 
-int arm_cpuidle_suspend(int index)
+int arm_idle(int index)
 {
 	int ret = -EOPNOTSUPP;
 	int cpu = smp_processor_id();

@@ -75,7 +75,7 @@ static int __init arm_cpuidle_read_ops(struct device_node *dn, int cpu)
 	return 0;
 }
 
-int __init arm_cpuidle_init(int cpu)
+int __init arm_idle_cpu_init(int cpu)
 {
 	int ret = -EOPNOTSUPP;
 	struct device_node *cpu_node = of_cpu_device_node_get(cpu);

arch/arm64/include/asm/cpuidle.h +3 -3

index 141b2fc..e9c0dc4e 100644
@@ -4,10 +4,10 @@
 #include <asm/proc-fns.h>
 
 #ifdef CONFIG_CPU_IDLE
-extern int arm_cpuidle_init(unsigned int cpu);
+extern int arm_idle_cpu_init(unsigned int cpu);
 extern int cpu_suspend(unsigned long arg);
 #else
-static inline int arm_cpuidle_init(unsigned int cpu)
+static inline int arm_idle_cpu_init(unsigned int cpu)
 {
 	return -EOPNOTSUPP;
 }

@@ -17,7 +17,7 @@ static inline int cpu_suspend(unsigned long arg)
 	return -EOPNOTSUPP;
 }
 #endif
-static inline int arm_cpuidle_suspend(int index)
+static inline int arm_idle(int index)
 {
 	return cpu_suspend(index);
 }

arch/arm64/kernel/cpuidle.c +1 -1

index a78143a..b6b4fcf 100644
@@ -15,7 +15,7 @@
 #include <asm/cpuidle.h>
 #include <asm/cpu_ops.h>
 
-int arm_cpuidle_init(unsigned int cpu)
+int arm_idle_cpu_init(unsigned int cpu)
 {
 	int ret = -EOPNOTSUPP;
 	struct device_node *cpu_node = of_cpu_device_node_get(cpu);

drivers/cpuidle/cpuidle-arm.c +2 -2

index e4a6eba..37c732d 100644
@@ -50,7 +50,7 @@ static int arm_enter_idle_state(struct cpuidle_device *dev,
 		 * call the CPU ops suspend protocol with idle index as a
 		 * parameter.
 		 */
-		arm_cpuidle_suspend(idx);
+		arm_idle(idx);
 
 		cpu_pm_exit();
 	}

@@ -118,7 +118,7 @@ static int __init arm_idle_init(void)
 	 * idle states suspend back-end specific data
 	 */
 	for_each_possible_cpu(cpu) {
-		ret = arm_cpuidle_init(cpu);
+		ret = arm_idle_cpu_init(cpu);
 
 		/* This cpu does not support any idle states */
 		if (ret == -ENXIO)

Signature · 1 line

1.9.1

There is a big number of cpuidle drivers for the ARM architecture.

These drivers have been cleaned up and grouped into the drivers/cpuidle directory to keep track of the changes more easily and ensure the code is following the same scheme across the drivers.

That had the benefit of simplifying the code and factor out a lot of common parts. Beside that, as the drivers belong to the 'drivers' directory, we had to split the arch specific bits and the generic code in order to keep everything self contained. The platform driver paradigm was used for this purpose.

Unfortunately, this approach is now no longer accepted and a different solution must be provided to reach the same goal: one example is the Qualcomm cpuidle driver upstreaming attempt.

In the meantime, ARM64 developed a generic cpuidle driver based on DT definition.

The DT definition provides an 'enable-method' to specify one of the cpu operations (PSCI, ...).

This patchset unify this driver with ARM32, using the same DT definition.

Thanks with this patchset we can use the 'enable-method' to specify a cpu operations, hence get rid of the platform driver approach and go further in the cpuidle driver flexibility via the DT.

Hi Daniel,

Quoted 21 lines · Daniel Lezcano

There is a big number of cpuidle drivers for the ARM architecture.

These drivers have been cleaned up and grouped into the drivers/cpuidle directory to keep track of the changes more easily and ensure the code is following the same scheme across the drivers.

That had the benefit of simplifying the code and factor out a lot of common parts. Beside that, as the drivers belong to the 'drivers' directory, we had to split the arch specific bits and the generic code in order to keep everything self contained. The platform driver paradigm was used for this purpose.

Unfortunately, this approach is now no longer accepted and a different solution must be provided to reach the same goal: one example is the Qualcomm cpuidle driver upstreaming attempt.

In the meantime, ARM64 developed a generic cpuidle driver based on DT definition.

The DT definition provides an 'enable-method' to specify one of the cpu operations (PSCI, ...).

Quoted 5 lines

This patchset unify this driver with ARM32, using the same DT definition.

Thanks with this patchset we can use the 'enable-method' to specify a cpu operations, hence get rid of the platform driver approach and go further in the cpuidle driver flexibility via the DT.

I had a look and the series seems fine, if you have a branch I can pull from I will test on arm64 and add the required tags.

There is a big number of cpuidle drivers for the ARM architecture.

These drivers have been cleaned up and grouped into the drivers/cpuidle directory to keep track of the changes more easily and ensure the code is following the same scheme across the drivers.

That had the benefit of simplifying the code and factor out a lot of common parts. Beside that, as the drivers belong to the 'drivers' directory, we had to split the arch specific bits and the generic code in order to keep everything self contained. The platform driver paradigm was used for this purpose.

Unfortunately, this approach is now no longer accepted and a different solution must be provided to reach the same goal: one example is the Qualcomm cpuidle driver upstreaming attempt.

In the meantime, ARM64 developed a generic cpuidle driver based on DT definition.

The DT definition provides an 'enable-method' to specify one of the cpu operations (PSCI, ...).

This patchset unify this driver with ARM32, using the same DT definition.

Thanks with this patchset we can use the 'enable-method' to specify a cpu operations, hence get rid of the platform driver approach and go further in the cpuidle driver flexibility via the DT.

Changelog:

V3:
* Fixed unroll loop when failing to register the device
* Removed the per cpu cpuidle_device
* Remove goto statement in the registration path
* Fixed a compilation failure with allyesconfig on arm64

V2:
* Used smp_operations style for cpuidle_ops
* Fixed some nits in the comments
* Added a patch to change the name of the functions
* Added per cpu device registration patch

Daniel Lezcano (8):
ARM: cpuidle: Remove duplicate header inclusion
ARM: cpuidle: Add a cpuidle ops structure to be used for DT
ARM64: cpuidle: Replace cpu_suspend by the common ARM/ARM64 function
ARM64: cpuidle: Rename cpu_init_idle to a common function name
ARM64: cpuidle: Remove arm64 reference
ARM: cpuidle: Enable the ARM64 driver for both ARM32/ARM64
ARM: cpuidle: Register per cpuidle device
ARM: cpuidle: Change function name to be consistent with x86

 arch/arm/include/asm/cpuidle.h                     | 23 +++++++
 arch/arm/kernel/cpuidle.c                          | 74 +++++++++++++++++++-
 arch/arm/mach-davinci/cpuidle.c                    |  1 -
 arch/arm/mach-imx/cpuidle-imx6q.c                  |  1 -
 arch/arm/mach-imx/cpuidle-imx6sl.c                 |  1 -
 arch/arm/mach-imx/cpuidle-imx6sx.c                 |  1 -
 arch/arm/mach-omap2/cpuidle44xx.c                  |  1 -
 arch/arm/mach-s3c64xx/cpuidle.c                    |  2 +-
 arch/arm/mach-tegra/cpuidle-tegra20.c              |  1 -
 arch/arm/mach-tegra/cpuidle-tegra30.c              |  1 -
 arch/arm64/include/asm/cpuidle.h                   |  9 ++-
 arch/arm64/kernel/cpuidle.c                        |  2 +-
 drivers/cpuidle/Kconfig                            |  7 +-
 drivers/cpuidle/Kconfig.arm                        | 12 +++-
 drivers/cpuidle/Kconfig.arm64                      | 13 ----
 drivers/cpuidle/Makefile                           |  5 +-
 drivers/cpuidle/{cpuidle-arm64.c => cpuidle-arm.c} | 80 ++++++++++++++++------
 drivers/cpuidle/cpuidle-at91.c                     |  1 -
 drivers/cpuidle/cpuidle-exynos.c                   |  1 -
 drivers/cpuidle/cpuidle-kirkwood.c                 |  1 -
 drivers/cpuidle/cpuidle-ux500.c                    |  1 -
 drivers/cpuidle/cpuidle-zynq.c                     |  1 -
 include/asm-generic/vmlinux.lds.h                  |  2 +
 23 files changed, 178 insertions(+), 63 deletions(-)
 delete mode 100644 drivers/cpuidle/Kconfig.arm64
 rename drivers/cpuidle/{cpuidle-arm64.c => cpuidle-arm.c} (57%)

Signature · 1 line

1.9.1

There is a big number of cpuidle drivers for the ARM architecture.

These drivers have been cleaned up and grouped into the drivers/cpuidle directory to keep track of the changes more easily and ensure the code is following the same scheme across the drivers.

That had the benefit of simplifying the code and factor out a lot of common parts. Beside that, as the drivers belong to the 'drivers' directory, we had to split the arch specific bits and the generic code in order to keep everything self contained. The platform driver paradigm was used for this purpose.

Unfortunately, this approach is now no longer accepted and a different solution must be provided to reach the same goal: one example is the Qualcomm cpuidle driver upstreaming attempt.

In the meantime, ARM64 developed a generic cpuidle driver based on DT definition.

The DT definition provides an 'enable-method' to specify one of the cpu operations (PSCI, ...).

This patchset unify this driver with ARM32, using the same DT definition.

Thanks with this patchset we can use the 'enable-method' to specify a cpu operations, hence get rid of the platform driver approach and go further in the cpuidle driver flexibility via the DT.

Changelog:

V3:
* Fixed unroll loop when failing to register the device
* Removed the per cpu cpuidle_device
* Remove goto statement in the registration path
* Fixed a compilation failure with allyesconfig on arm64

V2:
* Used smp_operations style for cpuidle_ops
* Fixed some nits in the comments
* Added a patch to change the name of the functions
* Added per cpu device registration patch

Daniel Lezcano (8):
ARM: cpuidle: Remove duplicate header inclusion
ARM: cpuidle: Add a cpuidle ops structure to be used for DT
ARM64: cpuidle: Replace cpu_suspend by the common ARM/ARM64 function
ARM64: cpuidle: Rename cpu_init_idle to a common function name
ARM64: cpuidle: Remove arm64 reference
ARM: cpuidle: Enable the ARM64 driver for both ARM32/ARM64
ARM: cpuidle: Register per cpuidle device
ARM: cpuidle: Change function name to be consistent with x86

 arch/arm/include/asm/cpuidle.h                     | 23 +++++++
 arch/arm/kernel/cpuidle.c                          | 74 +++++++++++++++++++-
 arch/arm/mach-davinci/cpuidle.c                    |  1 -
 arch/arm/mach-imx/cpuidle-imx6q.c                  |  1 -
 arch/arm/mach-imx/cpuidle-imx6sl.c                 |  1 -
 arch/arm/mach-imx/cpuidle-imx6sx.c                 |  1 -
 arch/arm/mach-omap2/cpuidle44xx.c                  |  1 -
 arch/arm/mach-s3c64xx/cpuidle.c                    |  2 +-
 arch/arm/mach-tegra/cpuidle-tegra20.c              |  1 -
 arch/arm/mach-tegra/cpuidle-tegra30.c              |  1 -
 arch/arm64/include/asm/cpuidle.h                   |  9 ++-
 arch/arm64/kernel/cpuidle.c                        |  2 +-
 drivers/cpuidle/Kconfig                            |  7 +-
 drivers/cpuidle/Kconfig.arm                        | 12 +++-
 drivers/cpuidle/Kconfig.arm64                      | 13 ----
 drivers/cpuidle/Makefile                           |  5 +-
 drivers/cpuidle/{cpuidle-arm64.c => cpuidle-arm.c} | 80 ++++++++++++++++------
 drivers/cpuidle/cpuidle-at91.c                     |  1 -
 drivers/cpuidle/cpuidle-exynos.c                   |  1 -
 drivers/cpuidle/cpuidle-kirkwood.c                 |  1 -
 drivers/cpuidle/cpuidle-ux500.c                    |  1 -
 drivers/cpuidle/cpuidle-zynq.c                     |  1 -
 include/asm-generic/vmlinux.lds.h                  |  2 +
 23 files changed, 178 insertions(+), 63 deletions(-)
 delete mode 100644 drivers/cpuidle/Kconfig.arm64
 rename drivers/cpuidle/{cpuidle-arm64.c => cpuidle-arm.c} (57%)

Signature · 1 line

1.9.1

Quoted 21 lines · Daniel Lezcano

There is a big number of cpuidle drivers for the ARM architecture.

These drivers have been cleaned up and grouped into the drivers/cpuidle directory to keep track of the changes more easily and ensure the code is following the same scheme across the drivers.

That had the benefit of simplifying the code and factor out a lot of common parts. Beside that, as the drivers belong to the 'drivers' directory, we had to split the arch specific bits and the generic code in order to keep everything self contained. The platform driver paradigm was used for this purpose.

Unfortunately, this approach is now no longer accepted and a different solution must be provided to reach the same goal: one example is the Qualcomm cpuidle driver upstreaming attempt.

In the meantime, ARM64 developed a generic cpuidle driver based on DT definition.

The DT definition provides an 'enable-method' to specify one of the cpu operations (PSCI, ...).

Quoted 5 lines

This patchset unify this driver with ARM32, using the same DT definition.

Thanks with this patchset we can use the 'enable-method' to specify a cpu operations, hence get rid of the platform driver approach and go further in the cpuidle driver flexibility via the DT.

Tested on arm64 Juno and FVP models.

Tested-by Lorenzo Pieralisi <[email protected]>

Quoted 56 lines

Changelog:

V3:
* Fixed unroll loop when failing to register the device
* Removed the per cpu cpuidle_device
* Remove goto statement in the registration path
* Fixed a compilation failure with allyesconfig on arm64

V2:
* Used smp_operations style for cpuidle_ops
* Fixed some nits in the comments
* Added a patch to change the name of the functions
* Added per cpu device registration patch

Daniel Lezcano (8):
ARM: cpuidle: Remove duplicate header inclusion
ARM: cpuidle: Add a cpuidle ops structure to be used for DT
ARM64: cpuidle: Replace cpu_suspend by the common ARM/ARM64 function
ARM64: cpuidle: Rename cpu_init_idle to a common function name
ARM64: cpuidle: Remove arm64 reference
ARM: cpuidle: Enable the ARM64 driver for both ARM32/ARM64
ARM: cpuidle: Register per cpuidle device
ARM: cpuidle: Change function name to be consistent with x86

  arch/arm/include/asm/cpuidle.h                     | 23 +++++++
  arch/arm/kernel/cpuidle.c                          | 74 +++++++++++++++++++-
  arch/arm/mach-davinci/cpuidle.c                    |  1 -
  arch/arm/mach-imx/cpuidle-imx6q.c                  |  1 -
  arch/arm/mach-imx/cpuidle-imx6sl.c                 |  1 -
  arch/arm/mach-imx/cpuidle-imx6sx.c                 |  1 -
  arch/arm/mach-omap2/cpuidle44xx.c                  |  1 -
  arch/arm/mach-s3c64xx/cpuidle.c                    |  2 +-
  arch/arm/mach-tegra/cpuidle-tegra20.c              |  1 -
  arch/arm/mach-tegra/cpuidle-tegra30.c              |  1 -
  arch/arm64/include/asm/cpuidle.h                   |  9 ++-
  arch/arm64/kernel/cpuidle.c                        |  2 +-
  drivers/cpuidle/Kconfig                            |  7 +-
  drivers/cpuidle/Kconfig.arm                        | 12 +++-
  drivers/cpuidle/Kconfig.arm64                      | 13 ----
  drivers/cpuidle/Makefile                           |  5 +-
  drivers/cpuidle/{cpuidle-arm64.c => cpuidle-arm.c} | 80 ++++++++++++++++------
  drivers/cpuidle/cpuidle-at91.c                     |  1 -
  drivers/cpuidle/cpuidle-exynos.c                   |  1 -
  drivers/cpuidle/cpuidle-kirkwood.c                 |  1 -
  drivers/cpuidle/cpuidle-ux500.c                    |  1 -
  drivers/cpuidle/cpuidle-zynq.c                     |  1 -
  include/asm-generic/vmlinux.lds.h                  |  2 +
  23 files changed, 178 insertions(+), 63 deletions(-)

delete mode 100644 drivers/cpuidle/Kconfig.arm64 rename drivers/cpuidle/{cpuidle-arm64.c => cpuidle-arm.c} (57%)

--
1.9.1