xref: /freebsd/sys/dev/acpica/acpi_throttle.c (revision aca5021d5f7dcab1e11692923266373e35322d9a)
1 /*-
2  * Copyright (c) 2003-2005 Nate Lawson (SDG)
3  * Copyright (c) 2001 Michael Smith
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 AND CONTRIBUTORS ``AS IS'' AND
16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23  * LIABILITY, 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 
28 #include <sys/cdefs.h>
29 __FBSDID("$FreeBSD$");
30 
31 #include "opt_acpi.h"
32 #include <sys/param.h>
33 #include <sys/bus.h>
34 #include <sys/cpu.h>
35 #include <sys/kernel.h>
36 #include <sys/malloc.h>
37 #include <sys/module.h>
38 #include <sys/rman.h>
39 
40 #include <machine/bus.h>
41 
42 #include <contrib/dev/acpica/include/acpi.h>
43 
44 #include <dev/acpica/acpivar.h>
45 #include <dev/pci/pcivar.h>
46 
47 #include "cpufreq_if.h"
48 
49 /*
50  * Throttling provides relative frequency control.  It involves modulating
51  * the clock so that the CPU is active for only a fraction of the normal
52  * clock cycle.  It does not change voltage and so is less efficient than
53  * other mechanisms.  Since it is relative, it can be used in addition to
54  * absolute cpufreq drivers.  We support the ACPI 2.0 specification.
55  */
56 
57 struct acpi_throttle_softc {
58 	device_t	 cpu_dev;
59 	ACPI_HANDLE	 cpu_handle;
60 	uint32_t	 cpu_p_blk;	/* ACPI P_BLK location */
61 	uint32_t	 cpu_p_blk_len;	/* P_BLK length (must be 6). */
62 	struct resource	*cpu_p_cnt;	/* Throttling control register */
63 	int		 cpu_p_type;	/* Resource type for cpu_p_cnt. */
64 	uint32_t	 cpu_thr_state;	/* Current throttle setting. */
65 };
66 
67 #define THR_GET_REG(reg) 					\
68 	(bus_space_read_4(rman_get_bustag((reg)), 		\
69 			  rman_get_bushandle((reg)), 0))
70 #define THR_SET_REG(reg, val)					\
71 	(bus_space_write_4(rman_get_bustag((reg)), 		\
72 			   rman_get_bushandle((reg)), 0, (val)))
73 
74 /*
75  * Speeds are stored in counts, from 1 to CPU_MAX_SPEED, and
76  * reported to the user in hundredths of a percent.
77  */
78 #define CPU_MAX_SPEED		(1 << cpu_duty_width)
79 #define CPU_SPEED_PERCENT(x)	((10000 * (x)) / CPU_MAX_SPEED)
80 #define CPU_SPEED_PRINTABLE(x)	(CPU_SPEED_PERCENT(x) / 10),	\
81 				(CPU_SPEED_PERCENT(x) % 10)
82 #define CPU_P_CNT_THT_EN	(1<<4)
83 #define CPU_QUIRK_NO_THROTTLE	(1<<1)	/* Throttling is not usable. */
84 
85 #define PCI_VENDOR_INTEL	0x8086
86 #define PCI_DEVICE_82371AB_3	0x7113	/* PIIX4 chipset for quirks. */
87 #define PCI_REVISION_A_STEP	0
88 #define PCI_REVISION_B_STEP	1
89 
90 static uint32_t	cpu_duty_offset;	/* Offset in P_CNT of throttle val. */
91 static uint32_t	cpu_duty_width;		/* Bit width of throttle value. */
92 static int	thr_rid;		/* Driver-wide resource id. */
93 static int	thr_quirks;		/* Indicate any hardware bugs. */
94 
95 static void	acpi_throttle_identify(driver_t *driver, device_t parent);
96 static int	acpi_throttle_probe(device_t dev);
97 static int	acpi_throttle_attach(device_t dev);
98 static int	acpi_throttle_evaluate(struct acpi_throttle_softc *sc);
99 static int	acpi_throttle_quirks(struct acpi_throttle_softc *sc);
100 static int	acpi_thr_settings(device_t dev, struct cf_setting *sets,
101 		    int *count);
102 static int	acpi_thr_set(device_t dev, const struct cf_setting *set);
103 static int	acpi_thr_get(device_t dev, struct cf_setting *set);
104 static int	acpi_thr_type(device_t dev, int *type);
105 
106 static device_method_t acpi_throttle_methods[] = {
107 	/* Device interface */
108 	DEVMETHOD(device_identify,	acpi_throttle_identify),
109 	DEVMETHOD(device_probe,		acpi_throttle_probe),
110 	DEVMETHOD(device_attach,	acpi_throttle_attach),
111 
112 	/* cpufreq interface */
113 	DEVMETHOD(cpufreq_drv_set,	acpi_thr_set),
114 	DEVMETHOD(cpufreq_drv_get,	acpi_thr_get),
115 	DEVMETHOD(cpufreq_drv_type,	acpi_thr_type),
116 	DEVMETHOD(cpufreq_drv_settings,	acpi_thr_settings),
117 	DEVMETHOD_END
118 };
119 
120 static driver_t acpi_throttle_driver = {
121 	"acpi_throttle",
122 	acpi_throttle_methods,
123 	sizeof(struct acpi_throttle_softc),
124 };
125 
126 static devclass_t acpi_throttle_devclass;
127 DRIVER_MODULE(acpi_throttle, cpu, acpi_throttle_driver, acpi_throttle_devclass,
128     0, 0);
129 
130 static void
131 acpi_throttle_identify(driver_t *driver, device_t parent)
132 {
133 	ACPI_BUFFER buf;
134 	ACPI_HANDLE handle;
135 	ACPI_OBJECT *obj;
136 
137 	/* Make sure we're not being doubly invoked. */
138 	if (device_find_child(parent, "acpi_throttle", -1))
139 		return;
140 
141 	/* Check for a valid duty width and parent CPU type. */
142 	handle = acpi_get_handle(parent);
143 	if (handle == NULL)
144 		return;
145 	if (AcpiGbl_FADT.DutyWidth == 0 ||
146 	    acpi_get_type(parent) != ACPI_TYPE_PROCESSOR)
147 		return;
148 
149 	/*
150 	 * Add a child if there's a non-NULL P_BLK and correct length, or
151 	 * if the _PTC method is present.
152 	 */
153 	buf.Pointer = NULL;
154 	buf.Length = ACPI_ALLOCATE_BUFFER;
155 	if (ACPI_FAILURE(AcpiEvaluateObject(handle, NULL, NULL, &buf)))
156 		return;
157 	obj = (ACPI_OBJECT *)buf.Pointer;
158 	if ((obj->Processor.PblkAddress && obj->Processor.PblkLength >= 4) ||
159 	    ACPI_SUCCESS(AcpiEvaluateObject(handle, "_PTC", NULL, NULL))) {
160 		if (BUS_ADD_CHILD(parent, 0, "acpi_throttle", -1) == NULL)
161 			device_printf(parent, "add throttle child failed\n");
162 	}
163 	AcpiOsFree(obj);
164 }
165 
166 static int
167 acpi_throttle_probe(device_t dev)
168 {
169 
170 	if (resource_disabled("acpi_throttle", 0))
171 		return (ENXIO);
172 
173 	/*
174 	 * On i386 platforms at least, ACPI throttling is accomplished by
175 	 * the chipset modulating the STPCLK# pin based on the duty cycle.
176 	 * Since p4tcc uses the same mechanism (but internal to the CPU),
177 	 * we disable acpi_throttle when p4tcc is also present.
178 	 */
179 	if (device_find_child(device_get_parent(dev), "p4tcc", -1) &&
180 	    !resource_disabled("p4tcc", 0))
181 		return (ENXIO);
182 
183 	device_set_desc(dev, "ACPI CPU Throttling");
184 	return (0);
185 }
186 
187 static int
188 acpi_throttle_attach(device_t dev)
189 {
190 	struct acpi_throttle_softc *sc;
191 	struct cf_setting set;
192 	ACPI_BUFFER buf;
193 	ACPI_OBJECT *obj;
194 	ACPI_STATUS status;
195 	int error;
196 
197 	sc = device_get_softc(dev);
198 	sc->cpu_dev = dev;
199 	sc->cpu_handle = acpi_get_handle(dev);
200 
201 	buf.Pointer = NULL;
202 	buf.Length = ACPI_ALLOCATE_BUFFER;
203 	status = AcpiEvaluateObject(sc->cpu_handle, NULL, NULL, &buf);
204 	if (ACPI_FAILURE(status)) {
205 		device_printf(dev, "attach failed to get Processor obj - %s\n",
206 		    AcpiFormatException(status));
207 		return (ENXIO);
208 	}
209 	obj = (ACPI_OBJECT *)buf.Pointer;
210 	sc->cpu_p_blk = obj->Processor.PblkAddress;
211 	sc->cpu_p_blk_len = obj->Processor.PblkLength;
212 	AcpiOsFree(obj);
213 
214 	/* If this is the first device probed, check for quirks. */
215 	if (device_get_unit(dev) == 0)
216 		acpi_throttle_quirks(sc);
217 
218 	/* Attempt to attach the actual throttling register. */
219 	error = acpi_throttle_evaluate(sc);
220 	if (error)
221 		return (error);
222 
223 	/*
224 	 * Set our initial frequency to the highest since some systems
225 	 * seem to boot with this at the lowest setting.
226 	 */
227 	set.freq = 10000;
228 	acpi_thr_set(dev, &set);
229 
230 	/* Everything went ok, register with cpufreq(4). */
231 	cpufreq_register(dev);
232 	return (0);
233 }
234 
235 static int
236 acpi_throttle_evaluate(struct acpi_throttle_softc *sc)
237 {
238 	uint32_t duty_end;
239 	ACPI_BUFFER buf;
240 	ACPI_OBJECT obj;
241 	ACPI_GENERIC_ADDRESS gas;
242 	ACPI_STATUS status;
243 
244 	/* Get throttling parameters from the FADT.  0 means not supported. */
245 	if (device_get_unit(sc->cpu_dev) == 0) {
246 		cpu_duty_offset = AcpiGbl_FADT.DutyOffset;
247 		cpu_duty_width = AcpiGbl_FADT.DutyWidth;
248 	}
249 	if (cpu_duty_width == 0 || (thr_quirks & CPU_QUIRK_NO_THROTTLE) != 0)
250 		return (ENXIO);
251 
252 	/* Validate the duty offset/width. */
253 	duty_end = cpu_duty_offset + cpu_duty_width - 1;
254 	if (duty_end > 31) {
255 		device_printf(sc->cpu_dev,
256 		    "CLK_VAL field overflows P_CNT register\n");
257 		return (ENXIO);
258 	}
259 	if (cpu_duty_offset <= 4 && duty_end >= 4) {
260 		device_printf(sc->cpu_dev,
261 		    "CLK_VAL field overlaps THT_EN bit\n");
262 		return (ENXIO);
263 	}
264 
265 	/*
266 	 * If not present, fall back to using the processor's P_BLK to find
267 	 * the P_CNT register.
268 	 *
269 	 * Note that some systems seem to duplicate the P_BLK pointer
270 	 * across multiple CPUs, so not getting the resource is not fatal.
271 	 */
272 	buf.Pointer = &obj;
273 	buf.Length = sizeof(obj);
274 	status = AcpiEvaluateObject(sc->cpu_handle, "_PTC", NULL, &buf);
275 	if (ACPI_SUCCESS(status)) {
276 		if (obj.Buffer.Length < sizeof(ACPI_GENERIC_ADDRESS) + 3) {
277 			device_printf(sc->cpu_dev, "_PTC buffer too small\n");
278 			return (ENXIO);
279 		}
280 		memcpy(&gas, obj.Buffer.Pointer + 3, sizeof(gas));
281 		acpi_bus_alloc_gas(sc->cpu_dev, &sc->cpu_p_type, &thr_rid,
282 		    &gas, &sc->cpu_p_cnt, 0);
283 		if (sc->cpu_p_cnt != NULL && bootverbose) {
284 			device_printf(sc->cpu_dev, "P_CNT from _PTC %#jx\n",
285 			    gas.Address);
286 		}
287 	}
288 
289 	/* If _PTC not present or other failure, try the P_BLK. */
290 	if (sc->cpu_p_cnt == NULL) {
291 		/*
292 		 * The spec says P_BLK must be 6 bytes long.  However, some
293 		 * systems use it to indicate a fractional set of features
294 		 * present so we take anything >= 4.
295 		 */
296 		if (sc->cpu_p_blk_len < 4)
297 			return (ENXIO);
298 		gas.Address = sc->cpu_p_blk;
299 		gas.SpaceId = ACPI_ADR_SPACE_SYSTEM_IO;
300 		gas.BitWidth = 32;
301 		acpi_bus_alloc_gas(sc->cpu_dev, &sc->cpu_p_type, &thr_rid,
302 		    &gas, &sc->cpu_p_cnt, 0);
303 		if (sc->cpu_p_cnt != NULL) {
304 			if (bootverbose)
305 				device_printf(sc->cpu_dev,
306 				    "P_CNT from P_BLK %#x\n", sc->cpu_p_blk);
307 		} else {
308 			device_printf(sc->cpu_dev, "failed to attach P_CNT\n");
309 			return (ENXIO);
310 		}
311 	}
312 	thr_rid++;
313 
314 	return (0);
315 }
316 
317 static int
318 acpi_throttle_quirks(struct acpi_throttle_softc *sc)
319 {
320 	device_t acpi_dev;
321 
322 	/* Look for various quirks of the PIIX4 part. */
323 	acpi_dev = pci_find_device(PCI_VENDOR_INTEL, PCI_DEVICE_82371AB_3);
324 	if (acpi_dev) {
325 		switch (pci_get_revid(acpi_dev)) {
326 		/*
327 		 * Disable throttling control on PIIX4 A and B-step.
328 		 * See specification changes #13 ("Manual Throttle Duty Cycle")
329 		 * and #14 ("Enabling and Disabling Manual Throttle"), plus
330 		 * erratum #5 ("STPCLK# Deassertion Time") from the January
331 		 * 2002 PIIX4 specification update.  Note that few (if any)
332 		 * mobile systems ever used this part.
333 		 */
334 		case PCI_REVISION_A_STEP:
335 		case PCI_REVISION_B_STEP:
336 			thr_quirks |= CPU_QUIRK_NO_THROTTLE;
337 			break;
338 		default:
339 			break;
340 		}
341 	}
342 
343 	return (0);
344 }
345 
346 static int
347 acpi_thr_settings(device_t dev, struct cf_setting *sets, int *count)
348 {
349 	int i, speed;
350 
351 	if (sets == NULL || count == NULL)
352 		return (EINVAL);
353 	if (*count < CPU_MAX_SPEED)
354 		return (E2BIG);
355 
356 	/* Return a list of valid settings for this driver. */
357 	memset(sets, CPUFREQ_VAL_UNKNOWN, sizeof(*sets) * CPU_MAX_SPEED);
358 	for (i = 0, speed = CPU_MAX_SPEED; speed != 0; i++, speed--) {
359 		sets[i].freq = CPU_SPEED_PERCENT(speed);
360 		sets[i].dev = dev;
361 	}
362 	*count = CPU_MAX_SPEED;
363 
364 	return (0);
365 }
366 
367 static int
368 acpi_thr_set(device_t dev, const struct cf_setting *set)
369 {
370 	struct acpi_throttle_softc *sc;
371 	uint32_t clk_val, p_cnt, speed;
372 
373 	if (set == NULL)
374 		return (EINVAL);
375 	sc = device_get_softc(dev);
376 
377 	/*
378 	 * Validate requested state converts to a duty cycle that is an
379 	 * integer from [1 .. CPU_MAX_SPEED].
380 	 */
381 	speed = set->freq * CPU_MAX_SPEED / 10000;
382 	if (speed * 10000 != set->freq * CPU_MAX_SPEED ||
383 	    speed < 1 || speed > CPU_MAX_SPEED)
384 		return (EINVAL);
385 
386 	/* If we're at this setting, don't bother applying it again. */
387 	if (speed == sc->cpu_thr_state)
388 		return (0);
389 
390 	/* Get the current P_CNT value and disable throttling */
391 	p_cnt = THR_GET_REG(sc->cpu_p_cnt);
392 	p_cnt &= ~CPU_P_CNT_THT_EN;
393 	THR_SET_REG(sc->cpu_p_cnt, p_cnt);
394 
395 	/* If we're at maximum speed, that's all */
396 	if (speed < CPU_MAX_SPEED) {
397 		/* Mask the old CLK_VAL off and OR in the new value */
398 		clk_val = (CPU_MAX_SPEED - 1) << cpu_duty_offset;
399 		p_cnt &= ~clk_val;
400 		p_cnt |= (speed << cpu_duty_offset);
401 
402 		/* Write the new P_CNT value and then enable throttling */
403 		THR_SET_REG(sc->cpu_p_cnt, p_cnt);
404 		p_cnt |= CPU_P_CNT_THT_EN;
405 		THR_SET_REG(sc->cpu_p_cnt, p_cnt);
406 	}
407 	sc->cpu_thr_state = speed;
408 
409 	return (0);
410 }
411 
412 static int
413 acpi_thr_get(device_t dev, struct cf_setting *set)
414 {
415 	struct acpi_throttle_softc *sc;
416 	uint32_t p_cnt, clk_val;
417 
418 	if (set == NULL)
419 		return (EINVAL);
420 	sc = device_get_softc(dev);
421 
422 	/* Get the current throttling setting from P_CNT. */
423 	p_cnt = THR_GET_REG(sc->cpu_p_cnt);
424 	clk_val = (p_cnt >> cpu_duty_offset) & (CPU_MAX_SPEED - 1);
425 	sc->cpu_thr_state = clk_val;
426 
427 	memset(set, CPUFREQ_VAL_UNKNOWN, sizeof(*set));
428 	set->freq = CPU_SPEED_PERCENT(clk_val);
429 	set->dev = dev;
430 
431 	return (0);
432 }
433 
434 static int
435 acpi_thr_type(device_t dev, int *type)
436 {
437 
438 	if (type == NULL)
439 		return (EINVAL);
440 
441 	*type = CPUFREQ_TYPE_RELATIVE;
442 	return (0);
443 }
444