2 * ARM big.LITTLE Platforms CPUFreq support
4 * Copyright (C) 2013 ARM Ltd.
5 * Sudeep KarkadaNagesha <sudeep.karkadanagesha@arm.com>
7 * Copyright (C) 2013 Linaro.
8 * Viresh Kumar <viresh.kumar@linaro.org>
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License version 2 as
12 * published by the Free Software Foundation.
14 * This program is distributed "as is" WITHOUT ANY WARRANTY of any
15 * kind, whether express or implied; without even the implied warranty
16 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
20 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
22 #include <linux/clk.h>
23 #include <linux/cpu.h>
24 #include <linux/cpufreq.h>
25 #include <linux/cpumask.h>
26 #include <linux/export.h>
27 #include <linux/module.h>
28 #include <linux/mutex.h>
29 #include <linux/of_platform.h>
30 #include <linux/pm_opp.h>
31 #include <linux/slab.h>
32 #include <linux/topology.h>
33 #include <linux/types.h>
34 #include <asm/bL_switcher.h>
36 #include "arm_big_little.h"
38 /* Currently we support only two clusters */
41 #define MAX_CLUSTERS 2
43 #ifdef CONFIG_BL_SWITCHER
44 static bool bL_switching_enabled
;
45 #define is_bL_switching_enabled() bL_switching_enabled
46 #define set_switching_enabled(x) (bL_switching_enabled = (x))
48 #define is_bL_switching_enabled() false
49 #define set_switching_enabled(x) do { } while (0)
52 #define ACTUAL_FREQ(cluster, freq) ((cluster == A7_CLUSTER) ? freq << 1 : freq)
53 #define VIRT_FREQ(cluster, freq) ((cluster == A7_CLUSTER) ? freq >> 1 : freq)
55 static struct cpufreq_arm_bL_ops
*arm_bL_ops
;
56 static struct clk
*clk
[MAX_CLUSTERS
];
57 static struct cpufreq_frequency_table
*freq_table
[MAX_CLUSTERS
+ 1];
58 static atomic_t cluster_usage
[MAX_CLUSTERS
+ 1];
60 static unsigned int clk_big_min
; /* (Big) clock frequencies */
61 static unsigned int clk_little_max
; /* Maximum clock frequency (Little) */
63 static DEFINE_PER_CPU(unsigned int, physical_cluster
);
64 static DEFINE_PER_CPU(unsigned int, cpu_last_req_freq
);
66 static struct mutex cluster_lock
[MAX_CLUSTERS
];
68 static inline int raw_cpu_to_cluster(int cpu
)
70 return topology_physical_package_id(cpu
);
73 static inline int cpu_to_cluster(int cpu
)
75 return is_bL_switching_enabled() ?
76 MAX_CLUSTERS
: raw_cpu_to_cluster(cpu
);
79 static unsigned int find_cluster_maxfreq(int cluster
)
82 u32 max_freq
= 0, cpu_freq
;
84 for_each_online_cpu(j
) {
85 cpu_freq
= per_cpu(cpu_last_req_freq
, j
);
87 if ((cluster
== per_cpu(physical_cluster
, j
)) &&
88 (max_freq
< cpu_freq
))
92 pr_debug("%s: cluster: %d, max freq: %d\n", __func__
, cluster
,
98 static unsigned int clk_get_cpu_rate(unsigned int cpu
)
100 u32 cur_cluster
= per_cpu(physical_cluster
, cpu
);
101 u32 rate
= clk_get_rate(clk
[cur_cluster
]) / 1000;
103 /* For switcher we use virtual A7 clock rates */
104 if (is_bL_switching_enabled())
105 rate
= VIRT_FREQ(cur_cluster
, rate
);
107 pr_debug("%s: cpu: %d, cluster: %d, freq: %u\n", __func__
, cpu
,
113 static unsigned int bL_cpufreq_get_rate(unsigned int cpu
)
115 if (is_bL_switching_enabled()) {
116 pr_debug("%s: freq: %d\n", __func__
, per_cpu(cpu_last_req_freq
,
119 return per_cpu(cpu_last_req_freq
, cpu
);
121 return clk_get_cpu_rate(cpu
);
126 bL_cpufreq_set_rate(u32 cpu
, u32 old_cluster
, u32 new_cluster
, u32 rate
)
128 u32 new_rate
, prev_rate
;
130 bool bLs
= is_bL_switching_enabled();
132 mutex_lock(&cluster_lock
[new_cluster
]);
135 prev_rate
= per_cpu(cpu_last_req_freq
, cpu
);
136 per_cpu(cpu_last_req_freq
, cpu
) = rate
;
137 per_cpu(physical_cluster
, cpu
) = new_cluster
;
139 new_rate
= find_cluster_maxfreq(new_cluster
);
140 new_rate
= ACTUAL_FREQ(new_cluster
, new_rate
);
145 pr_debug("%s: cpu: %d, old cluster: %d, new cluster: %d, freq: %d\n",
146 __func__
, cpu
, old_cluster
, new_cluster
, new_rate
);
148 ret
= clk_set_rate(clk
[new_cluster
], new_rate
* 1000);
150 pr_err("clk_set_rate failed: %d, new cluster: %d\n", ret
,
153 per_cpu(cpu_last_req_freq
, cpu
) = prev_rate
;
154 per_cpu(physical_cluster
, cpu
) = old_cluster
;
157 mutex_unlock(&cluster_lock
[new_cluster
]);
162 mutex_unlock(&cluster_lock
[new_cluster
]);
164 /* Recalc freq for old cluster when switching clusters */
165 if (old_cluster
!= new_cluster
) {
166 pr_debug("%s: cpu: %d, old cluster: %d, new cluster: %d\n",
167 __func__
, cpu
, old_cluster
, new_cluster
);
170 bL_switch_request(cpu
, new_cluster
);
172 mutex_lock(&cluster_lock
[old_cluster
]);
174 /* Set freq of old cluster if there are cpus left on it */
175 new_rate
= find_cluster_maxfreq(old_cluster
);
176 new_rate
= ACTUAL_FREQ(old_cluster
, new_rate
);
179 pr_debug("%s: Updating rate of old cluster: %d, to freq: %d\n",
180 __func__
, old_cluster
, new_rate
);
182 if (clk_set_rate(clk
[old_cluster
], new_rate
* 1000))
183 pr_err("%s: clk_set_rate failed: %d, old cluster: %d\n",
184 __func__
, ret
, old_cluster
);
186 mutex_unlock(&cluster_lock
[old_cluster
]);
192 /* Set clock frequency */
193 static int bL_cpufreq_set_target(struct cpufreq_policy
*policy
,
196 u32 cpu
= policy
->cpu
, cur_cluster
, new_cluster
, actual_cluster
;
197 unsigned int freqs_new
;
199 cur_cluster
= cpu_to_cluster(cpu
);
200 new_cluster
= actual_cluster
= per_cpu(physical_cluster
, cpu
);
202 freqs_new
= freq_table
[cur_cluster
][index
].frequency
;
204 if (is_bL_switching_enabled()) {
205 if ((actual_cluster
== A15_CLUSTER
) &&
206 (freqs_new
< clk_big_min
)) {
207 new_cluster
= A7_CLUSTER
;
208 } else if ((actual_cluster
== A7_CLUSTER
) &&
209 (freqs_new
> clk_little_max
)) {
210 new_cluster
= A15_CLUSTER
;
214 return bL_cpufreq_set_rate(cpu
, actual_cluster
, new_cluster
, freqs_new
);
217 static inline u32
get_table_count(struct cpufreq_frequency_table
*table
)
221 for (count
= 0; table
[count
].frequency
!= CPUFREQ_TABLE_END
; count
++)
227 /* get the minimum frequency in the cpufreq_frequency_table */
228 static inline u32
get_table_min(struct cpufreq_frequency_table
*table
)
230 struct cpufreq_frequency_table
*pos
;
231 uint32_t min_freq
= ~0;
232 cpufreq_for_each_entry(pos
, table
)
233 if (pos
->frequency
< min_freq
)
234 min_freq
= pos
->frequency
;
238 /* get the maximum frequency in the cpufreq_frequency_table */
239 static inline u32
get_table_max(struct cpufreq_frequency_table
*table
)
241 struct cpufreq_frequency_table
*pos
;
242 uint32_t max_freq
= 0;
243 cpufreq_for_each_entry(pos
, table
)
244 if (pos
->frequency
> max_freq
)
245 max_freq
= pos
->frequency
;
249 static int merge_cluster_tables(void)
251 int i
, j
, k
= 0, count
= 1;
252 struct cpufreq_frequency_table
*table
;
254 for (i
= 0; i
< MAX_CLUSTERS
; i
++)
255 count
+= get_table_count(freq_table
[i
]);
257 table
= kzalloc(sizeof(*table
) * count
, GFP_KERNEL
);
261 freq_table
[MAX_CLUSTERS
] = table
;
263 /* Add in reverse order to get freqs in increasing order */
264 for (i
= MAX_CLUSTERS
- 1; i
>= 0; i
--) {
265 for (j
= 0; freq_table
[i
][j
].frequency
!= CPUFREQ_TABLE_END
;
267 table
[k
].frequency
= VIRT_FREQ(i
,
268 freq_table
[i
][j
].frequency
);
269 pr_debug("%s: index: %d, freq: %d\n", __func__
, k
,
275 table
[k
].driver_data
= k
;
276 table
[k
].frequency
= CPUFREQ_TABLE_END
;
278 pr_debug("%s: End, table: %p, count: %d\n", __func__
, table
, k
);
283 static void _put_cluster_clk_and_freq_table(struct device
*cpu_dev
)
285 u32 cluster
= raw_cpu_to_cluster(cpu_dev
->id
);
287 if (!freq_table
[cluster
])
290 clk_put(clk
[cluster
]);
291 dev_pm_opp_free_cpufreq_table(cpu_dev
, &freq_table
[cluster
]);
292 dev_dbg(cpu_dev
, "%s: cluster: %d\n", __func__
, cluster
);
295 static void put_cluster_clk_and_freq_table(struct device
*cpu_dev
)
297 u32 cluster
= cpu_to_cluster(cpu_dev
->id
);
300 if (atomic_dec_return(&cluster_usage
[cluster
]))
303 if (cluster
< MAX_CLUSTERS
)
304 return _put_cluster_clk_and_freq_table(cpu_dev
);
306 for_each_present_cpu(i
) {
307 struct device
*cdev
= get_cpu_device(i
);
309 pr_err("%s: failed to get cpu%d device\n", __func__
, i
);
313 _put_cluster_clk_and_freq_table(cdev
);
316 /* free virtual table */
317 kfree(freq_table
[cluster
]);
320 static int _get_cluster_clk_and_freq_table(struct device
*cpu_dev
)
322 u32 cluster
= raw_cpu_to_cluster(cpu_dev
->id
);
323 char name
[14] = "cpu-cluster.";
326 if (freq_table
[cluster
])
329 ret
= arm_bL_ops
->init_opp_table(cpu_dev
);
331 dev_err(cpu_dev
, "%s: init_opp_table failed, cpu: %d, err: %d\n",
332 __func__
, cpu_dev
->id
, ret
);
336 ret
= dev_pm_opp_init_cpufreq_table(cpu_dev
, &freq_table
[cluster
]);
338 dev_err(cpu_dev
, "%s: failed to init cpufreq table, cpu: %d, err: %d\n",
339 __func__
, cpu_dev
->id
, ret
);
343 name
[12] = cluster
+ '0';
344 clk
[cluster
] = clk_get(cpu_dev
, name
);
345 if (!IS_ERR(clk
[cluster
])) {
346 dev_dbg(cpu_dev
, "%s: clk: %p & freq table: %p, cluster: %d\n",
347 __func__
, clk
[cluster
], freq_table
[cluster
],
352 dev_err(cpu_dev
, "%s: Failed to get clk for cpu: %d, cluster: %d\n",
353 __func__
, cpu_dev
->id
, cluster
);
354 ret
= PTR_ERR(clk
[cluster
]);
355 dev_pm_opp_free_cpufreq_table(cpu_dev
, &freq_table
[cluster
]);
358 dev_err(cpu_dev
, "%s: Failed to get data for cluster: %d\n", __func__
,
363 static int get_cluster_clk_and_freq_table(struct device
*cpu_dev
)
365 u32 cluster
= cpu_to_cluster(cpu_dev
->id
);
368 if (atomic_inc_return(&cluster_usage
[cluster
]) != 1)
371 if (cluster
< MAX_CLUSTERS
) {
372 ret
= _get_cluster_clk_and_freq_table(cpu_dev
);
374 atomic_dec(&cluster_usage
[cluster
]);
379 * Get data for all clusters and fill virtual cluster with a merge of
382 for_each_present_cpu(i
) {
383 struct device
*cdev
= get_cpu_device(i
);
385 pr_err("%s: failed to get cpu%d device\n", __func__
, i
);
389 ret
= _get_cluster_clk_and_freq_table(cdev
);
394 ret
= merge_cluster_tables();
398 /* Assuming 2 cluster, set clk_big_min and clk_little_max */
399 clk_big_min
= get_table_min(freq_table
[0]);
400 clk_little_max
= VIRT_FREQ(1, get_table_max(freq_table
[1]));
402 pr_debug("%s: cluster: %d, clk_big_min: %d, clk_little_max: %d\n",
403 __func__
, cluster
, clk_big_min
, clk_little_max
);
408 for_each_present_cpu(i
) {
409 struct device
*cdev
= get_cpu_device(i
);
411 pr_err("%s: failed to get cpu%d device\n", __func__
, i
);
415 _put_cluster_clk_and_freq_table(cdev
);
418 atomic_dec(&cluster_usage
[cluster
]);
423 /* Per-CPU initialization */
424 static int bL_cpufreq_init(struct cpufreq_policy
*policy
)
426 u32 cur_cluster
= cpu_to_cluster(policy
->cpu
);
427 struct device
*cpu_dev
;
430 cpu_dev
= get_cpu_device(policy
->cpu
);
432 pr_err("%s: failed to get cpu%d device\n", __func__
,
437 ret
= get_cluster_clk_and_freq_table(cpu_dev
);
441 ret
= cpufreq_table_validate_and_show(policy
, freq_table
[cur_cluster
]);
443 dev_err(cpu_dev
, "CPU %d, cluster: %d invalid freq table\n",
444 policy
->cpu
, cur_cluster
);
445 put_cluster_clk_and_freq_table(cpu_dev
);
449 if (cur_cluster
< MAX_CLUSTERS
) {
452 cpumask_copy(policy
->cpus
, topology_core_cpumask(policy
->cpu
));
454 for_each_cpu(cpu
, policy
->cpus
)
455 per_cpu(physical_cluster
, cpu
) = cur_cluster
;
457 /* Assumption: during init, we are always running on A15 */
458 per_cpu(physical_cluster
, policy
->cpu
) = A15_CLUSTER
;
461 if (arm_bL_ops
->get_transition_latency
)
462 policy
->cpuinfo
.transition_latency
=
463 arm_bL_ops
->get_transition_latency(cpu_dev
);
465 policy
->cpuinfo
.transition_latency
= CPUFREQ_ETERNAL
;
467 if (is_bL_switching_enabled())
468 per_cpu(cpu_last_req_freq
, policy
->cpu
) = clk_get_cpu_rate(policy
->cpu
);
470 dev_info(cpu_dev
, "%s: CPU %d initialized\n", __func__
, policy
->cpu
);
474 static int bL_cpufreq_exit(struct cpufreq_policy
*policy
)
476 struct device
*cpu_dev
;
478 cpu_dev
= get_cpu_device(policy
->cpu
);
480 pr_err("%s: failed to get cpu%d device\n", __func__
,
485 put_cluster_clk_and_freq_table(cpu_dev
);
486 dev_dbg(cpu_dev
, "%s: Exited, cpu: %d\n", __func__
, policy
->cpu
);
491 static struct cpufreq_driver bL_cpufreq_driver
= {
492 .name
= "arm-big-little",
493 .flags
= CPUFREQ_STICKY
|
494 CPUFREQ_HAVE_GOVERNOR_PER_POLICY
|
495 CPUFREQ_NEED_INITIAL_FREQ_CHECK
,
496 .verify
= cpufreq_generic_frequency_table_verify
,
497 .target_index
= bL_cpufreq_set_target
,
498 .get
= bL_cpufreq_get_rate
,
499 .init
= bL_cpufreq_init
,
500 .exit
= bL_cpufreq_exit
,
501 .attr
= cpufreq_generic_attr
,
504 static int bL_cpufreq_switcher_notifier(struct notifier_block
*nfb
,
505 unsigned long action
, void *_arg
)
507 pr_debug("%s: action: %ld\n", __func__
, action
);
510 case BL_NOTIFY_PRE_ENABLE
:
511 case BL_NOTIFY_PRE_DISABLE
:
512 cpufreq_unregister_driver(&bL_cpufreq_driver
);
515 case BL_NOTIFY_POST_ENABLE
:
516 set_switching_enabled(true);
517 cpufreq_register_driver(&bL_cpufreq_driver
);
520 case BL_NOTIFY_POST_DISABLE
:
521 set_switching_enabled(false);
522 cpufreq_register_driver(&bL_cpufreq_driver
);
532 static struct notifier_block bL_switcher_notifier
= {
533 .notifier_call
= bL_cpufreq_switcher_notifier
,
536 int bL_cpufreq_register(struct cpufreq_arm_bL_ops
*ops
)
541 pr_debug("%s: Already registered: %s, exiting\n", __func__
,
546 if (!ops
|| !strlen(ops
->name
) || !ops
->init_opp_table
) {
547 pr_err("%s: Invalid arm_bL_ops, exiting\n", __func__
);
553 ret
= bL_switcher_get_enabled();
554 set_switching_enabled(ret
);
556 for (i
= 0; i
< MAX_CLUSTERS
; i
++)
557 mutex_init(&cluster_lock
[i
]);
559 ret
= cpufreq_register_driver(&bL_cpufreq_driver
);
561 pr_info("%s: Failed registering platform driver: %s, err: %d\n",
562 __func__
, ops
->name
, ret
);
565 ret
= bL_switcher_register_notifier(&bL_switcher_notifier
);
567 cpufreq_unregister_driver(&bL_cpufreq_driver
);
570 pr_info("%s: Registered platform driver: %s\n",
571 __func__
, ops
->name
);
575 bL_switcher_put_enabled();
578 EXPORT_SYMBOL_GPL(bL_cpufreq_register
);
580 void bL_cpufreq_unregister(struct cpufreq_arm_bL_ops
*ops
)
582 if (arm_bL_ops
!= ops
) {
583 pr_err("%s: Registered with: %s, can't unregister, exiting\n",
584 __func__
, arm_bL_ops
->name
);
588 bL_switcher_get_enabled();
589 bL_switcher_unregister_notifier(&bL_switcher_notifier
);
590 cpufreq_unregister_driver(&bL_cpufreq_driver
);
591 bL_switcher_put_enabled();
592 pr_info("%s: Un-registered platform driver: %s\n", __func__
,
596 EXPORT_SYMBOL_GPL(bL_cpufreq_unregister
);
598 MODULE_AUTHOR("Viresh Kumar <viresh.kumar@linaro.org>");
599 MODULE_DESCRIPTION("Generic ARM big LITTLE cpufreq driver");
600 MODULE_LICENSE("GPL v2");