1 /*-
2 * Copyright (c) 2018 Emmanuel Vadot <[email protected]>
3 * Copyright (c) 2016 Jared McNeill <[email protected]>
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
20 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
21 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
22 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
23 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25 * SUCH DAMAGE.
26 *
27 * $FreeBSD$
28 */
29
30 /*
31 * Generic DT based cpufreq driver
32 */
33
34 #include <sys/cdefs.h>
35 __FBSDID("$FreeBSD$");
36
37 #include <sys/param.h>
38 #include <sys/systm.h>
39 #include <sys/bus.h>
40 #include <sys/rman.h>
41 #include <sys/kernel.h>
42 #include <sys/module.h>
43 #include <sys/cpu.h>
44 #include <sys/cpuset.h>
45 #include <sys/smp.h>
46
47 #include <dev/ofw/ofw_bus.h>
48 #include <dev/ofw/ofw_bus_subr.h>
49
50 #include <dev/extres/clk/clk.h>
51 #include <dev/extres/regulator/regulator.h>
52
53 #include "cpufreq_if.h"
54
55 #if 0
56 #define DEBUG(dev, msg...) device_printf(dev, "cpufreq_dt: " msg);
57 #else
58 #define DEBUG(dev, msg...)
59 #endif
60
61 enum opp_version {
62 OPP_V1 = 1,
63 OPP_V2,
64 };
65
66 struct cpufreq_dt_opp {
67 uint64_t freq;
68 uint32_t uvolt_target;
69 uint32_t uvolt_min;
70 uint32_t uvolt_max;
71 uint32_t uamps;
72 uint32_t clk_latency;
73 bool turbo_mode;
74 bool opp_suspend;
75 };
76
77 struct cpufreq_dt_softc {
78 device_t dev;
79 clk_t clk;
80 regulator_t reg;
81
82 struct cpufreq_dt_opp *opp;
83 ssize_t nopp;
84
85 cpuset_t cpus;
86 };
87
88 static void
cpufreq_dt_notify(device_t dev,uint64_t freq)89 cpufreq_dt_notify(device_t dev, uint64_t freq)
90 {
91 struct cpufreq_dt_softc *sc;
92 struct pcpu *pc;
93 int cpu;
94
95 sc = device_get_softc(dev);
96
97 CPU_FOREACH(cpu) {
98 if (CPU_ISSET(cpu, &sc->cpus)) {
99 pc = pcpu_find(cpu);
100 pc->pc_clock = freq;
101 }
102 }
103 }
104
105 static const struct cpufreq_dt_opp *
cpufreq_dt_find_opp(device_t dev,uint64_t freq)106 cpufreq_dt_find_opp(device_t dev, uint64_t freq)
107 {
108 struct cpufreq_dt_softc *sc;
109 ssize_t n;
110
111 sc = device_get_softc(dev);
112
113 DEBUG(dev, "Looking for freq %ju\n", freq);
114 for (n = 0; n < sc->nopp; n++)
115 if (CPUFREQ_CMP(sc->opp[n].freq, freq))
116 return (&sc->opp[n]);
117
118 DEBUG(dev, "Couldn't find one\n");
119 return (NULL);
120 }
121
122 static void
cpufreq_dt_opp_to_setting(device_t dev,const struct cpufreq_dt_opp * opp,struct cf_setting * set)123 cpufreq_dt_opp_to_setting(device_t dev, const struct cpufreq_dt_opp *opp,
124 struct cf_setting *set)
125 {
126 struct cpufreq_dt_softc *sc;
127
128 sc = device_get_softc(dev);
129
130 memset(set, 0, sizeof(*set));
131 set->freq = opp->freq / 1000000;
132 set->volts = opp->uvolt_target / 1000;
133 set->power = CPUFREQ_VAL_UNKNOWN;
134 set->lat = opp->clk_latency;
135 set->dev = dev;
136 }
137
138 static int
cpufreq_dt_get(device_t dev,struct cf_setting * set)139 cpufreq_dt_get(device_t dev, struct cf_setting *set)
140 {
141 struct cpufreq_dt_softc *sc;
142 const struct cpufreq_dt_opp *opp;
143 uint64_t freq;
144
145 sc = device_get_softc(dev);
146
147 DEBUG(dev, "cpufreq_dt_get\n");
148 if (clk_get_freq(sc->clk, &freq) != 0)
149 return (ENXIO);
150
151 opp = cpufreq_dt_find_opp(dev, freq);
152 if (opp == NULL) {
153 device_printf(dev, "Can't find the current freq in opp\n");
154 return (ENOENT);
155 }
156
157 cpufreq_dt_opp_to_setting(dev, opp, set);
158
159 DEBUG(dev, "Current freq %dMhz\n", set->freq);
160 return (0);
161 }
162
163 static int
cpufreq_dt_set(device_t dev,const struct cf_setting * set)164 cpufreq_dt_set(device_t dev, const struct cf_setting *set)
165 {
166 struct cpufreq_dt_softc *sc;
167 const struct cpufreq_dt_opp *opp, *copp;
168 uint64_t freq;
169 int uvolt, error;
170
171 sc = device_get_softc(dev);
172
173 if (clk_get_freq(sc->clk, &freq) != 0) {
174 device_printf(dev, "Can't get current clk freq\n");
175 return (ENXIO);
176 }
177 /* Try to get current valtage by using regulator first. */
178 error = regulator_get_voltage(sc->reg, &uvolt);
179 if (error != 0) {
180 /*
181 * Try oppoints table as backup way. However,
182 * this is insufficient because the actual processor
183 * frequency may not be in the table. PLL frequency
184 * granularity can be different that granularity of
185 * oppoint table.
186 */
187 copp = cpufreq_dt_find_opp(sc->dev, freq);
188 if (copp == NULL) {
189 device_printf(dev,
190 "Can't find the current freq in opp\n");
191 return (ENOENT);
192 }
193 uvolt = copp->uvolt_target;
194
195 }
196
197 opp = cpufreq_dt_find_opp(sc->dev, set->freq * 1000000);
198 if (opp == NULL) {
199 device_printf(dev, "Couldn't find an opp for this freq\n");
200 return (EINVAL);
201 }
202 DEBUG(sc->dev, "Current freq %ju, uvolt: %d\n", freq, uvolt);
203 DEBUG(sc->dev, "Target freq %ju, , uvolt: %d\n",
204 opp->freq, opp->uvolt_target);
205
206 if (uvolt < opp->uvolt_target) {
207 DEBUG(dev, "Changing regulator from %u to %u\n",
208 uvolt, opp->uvolt_target);
209 error = regulator_set_voltage(sc->reg,
210 opp->uvolt_min,
211 opp->uvolt_max);
212 if (error != 0) {
213 DEBUG(dev, "Failed, backout\n");
214 return (ENXIO);
215 }
216 }
217
218 DEBUG(dev, "Setting clk to %ju\n", opp->freq);
219 error = clk_set_freq(sc->clk, opp->freq, CLK_SET_ROUND_DOWN);
220 if (error != 0) {
221 DEBUG(dev, "Failed, backout\n");
222 /* Restore previous voltage (best effort) */
223 error = regulator_set_voltage(sc->reg,
224 copp->uvolt_min,
225 copp->uvolt_max);
226 return (ENXIO);
227 }
228
229 if (uvolt > opp->uvolt_target) {
230 DEBUG(dev, "Changing regulator from %u to %u\n",
231 uvolt, opp->uvolt_target);
232 error = regulator_set_voltage(sc->reg,
233 opp->uvolt_min,
234 opp->uvolt_max);
235 if (error != 0) {
236 DEBUG(dev, "Failed to switch regulator to %d\n",
237 opp->uvolt_target);
238 /* Restore previous CPU frequency (best effort) */
239 (void)clk_set_freq(sc->clk, copp->freq, 0);
240 return (ENXIO);
241 }
242 }
243
244 if (clk_get_freq(sc->clk, &freq) == 0)
245 cpufreq_dt_notify(dev, freq);
246
247 return (0);
248 }
249
250
251 static int
cpufreq_dt_type(device_t dev,int * type)252 cpufreq_dt_type(device_t dev, int *type)
253 {
254 if (type == NULL)
255 return (EINVAL);
256
257 *type = CPUFREQ_TYPE_ABSOLUTE;
258 return (0);
259 }
260
261 static int
cpufreq_dt_settings(device_t dev,struct cf_setting * sets,int * count)262 cpufreq_dt_settings(device_t dev, struct cf_setting *sets, int *count)
263 {
264 struct cpufreq_dt_softc *sc;
265 ssize_t n;
266
267 DEBUG(dev, "cpufreq_dt_settings\n");
268 if (sets == NULL || count == NULL)
269 return (EINVAL);
270
271 sc = device_get_softc(dev);
272
273 if (*count < sc->nopp) {
274 *count = (int)sc->nopp;
275 return (E2BIG);
276 }
277
278 for (n = 0; n < sc->nopp; n++)
279 cpufreq_dt_opp_to_setting(dev, &sc->opp[n], &sets[n]);
280
281 *count = (int)sc->nopp;
282
283 return (0);
284 }
285
286 static void
cpufreq_dt_identify(driver_t * driver,device_t parent)287 cpufreq_dt_identify(driver_t *driver, device_t parent)
288 {
289 phandle_t node;
290
291 /* Properties must be listed under node /cpus/cpu@0 */
292 node = ofw_bus_get_node(parent);
293
294 /* The cpu@0 node must have the following properties */
295 if (!OF_hasprop(node, "clocks") ||
296 (!OF_hasprop(node, "cpu-supply") &&
297 !OF_hasprop(node, "cpu0-supply")))
298 return;
299
300 if (!OF_hasprop(node, "operating-points") &&
301 !OF_hasprop(node, "operating-points-v2"))
302 return;
303
304 if (device_find_child(parent, "cpufreq_dt", -1) != NULL)
305 return;
306
307 if (BUS_ADD_CHILD(parent, 0, "cpufreq_dt", -1) == NULL)
308 device_printf(parent, "add cpufreq_dt child failed\n");
309 }
310
311 static int
cpufreq_dt_probe(device_t dev)312 cpufreq_dt_probe(device_t dev)
313 {
314 phandle_t node;
315
316 node = ofw_bus_get_node(device_get_parent(dev));
317
318 if (!OF_hasprop(node, "clocks") ||
319 (!OF_hasprop(node, "cpu-supply") &&
320 !OF_hasprop(node, "cpu0-supply")))
321
322 return (ENXIO);
323
324 if (!OF_hasprop(node, "operating-points") &&
325 !OF_hasprop(node, "operating-points-v2"))
326 return (ENXIO);
327
328 device_set_desc(dev, "Generic cpufreq driver");
329 return (BUS_PROBE_GENERIC);
330 }
331
332 static int
cpufreq_dt_oppv1_parse(struct cpufreq_dt_softc * sc,phandle_t node)333 cpufreq_dt_oppv1_parse(struct cpufreq_dt_softc *sc, phandle_t node)
334 {
335 uint32_t *opp, lat;
336 ssize_t n;
337
338 sc->nopp = OF_getencprop_alloc_multi(node, "operating-points",
339 sizeof(uint32_t) * 2, (void **)&opp);
340 if (sc->nopp == -1)
341 return (ENXIO);
342
343 if (OF_getencprop(node, "clock-latency", &lat, sizeof(lat)) == -1)
344 lat = CPUFREQ_VAL_UNKNOWN;
345
346 sc->opp = malloc(sizeof(*sc->opp) * sc->nopp, M_DEVBUF, M_WAITOK);
347
348 for (n = 0; n < sc->nopp; n++) {
349 sc->opp[n].freq = opp[n * 2 + 0] * 1000;
350 sc->opp[n].uvolt_min = opp[n * 2 + 1];
351 sc->opp[n].uvolt_max = sc->opp[n].uvolt_min;
352 sc->opp[n].uvolt_target = sc->opp[n].uvolt_min;
353 sc->opp[n].clk_latency = lat;
354
355 if (bootverbose)
356 device_printf(sc->dev, "%ju.%03ju MHz, %u uV\n",
357 sc->opp[n].freq / 1000000,
358 sc->opp[n].freq % 1000000,
359 sc->opp[n].uvolt_target);
360 }
361 free(opp, M_OFWPROP);
362
363 return (0);
364 }
365
366 static int
cpufreq_dt_oppv2_parse(struct cpufreq_dt_softc * sc,phandle_t node)367 cpufreq_dt_oppv2_parse(struct cpufreq_dt_softc *sc, phandle_t node)
368 {
369 phandle_t opp, opp_table, opp_xref;
370 pcell_t cell[2];
371 uint32_t *volts, lat;
372 int nvolt, i;
373
374 if (OF_getencprop(node, "operating-points-v2", &opp_xref,
375 sizeof(opp_xref)) == -1) {
376 device_printf(sc->dev, "Cannot get xref to oppv2 table\n");
377 return (ENXIO);
378 }
379
380 opp_table = OF_node_from_xref(opp_xref);
381 if (opp_table == opp_xref)
382 return (ENXIO);
383
384 if (!OF_hasprop(opp_table, "opp-shared")) {
385 device_printf(sc->dev, "Only opp-shared is supported\n");
386 return (ENXIO);
387 }
388
389 for (opp = OF_child(opp_table); opp > 0; opp = OF_peer(opp))
390 sc->nopp += 1;
391
392 sc->opp = malloc(sizeof(*sc->opp) * sc->nopp, M_DEVBUF, M_WAITOK);
393
394 for (i = 0, opp_table = OF_child(opp_table); opp_table > 0;
395 opp_table = OF_peer(opp_table), i++) {
396 /* opp-hz is a required property */
397 if (OF_getencprop(opp_table, "opp-hz", cell,
398 sizeof(cell)) == -1)
399 continue;
400
401 sc->opp[i].freq = cell[0];
402 sc->opp[i].freq <<= 32;
403 sc->opp[i].freq |= cell[1];
404
405 if (OF_getencprop(opp_table, "clock-latency", &lat,
406 sizeof(lat)) == -1)
407 sc->opp[i].clk_latency = CPUFREQ_VAL_UNKNOWN;
408 else
409 sc->opp[i].clk_latency = (int)lat;
410
411 if (OF_hasprop(opp_table, "turbo-mode"))
412 sc->opp[i].turbo_mode = true;
413 if (OF_hasprop(opp_table, "opp-suspend"))
414 sc->opp[i].opp_suspend = true;
415
416 nvolt = OF_getencprop_alloc_multi(opp_table, "opp-microvolt",
417 sizeof(*volts), (void **)&volts);
418 if (nvolt == 1) {
419 sc->opp[i].uvolt_target = volts[0];
420 sc->opp[i].uvolt_min = volts[0];
421 sc->opp[i].uvolt_max = volts[0];
422 } else if (nvolt == 3) {
423 sc->opp[i].uvolt_target = volts[0];
424 sc->opp[i].uvolt_min = volts[1];
425 sc->opp[i].uvolt_max = volts[2];
426 } else {
427 device_printf(sc->dev,
428 "Wrong count of opp-microvolt property\n");
429 OF_prop_free(volts);
430 free(sc->opp, M_DEVBUF);
431 return (ENXIO);
432 }
433 OF_prop_free(volts);
434
435 if (bootverbose)
436 device_printf(sc->dev, "%ju.%03ju Mhz (%u uV)\n",
437 sc->opp[i].freq / 1000000,
438 sc->opp[i].freq % 1000000,
439 sc->opp[i].uvolt_target);
440 }
441 return (0);
442 }
443
444 static int
cpufreq_dt_attach(device_t dev)445 cpufreq_dt_attach(device_t dev)
446 {
447 struct cpufreq_dt_softc *sc;
448 phandle_t node;
449 phandle_t cnode, opp, copp;
450 int cpu;
451 uint64_t freq;
452 int rv = 0;
453 enum opp_version version;
454
455 sc = device_get_softc(dev);
456 sc->dev = dev;
457 node = ofw_bus_get_node(device_get_parent(dev));
458
459 if (regulator_get_by_ofw_property(dev, node,
460 "cpu-supply", &sc->reg) != 0) {
461 if (regulator_get_by_ofw_property(dev, node,
462 "cpu0-supply", &sc->reg) != 0) {
463 device_printf(dev, "no regulator for %s\n",
464 ofw_bus_get_name(device_get_parent(dev)));
465 return (ENXIO);
466 }
467 }
468
469 if (clk_get_by_ofw_index(dev, node, 0, &sc->clk) != 0) {
470 device_printf(dev, "no clock for %s\n",
471 ofw_bus_get_name(device_get_parent(dev)));
472 regulator_release(sc->reg);
473 return (ENXIO);
474 }
475
476 if (OF_hasprop(node, "operating-points")) {
477 version = OPP_V1;
478 rv = cpufreq_dt_oppv1_parse(sc, node);
479 if (rv != 0) {
480 device_printf(dev, "Failed to parse opp-v1 table\n");
481 return (rv);
482 }
483 OF_getencprop(node, "operating-points", &opp,
484 sizeof(opp));
485 } else {
486 version = OPP_V2;
487 rv = cpufreq_dt_oppv2_parse(sc, node);
488 if (rv != 0) {
489 device_printf(dev, "Failed to parse opp-v2 table\n");
490 return (rv);
491 }
492 OF_getencprop(node, "operating-points-v2", &opp,
493 sizeof(opp));
494 }
495
496 /*
497 * Find all CPUs that share the same opp table
498 */
499 CPU_ZERO(&sc->cpus);
500 cpu = device_get_unit(device_get_parent(dev));
501 for (cnode = node; cnode > 0; cnode = OF_peer(cnode), cpu++) {
502 copp = -1;
503 if (version == OPP_V1)
504 OF_getencprop(cnode, "operating-points", &copp,
505 sizeof(copp));
506 else if (version == OPP_V2)
507 OF_getencprop(cnode, "operating-points-v2",
508 &copp, sizeof(copp));
509 if (opp == copp)
510 CPU_SET(cpu, &sc->cpus);
511 }
512
513 if (clk_get_freq(sc->clk, &freq) == 0)
514 cpufreq_dt_notify(dev, freq);
515
516 cpufreq_register(dev);
517
518 return (0);
519 }
520
521
522 static device_method_t cpufreq_dt_methods[] = {
523 /* Device interface */
524 DEVMETHOD(device_identify, cpufreq_dt_identify),
525 DEVMETHOD(device_probe, cpufreq_dt_probe),
526 DEVMETHOD(device_attach, cpufreq_dt_attach),
527
528 /* cpufreq interface */
529 DEVMETHOD(cpufreq_drv_get, cpufreq_dt_get),
530 DEVMETHOD(cpufreq_drv_set, cpufreq_dt_set),
531 DEVMETHOD(cpufreq_drv_type, cpufreq_dt_type),
532 DEVMETHOD(cpufreq_drv_settings, cpufreq_dt_settings),
533
534 DEVMETHOD_END
535 };
536
537 static driver_t cpufreq_dt_driver = {
538 "cpufreq_dt",
539 cpufreq_dt_methods,
540 sizeof(struct cpufreq_dt_softc),
541 };
542
543 static devclass_t cpufreq_dt_devclass;
544
545 DRIVER_MODULE(cpufreq_dt, cpu, cpufreq_dt_driver, cpufreq_dt_devclass, 0, 0);
546 MODULE_VERSION(cpufreq_dt, 1);
547