2 * Copyright (C) 2012 Freescale Semiconductor, Inc.
4 * Copyright (C) 2014 Linaro.
5 * Viresh Kumar <viresh.kumar@linaro.org>
7 * The OPP code in function set_target() is reused from
8 * drivers/cpufreq/omap-cpufreq.c
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.
15 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
17 #include <linux/clk.h>
18 #include <linux/cpu.h>
19 #include <linux/cpu_cooling.h>
20 #include <linux/cpufreq.h>
21 #include <linux/cpufreq-dt.h>
22 #include <linux/cpumask.h>
23 #include <linux/err.h>
24 #include <linux/module.h>
26 #include <linux/pm_opp.h>
27 #include <linux/platform_device.h>
28 #include <linux/regulator/consumer.h>
29 #include <linux/slab.h>
30 #include <linux/thermal.h>
33 struct device
*cpu_dev
;
34 struct regulator
*cpu_reg
;
35 struct thermal_cooling_device
*cdev
;
36 unsigned int voltage_tolerance
; /* in percentage */
40 static struct freq_attr
*cpufreq_dt_attr
[] = {
41 &cpufreq_freq_attr_scaling_available_freqs
,
42 NULL
, /* Extra space for boost-attr if required */
46 static int set_target(struct cpufreq_policy
*policy
, unsigned int index
)
48 struct dev_pm_opp
*opp
;
49 struct cpufreq_frequency_table
*freq_table
= policy
->freq_table
;
50 struct clk
*cpu_clk
= policy
->clk
;
51 struct private_data
*priv
= policy
->driver_data
;
52 struct device
*cpu_dev
= priv
->cpu_dev
;
53 struct regulator
*cpu_reg
= priv
->cpu_reg
;
54 unsigned long volt
= 0, tol
= 0;
56 unsigned int old_freq
, new_freq
;
57 long freq_Hz
, freq_exact
;
60 freq_Hz
= clk_round_rate(cpu_clk
, freq_table
[index
].frequency
* 1000);
62 freq_Hz
= freq_table
[index
].frequency
* 1000;
65 new_freq
= freq_Hz
/ 1000;
66 old_freq
= clk_get_rate(cpu_clk
) / 1000;
68 if (!IS_ERR(cpu_reg
)) {
69 unsigned long opp_freq
;
72 opp
= dev_pm_opp_find_freq_ceil(cpu_dev
, &freq_Hz
);
75 dev_err(cpu_dev
, "failed to find OPP for %ld\n",
79 volt
= dev_pm_opp_get_voltage(opp
);
80 opp_freq
= dev_pm_opp_get_freq(opp
);
82 tol
= volt
* priv
->voltage_tolerance
/ 100;
83 volt_old
= regulator_get_voltage(cpu_reg
);
84 dev_dbg(cpu_dev
, "Found OPP: %ld kHz, %ld uV\n",
85 opp_freq
/ 1000, volt
);
88 dev_dbg(cpu_dev
, "%u MHz, %d mV --> %u MHz, %ld mV\n",
89 old_freq
/ 1000, (volt_old
> 0) ? volt_old
/ 1000 : -1,
90 new_freq
/ 1000, volt
? volt
/ 1000 : -1);
92 /* scaling up? scale voltage before frequency */
93 if (!IS_ERR(cpu_reg
) && new_freq
> old_freq
) {
94 ret
= regulator_set_voltage_tol(cpu_reg
, volt
, tol
);
96 dev_err(cpu_dev
, "failed to scale voltage up: %d\n",
102 ret
= clk_set_rate(cpu_clk
, freq_exact
);
104 dev_err(cpu_dev
, "failed to set clock rate: %d\n", ret
);
105 if (!IS_ERR(cpu_reg
) && volt_old
> 0)
106 regulator_set_voltage_tol(cpu_reg
, volt_old
, tol
);
110 /* scaling down? scale voltage after frequency */
111 if (!IS_ERR(cpu_reg
) && new_freq
< old_freq
) {
112 ret
= regulator_set_voltage_tol(cpu_reg
, volt
, tol
);
114 dev_err(cpu_dev
, "failed to scale voltage down: %d\n",
116 clk_set_rate(cpu_clk
, old_freq
* 1000);
124 * An earlier version of opp-v1 bindings used to name the regulator
125 * "cpu0-supply", we still need to handle that for backwards compatibility.
127 static const char *find_supply_name(struct device
*dev
, struct device_node
*np
)
132 /* Try "cpu0" for older DTs */
134 pp
= of_find_property(np
, "cpu0-supply", NULL
);
139 pp
= of_find_property(np
, "cpu-supply", NULL
);
143 dev_dbg(dev
, "no regulator for cpu%d\n", cpu
);
147 static int allocate_resources(int cpu
, struct device
**cdev
,
148 struct regulator
**creg
, struct clk
**cclk
)
150 struct device
*cpu_dev
;
151 struct regulator
*cpu_reg
;
154 char *reg_cpu0
= "cpu0", *reg_cpu
= "cpu", *reg
;
156 cpu_dev
= get_cpu_device(cpu
);
158 pr_err("failed to get cpu%d device\n", cpu
);
162 /* Try "cpu0" for older DTs */
169 cpu_reg
= regulator_get_optional(cpu_dev
, reg
);
170 ret
= PTR_ERR_OR_ZERO(cpu_reg
);
173 * If cpu's regulator supply node is present, but regulator is
174 * not yet registered, we should try defering probe.
176 if (ret
== -EPROBE_DEFER
) {
177 dev_dbg(cpu_dev
, "cpu%d regulator not ready, retry\n",
182 /* Try with "cpu-supply" */
183 if (reg
== reg_cpu0
) {
188 dev_dbg(cpu_dev
, "no regulator for cpu%d: %d\n", cpu
, ret
);
191 cpu_clk
= clk_get(cpu_dev
, NULL
);
192 ret
= PTR_ERR_OR_ZERO(cpu_clk
);
195 if (!IS_ERR(cpu_reg
))
196 regulator_put(cpu_reg
);
199 * If cpu's clk node is present, but clock is not yet
200 * registered, we should try defering probe.
202 if (ret
== -EPROBE_DEFER
)
203 dev_dbg(cpu_dev
, "cpu%d clock not ready, retry\n", cpu
);
205 dev_err(cpu_dev
, "failed to get cpu%d clock: %d\n", cpu
,
216 static int cpufreq_init(struct cpufreq_policy
*policy
)
218 struct cpufreq_frequency_table
*freq_table
;
219 struct device_node
*np
;
220 struct private_data
*priv
;
221 struct device
*cpu_dev
;
222 struct regulator
*cpu_reg
;
224 struct dev_pm_opp
*suspend_opp
;
225 unsigned long min_uV
= ~0, max_uV
= 0;
226 unsigned int transition_latency
;
231 ret
= allocate_resources(policy
->cpu
, &cpu_dev
, &cpu_reg
, &cpu_clk
);
233 pr_err("%s: Failed to allocate resources: %d\n", __func__
, ret
);
237 np
= of_node_get(cpu_dev
->of_node
);
239 dev_err(cpu_dev
, "failed to find cpu%d node\n", policy
->cpu
);
241 goto out_put_reg_clk
;
244 /* Get OPP-sharing information from "operating-points-v2" bindings */
245 ret
= dev_pm_opp_of_get_sharing_cpus(cpu_dev
, policy
->cpus
);
248 * operating-points-v2 not supported, fallback to old method of
249 * finding shared-OPPs for backward compatibility.
258 * OPP layer will be taking care of regulators now, but it needs to know
259 * the name of the regulator first.
261 name
= find_supply_name(cpu_dev
, np
);
263 ret
= dev_pm_opp_set_regulator(cpu_dev
, name
);
265 dev_err(cpu_dev
, "Failed to set regulator for cpu%d: %d\n",
272 * Initialize OPP tables for all policy->cpus. They will be shared by
273 * all CPUs which have marked their CPUs shared with OPP bindings.
275 * For platforms not using operating-points-v2 bindings, we do this
276 * before updating policy->cpus. Otherwise, we will end up creating
277 * duplicate OPPs for policy->cpus.
279 * OPPs might be populated at runtime, don't check for error here
281 dev_pm_opp_of_cpumask_add_table(policy
->cpus
);
284 * But we need OPP table to function so if it is not there let's
285 * give platform code chance to provide it for us.
287 ret
= dev_pm_opp_get_opp_count(cpu_dev
);
289 dev_dbg(cpu_dev
, "OPP table is not ready, deferring probe\n");
295 struct cpufreq_dt_platform_data
*pd
= cpufreq_get_driver_data();
297 if (!pd
|| !pd
->independent_clocks
)
298 cpumask_setall(policy
->cpus
);
301 * OPP tables are initialized only for policy->cpu, do it for
304 ret
= dev_pm_opp_set_sharing_cpus(cpu_dev
, policy
->cpus
);
306 dev_err(cpu_dev
, "%s: failed to mark OPPs as shared: %d\n",
310 priv
= kzalloc(sizeof(*priv
), GFP_KERNEL
);
316 priv
->reg_name
= name
;
317 of_property_read_u32(np
, "voltage-tolerance", &priv
->voltage_tolerance
);
319 transition_latency
= dev_pm_opp_get_max_clock_latency(cpu_dev
);
320 if (!transition_latency
)
321 transition_latency
= CPUFREQ_ETERNAL
;
323 if (!IS_ERR(cpu_reg
)) {
324 unsigned long opp_freq
= 0;
327 * Disable any OPPs where the connected regulator isn't able to
328 * provide the specified voltage and record minimum and maximum
332 struct dev_pm_opp
*opp
;
333 unsigned long opp_uV
, tol_uV
;
336 opp
= dev_pm_opp_find_freq_ceil(cpu_dev
, &opp_freq
);
341 opp_uV
= dev_pm_opp_get_voltage(opp
);
344 tol_uV
= opp_uV
* priv
->voltage_tolerance
/ 100;
345 if (regulator_is_supported_voltage(cpu_reg
,
357 ret
= regulator_set_voltage_time(cpu_reg
, min_uV
, max_uV
);
359 transition_latency
+= ret
* 1000;
362 ret
= dev_pm_opp_init_cpufreq_table(cpu_dev
, &freq_table
);
364 dev_err(cpu_dev
, "failed to init cpufreq table: %d\n", ret
);
368 priv
->cpu_dev
= cpu_dev
;
369 priv
->cpu_reg
= cpu_reg
;
370 policy
->driver_data
= priv
;
372 policy
->clk
= cpu_clk
;
375 suspend_opp
= dev_pm_opp_get_suspend_opp(cpu_dev
);
377 policy
->suspend_freq
= dev_pm_opp_get_freq(suspend_opp
) / 1000;
380 ret
= cpufreq_table_validate_and_show(policy
, freq_table
);
382 dev_err(cpu_dev
, "%s: invalid frequency table: %d\n", __func__
,
384 goto out_free_cpufreq_table
;
387 /* Support turbo/boost mode */
388 if (policy_has_boost_freq(policy
)) {
389 /* This gets disabled by core on driver unregister */
390 ret
= cpufreq_enable_boost_support();
392 goto out_free_cpufreq_table
;
393 cpufreq_dt_attr
[1] = &cpufreq_freq_attr_scaling_boost_freqs
;
396 policy
->cpuinfo
.transition_latency
= transition_latency
;
402 out_free_cpufreq_table
:
403 dev_pm_opp_free_cpufreq_table(cpu_dev
, &freq_table
);
407 dev_pm_opp_of_cpumask_remove_table(policy
->cpus
);
409 dev_pm_opp_put_regulator(cpu_dev
);
414 if (!IS_ERR(cpu_reg
))
415 regulator_put(cpu_reg
);
420 static int cpufreq_exit(struct cpufreq_policy
*policy
)
422 struct private_data
*priv
= policy
->driver_data
;
424 cpufreq_cooling_unregister(priv
->cdev
);
425 dev_pm_opp_free_cpufreq_table(priv
->cpu_dev
, &policy
->freq_table
);
426 dev_pm_opp_of_cpumask_remove_table(policy
->related_cpus
);
428 dev_pm_opp_put_regulator(priv
->cpu_dev
);
430 clk_put(policy
->clk
);
431 if (!IS_ERR(priv
->cpu_reg
))
432 regulator_put(priv
->cpu_reg
);
438 static void cpufreq_ready(struct cpufreq_policy
*policy
)
440 struct private_data
*priv
= policy
->driver_data
;
441 struct device_node
*np
= of_node_get(priv
->cpu_dev
->of_node
);
447 * For now, just loading the cooling device;
448 * thermal DT code takes care of matching them.
450 if (of_find_property(np
, "#cooling-cells", NULL
)) {
451 u32 power_coefficient
= 0;
453 of_property_read_u32(np
, "dynamic-power-coefficient",
456 priv
->cdev
= of_cpufreq_power_cooling_register(np
,
457 policy
->related_cpus
, power_coefficient
, NULL
);
458 if (IS_ERR(priv
->cdev
)) {
459 dev_err(priv
->cpu_dev
,
460 "running cpufreq without cooling device: %ld\n",
461 PTR_ERR(priv
->cdev
));
470 static struct cpufreq_driver dt_cpufreq_driver
= {
471 .flags
= CPUFREQ_STICKY
| CPUFREQ_NEED_INITIAL_FREQ_CHECK
,
472 .verify
= cpufreq_generic_frequency_table_verify
,
473 .target_index
= set_target
,
474 .get
= cpufreq_generic_get
,
475 .init
= cpufreq_init
,
476 .exit
= cpufreq_exit
,
477 .ready
= cpufreq_ready
,
478 .name
= "cpufreq-dt",
479 .attr
= cpufreq_dt_attr
,
480 .suspend
= cpufreq_generic_suspend
,
483 static int dt_cpufreq_probe(struct platform_device
*pdev
)
485 struct device
*cpu_dev
;
486 struct regulator
*cpu_reg
;
491 * All per-cluster (CPUs sharing clock/voltages) initialization is done
492 * from ->init(). In probe(), we just need to make sure that clk and
493 * regulators are available. Else defer probe and retry.
495 * FIXME: Is checking this only for CPU0 sufficient ?
497 ret
= allocate_resources(0, &cpu_dev
, &cpu_reg
, &cpu_clk
);
502 if (!IS_ERR(cpu_reg
))
503 regulator_put(cpu_reg
);
505 dt_cpufreq_driver
.driver_data
= dev_get_platdata(&pdev
->dev
);
507 ret
= cpufreq_register_driver(&dt_cpufreq_driver
);
509 dev_err(cpu_dev
, "failed register driver: %d\n", ret
);
514 static int dt_cpufreq_remove(struct platform_device
*pdev
)
516 cpufreq_unregister_driver(&dt_cpufreq_driver
);
520 static struct platform_driver dt_cpufreq_platdrv
= {
522 .name
= "cpufreq-dt",
524 .probe
= dt_cpufreq_probe
,
525 .remove
= dt_cpufreq_remove
,
527 module_platform_driver(dt_cpufreq_platdrv
);
529 MODULE_ALIAS("platform:cpufreq-dt");
530 MODULE_AUTHOR("Viresh Kumar <viresh.kumar@linaro.org>");
531 MODULE_AUTHOR("Shawn Guo <shawn.guo@linaro.org>");
532 MODULE_DESCRIPTION("Generic cpufreq driver");
533 MODULE_LICENSE("GPL");