xref: /freebsd/sys/dev/acpica/acpi_perf.c (revision a5921bc3653e2e286715e6fe8d473ec0d02da38c)
1 /*-
2  * Copyright (c) 2003-2005 Nate Lawson (SDG)
3  * All rights reserved.
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 AND CONTRIBUTORS ``AS IS'' AND
15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22  * LIABILITY, 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 
27 #include <sys/cdefs.h>
28 __FBSDID("$FreeBSD$");
29 
30 #include "opt_acpi.h"
31 #include <sys/param.h>
32 #include <sys/kernel.h>
33 #include <sys/proc.h>
34 #include <sys/sched.h>
35 #include <sys/bus.h>
36 #include <sys/cpu.h>
37 #include <sys/power.h>
38 #include <sys/malloc.h>
39 #include <sys/module.h>
40 #include <sys/sbuf.h>
41 #include <sys/pcpu.h>
42 
43 #include <machine/bus.h>
44 #include <machine/resource.h>
45 #include <sys/rman.h>
46 
47 #include <contrib/dev/acpica/include/acpi.h>
48 
49 #include <dev/acpica/acpivar.h>
50 
51 #include "cpufreq_if.h"
52 
53 /*
54  * Support for ACPI processor performance states (Px) according to
55  * section 8.3.3 of the ACPI 2.0c specification.
56  */
57 
58 struct acpi_px {
59 	uint32_t	 core_freq;
60 	uint32_t	 power;
61 	uint32_t	 trans_lat;
62 	uint32_t	 bm_lat;
63 	uint32_t	 ctrl_val;
64 	uint32_t	 sts_val;
65 };
66 
67 /* Offsets in struct cf_setting array for storing driver-specific values. */
68 #define PX_SPEC_CONTROL	0
69 #define PX_SPEC_STATUS	1
70 
71 #define MAX_PX_STATES	16
72 
73 struct acpi_perf_softc {
74 	device_t	 dev;
75 	ACPI_HANDLE	 handle;
76 	struct resource	*perf_ctrl;	/* Set new performance state. */
77 	int		 perf_ctrl_type; /* Resource type for perf_ctrl. */
78 	struct resource	*perf_status;	/* Check that transition succeeded. */
79 	int		 perf_sts_type;	/* Resource type for perf_status. */
80 	struct acpi_px	*px_states;	/* ACPI perf states. */
81 	uint32_t	 px_count;	/* Total number of perf states. */
82 	uint32_t	 px_max_avail;	/* Lowest index state available. */
83 	int		 px_curr_state;	/* Active state index. */
84 	int		 px_rid;
85 	int		 info_only;	/* Can we set new states? */
86 };
87 
88 #define PX_GET_REG(reg) 				\
89 	(bus_space_read_4(rman_get_bustag((reg)), 	\
90 	    rman_get_bushandle((reg)), 0))
91 #define PX_SET_REG(reg, val)				\
92 	(bus_space_write_4(rman_get_bustag((reg)), 	\
93 	    rman_get_bushandle((reg)), 0, (val)))
94 
95 #define ACPI_NOTIFY_PERF_STATES		0x80	/* _PSS changed. */
96 
97 static void	acpi_perf_identify(driver_t *driver, device_t parent);
98 static int	acpi_perf_probe(device_t dev);
99 static int	acpi_perf_attach(device_t dev);
100 static int	acpi_perf_detach(device_t dev);
101 static int	acpi_perf_evaluate(device_t dev);
102 static int	acpi_px_to_set(device_t dev, struct acpi_px *px,
103 		    struct cf_setting *set);
104 static void	acpi_px_available(struct acpi_perf_softc *sc);
105 static void	acpi_px_startup(void *arg);
106 static void	acpi_px_notify(ACPI_HANDLE h, UINT32 notify, void *context);
107 static int	acpi_px_settings(device_t dev, struct cf_setting *sets,
108 		    int *count);
109 static int	acpi_px_set(device_t dev, const struct cf_setting *set);
110 static int	acpi_px_get(device_t dev, struct cf_setting *set);
111 static int	acpi_px_type(device_t dev, int *type);
112 
113 static device_method_t acpi_perf_methods[] = {
114 	/* Device interface */
115 	DEVMETHOD(device_identify,	acpi_perf_identify),
116 	DEVMETHOD(device_probe,		acpi_perf_probe),
117 	DEVMETHOD(device_attach,	acpi_perf_attach),
118 	DEVMETHOD(device_detach,	acpi_perf_detach),
119 
120 	/* cpufreq interface */
121 	DEVMETHOD(cpufreq_drv_set,	acpi_px_set),
122 	DEVMETHOD(cpufreq_drv_get,	acpi_px_get),
123 	DEVMETHOD(cpufreq_drv_type,	acpi_px_type),
124 	DEVMETHOD(cpufreq_drv_settings,	acpi_px_settings),
125 
126 	DEVMETHOD_END
127 };
128 
129 static driver_t acpi_perf_driver = {
130 	"acpi_perf",
131 	acpi_perf_methods,
132 	sizeof(struct acpi_perf_softc),
133 };
134 
135 static devclass_t acpi_perf_devclass;
136 DRIVER_MODULE(acpi_perf, cpu, acpi_perf_driver, acpi_perf_devclass, 0, 0);
137 MODULE_DEPEND(acpi_perf, acpi, 1, 1, 1);
138 
139 static MALLOC_DEFINE(M_ACPIPERF, "acpi_perf", "ACPI Performance states");
140 
141 static void
142 acpi_perf_identify(driver_t *driver, device_t parent)
143 {
144 	ACPI_HANDLE handle;
145 	device_t dev;
146 
147 	/* Make sure we're not being doubly invoked. */
148 	if (device_find_child(parent, "acpi_perf", -1) != NULL)
149 		return;
150 
151 	/* Get the handle for the Processor object and check for perf states. */
152 	handle = acpi_get_handle(parent);
153 	if (handle == NULL)
154 		return;
155 	if (ACPI_FAILURE(AcpiEvaluateObject(handle, "_PSS", NULL, NULL)))
156 		return;
157 
158 	/*
159 	 * Add a child to every CPU that has the right methods.  In future
160 	 * versions of the ACPI spec, CPUs can have different settings.
161 	 * We probe this child now so that other devices that depend
162 	 * on it (i.e., for info about supported states) will see it.
163 	 */
164 	if ((dev = BUS_ADD_CHILD(parent, 0, "acpi_perf", -1)) != NULL)
165 		device_probe_and_attach(dev);
166 	else
167 		device_printf(parent, "add acpi_perf child failed\n");
168 }
169 
170 static int
171 acpi_perf_probe(device_t dev)
172 {
173 	ACPI_HANDLE handle;
174 	ACPI_OBJECT *pkg;
175 	struct resource *res;
176 	ACPI_BUFFER buf;
177 	int error, rid, type;
178 
179 	if (resource_disabled("acpi_perf", 0))
180 		return (ENXIO);
181 
182 	/*
183 	 * Check the performance state registers.  If they are of type
184 	 * "functional fixed hardware", we attach quietly since we will
185 	 * only be providing information on settings to other drivers.
186 	 */
187 	error = ENXIO;
188 	handle = acpi_get_handle(dev);
189 	buf.Pointer = NULL;
190 	buf.Length = ACPI_ALLOCATE_BUFFER;
191 	if (ACPI_FAILURE(AcpiEvaluateObject(handle, "_PCT", NULL, &buf)))
192 		return (error);
193 	pkg = (ACPI_OBJECT *)buf.Pointer;
194 	if (ACPI_PKG_VALID(pkg, 2)) {
195 		rid = 0;
196 		error = acpi_PkgGas(dev, pkg, 0, &type, &rid, &res, 0);
197 		switch (error) {
198 		case 0:
199 			bus_release_resource(dev, type, rid, res);
200 			bus_delete_resource(dev, type, rid);
201 			device_set_desc(dev, "ACPI CPU Frequency Control");
202 			break;
203 		case EOPNOTSUPP:
204 			device_quiet(dev);
205 			error = 0;
206 			break;
207 		}
208 	}
209 	AcpiOsFree(buf.Pointer);
210 
211 	return (error);
212 }
213 
214 static int
215 acpi_perf_attach(device_t dev)
216 {
217 	struct acpi_perf_softc *sc;
218 
219 	sc = device_get_softc(dev);
220 	sc->dev = dev;
221 	sc->handle = acpi_get_handle(dev);
222 	sc->px_max_avail = 0;
223 	sc->px_curr_state = CPUFREQ_VAL_UNKNOWN;
224 	if (acpi_perf_evaluate(dev) != 0)
225 		return (ENXIO);
226 	AcpiOsExecute(OSL_NOTIFY_HANDLER, acpi_px_startup, NULL);
227 	if (!sc->info_only)
228 		cpufreq_register(dev);
229 
230 	return (0);
231 }
232 
233 static int
234 acpi_perf_detach(device_t dev)
235 {
236 	/* TODO: teardown registers, remove notify handler. */
237 	return (ENXIO);
238 }
239 
240 /* Probe and setup any valid performance states (Px). */
241 static int
242 acpi_perf_evaluate(device_t dev)
243 {
244 	struct acpi_perf_softc *sc;
245 	ACPI_BUFFER buf;
246 	ACPI_OBJECT *pkg, *res;
247 	ACPI_STATUS status;
248 	int count, error, i, j;
249 	static int once = 1;
250 	uint32_t *p;
251 
252 	/* Get the control values and parameters for each state. */
253 	error = ENXIO;
254 	sc = device_get_softc(dev);
255 	buf.Pointer = NULL;
256 	buf.Length = ACPI_ALLOCATE_BUFFER;
257 	status = AcpiEvaluateObject(sc->handle, "_PSS", NULL, &buf);
258 	if (ACPI_FAILURE(status))
259 		return (ENXIO);
260 
261 	pkg = (ACPI_OBJECT *)buf.Pointer;
262 	if (!ACPI_PKG_VALID(pkg, 1)) {
263 		device_printf(dev, "invalid top level _PSS package\n");
264 		goto out;
265 	}
266 	sc->px_count = pkg->Package.Count;
267 
268 	sc->px_states = malloc(sc->px_count * sizeof(struct acpi_px),
269 	    M_ACPIPERF, M_WAITOK | M_ZERO);
270 	if (sc->px_states == NULL)
271 		goto out;
272 
273 	/*
274 	 * Each state is a package of {CoreFreq, Power, TransitionLatency,
275 	 * BusMasterLatency, ControlVal, StatusVal}, sorted from highest
276 	 * performance to lowest.
277 	 */
278 	count = 0;
279 	for (i = 0; i < sc->px_count; i++) {
280 		res = &pkg->Package.Elements[i];
281 		if (!ACPI_PKG_VALID(res, 6)) {
282 			if (once) {
283 				once = 0;
284 				device_printf(dev, "invalid _PSS package\n");
285 			}
286 			continue;
287 		}
288 
289 		/* Parse the rest of the package into the struct. */
290 		p = &sc->px_states[count].core_freq;
291 		for (j = 0; j < 6; j++, p++)
292 			acpi_PkgInt32(res, j, p);
293 
294 		/*
295 		 * Check for some impossible frequencies that some systems
296 		 * use to indicate they don't actually support this Px state.
297 		 */
298 		if (sc->px_states[count].core_freq == 0 ||
299 		    sc->px_states[count].core_freq == 9999 ||
300 		    sc->px_states[count].core_freq == 0x9999 ||
301 		    sc->px_states[count].core_freq >= 0xffff)
302 			continue;
303 
304 		/* Check for duplicate entries */
305 		if (count > 0 &&
306 		    sc->px_states[count - 1].core_freq ==
307 			sc->px_states[count].core_freq)
308 			continue;
309 
310 		count++;
311 	}
312 	sc->px_count = count;
313 
314 	/* No valid Px state found so give up. */
315 	if (count == 0)
316 		goto out;
317 	AcpiOsFree(buf.Pointer);
318 
319 	/* Get the control and status registers (one of each). */
320 	buf.Pointer = NULL;
321 	buf.Length = ACPI_ALLOCATE_BUFFER;
322 	status = AcpiEvaluateObject(sc->handle, "_PCT", NULL, &buf);
323 	if (ACPI_FAILURE(status))
324 		goto out;
325 
326 	/* Check the package of two registers, each a Buffer in GAS format. */
327 	pkg = (ACPI_OBJECT *)buf.Pointer;
328 	if (!ACPI_PKG_VALID(pkg, 2)) {
329 		device_printf(dev, "invalid perf register package\n");
330 		goto out;
331 	}
332 
333 	error = acpi_PkgGas(sc->dev, pkg, 0, &sc->perf_ctrl_type, &sc->px_rid,
334 	    &sc->perf_ctrl, 0);
335 	if (error) {
336 		/*
337 		 * If the register is of type FFixedHW, we can only return
338 		 * info, we can't get or set new settings.
339 		 */
340 		if (error == EOPNOTSUPP) {
341 			sc->info_only = TRUE;
342 			error = 0;
343 		} else
344 			device_printf(dev, "failed in PERF_CTL attach\n");
345 		goto out;
346 	}
347 	sc->px_rid++;
348 
349 	error = acpi_PkgGas(sc->dev, pkg, 1, &sc->perf_sts_type, &sc->px_rid,
350 	    &sc->perf_status, 0);
351 	if (error) {
352 		if (error == EOPNOTSUPP) {
353 			sc->info_only = TRUE;
354 			error = 0;
355 		} else
356 			device_printf(dev, "failed in PERF_STATUS attach\n");
357 		goto out;
358 	}
359 	sc->px_rid++;
360 
361 	/* Get our current limit and register for notifies. */
362 	acpi_px_available(sc);
363 	AcpiInstallNotifyHandler(sc->handle, ACPI_DEVICE_NOTIFY,
364 	    acpi_px_notify, sc);
365 	error = 0;
366 
367 out:
368 	if (error) {
369 		if (sc->px_states) {
370 			free(sc->px_states, M_ACPIPERF);
371 			sc->px_states = NULL;
372 		}
373 		if (sc->perf_ctrl) {
374 			bus_release_resource(sc->dev, sc->perf_ctrl_type, 0,
375 			    sc->perf_ctrl);
376 			bus_delete_resource(sc->dev, sc->perf_ctrl_type, 0);
377 			sc->perf_ctrl = NULL;
378 		}
379 		if (sc->perf_status) {
380 			bus_release_resource(sc->dev, sc->perf_sts_type, 1,
381 			    sc->perf_status);
382 			bus_delete_resource(sc->dev, sc->perf_sts_type, 1);
383 			sc->perf_status = NULL;
384 		}
385 		sc->px_rid = 0;
386 		sc->px_count = 0;
387 	}
388 	if (buf.Pointer)
389 		AcpiOsFree(buf.Pointer);
390 	return (error);
391 }
392 
393 static void
394 acpi_px_startup(void *arg)
395 {
396 
397 	/* Signal to the platform that we are taking over CPU control. */
398 	if (AcpiGbl_FADT.PstateControl == 0)
399 		return;
400 	ACPI_LOCK(acpi);
401 	AcpiOsWritePort(AcpiGbl_FADT.SmiCommand, AcpiGbl_FADT.PstateControl, 8);
402 	ACPI_UNLOCK(acpi);
403 }
404 
405 static void
406 acpi_px_notify(ACPI_HANDLE h, UINT32 notify, void *context)
407 {
408 	struct acpi_perf_softc *sc;
409 
410 	sc = context;
411 	if (notify != ACPI_NOTIFY_PERF_STATES)
412 		return;
413 
414 	acpi_px_available(sc);
415 
416 	/* TODO: Implement notification when frequency changes. */
417 }
418 
419 /*
420  * Find the highest currently-supported performance state.
421  * This can be called at runtime (e.g., due to a docking event) at
422  * the request of a Notify on the processor object.
423  */
424 static void
425 acpi_px_available(struct acpi_perf_softc *sc)
426 {
427 	ACPI_STATUS status;
428 	struct cf_setting set;
429 
430 	status = acpi_GetInteger(sc->handle, "_PPC", &sc->px_max_avail);
431 
432 	/* If the old state is too high, set current state to the new max. */
433 	if (ACPI_SUCCESS(status)) {
434 		if (sc->px_curr_state != CPUFREQ_VAL_UNKNOWN &&
435 		    sc->px_curr_state > sc->px_max_avail) {
436 			acpi_px_to_set(sc->dev,
437 			    &sc->px_states[sc->px_max_avail], &set);
438 			acpi_px_set(sc->dev, &set);
439 		}
440 	} else
441 		sc->px_max_avail = 0;
442 }
443 
444 static int
445 acpi_px_to_set(device_t dev, struct acpi_px *px, struct cf_setting *set)
446 {
447 
448 	if (px == NULL || set == NULL)
449 		return (EINVAL);
450 
451 	set->freq = px->core_freq;
452 	set->power = px->power;
453 	/* XXX Include BM latency too? */
454 	set->lat = px->trans_lat;
455 	set->volts = CPUFREQ_VAL_UNKNOWN;
456 	set->dev = dev;
457 	set->spec[PX_SPEC_CONTROL] = px->ctrl_val;
458 	set->spec[PX_SPEC_STATUS] = px->sts_val;
459 
460 	return (0);
461 }
462 
463 static int
464 acpi_px_settings(device_t dev, struct cf_setting *sets, int *count)
465 {
466 	struct acpi_perf_softc *sc;
467 	int x, y;
468 
469 	sc = device_get_softc(dev);
470 	if (sets == NULL || count == NULL)
471 		return (EINVAL);
472 	if (*count < sc->px_count - sc->px_max_avail)
473 		return (E2BIG);
474 
475 	/* Return a list of settings that are currently valid. */
476 	y = 0;
477 	for (x = sc->px_max_avail; x < sc->px_count; x++, y++)
478 		acpi_px_to_set(dev, &sc->px_states[x], &sets[y]);
479 	*count = sc->px_count - sc->px_max_avail;
480 
481 	return (0);
482 }
483 
484 static int
485 acpi_px_set(device_t dev, const struct cf_setting *set)
486 {
487 	struct acpi_perf_softc *sc;
488 	int i, status, sts_val, tries;
489 
490 	if (set == NULL)
491 		return (EINVAL);
492 	sc = device_get_softc(dev);
493 
494 	/* If we can't set new states, return immediately. */
495 	if (sc->info_only)
496 		return (ENXIO);
497 
498 	/* Look up appropriate state, based on frequency. */
499 	for (i = sc->px_max_avail; i < sc->px_count; i++) {
500 		if (CPUFREQ_CMP(set->freq, sc->px_states[i].core_freq))
501 			break;
502 	}
503 	if (i == sc->px_count)
504 		return (EINVAL);
505 
506 	/* Write the appropriate value to the register. */
507 	PX_SET_REG(sc->perf_ctrl, sc->px_states[i].ctrl_val);
508 
509 	/*
510 	 * Try for up to 10 ms to verify the desired state was selected.
511 	 * This is longer than the standard says (1 ms) but in some modes,
512 	 * systems may take longer to respond.
513 	 */
514 	sts_val = sc->px_states[i].sts_val;
515 	for (tries = 0; tries < 1000; tries++) {
516 		status = PX_GET_REG(sc->perf_status);
517 
518 		/*
519 		 * If we match the status or the desired status is 8 bits
520 		 * and matches the relevant bits, assume we succeeded.  It
521 		 * appears some systems (IBM R32) expect byte-wide access
522 		 * even though the standard says the register is 32-bit.
523 		 */
524 		if (status == sts_val ||
525 		    ((sts_val & ~0xff) == 0 && (status & 0xff) == sts_val))
526 			break;
527 		DELAY(10);
528 	}
529 	if (tries == 1000) {
530 		device_printf(dev, "Px transition to %d failed\n",
531 		    sc->px_states[i].core_freq);
532 		return (ENXIO);
533 	}
534 	sc->px_curr_state = i;
535 
536 	return (0);
537 }
538 
539 static int
540 acpi_px_get(device_t dev, struct cf_setting *set)
541 {
542 	struct acpi_perf_softc *sc;
543 	uint64_t rate;
544 	int i;
545 	struct pcpu *pc;
546 
547 	if (set == NULL)
548 		return (EINVAL);
549 	sc = device_get_softc(dev);
550 
551 	/* If we can't get new states, return immediately. */
552 	if (sc->info_only)
553 		return (ENXIO);
554 
555 	/* If we've set the rate before, use the cached value. */
556 	if (sc->px_curr_state != CPUFREQ_VAL_UNKNOWN) {
557 		acpi_px_to_set(dev, &sc->px_states[sc->px_curr_state], set);
558 		return (0);
559 	}
560 
561 	/* Otherwise, estimate and try to match against our settings. */
562 	pc = cpu_get_pcpu(dev);
563 	if (pc == NULL)
564 		return (ENXIO);
565 	cpu_est_clockrate(pc->pc_cpuid, &rate);
566 	rate /= 1000000;
567 	for (i = 0; i < sc->px_count; i++) {
568 		if (CPUFREQ_CMP(sc->px_states[i].core_freq, rate)) {
569 			sc->px_curr_state = i;
570 			acpi_px_to_set(dev, &sc->px_states[i], set);
571 			break;
572 		}
573 	}
574 
575 	/* No match, give up. */
576 	if (i == sc->px_count) {
577 		sc->px_curr_state = CPUFREQ_VAL_UNKNOWN;
578 		set->freq = CPUFREQ_VAL_UNKNOWN;
579 	}
580 
581 	return (0);
582 }
583 
584 static int
585 acpi_px_type(device_t dev, int *type)
586 {
587 	struct acpi_perf_softc *sc;
588 
589 	if (type == NULL)
590 		return (EINVAL);
591 	sc = device_get_softc(dev);
592 
593 	*type = CPUFREQ_TYPE_ABSOLUTE;
594 	if (sc->info_only)
595 		*type |= CPUFREQ_FLAG_INFO_ONLY;
596 	return (0);
597 }
598