cpufreq: ARM big LITTLE: Replace "bl" with standard shortname "bL"

Throughout Linux code big LITTLE is written as "bL". We have used "bl" instead
of "bL". Lets fix it.

Signed-off-by: Viresh Kumar <viresh.kumar@linaro.org>
Reported-by: Nicolas Pitre <nicolas.pitre@linaro.org>

4 files changed, 62 insertions, 62 deletions

diff --git a/drivers/cpufreq/arm_big_little.c b/drivers/cpufreq/arm_big_little.c
index 45a2ddaba4c..b5601fcd79e 100644
--- a/drivers/cpufreq/arm_big_little.c
+++ b/drivers/cpufreq/arm_big_little.c
@@ -31,7 +31,7 @@
 
 #define MAX_CLUSTERS	2
 
-static struct cpufreq_arm_bl_ops *arm_bl_ops;
+static struct cpufreq_arm_bL_ops *arm_bL_ops;
 static struct clk *clk[MAX_CLUSTERS];
 static struct cpufreq_frequency_table *freq_table[MAX_CLUSTERS];
 static atomic_t cluster_usage[MAX_CLUSTERS] = {ATOMIC_INIT(0), ATOMIC_INIT(0)};
@@ -46,7 +46,7 @@ static int cpu_to_cluster(int cpu)
 	return topology_physical_package_id(cpu);
 }
 
-static unsigned int bl_cpufreq_get(unsigned int cpu)
+static unsigned int bL_cpufreq_get(unsigned int cpu)
 {
 	u32 cur_cluster = cpu_to_cluster(cpu);
 
@@ -54,7 +54,7 @@ static unsigned int bl_cpufreq_get(unsigned int cpu)
 }
 
 /* Validate policy frequency range */
-static int bl_cpufreq_verify_policy(struct cpufreq_policy *policy)
+static int bL_cpufreq_verify_policy(struct cpufreq_policy *policy)
 {
 	u32 cur_cluster = cpu_to_cluster(policy->cpu);
 
@@ -63,7 +63,7 @@ static int bl_cpufreq_verify_policy(struct cpufreq_policy *policy)
 }
 
 /* Set clock frequency */
-static int bl_cpufreq_set_target(struct cpufreq_policy *policy,
+static int bL_cpufreq_set_target(struct cpufreq_policy *policy,
 		unsigned int target_freq, unsigned int relation)
 {
 	struct cpufreq_freqs freqs;
@@ -73,7 +73,7 @@ static int bl_cpufreq_set_target(struct cpufreq_policy *policy,
 	/* ASSUMPTION: The cpu can't be hotplugged in this function */
 	cur_cluster = cpu_to_cluster(policy->cpu);
 
-	freqs.old = bl_cpufreq_get(policy->cpu);
+	freqs.old = bL_cpufreq_get(policy->cpu);
 
 	/* Determine valid target frequency using freq_table */
 	cpufreq_frequency_table_target(policy, freq_table[cur_cluster],
@@ -108,7 +108,7 @@ static int bl_cpufreq_set_target(struct cpufreq_policy *policy,
 
 /* translate the integer array into cpufreq_frequency_table entries */
 struct cpufreq_frequency_table *
-arm_bl_copy_table_from_array(unsigned int *table, int count)
+arm_bL_copy_table_from_array(unsigned int *table, int count)
 {
 	int i;
 
@@ -131,22 +131,22 @@ arm_bl_copy_table_from_array(unsigned int *table, int count)
 
 	return freq_table;
 }
-EXPORT_SYMBOL_GPL(arm_bl_copy_table_from_array);
+EXPORT_SYMBOL_GPL(arm_bL_copy_table_from_array);
 
-void arm_bl_free_freq_table(u32 cluster)
+void arm_bL_free_freq_table(u32 cluster)
 {
 	pr_debug("%s: free freq table\n", __func__);
 
 	kfree(freq_table[cluster]);
 }
-EXPORT_SYMBOL_GPL(arm_bl_free_freq_table);
+EXPORT_SYMBOL_GPL(arm_bL_free_freq_table);
 
 static void put_cluster_clk_and_freq_table(u32 cluster)
 {
 	if (!atomic_dec_return(&cluster_usage[cluster])) {
 		clk_put(clk[cluster]);
 		clk[cluster] = NULL;
-		arm_bl_ops->put_freq_tbl(cluster);
+		arm_bL_ops->put_freq_tbl(cluster);
 		freq_table[cluster] = NULL;
 		pr_debug("%s: cluster: %d\n", __func__, cluster);
 	}
@@ -160,7 +160,7 @@ static int get_cluster_clk_and_freq_table(u32 cluster)
 	if (atomic_inc_return(&cluster_usage[cluster]) != 1)
 		return 0;
 
-	freq_table[cluster] = arm_bl_ops->get_freq_tbl(cluster, &count);
+	freq_table[cluster] = arm_bL_ops->get_freq_tbl(cluster, &count);
 	if (!freq_table[cluster])
 		goto atomic_dec;
 
@@ -173,7 +173,7 @@ static int get_cluster_clk_and_freq_table(u32 cluster)
 		return 0;
 	}
 
-	arm_bl_ops->put_freq_tbl(cluster);
+	arm_bL_ops->put_freq_tbl(cluster);
 
 atomic_dec:
 	atomic_dec(&cluster_usage[cluster]);
@@ -182,7 +182,7 @@ atomic_dec:
 }
 
 /* Per-CPU initialization */
-static int bl_cpufreq_init(struct cpufreq_policy *policy)
+static int bL_cpufreq_init(struct cpufreq_policy *policy)
 {
 	u32 cur_cluster = cpu_to_cluster(policy->cpu);
 	int result;
@@ -203,7 +203,7 @@ static int bl_cpufreq_init(struct cpufreq_policy *policy)
 	cpufreq_frequency_table_get_attr(freq_table[cur_cluster], policy->cpu);
 
 	policy->cpuinfo.transition_latency = 1000000;	/* 1 ms assumed */
-	policy->cur = bl_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);
@@ -212,7 +212,7 @@ static int bl_cpufreq_init(struct cpufreq_policy *policy)
 	return 0;
 }
 
-static int bl_cpufreq_exit(struct cpufreq_policy *policy)
+static int bL_cpufreq_exit(struct cpufreq_policy *policy)
 {
 	put_cluster_clk_and_freq_table(cpu_to_cluster(policy->cpu));
 	pr_debug("%s: Exited, cpu: %d\n", __func__, policy->cpu);
@@ -221,44 +221,44 @@ static int bl_cpufreq_exit(struct cpufreq_policy *policy)
 }
 
 /* Export freq_table to sysfs */
-static struct freq_attr *bl_cpufreq_attr[] = {
+static struct freq_attr *bL_cpufreq_attr[] = {
 	&cpufreq_freq_attr_scaling_available_freqs,
 	NULL,
 };
 
-static struct cpufreq_driver bl_cpufreq_driver = {
+static struct cpufreq_driver bL_cpufreq_driver = {
 	.name	= "arm-big-little",
 	.flags	= CPUFREQ_STICKY,
-	.verify	= bl_cpufreq_verify_policy,
-	.target	= bl_cpufreq_set_target,
-	.get	= bl_cpufreq_get,
-	.init	= bl_cpufreq_init,
-	.exit	= bl_cpufreq_exit,
-	.attr	= bl_cpufreq_attr,
+	.verify	= bL_cpufreq_verify_policy,
+	.target	= bL_cpufreq_set_target,
+	.get	= bL_cpufreq_get,
+	.init	= bL_cpufreq_init,
+	.exit	= bL_cpufreq_exit,
+	.attr	= bL_cpufreq_attr,
 };
 
-int bl_cpufreq_register(struct cpufreq_arm_bl_ops *ops)
+int bL_cpufreq_register(struct cpufreq_arm_bL_ops *ops)
 {
 	int ret;
 
-	if (arm_bl_ops) {
+	if (arm_bL_ops) {
 		pr_debug("%s: Already registered: %s, exiting\n", __func__,
-				arm_bl_ops->name);
+				arm_bL_ops->name);
 		return -EBUSY;
 	}
 
 	if (!ops || !strlen(ops->name) || !ops->get_freq_tbl) {
-		pr_err("%s: Invalid arm_bl_ops, exiting\n", __func__);
+		pr_err("%s: Invalid arm_bL_ops, exiting\n", __func__);
 		return -ENODEV;
 	}
 
-	arm_bl_ops = ops;
+	arm_bL_ops = ops;
 
-	ret = cpufreq_register_driver(&bl_cpufreq_driver);
+	ret = cpufreq_register_driver(&bL_cpufreq_driver);
 	if (ret) {
 		pr_info("%s: Failed registering platform driver: %s, err: %d\n",
 				__func__, ops->name, ret);
-		arm_bl_ops = NULL;
+		arm_bL_ops = NULL;
 	} else {
 		pr_info("%s: Registered platform driver: %s\n", __func__,
 				ops->name);
@@ -266,18 +266,18 @@ int bl_cpufreq_register(struct cpufreq_arm_bl_ops *ops)
 
 	return ret;
 }
-EXPORT_SYMBOL_GPL(bl_cpufreq_register);
+EXPORT_SYMBOL_GPL(bL_cpufreq_register);
 
-void bl_cpufreq_unregister(struct cpufreq_arm_bl_ops *ops)
+void bL_cpufreq_unregister(struct cpufreq_arm_bL_ops *ops)
 {
-	if (arm_bl_ops != ops) {
+	if (arm_bL_ops != ops) {
 		pr_info("%s: Registered with: %s, can't unregister, exiting\n",
-				__func__, arm_bl_ops->name);
+				__func__, arm_bL_ops->name);
 	}
 
-	cpufreq_unregister_driver(&bl_cpufreq_driver);
+	cpufreq_unregister_driver(&bL_cpufreq_driver);
 	pr_info("%s: Un-registered platform driver: %s\n", __func__,
-			arm_bl_ops->name);
-	arm_bl_ops = NULL;
+			arm_bL_ops->name);
+	arm_bL_ops = NULL;
 }
-EXPORT_SYMBOL_GPL(bl_cpufreq_unregister);
+EXPORT_SYMBOL_GPL(bL_cpufreq_unregister);
diff --git a/drivers/cpufreq/arm_big_little.h b/drivers/cpufreq/arm_big_little.h
index 5b50fc72abc..6712a501198 100644
--- a/drivers/cpufreq/arm_big_little.h
+++ b/drivers/cpufreq/arm_big_little.h
@@ -22,17 +22,17 @@
 #include <linux/cpufreq.h>
 #include <linux/types.h>
 
-struct cpufreq_arm_bl_ops {
+struct cpufreq_arm_bL_ops {
 	char name[CPUFREQ_NAME_LEN];
 	struct cpufreq_frequency_table *(*get_freq_tbl)(u32 cluster, int *count);
 	void (*put_freq_tbl)(u32 cluster);
 };
 
 struct cpufreq_frequency_table *
-arm_bl_copy_table_from_array(unsigned int *table, int count);
-void arm_bl_free_freq_table(u32 cluster);
+arm_bL_copy_table_from_array(unsigned int *table, int count);
+void arm_bL_free_freq_table(u32 cluster);
 
-int bl_cpufreq_register(struct cpufreq_arm_bl_ops *ops);
-void bl_cpufreq_unregister(struct cpufreq_arm_bl_ops *ops);
+int bL_cpufreq_register(struct cpufreq_arm_bL_ops *ops);
+void bL_cpufreq_unregister(struct cpufreq_arm_bL_ops *ops);
 
 #endif /* CPUFREQ_ARM_BIG_LITTLE_H */
diff --git a/drivers/cpufreq/arm_dt_big_little.c b/drivers/cpufreq/arm_dt_big_little.c
index 2a41854bd4c..fabfb9c5c37 100644
--- a/drivers/cpufreq/arm_dt_big_little.c
+++ b/drivers/cpufreq/arm_dt_big_little.c
@@ -68,7 +68,7 @@ static struct cpufreq_frequency_table *generic_get_freq_tbl(u32 cluster,
 		return NULL;
 	}
 
-	cpufreq_table = arm_bl_copy_table_from_array(table, *count);
+	cpufreq_table = arm_bL_copy_table_from_array(table, *count);
 	kfree(table);
 
 	return cpufreq_table;
@@ -76,26 +76,26 @@ static struct cpufreq_frequency_table *generic_get_freq_tbl(u32 cluster,
 
 static void generic_put_freq_tbl(u32 cluster)
 {
-	arm_bl_free_freq_table(cluster);
+	arm_bL_free_freq_table(cluster);
 }
 
-static struct cpufreq_arm_bl_ops generic_bl_ops = {
+static struct cpufreq_arm_bL_ops generic_bL_ops = {
 	.name	= "generic-bl",
 	.get_freq_tbl = generic_get_freq_tbl,
 	.put_freq_tbl = generic_put_freq_tbl,
 };
 
-static int generic_bl_init(void)
+static int generic_bL_init(void)
 {
-	return bl_cpufreq_register(&generic_bl_ops);
+	return bL_cpufreq_register(&generic_bL_ops);
 }
-module_init(generic_bl_init);
+module_init(generic_bL_init);
 
-static void generic_bl_exit(void)
+static void generic_bL_exit(void)
 {
-	return bl_cpufreq_unregister(&generic_bl_ops);
+	return bL_cpufreq_unregister(&generic_bL_ops);
 }
-module_exit(generic_bl_exit);
+module_exit(generic_bL_exit);
 
 MODULE_DESCRIPTION("Generic ARM big LITTLE cpufreq driver");
 MODULE_LICENSE("GPL");
diff --git a/drivers/cpufreq/vexpress_big_little.c b/drivers/cpufreq/vexpress_big_little.c
index 81080b1f437..66648c3fc94 100644
--- a/drivers/cpufreq/vexpress_big_little.c
+++ b/drivers/cpufreq/vexpress_big_little.c
@@ -39,36 +39,36 @@ static struct cpufreq_frequency_table *vexpress_get_freq_tbl(u32 cluster,
 		return NULL;
 	}
 
-	return arm_bl_copy_table_from_array(table, *count);
+	return arm_bL_copy_table_from_array(table, *count);
 }
 
 static void vexpress_put_freq_tbl(u32 cluster)
 {
-	arm_bl_free_freq_table(cluster);
+	arm_bL_free_freq_table(cluster);
 }
 
-static struct cpufreq_arm_bl_ops vexpress_bl_ops = {
-	.name	= "vexpress-bl",
+static struct cpufreq_arm_bL_ops vexpress_bL_ops = {
+	.name	= "vexpress-bL",
 	.get_freq_tbl = vexpress_get_freq_tbl,
 	.put_freq_tbl = vexpress_put_freq_tbl,
 };
 
-static int vexpress_bl_init(void)
+static int vexpress_bL_init(void)
 {
 	if (!vexpress_spc_check_loaded()) {
 		pr_info("%s: No SPC found\n", __func__);
 		return -ENOENT;
 	}
 
-	return bl_cpufreq_register(&vexpress_bl_ops);
+	return bL_cpufreq_register(&vexpress_bL_ops);
 }
-module_init(vexpress_bl_init);
+module_init(vexpress_bL_init);
 
-static void vexpress_bl_exit(void)
+static void vexpress_bL_exit(void)
 {
-	return bl_cpufreq_unregister(&vexpress_bl_ops);
+	return bL_cpufreq_unregister(&vexpress_bL_ops);
 }
-module_exit(vexpress_bl_exit);
+module_exit(vexpress_bL_exit);
 
 MODULE_DESCRIPTION("ARM Vexpress big LITTLE cpufreq driver");
 MODULE_LICENSE("GPL");