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