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