Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-only
2 : : /*
3 : : * Copyright (C) 2012 Freescale Semiconductor, Inc.
4 : : *
5 : : * Copyright (C) 2014 Linaro.
6 : : * Viresh Kumar <viresh.kumar@linaro.org>
7 : : */
8 : :
9 : : #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
10 : :
11 : : #include <linux/clk.h>
12 : : #include <linux/cpu.h>
13 : : #include <linux/cpufreq.h>
14 : : #include <linux/cpumask.h>
15 : : #include <linux/err.h>
16 : : #include <linux/module.h>
17 : : #include <linux/of.h>
18 : : #include <linux/pm_opp.h>
19 : : #include <linux/platform_device.h>
20 : : #include <linux/regulator/consumer.h>
21 : : #include <linux/slab.h>
22 : : #include <linux/thermal.h>
23 : :
24 : : #include "cpufreq-dt.h"
25 : :
26 : : struct private_data {
27 : : struct opp_table *opp_table;
28 : : struct device *cpu_dev;
29 : : const char *reg_name;
30 : : bool have_static_opps;
31 : : };
32 : :
33 : : static struct freq_attr *cpufreq_dt_attr[] = {
34 : : &cpufreq_freq_attr_scaling_available_freqs,
35 : : NULL, /* Extra space for boost-attr if required */
36 : : NULL,
37 : : };
38 : :
39 : 18170 : static int set_target(struct cpufreq_policy *policy, unsigned int index)
40 : : {
41 : 18170 : struct private_data *priv = policy->driver_data;
42 : 18170 : unsigned long freq = policy->freq_table[index].frequency;
43 : : int ret;
44 : :
45 : 18170 : ret = dev_pm_opp_set_rate(priv->cpu_dev, freq * 1000);
46 : :
47 [ + - ]: 18170 : if (!ret) {
48 : 36340 : arch_set_freq_scale(policy->related_cpus, freq,
49 : 18170 : policy->cpuinfo.max_freq);
50 : : }
51 : :
52 : 18170 : return ret;
53 : : }
54 : :
55 : : /*
56 : : * An earlier version of opp-v1 bindings used to name the regulator
57 : : * "cpu0-supply", we still need to handle that for backwards compatibility.
58 : : */
59 : 414 : static const char *find_supply_name(struct device *dev)
60 : : {
61 : : struct device_node *np;
62 : : struct property *pp;
63 : 414 : int cpu = dev->id;
64 : : const char *name = NULL;
65 : :
66 : 414 : np = of_node_get(dev->of_node);
67 : :
68 : : /* This must be valid for sure */
69 [ - + + - ]: 414 : if (WARN_ON(!np))
70 : : return NULL;
71 : :
72 : : /* Try "cpu0" for older DTs */
73 [ + - ]: 414 : if (!cpu) {
74 : 414 : pp = of_find_property(np, "cpu0-supply", NULL);
75 [ + - ]: 414 : if (pp) {
76 : : name = "cpu0";
77 : : goto node_put;
78 : : }
79 : : }
80 : :
81 : 414 : pp = of_find_property(np, "cpu-supply", NULL);
82 [ - + ]: 414 : if (pp) {
83 : : name = "cpu";
84 : 0 : goto node_put;
85 : : }
86 : :
87 : : dev_dbg(dev, "no regulator for cpu%d\n", cpu);
88 : : node_put:
89 : 414 : of_node_put(np);
90 : 414 : return name;
91 : : }
92 : :
93 : 207 : static int resources_available(void)
94 : : {
95 : : struct device *cpu_dev;
96 : : struct regulator *cpu_reg;
97 : : struct clk *cpu_clk;
98 : : int ret = 0;
99 : : const char *name;
100 : :
101 : 207 : cpu_dev = get_cpu_device(0);
102 [ - + ]: 207 : if (!cpu_dev) {
103 : 0 : pr_err("failed to get cpu0 device\n");
104 : 0 : return -ENODEV;
105 : : }
106 : :
107 : 207 : cpu_clk = clk_get(cpu_dev, NULL);
108 : : ret = PTR_ERR_OR_ZERO(cpu_clk);
109 [ - + ]: 207 : if (ret) {
110 : : /*
111 : : * If cpu's clk node is present, but clock is not yet
112 : : * registered, we should try defering probe.
113 : : */
114 [ # # ]: 0 : if (ret == -EPROBE_DEFER)
115 : : dev_dbg(cpu_dev, "clock not ready, retry\n");
116 : : else
117 : 0 : dev_err(cpu_dev, "failed to get clock: %d\n", ret);
118 : :
119 : 0 : return ret;
120 : : }
121 : :
122 : 207 : clk_put(cpu_clk);
123 : :
124 : 207 : name = find_supply_name(cpu_dev);
125 : : /* Platform doesn't require regulator */
126 [ - + ]: 207 : if (!name)
127 : : return 0;
128 : :
129 : 0 : cpu_reg = regulator_get_optional(cpu_dev, name);
130 : : ret = PTR_ERR_OR_ZERO(cpu_reg);
131 [ # # ]: 0 : if (ret) {
132 : : /*
133 : : * If cpu's regulator supply node is present, but regulator is
134 : : * not yet registered, we should try defering probe.
135 : : */
136 : : if (ret == -EPROBE_DEFER)
137 : : dev_dbg(cpu_dev, "cpu0 regulator not ready, retry\n");
138 : : else
139 : : dev_dbg(cpu_dev, "no regulator for cpu0: %d\n", ret);
140 : :
141 : : return ret;
142 : : }
143 : :
144 : 0 : regulator_put(cpu_reg);
145 : 0 : return 0;
146 : : }
147 : :
148 : 207 : static int cpufreq_init(struct cpufreq_policy *policy)
149 : : {
150 : : struct cpufreq_frequency_table *freq_table;
151 : : struct opp_table *opp_table = NULL;
152 : : struct private_data *priv;
153 : : struct device *cpu_dev;
154 : : struct clk *cpu_clk;
155 : : unsigned int transition_latency;
156 : : bool fallback = false;
157 : : const char *name;
158 : : int ret;
159 : :
160 : 207 : cpu_dev = get_cpu_device(policy->cpu);
161 [ - + ]: 207 : if (!cpu_dev) {
162 : 0 : pr_err("failed to get cpu%d device\n", policy->cpu);
163 : 0 : return -ENODEV;
164 : : }
165 : :
166 : 207 : cpu_clk = clk_get(cpu_dev, NULL);
167 [ - + ]: 207 : if (IS_ERR(cpu_clk)) {
168 : : ret = PTR_ERR(cpu_clk);
169 : 0 : dev_err(cpu_dev, "%s: failed to get clk: %d\n", __func__, ret);
170 : 0 : return ret;
171 : : }
172 : :
173 : : /* Get OPP-sharing information from "operating-points-v2" bindings */
174 : 207 : ret = dev_pm_opp_of_get_sharing_cpus(cpu_dev, policy->cpus);
175 [ + - ]: 207 : if (ret) {
176 [ + - ]: 207 : if (ret != -ENOENT)
177 : : goto out_put_clk;
178 : :
179 : : /*
180 : : * operating-points-v2 not supported, fallback to old method of
181 : : * finding shared-OPPs for backward compatibility if the
182 : : * platform hasn't set sharing CPUs.
183 : : */
184 [ + - ]: 207 : if (dev_pm_opp_get_sharing_cpus(cpu_dev, policy->cpus))
185 : : fallback = true;
186 : : }
187 : :
188 : : /*
189 : : * OPP layer will be taking care of regulators now, but it needs to know
190 : : * the name of the regulator first.
191 : : */
192 : 207 : name = find_supply_name(cpu_dev);
193 [ - + ]: 207 : if (name) {
194 : 0 : opp_table = dev_pm_opp_set_regulators(cpu_dev, &name, 1);
195 [ # # ]: 0 : if (IS_ERR(opp_table)) {
196 : : ret = PTR_ERR(opp_table);
197 : 0 : dev_err(cpu_dev, "Failed to set regulator for cpu%d: %d\n",
198 : : policy->cpu, ret);
199 : 0 : goto out_put_clk;
200 : : }
201 : : }
202 : :
203 : 207 : priv = kzalloc(sizeof(*priv), GFP_KERNEL);
204 [ + - ]: 207 : if (!priv) {
205 : : ret = -ENOMEM;
206 : : goto out_put_regulator;
207 : : }
208 : :
209 : 207 : priv->reg_name = name;
210 : 207 : priv->opp_table = opp_table;
211 : :
212 : : /*
213 : : * Initialize OPP tables for all policy->cpus. They will be shared by
214 : : * all CPUs which have marked their CPUs shared with OPP bindings.
215 : : *
216 : : * For platforms not using operating-points-v2 bindings, we do this
217 : : * before updating policy->cpus. Otherwise, we will end up creating
218 : : * duplicate OPPs for policy->cpus.
219 : : *
220 : : * OPPs might be populated at runtime, don't check for error here
221 : : */
222 [ - + ]: 207 : if (!dev_pm_opp_of_cpumask_add_table(policy->cpus))
223 : 0 : priv->have_static_opps = true;
224 : :
225 : : /*
226 : : * But we need OPP table to function so if it is not there let's
227 : : * give platform code chance to provide it for us.
228 : : */
229 : 207 : ret = dev_pm_opp_get_opp_count(cpu_dev);
230 [ + - ]: 207 : if (ret <= 0) {
231 : : dev_dbg(cpu_dev, "OPP table is not ready, deferring probe\n");
232 : : ret = -EPROBE_DEFER;
233 : : goto out_free_opp;
234 : : }
235 : :
236 [ + - ]: 207 : if (fallback) {
237 : : cpumask_setall(policy->cpus);
238 : :
239 : : /*
240 : : * OPP tables are initialized only for policy->cpu, do it for
241 : : * others as well.
242 : : */
243 : 207 : ret = dev_pm_opp_set_sharing_cpus(cpu_dev, policy->cpus);
244 [ - + ]: 207 : if (ret)
245 : 0 : dev_err(cpu_dev, "%s: failed to mark OPPs as shared: %d\n",
246 : : __func__, ret);
247 : : }
248 : :
249 : 207 : ret = dev_pm_opp_init_cpufreq_table(cpu_dev, &freq_table);
250 [ - + ]: 207 : if (ret) {
251 : 0 : dev_err(cpu_dev, "failed to init cpufreq table: %d\n", ret);
252 : 0 : goto out_free_opp;
253 : : }
254 : :
255 : 207 : priv->cpu_dev = cpu_dev;
256 : 207 : policy->driver_data = priv;
257 : 207 : policy->clk = cpu_clk;
258 : 207 : policy->freq_table = freq_table;
259 : :
260 : 207 : policy->suspend_freq = dev_pm_opp_get_suspend_opp_freq(cpu_dev) / 1000;
261 : :
262 : : /* Support turbo/boost mode */
263 [ - + ]: 207 : if (policy_has_boost_freq(policy)) {
264 : : /* This gets disabled by core on driver unregister */
265 : 0 : ret = cpufreq_enable_boost_support();
266 [ # # ]: 0 : if (ret)
267 : : goto out_free_cpufreq_table;
268 : 0 : cpufreq_dt_attr[1] = &cpufreq_freq_attr_scaling_boost_freqs;
269 : : }
270 : :
271 : 207 : transition_latency = dev_pm_opp_get_max_transition_latency(cpu_dev);
272 [ + - ]: 207 : if (!transition_latency)
273 : : transition_latency = CPUFREQ_ETERNAL;
274 : :
275 : 207 : policy->cpuinfo.transition_latency = transition_latency;
276 : 207 : policy->dvfs_possible_from_any_cpu = true;
277 : :
278 : 207 : dev_pm_opp_of_register_em(policy->cpus);
279 : :
280 : 207 : return 0;
281 : :
282 : : out_free_cpufreq_table:
283 : 0 : dev_pm_opp_free_cpufreq_table(cpu_dev, &freq_table);
284 : : out_free_opp:
285 [ # # ]: 0 : if (priv->have_static_opps)
286 : 0 : dev_pm_opp_of_cpumask_remove_table(policy->cpus);
287 : 0 : kfree(priv);
288 : : out_put_regulator:
289 [ # # ]: 0 : if (name)
290 : 0 : dev_pm_opp_put_regulators(opp_table);
291 : : out_put_clk:
292 : 0 : clk_put(cpu_clk);
293 : :
294 : 0 : return ret;
295 : : }
296 : :
297 : 0 : static int cpufreq_online(struct cpufreq_policy *policy)
298 : : {
299 : : /* We did light-weight tear down earlier, nothing to do here */
300 : 0 : return 0;
301 : : }
302 : :
303 : 0 : static int cpufreq_offline(struct cpufreq_policy *policy)
304 : : {
305 : : /*
306 : : * Preserve policy->driver_data and don't free resources on light-weight
307 : : * tear down.
308 : : */
309 : 0 : return 0;
310 : : }
311 : :
312 : 0 : static int cpufreq_exit(struct cpufreq_policy *policy)
313 : : {
314 : 0 : struct private_data *priv = policy->driver_data;
315 : :
316 : 0 : dev_pm_opp_free_cpufreq_table(priv->cpu_dev, &policy->freq_table);
317 [ # # ]: 0 : if (priv->have_static_opps)
318 : 0 : dev_pm_opp_of_cpumask_remove_table(policy->related_cpus);
319 [ # # ]: 0 : if (priv->reg_name)
320 : 0 : dev_pm_opp_put_regulators(priv->opp_table);
321 : :
322 : 0 : clk_put(policy->clk);
323 : 0 : kfree(priv);
324 : :
325 : 0 : return 0;
326 : : }
327 : :
328 : : static struct cpufreq_driver dt_cpufreq_driver = {
329 : : .flags = CPUFREQ_STICKY | CPUFREQ_NEED_INITIAL_FREQ_CHECK |
330 : : CPUFREQ_IS_COOLING_DEV,
331 : : .verify = cpufreq_generic_frequency_table_verify,
332 : : .target_index = set_target,
333 : : .get = cpufreq_generic_get,
334 : : .init = cpufreq_init,
335 : : .exit = cpufreq_exit,
336 : : .online = cpufreq_online,
337 : : .offline = cpufreq_offline,
338 : : .name = "cpufreq-dt",
339 : : .attr = cpufreq_dt_attr,
340 : : .suspend = cpufreq_generic_suspend,
341 : : };
342 : :
343 : 207 : static int dt_cpufreq_probe(struct platform_device *pdev)
344 : : {
345 : : struct cpufreq_dt_platform_data *data = dev_get_platdata(&pdev->dev);
346 : : int ret;
347 : :
348 : : /*
349 : : * All per-cluster (CPUs sharing clock/voltages) initialization is done
350 : : * from ->init(). In probe(), we just need to make sure that clk and
351 : : * regulators are available. Else defer probe and retry.
352 : : *
353 : : * FIXME: Is checking this only for CPU0 sufficient ?
354 : : */
355 : 207 : ret = resources_available();
356 [ + - ]: 207 : if (ret)
357 : : return ret;
358 : :
359 [ - + ]: 207 : if (data) {
360 [ # # ]: 0 : if (data->have_governor_per_policy)
361 : 0 : dt_cpufreq_driver.flags |= CPUFREQ_HAVE_GOVERNOR_PER_POLICY;
362 : :
363 : 0 : dt_cpufreq_driver.resume = data->resume;
364 [ # # ]: 0 : if (data->suspend)
365 : 0 : dt_cpufreq_driver.suspend = data->suspend;
366 : : }
367 : :
368 : 207 : ret = cpufreq_register_driver(&dt_cpufreq_driver);
369 [ - + ]: 207 : if (ret)
370 : 0 : dev_err(&pdev->dev, "failed register driver: %d\n", ret);
371 : :
372 : 207 : return ret;
373 : : }
374 : :
375 : 0 : static int dt_cpufreq_remove(struct platform_device *pdev)
376 : : {
377 : 0 : cpufreq_unregister_driver(&dt_cpufreq_driver);
378 : 0 : return 0;
379 : : }
380 : :
381 : : static struct platform_driver dt_cpufreq_platdrv = {
382 : : .driver = {
383 : : .name = "cpufreq-dt",
384 : : },
385 : : .probe = dt_cpufreq_probe,
386 : : .remove = dt_cpufreq_remove,
387 : : };
388 : 207 : module_platform_driver(dt_cpufreq_platdrv);
389 : :
390 : : MODULE_ALIAS("platform:cpufreq-dt");
391 : : MODULE_AUTHOR("Viresh Kumar <viresh.kumar@linaro.org>");
392 : : MODULE_AUTHOR("Shawn Guo <shawn.guo@linaro.org>");
393 : : MODULE_DESCRIPTION("Generic cpufreq driver");
394 : : MODULE_LICENSE("GPL");
|
