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 */
39 static struct freq_attr
*cpufreq_dt_attr
[] = {
40 &cpufreq_freq_attr_scaling_available_freqs
,
41 NULL
, /* Extra space for boost-attr if required */
45 static int set_target(struct cpufreq_policy
*policy
, unsigned int index
)
47 struct dev_pm_opp
*opp
;
48 struct cpufreq_frequency_table
*freq_table
= policy
->freq_table
;
49 struct clk
*cpu_clk
= policy
->clk
;
50 struct private_data
*priv
= policy
->driver_data
;
51 struct device
*cpu_dev
= priv
->cpu_dev
;
52 struct regulator
*cpu_reg
= priv
->cpu_reg
;
53 unsigned long volt
= 0, tol
= 0;
55 unsigned int old_freq
, new_freq
;
56 long freq_Hz
, freq_exact
;
59 freq_Hz
= clk_round_rate(cpu_clk
, freq_table
[index
].frequency
* 1000);
61 freq_Hz
= freq_table
[index
].frequency
* 1000;
64 new_freq
= freq_Hz
/ 1000;
65 old_freq
= clk_get_rate(cpu_clk
) / 1000;
67 if (!IS_ERR(cpu_reg
)) {
68 unsigned long opp_freq
;
71 opp
= dev_pm_opp_find_freq_ceil(cpu_dev
, &freq_Hz
);
74 dev_err(cpu_dev
, "failed to find OPP for %ld\n",
78 volt
= dev_pm_opp_get_voltage(opp
);
79 opp_freq
= dev_pm_opp_get_freq(opp
);
81 tol
= volt
* priv
->voltage_tolerance
/ 100;
82 volt_old
= regulator_get_voltage(cpu_reg
);
83 dev_dbg(cpu_dev
, "Found OPP: %ld kHz, %ld uV\n",
84 opp_freq
/ 1000, volt
);
87 dev_dbg(cpu_dev
, "%u MHz, %d mV --> %u MHz, %ld mV\n",
88 old_freq
/ 1000, (volt_old
> 0) ? volt_old
/ 1000 : -1,
89 new_freq
/ 1000, volt
? volt
/ 1000 : -1);
91 /* scaling up? scale voltage before frequency */
92 if (!IS_ERR(cpu_reg
) && new_freq
> old_freq
) {
93 ret
= regulator_set_voltage_tol(cpu_reg
, volt
, tol
);
95 dev_err(cpu_dev
, "failed to scale voltage up: %d\n",
101 ret
= clk_set_rate(cpu_clk
, freq_exact
);
103 dev_err(cpu_dev
, "failed to set clock rate: %d\n", ret
);
104 if (!IS_ERR(cpu_reg
) && volt_old
> 0)
105 regulator_set_voltage_tol(cpu_reg
, volt_old
, tol
);
109 /* scaling down? scale voltage after frequency */
110 if (!IS_ERR(cpu_reg
) && new_freq
< old_freq
) {
111 ret
= regulator_set_voltage_tol(cpu_reg
, volt
, tol
);
113 dev_err(cpu_dev
, "failed to scale voltage down: %d\n",
115 clk_set_rate(cpu_clk
, old_freq
* 1000);
122 static int allocate_resources(int cpu
, struct device
**cdev
,
123 struct regulator
**creg
, struct clk
**cclk
)
125 struct device
*cpu_dev
;
126 struct regulator
*cpu_reg
;
129 char *reg_cpu0
= "cpu0", *reg_cpu
= "cpu", *reg
;
131 cpu_dev
= get_cpu_device(cpu
);
133 pr_err("failed to get cpu%d device\n", cpu
);
137 /* Try "cpu0" for older DTs */
144 cpu_reg
= regulator_get_optional(cpu_dev
, reg
);
145 if (IS_ERR(cpu_reg
)) {
147 * If cpu's regulator supply node is present, but regulator is
148 * not yet registered, we should try defering probe.
150 if (PTR_ERR(cpu_reg
) == -EPROBE_DEFER
) {
151 dev_dbg(cpu_dev
, "cpu%d regulator not ready, retry\n",
153 return -EPROBE_DEFER
;
156 /* Try with "cpu-supply" */
157 if (reg
== reg_cpu0
) {
162 dev_dbg(cpu_dev
, "no regulator for cpu%d: %ld\n",
163 cpu
, PTR_ERR(cpu_reg
));
166 cpu_clk
= clk_get(cpu_dev
, NULL
);
167 if (IS_ERR(cpu_clk
)) {
169 if (!IS_ERR(cpu_reg
))
170 regulator_put(cpu_reg
);
172 ret
= PTR_ERR(cpu_clk
);
175 * If cpu's clk node is present, but clock is not yet
176 * registered, we should try defering probe.
178 if (ret
== -EPROBE_DEFER
)
179 dev_dbg(cpu_dev
, "cpu%d clock not ready, retry\n", cpu
);
181 dev_err(cpu_dev
, "failed to get cpu%d clock: %d\n", cpu
,
192 static int cpufreq_init(struct cpufreq_policy
*policy
)
194 struct cpufreq_frequency_table
*freq_table
;
195 struct device_node
*np
;
196 struct private_data
*priv
;
197 struct device
*cpu_dev
;
198 struct regulator
*cpu_reg
;
200 struct dev_pm_opp
*suspend_opp
;
201 unsigned long min_uV
= ~0, max_uV
= 0;
202 unsigned int transition_latency
;
203 bool need_update
= false;
206 ret
= allocate_resources(policy
->cpu
, &cpu_dev
, &cpu_reg
, &cpu_clk
);
208 pr_err("%s: Failed to allocate resources: %d\n", __func__
, ret
);
212 np
= of_node_get(cpu_dev
->of_node
);
214 dev_err(cpu_dev
, "failed to find cpu%d node\n", policy
->cpu
);
216 goto out_put_reg_clk
;
219 /* Get OPP-sharing information from "operating-points-v2" bindings */
220 ret
= dev_pm_opp_of_get_sharing_cpus(cpu_dev
, policy
->cpus
);
223 * operating-points-v2 not supported, fallback to old method of
224 * finding shared-OPPs for backward compatibility.
233 * Initialize OPP tables for all policy->cpus. They will be shared by
234 * all CPUs which have marked their CPUs shared with OPP bindings.
236 * For platforms not using operating-points-v2 bindings, we do this
237 * before updating policy->cpus. Otherwise, we will end up creating
238 * duplicate OPPs for policy->cpus.
240 * OPPs might be populated at runtime, don't check for error here
242 dev_pm_opp_of_cpumask_add_table(policy
->cpus
);
245 * But we need OPP table to function so if it is not there let's
246 * give platform code chance to provide it for us.
248 ret
= dev_pm_opp_get_opp_count(cpu_dev
);
250 pr_debug("OPP table is not ready, deferring probe\n");
256 struct cpufreq_dt_platform_data
*pd
= cpufreq_get_driver_data();
258 if (!pd
|| !pd
->independent_clocks
)
259 cpumask_setall(policy
->cpus
);
262 * OPP tables are initialized only for policy->cpu, do it for
265 ret
= dev_pm_opp_set_sharing_cpus(cpu_dev
, policy
->cpus
);
267 dev_err(cpu_dev
, "%s: failed to mark OPPs as shared: %d\n",
270 of_property_read_u32(np
, "clock-latency", &transition_latency
);
272 transition_latency
= dev_pm_opp_get_max_clock_latency(cpu_dev
);
275 priv
= kzalloc(sizeof(*priv
), GFP_KERNEL
);
281 of_property_read_u32(np
, "voltage-tolerance", &priv
->voltage_tolerance
);
283 if (!transition_latency
)
284 transition_latency
= CPUFREQ_ETERNAL
;
286 if (!IS_ERR(cpu_reg
)) {
287 unsigned long opp_freq
= 0;
290 * Disable any OPPs where the connected regulator isn't able to
291 * provide the specified voltage and record minimum and maximum
295 struct dev_pm_opp
*opp
;
296 unsigned long opp_uV
, tol_uV
;
299 opp
= dev_pm_opp_find_freq_ceil(cpu_dev
, &opp_freq
);
304 opp_uV
= dev_pm_opp_get_voltage(opp
);
307 tol_uV
= opp_uV
* priv
->voltage_tolerance
/ 100;
308 if (regulator_is_supported_voltage(cpu_reg
,
316 dev_pm_opp_disable(cpu_dev
, opp_freq
);
322 ret
= regulator_set_voltage_time(cpu_reg
, min_uV
, max_uV
);
324 transition_latency
+= ret
* 1000;
327 ret
= dev_pm_opp_init_cpufreq_table(cpu_dev
, &freq_table
);
329 pr_err("failed to init cpufreq table: %d\n", ret
);
333 priv
->cpu_dev
= cpu_dev
;
334 priv
->cpu_reg
= cpu_reg
;
335 policy
->driver_data
= priv
;
337 policy
->clk
= cpu_clk
;
340 suspend_opp
= dev_pm_opp_get_suspend_opp(cpu_dev
);
342 policy
->suspend_freq
= dev_pm_opp_get_freq(suspend_opp
) / 1000;
345 ret
= cpufreq_table_validate_and_show(policy
, freq_table
);
347 dev_err(cpu_dev
, "%s: invalid frequency table: %d\n", __func__
,
349 goto out_free_cpufreq_table
;
352 /* Support turbo/boost mode */
353 if (policy_has_boost_freq(policy
)) {
354 /* This gets disabled by core on driver unregister */
355 ret
= cpufreq_enable_boost_support();
357 goto out_free_cpufreq_table
;
358 cpufreq_dt_attr
[1] = &cpufreq_freq_attr_scaling_boost_freqs
;
361 policy
->cpuinfo
.transition_latency
= transition_latency
;
367 out_free_cpufreq_table
:
368 dev_pm_opp_free_cpufreq_table(cpu_dev
, &freq_table
);
372 dev_pm_opp_of_cpumask_remove_table(policy
->cpus
);
377 if (!IS_ERR(cpu_reg
))
378 regulator_put(cpu_reg
);
383 static int cpufreq_exit(struct cpufreq_policy
*policy
)
385 struct private_data
*priv
= policy
->driver_data
;
387 cpufreq_cooling_unregister(priv
->cdev
);
388 dev_pm_opp_free_cpufreq_table(priv
->cpu_dev
, &policy
->freq_table
);
389 dev_pm_opp_of_cpumask_remove_table(policy
->related_cpus
);
390 clk_put(policy
->clk
);
391 if (!IS_ERR(priv
->cpu_reg
))
392 regulator_put(priv
->cpu_reg
);
398 static void cpufreq_ready(struct cpufreq_policy
*policy
)
400 struct private_data
*priv
= policy
->driver_data
;
401 struct device_node
*np
= of_node_get(priv
->cpu_dev
->of_node
);
407 * For now, just loading the cooling device;
408 * thermal DT code takes care of matching them.
410 if (of_find_property(np
, "#cooling-cells", NULL
)) {
411 u32 power_coefficient
= 0;
413 of_property_read_u32(np
, "dynamic-power-coefficient",
416 priv
->cdev
= of_cpufreq_power_cooling_register(np
,
417 policy
->related_cpus
, power_coefficient
, NULL
);
418 if (IS_ERR(priv
->cdev
)) {
419 dev_err(priv
->cpu_dev
,
420 "running cpufreq without cooling device: %ld\n",
421 PTR_ERR(priv
->cdev
));
430 static struct cpufreq_driver dt_cpufreq_driver
= {
431 .flags
= CPUFREQ_STICKY
| CPUFREQ_NEED_INITIAL_FREQ_CHECK
,
432 .verify
= cpufreq_generic_frequency_table_verify
,
433 .target_index
= set_target
,
434 .get
= cpufreq_generic_get
,
435 .init
= cpufreq_init
,
436 .exit
= cpufreq_exit
,
437 .ready
= cpufreq_ready
,
438 .name
= "cpufreq-dt",
439 .attr
= cpufreq_dt_attr
,
440 .suspend
= cpufreq_generic_suspend
,
443 static int dt_cpufreq_probe(struct platform_device
*pdev
)
445 struct device
*cpu_dev
;
446 struct regulator
*cpu_reg
;
451 * All per-cluster (CPUs sharing clock/voltages) initialization is done
452 * from ->init(). In probe(), we just need to make sure that clk and
453 * regulators are available. Else defer probe and retry.
455 * FIXME: Is checking this only for CPU0 sufficient ?
457 ret
= allocate_resources(0, &cpu_dev
, &cpu_reg
, &cpu_clk
);
462 if (!IS_ERR(cpu_reg
))
463 regulator_put(cpu_reg
);
465 dt_cpufreq_driver
.driver_data
= dev_get_platdata(&pdev
->dev
);
467 ret
= cpufreq_register_driver(&dt_cpufreq_driver
);
469 dev_err(cpu_dev
, "failed register driver: %d\n", ret
);
474 static int dt_cpufreq_remove(struct platform_device
*pdev
)
476 cpufreq_unregister_driver(&dt_cpufreq_driver
);
480 static struct platform_driver dt_cpufreq_platdrv
= {
482 .name
= "cpufreq-dt",
484 .probe
= dt_cpufreq_probe
,
485 .remove
= dt_cpufreq_remove
,
487 module_platform_driver(dt_cpufreq_platdrv
);
489 MODULE_ALIAS("platform:cpufreq-dt");
490 MODULE_AUTHOR("Viresh Kumar <viresh.kumar@linaro.org>");
491 MODULE_AUTHOR("Shawn Guo <shawn.guo@linaro.org>");
492 MODULE_DESCRIPTION("Generic cpufreq driver");
493 MODULE_LICENSE("GPL");