1
2
3
4
5
6
7
8
9
10
11
12#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
13
14#include <linux/clk.h>
15#include <linux/cpu.h>
16#include <linux/cpu_cooling.h>
17#include <linux/cpufreq.h>
18#include <linux/cpufreq-dt.h>
19#include <linux/cpumask.h>
20#include <linux/err.h>
21#include <linux/module.h>
22#include <linux/of.h>
23#include <linux/pm_opp.h>
24#include <linux/platform_device.h>
25#include <linux/regulator/consumer.h>
26#include <linux/slab.h>
27#include <linux/thermal.h>
28
29struct private_data {
30 struct device *cpu_dev;
31 struct thermal_cooling_device *cdev;
32 const char *reg_name;
33};
34
35static struct freq_attr *cpufreq_dt_attr[] = {
36 &cpufreq_freq_attr_scaling_available_freqs,
37 NULL,
38 NULL,
39};
40
41static int set_target(struct cpufreq_policy *policy, unsigned int index)
42{
43 struct private_data *priv = policy->driver_data;
44
45 return dev_pm_opp_set_rate(priv->cpu_dev,
46 policy->freq_table[index].frequency * 1000);
47}
48
49
50
51
52
53static const char *find_supply_name(struct device *dev)
54{
55 struct device_node *np;
56 struct property *pp;
57 int cpu = dev->id;
58 const char *name = NULL;
59
60 np = of_node_get(dev->of_node);
61
62
63 if (WARN_ON(!np))
64 return NULL;
65
66
67 if (!cpu) {
68 pp = of_find_property(np, "cpu0-supply", NULL);
69 if (pp) {
70 name = "cpu0";
71 goto node_put;
72 }
73 }
74
75 pp = of_find_property(np, "cpu-supply", NULL);
76 if (pp) {
77 name = "cpu";
78 goto node_put;
79 }
80
81 dev_dbg(dev, "no regulator for cpu%d\n", cpu);
82node_put:
83 of_node_put(np);
84 return name;
85}
86
87static int resources_available(void)
88{
89 struct device *cpu_dev;
90 struct regulator *cpu_reg;
91 struct clk *cpu_clk;
92 int ret = 0;
93 const char *name;
94
95 cpu_dev = get_cpu_device(0);
96 if (!cpu_dev) {
97 pr_err("failed to get cpu0 device\n");
98 return -ENODEV;
99 }
100
101 cpu_clk = clk_get(cpu_dev, NULL);
102 ret = PTR_ERR_OR_ZERO(cpu_clk);
103 if (ret) {
104
105
106
107
108 if (ret == -EPROBE_DEFER)
109 dev_dbg(cpu_dev, "clock not ready, retry\n");
110 else
111 dev_err(cpu_dev, "failed to get clock: %d\n", ret);
112
113 return ret;
114 }
115
116 clk_put(cpu_clk);
117
118 name = find_supply_name(cpu_dev);
119
120 if (!name)
121 return 0;
122
123 cpu_reg = regulator_get_optional(cpu_dev, name);
124 ret = PTR_ERR_OR_ZERO(cpu_reg);
125 if (ret) {
126
127
128
129
130 if (ret == -EPROBE_DEFER)
131 dev_dbg(cpu_dev, "cpu0 regulator not ready, retry\n");
132 else
133 dev_dbg(cpu_dev, "no regulator for cpu0: %d\n", ret);
134
135 return ret;
136 }
137
138 regulator_put(cpu_reg);
139 return 0;
140}
141
142static int cpufreq_init(struct cpufreq_policy *policy)
143{
144 struct cpufreq_frequency_table *freq_table;
145 struct private_data *priv;
146 struct device *cpu_dev;
147 struct clk *cpu_clk;
148 struct dev_pm_opp *suspend_opp;
149 unsigned int transition_latency;
150 bool opp_v1 = false;
151 const char *name;
152 int ret;
153
154 cpu_dev = get_cpu_device(policy->cpu);
155 if (!cpu_dev) {
156 pr_err("failed to get cpu%d device\n", policy->cpu);
157 return -ENODEV;
158 }
159
160 cpu_clk = clk_get(cpu_dev, NULL);
161 if (IS_ERR(cpu_clk)) {
162 ret = PTR_ERR(cpu_clk);
163 dev_err(cpu_dev, "%s: failed to get clk: %d\n", __func__, ret);
164 return ret;
165 }
166
167
168 ret = dev_pm_opp_of_get_sharing_cpus(cpu_dev, policy->cpus);
169 if (ret) {
170
171
172
173
174 if (ret == -ENOENT)
175 opp_v1 = true;
176 else
177 goto out_put_clk;
178 }
179
180
181
182
183
184 name = find_supply_name(cpu_dev);
185 if (name) {
186 ret = dev_pm_opp_set_regulator(cpu_dev, name);
187 if (ret) {
188 dev_err(cpu_dev, "Failed to set regulator for cpu%d: %d\n",
189 policy->cpu, ret);
190 goto out_put_clk;
191 }
192 }
193
194
195
196
197
198
199
200
201
202
203
204 dev_pm_opp_of_cpumask_add_table(policy->cpus);
205
206
207
208
209
210 ret = dev_pm_opp_get_opp_count(cpu_dev);
211 if (ret <= 0) {
212 dev_dbg(cpu_dev, "OPP table is not ready, deferring probe\n");
213 ret = -EPROBE_DEFER;
214 goto out_free_opp;
215 }
216
217 if (opp_v1) {
218 struct cpufreq_dt_platform_data *pd = cpufreq_get_driver_data();
219
220 if (!pd || !pd->independent_clocks)
221 cpumask_setall(policy->cpus);
222
223
224
225
226
227 ret = dev_pm_opp_set_sharing_cpus(cpu_dev, policy->cpus);
228 if (ret)
229 dev_err(cpu_dev, "%s: failed to mark OPPs as shared: %d\n",
230 __func__, ret);
231 }
232
233 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
234 if (!priv) {
235 ret = -ENOMEM;
236 goto out_free_opp;
237 }
238
239 priv->reg_name = name;
240
241 ret = dev_pm_opp_init_cpufreq_table(cpu_dev, &freq_table);
242 if (ret) {
243 dev_err(cpu_dev, "failed to init cpufreq table: %d\n", ret);
244 goto out_free_priv;
245 }
246
247 priv->cpu_dev = cpu_dev;
248 policy->driver_data = priv;
249 policy->clk = cpu_clk;
250
251 rcu_read_lock();
252 suspend_opp = dev_pm_opp_get_suspend_opp(cpu_dev);
253 if (suspend_opp)
254 policy->suspend_freq = dev_pm_opp_get_freq(suspend_opp) / 1000;
255 rcu_read_unlock();
256
257 ret = cpufreq_table_validate_and_show(policy, freq_table);
258 if (ret) {
259 dev_err(cpu_dev, "%s: invalid frequency table: %d\n", __func__,
260 ret);
261 goto out_free_cpufreq_table;
262 }
263
264
265 if (policy_has_boost_freq(policy)) {
266
267 ret = cpufreq_enable_boost_support();
268 if (ret)
269 goto out_free_cpufreq_table;
270 cpufreq_dt_attr[1] = &cpufreq_freq_attr_scaling_boost_freqs;
271 }
272
273 transition_latency = dev_pm_opp_get_max_transition_latency(cpu_dev);
274 if (!transition_latency)
275 transition_latency = CPUFREQ_ETERNAL;
276
277 policy->cpuinfo.transition_latency = transition_latency;
278
279 return 0;
280
281out_free_cpufreq_table:
282 dev_pm_opp_free_cpufreq_table(cpu_dev, &freq_table);
283out_free_priv:
284 kfree(priv);
285out_free_opp:
286 dev_pm_opp_of_cpumask_remove_table(policy->cpus);
287 if (name)
288 dev_pm_opp_put_regulator(cpu_dev);
289out_put_clk:
290 clk_put(cpu_clk);
291
292 return ret;
293}
294
295static int cpufreq_exit(struct cpufreq_policy *policy)
296{
297 struct private_data *priv = policy->driver_data;
298
299 cpufreq_cooling_unregister(priv->cdev);
300 dev_pm_opp_free_cpufreq_table(priv->cpu_dev, &policy->freq_table);
301 dev_pm_opp_of_cpumask_remove_table(policy->related_cpus);
302 if (priv->reg_name)
303 dev_pm_opp_put_regulator(priv->cpu_dev);
304
305 clk_put(policy->clk);
306 kfree(priv);
307
308 return 0;
309}
310
311static void cpufreq_ready(struct cpufreq_policy *policy)
312{
313 struct private_data *priv = policy->driver_data;
314 struct device_node *np = of_node_get(priv->cpu_dev->of_node);
315
316 if (WARN_ON(!np))
317 return;
318
319
320
321
322
323 if (of_find_property(np, "#cooling-cells", NULL)) {
324 u32 power_coefficient = 0;
325
326 of_property_read_u32(np, "dynamic-power-coefficient",
327 &power_coefficient);
328
329 priv->cdev = of_cpufreq_power_cooling_register(np,
330 policy->related_cpus, power_coefficient, NULL);
331 if (IS_ERR(priv->cdev)) {
332 dev_err(priv->cpu_dev,
333 "running cpufreq without cooling device: %ld\n",
334 PTR_ERR(priv->cdev));
335
336 priv->cdev = NULL;
337 }
338 }
339
340 of_node_put(np);
341}
342
343static struct cpufreq_driver dt_cpufreq_driver = {
344 .flags = CPUFREQ_STICKY | CPUFREQ_NEED_INITIAL_FREQ_CHECK,
345 .verify = cpufreq_generic_frequency_table_verify,
346 .target_index = set_target,
347 .get = cpufreq_generic_get,
348 .init = cpufreq_init,
349 .exit = cpufreq_exit,
350 .ready = cpufreq_ready,
351 .name = "cpufreq-dt",
352 .attr = cpufreq_dt_attr,
353 .suspend = cpufreq_generic_suspend,
354};
355
356static int dt_cpufreq_probe(struct platform_device *pdev)
357{
358 int ret;
359
360
361
362
363
364
365
366
367 ret = resources_available();
368 if (ret)
369 return ret;
370
371 dt_cpufreq_driver.driver_data = dev_get_platdata(&pdev->dev);
372
373 ret = cpufreq_register_driver(&dt_cpufreq_driver);
374 if (ret)
375 dev_err(&pdev->dev, "failed register driver: %d\n", ret);
376
377 return ret;
378}
379
380static int dt_cpufreq_remove(struct platform_device *pdev)
381{
382 cpufreq_unregister_driver(&dt_cpufreq_driver);
383 return 0;
384}
385
386static struct platform_driver dt_cpufreq_platdrv = {
387 .driver = {
388 .name = "cpufreq-dt",
389 },
390 .probe = dt_cpufreq_probe,
391 .remove = dt_cpufreq_remove,
392};
393module_platform_driver(dt_cpufreq_platdrv);
394
395MODULE_ALIAS("platform:cpufreq-dt");
396MODULE_AUTHOR("Viresh Kumar <viresh.kumar@linaro.org>");
397MODULE_AUTHOR("Shawn Guo <shawn.guo@linaro.org>");
398MODULE_DESCRIPTION("Generic cpufreq driver");
399MODULE_LICENSE("GPL");
400