cpufreq: arm_big_little: Make Vexpress bL as generic big LITTLE cpufreq driver

This driver shouldn't have any dependency on Vexpress Platform and so can be
converted into generic big LITTLE platform's cpufreq driver. All dependencies
which are currently there would be removed by other patches.

Signed-off-by: Viresh Kumar <viresh.kumar@linaro.org>

3 files changed, 50 insertions, 62 deletions

diff --git a/drivers/cpufreq/Kconfig.arm b/drivers/cpufreq/Kconfig.arm
index 2d4983aa23b..62944f40dca 100644
--- a/drivers/cpufreq/Kconfig.arm
+++ b/drivers/cpufreq/Kconfig.arm
@@ -114,12 +114,9 @@ config ARM_HIGHBANK_CPUFREQ
 
 	  If in doubt, say N.
 
-config ARM_VEXPRESS_BL_CPUFREQ
-	tristate "CPUfreq driver for ARM Vexpress big.LITTLE CPUs"
-	depends on ARCH_VEXPRESS && CPU_FREQ
+config ARM_BIG_LITTLE_CPUFREQ
+	tristate "CPUfreq driver for ARM big LITTLE CPUs"
 	depends on ARM_CPU_TOPOLOGY
 	help
-	  This enables the CPUfreq driver for ARM Vexpress big.LITTLE
-	  platform.
-
+	  This enables the CPUfreq driver for ARM big.LITTLE platforms.
 	  If in doubt, say N.
diff --git a/drivers/cpufreq/Makefile b/drivers/cpufreq/Makefile
index 039024c99e4..7071d4ec666 100644
--- a/drivers/cpufreq/Makefile
+++ b/drivers/cpufreq/Makefile
@@ -57,7 +57,7 @@ obj-$(CONFIG_ARM_OMAP2PLUS_CPUFREQ)	+= omap-cpufreq.o
 obj-$(CONFIG_ARM_SPEAR_CPUFREQ)		+= spear-cpufreq.o
 obj-$(CONFIG_ARM_HIGHBANK_CPUFREQ)	+= highbank-cpufreq.o
 obj-$(CONFIG_ARM_IMX6Q_CPUFREQ)		+= imx6q-cpufreq.o
-obj-$(CONFIG_ARM_VEXPRESS_BL_CPUFREQ)	+= vexpress_bL_cpufreq.o
+obj-$(CONFIG_ARM_BIG_LITTLE_CPUFREQ)	+= arm_big_little.o
 
 ##################################################################################
 # PowerPC platform drivers
diff --git a/drivers/cpufreq/vexpress_bL_cpufreq.c b/drivers/cpufreq/arm_big_little.c
index 253d59f9635..a89f4021456 100644
--- a/drivers/cpufreq/vexpress_bL_cpufreq.c
+++ b/drivers/cpufreq/arm_big_little.c
@@ -1,10 +1,12 @@
 /*
- * Vexpress big.LITTLE CPUFreq support
- * Based on mach-integrator
+ * ARM big.LITTLE Platforms CPUFreq support
  *
  * Copyright (C) 2012 ARM Ltd.
  * Author: Sudeep KarkadaNagesha <sudeep.karkadanagesha@arm.com>
  *
+ * Copyright (C) 2012 Linaro.
+ * Viresh Kumar <viresh.kumar@linaro.org>
+ *
  * 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.
@@ -14,27 +16,21 @@
  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  */
+
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/cpufreq.h>
 #include <linux/cpumask.h>
-#include <linux/init.h>
-#include <linux/io.h>
-#include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/of_platform.h>
-#include <linux/sched.h>
 #include <linux/slab.h>
-#include <linux/smp.h>
-#include <linux/spinlock.h>
-#include <linux/sysfs.h>
 #include <linux/types.h>
-
 #include <linux/vexpress.h>
-
 #include <asm/topology.h>
 
-#define VEXPRESS_MAX_CLUSTER	2
+#define MAX_CLUSTERS	2
 
-static struct cpufreq_frequency_table *freq_table[VEXPRESS_MAX_CLUSTER];
+static struct cpufreq_frequency_table *freq_table[MAX_CLUSTERS];
 static atomic_t freq_table_users = ATOMIC_INIT(0);
 
 /*
@@ -48,26 +44,22 @@ static int cpu_to_cluster(int cpu)
 }
 
 /* Validate policy frequency range */
-static int vexpress_cpufreq_verify_policy(struct cpufreq_policy *policy)
+static int bl_cpufreq_verify_policy(struct cpufreq_policy *policy)
 {
-	uint32_t cur_cluster = cpu_to_cluster(policy->cpu);
+	u32 cur_cluster = cpu_to_cluster(policy->cpu);
 
 	/* This call takes care of it all using freq_table */
 	return cpufreq_frequency_table_verify(policy, freq_table[cur_cluster]);
 }
 
 /* Set clock frequency */
-static int vexpress_cpufreq_set_target(struct cpufreq_policy *policy,
-			     unsigned int target_freq, unsigned int relation)
+static int bl_cpufreq_set_target(struct cpufreq_policy *policy,
+		unsigned int target_freq, unsigned int relation)
 {
-	uint32_t cpu = policy->cpu;
 	struct cpufreq_freqs freqs;
-	uint32_t freq_tab_idx;
-	uint32_t cur_cluster;
+	u32 cpu = policy->cpu, freq_tab_idx, cur_cluster;
 	int ret = 0;
 
-	/* Read current clock rate */
-
 	/* ASSUMPTION: The cpu can't be hotplugged in this function */
 	cur_cluster = cpu_to_cluster(policy->cpu);
 
@@ -76,7 +68,7 @@ static int vexpress_cpufreq_set_target(struct cpufreq_policy *policy,
 
 	/* Determine valid target frequency using freq_table */
 	cpufreq_frequency_table_target(policy, freq_table[cur_cluster],
-				       target_freq, relation, &freq_tab_idx);
+			target_freq, relation, &freq_tab_idx);
 	freqs.new = freq_table[cur_cluster][freq_tab_idx].frequency;
 
 	freqs.cpu = policy->cpu;
@@ -104,10 +96,10 @@ static int vexpress_cpufreq_set_target(struct cpufreq_policy *policy,
 }
 
 /* Get current clock frequency */
-static unsigned int vexpress_cpufreq_get(unsigned int cpu)
+static unsigned int bl_cpufreq_get(unsigned int cpu)
 {
-	uint32_t freq = 0;
-	uint32_t cur_cluster = cpu_to_cluster(cpu);
+	u32 freq = 0;
+	u32 cur_cluster = cpu_to_cluster(cpu);
 
 	/*
 	 * Read current clock rate with vexpress_spc call
@@ -119,23 +111,23 @@ static unsigned int vexpress_cpufreq_get(unsigned int cpu)
 }
 
 /* translate the integer array into cpufreq_frequency_table entries */
-static inline void _cpufreq_copy_table_from_array(uint32_t *table,
+static inline void _cpufreq_copy_table_from_array(u32 *table,
 			struct cpufreq_frequency_table *freq_table, int size)
 {
 	int i;
 	for (i = 0; i < size; i++) {
 		freq_table[i].index = i;
-		freq_table[i].frequency =  table[i] / 1000; /* in kHZ */
+		freq_table[i].frequency = table[i] / 1000; /* in kHZ */
 	}
 	freq_table[i].index = size;
 	freq_table[i].frequency = CPUFREQ_TABLE_END;
 }
 
-static int vexpress_cpufreq_of_init(void)
+static int bl_cpufreq_of_init(void)
 {
-	uint32_t cpu_opp_num;
-	struct cpufreq_frequency_table *freqtable[VEXPRESS_MAX_CLUSTER];
-	uint32_t *cpu_freqs;
+	u32 cpu_opp_num;
+	struct cpufreq_frequency_table *freqtable[MAX_CLUSTERS];
+	u32 *cpu_freqs;
 	int ret = 0, cluster_id = 0, len;
 	struct device_node *cluster = NULL;
 	const struct property *pp;
@@ -153,7 +145,7 @@ static int vexpress_cpufreq_of_init(void)
 		if (!cpu_opp_num)
 			return -ENODATA;
 
-		cpu_freqs = kzalloc(sizeof(uint32_t) * cpu_opp_num, GFP_KERNEL);
+		cpu_freqs = kzalloc(sizeof(u32) * cpu_opp_num, GFP_KERNEL);
 		freqtable[cluster_id] =
 			kzalloc(sizeof(struct cpufreq_frequency_table) *
 						(cpu_opp_num + 1), GFP_KERNEL);
@@ -178,13 +170,13 @@ free_mem:
 }
 
 /* Per-CPU initialization */
-static int vexpress_cpufreq_init(struct cpufreq_policy *policy)
+static int bl_cpufreq_init(struct cpufreq_policy *policy)
 {
 	int result = 0;
-	uint32_t cur_cluster = cpu_to_cluster(policy->cpu);
+	u32 cur_cluster = cpu_to_cluster(policy->cpu);
 
 	if (atomic_inc_return(&freq_table_users) == 1)
-		result = vexpress_cpufreq_of_init();
+		result = bl_cpufreq_of_init();
 
 	if (freq_table[cur_cluster] == NULL)
 		result = -ENODATA;
@@ -195,8 +187,8 @@ static int vexpress_cpufreq_init(struct cpufreq_policy *policy)
 		return result;
 	}
 
-	result =
-	    cpufreq_frequency_table_cpuinfo(policy, freq_table[cur_cluster]);
+	result = cpufreq_frequency_table_cpuinfo(policy,
+			freq_table[cur_cluster]);
 	if (result)
 		return result;
 
@@ -207,7 +199,7 @@ static int vexpress_cpufreq_init(struct cpufreq_policy *policy)
 	policy->max = policy->cpuinfo.max_freq;
 
 	policy->cpuinfo.transition_latency = 1000000;	/* 1 ms assumed */
-	policy->cur = vexpress_cpufreq_get(policy->cpu);
+	policy->cur = bl_cpufreq_get(policy->cpu);
 
 	cpumask_copy(policy->cpus, topology_core_cpumask(policy->cpu));
 	cpumask_copy(policy->related_cpus, policy->cpus);
@@ -217,38 +209,37 @@ static int vexpress_cpufreq_init(struct cpufreq_policy *policy)
 }
 
 /* Export freq_table to sysfs */
-static struct freq_attr *vexpress_cpufreq_attr[] = {
+static struct freq_attr *bl_cpufreq_attr[] = {
 	&cpufreq_freq_attr_scaling_available_freqs,
 	NULL,
 };
 
-static struct cpufreq_driver vexpress_cpufreq_driver = {
+static struct cpufreq_driver bl_cpufreq_driver = {
+	.name	= "arm-big-little",
 	.flags	= CPUFREQ_STICKY,
-	.verify	= vexpress_cpufreq_verify_policy,
-	.target	= vexpress_cpufreq_set_target,
-	.get	= vexpress_cpufreq_get,
-	.init	= vexpress_cpufreq_init,
-	.name	= "vexpress-spc",
-	.attr	= vexpress_cpufreq_attr,
+	.verify	= bl_cpufreq_verify_policy,
+	.target	= bl_cpufreq_set_target,
+	.get	= bl_cpufreq_get,
+	.init	= bl_cpufreq_init,
+	.attr	= bl_cpufreq_attr,
 };
 
-static int __init vexpress_cpufreq_modinit(void)
+static int __init bl_cpufreq_modinit(void)
 {
 	if (!vexpress_spc_check_loaded()) {
 		pr_info("vexpress cpufreq not initialised because no SPC found\n");
 		return -ENODEV;
 	}
 
-	return cpufreq_register_driver(&vexpress_cpufreq_driver);
+	return cpufreq_register_driver(&bl_cpufreq_driver);
 }
+module_init(bl_cpufreq_modinit);
 
-static void __exit vexpress_cpufreq_modexit(void)
+static void __exit bl_cpufreq_modexit(void)
 {
-	cpufreq_unregister_driver(&vexpress_cpufreq_driver);
+	cpufreq_unregister_driver(&bl_cpufreq_driver);
 }
+module_exit(bl_cpufreq_modexit);
 
-MODULE_DESCRIPTION("cpufreq driver for ARM vexpress big.LITTLE platform");
+MODULE_DESCRIPTION("ARM big LITTLE platforms cpufreq driver");
 MODULE_LICENSE("GPL");
-
-module_init(vexpress_cpufreq_modinit);
-module_exit(vexpress_cpufreq_modexit);