1 /*	$NetBSD: acpi_util.c,v 1.8 2011/06/21 03:37:21 jruoho Exp $ */
2 
3 /*-
4  * Copyright (c) 2003, 2007 The NetBSD Foundation, Inc.
5  * All rights reserved.
6  *
7  * This code is derived from software contributed to The NetBSD Foundation
8  * by Charles M. Hannum of By Noon Software, Inc.
9  *
10  * Redistribution and use in source and binary forms, with or without
11  * modification, are permitted provided that the following conditions
12  * are met:
13  * 1. Redistributions of source code must retain the above copyright
14  *    notice, this list of conditions and the following disclaimer.
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in the
17  *    documentation and/or other materials provided with the distribution.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29  * POSSIBILITY OF SUCH DAMAGE.
30  */
31 
32 /*
33  * Copyright 2001, 2003 Wasabi Systems, Inc.
34  * All rights reserved.
35  *
36  * Written by Jason R. Thorpe for Wasabi Systems, Inc.
37  *
38  * Redistribution and use in source and binary forms, with or without
39  * modification, are permitted provided that the following conditions
40  * are met:
41  * 1. Redistributions of source code must retain the above copyright
42  *    notice, this list of conditions and the following disclaimer.
43  * 2. Redistributions in binary form must reproduce the above copyright
44  *    notice, this list of conditions and the following disclaimer in the
45  *    documentation and/or other materials provided with the distribution.
46  * 3. All advertising materials mentioning features or use of this software
47  *    must display the following acknowledgement:
48  *	This product includes software developed for the NetBSD Project by
49  *	Wasabi Systems, Inc.
50  * 4. The name of Wasabi Systems, Inc. may not be used to endorse
51  *    or promote products derived from this software without specific prior
52  *    written permission.
53  *
54  * THIS SOFTWARE IS PROVIDED BY WASABI SYSTEMS, INC. ``AS IS'' AND
55  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
56  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
57  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL WASABI SYSTEMS, INC
58  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
59  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
60  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
61  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
62  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
63  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
64  * POSSIBILITY OF SUCH DAMAGE.
65  */
66 
67 #include <sys/cdefs.h>
68 __KERNEL_RCSID(0, "$NetBSD: acpi_util.c,v 1.8 2011/06/21 03:37:21 jruoho Exp $");
69 
70 #include <sys/param.h>
71 
72 #include <dev/acpi/acpireg.h>
73 #include <dev/acpi/acpivar.h>
74 
75 #define _COMPONENT	ACPI_BUS_COMPONENT
76 ACPI_MODULE_NAME	("acpi_util")
77 
78 static void		acpi_clean_node(ACPI_HANDLE, void *);
79 
80 static const char * const acpicpu_ids[] = {
81 	"ACPI0007",
82 	NULL
83 };
84 
85 /*
86  * Evaluate an integer object.
87  */
88 ACPI_STATUS
acpi_eval_integer(ACPI_HANDLE handle,const char * path,ACPI_INTEGER * valp)89 acpi_eval_integer(ACPI_HANDLE handle, const char *path, ACPI_INTEGER *valp)
90 {
91 	ACPI_OBJECT obj;
92 	ACPI_BUFFER buf;
93 	ACPI_STATUS rv;
94 
95 	if (handle == NULL)
96 		handle = ACPI_ROOT_OBJECT;
97 
98 	(void)memset(&obj, 0, sizeof(obj));
99 	buf.Pointer = &obj;
100 	buf.Length = sizeof(obj);
101 
102 	rv = AcpiEvaluateObject(handle, path, NULL, &buf);
103 
104 	if (ACPI_FAILURE(rv))
105 		return rv;
106 
107 	/* Check that evaluation produced a return value. */
108 	if (buf.Length == 0)
109 		return AE_NULL_OBJECT;
110 
111 	if (obj.Type != ACPI_TYPE_INTEGER)
112 		return AE_TYPE;
113 
114 	if (valp != NULL)
115 		*valp = obj.Integer.Value;
116 
117 	return AE_OK;
118 }
119 
120 /*
121  * Evaluate an integer object with a single integer input parameter.
122  */
123 ACPI_STATUS
acpi_eval_set_integer(ACPI_HANDLE handle,const char * path,ACPI_INTEGER val)124 acpi_eval_set_integer(ACPI_HANDLE handle, const char *path, ACPI_INTEGER val)
125 {
126 	ACPI_OBJECT_LIST arg;
127 	ACPI_OBJECT obj;
128 
129 	if (handle == NULL)
130 		handle = ACPI_ROOT_OBJECT;
131 
132 	obj.Type = ACPI_TYPE_INTEGER;
133 	obj.Integer.Value = val;
134 
135 	arg.Count = 1;
136 	arg.Pointer = &obj;
137 
138 	return AcpiEvaluateObject(handle, path, &arg, NULL);
139 }
140 
141 /*
142  * Evaluate a (Unicode) string object.
143  */
144 ACPI_STATUS
acpi_eval_string(ACPI_HANDLE handle,const char * path,char ** stringp)145 acpi_eval_string(ACPI_HANDLE handle, const char *path, char **stringp)
146 {
147 	ACPI_OBJECT *obj;
148 	ACPI_BUFFER buf;
149 	ACPI_STATUS rv;
150 
151 	rv = acpi_eval_struct(handle, path, &buf);
152 
153 	if (ACPI_FAILURE(rv))
154 		return rv;
155 
156 	obj = buf.Pointer;
157 
158 	if (obj->Type != ACPI_TYPE_STRING) {
159 		rv = AE_TYPE;
160 		goto out;
161 	}
162 
163 	if (obj->String.Length == 0) {
164 		rv = AE_BAD_DATA;
165 		goto out;
166 	}
167 
168 	*stringp = ACPI_ALLOCATE(obj->String.Length + 1);
169 
170 	if (*stringp == NULL) {
171 		rv = AE_NO_MEMORY;
172 		goto out;
173 	}
174 
175 	(void)memcpy(*stringp, obj->String.Pointer, obj->String.Length);
176 
177 	(*stringp)[obj->String.Length] = '\0';
178 
179 out:
180 	ACPI_FREE(buf.Pointer);
181 
182 	return rv;
183 }
184 
185 /*
186  * Evaluate a structure. Caller must free buf.Pointer by ACPI_FREE().
187  */
188 ACPI_STATUS
acpi_eval_struct(ACPI_HANDLE handle,const char * path,ACPI_BUFFER * buf)189 acpi_eval_struct(ACPI_HANDLE handle, const char *path, ACPI_BUFFER *buf)
190 {
191 
192 	if (handle == NULL)
193 		handle = ACPI_ROOT_OBJECT;
194 
195 	buf->Pointer = NULL;
196 	buf->Length = ACPI_ALLOCATE_LOCAL_BUFFER;
197 
198 	return AcpiEvaluateObject(handle, path, NULL, buf);
199 }
200 
201 /*
202  * Evaluate a reference handle from an element in a package.
203  */
204 ACPI_STATUS
acpi_eval_reference_handle(ACPI_OBJECT * elm,ACPI_HANDLE * handle)205 acpi_eval_reference_handle(ACPI_OBJECT *elm, ACPI_HANDLE *handle)
206 {
207 
208 	if (elm == NULL || handle == NULL)
209 		return AE_BAD_PARAMETER;
210 
211 	switch (elm->Type) {
212 
213 	case ACPI_TYPE_ANY:
214 	case ACPI_TYPE_LOCAL_REFERENCE:
215 
216 		if (elm->Reference.Handle == NULL)
217 			return AE_NULL_ENTRY;
218 
219 		*handle = elm->Reference.Handle;
220 
221 		return AE_OK;
222 
223 	case ACPI_TYPE_STRING:
224 		return AcpiGetHandle(NULL, elm->String.Pointer, handle);
225 
226 	default:
227 		return AE_TYPE;
228 	}
229 }
230 
231 /*
232  * Iterate over all objects in a package, and pass them all
233  * to a function. If the called function returns non-AE_OK,
234  * the iteration is stopped and that value is returned.
235  */
236 ACPI_STATUS
acpi_foreach_package_object(ACPI_OBJECT * pkg,ACPI_STATUS (* func)(ACPI_OBJECT *,void *),void * arg)237 acpi_foreach_package_object(ACPI_OBJECT *pkg,
238     ACPI_STATUS (*func)(ACPI_OBJECT *, void *), void *arg)
239 {
240 	ACPI_STATUS rv = AE_OK;
241 	uint32_t i;
242 
243 	if (pkg == NULL)
244 		return AE_BAD_PARAMETER;
245 
246 	if (pkg->Type != ACPI_TYPE_PACKAGE)
247 		return AE_TYPE;
248 
249 	for (i = 0; i < pkg->Package.Count; i++) {
250 
251 		rv = (*func)(&pkg->Package.Elements[i], arg);
252 
253 		if (ACPI_FAILURE(rv))
254 			break;
255 	}
256 
257 	return rv;
258 }
259 
260 /*
261  * Fetch data info the specified (empty) ACPI buffer.
262  * Caller must free buf.Pointer by ACPI_FREE().
263  */
264 ACPI_STATUS
acpi_get(ACPI_HANDLE handle,ACPI_BUFFER * buf,ACPI_STATUS (* getit)(ACPI_HANDLE,ACPI_BUFFER *))265 acpi_get(ACPI_HANDLE handle, ACPI_BUFFER *buf,
266     ACPI_STATUS (*getit)(ACPI_HANDLE, ACPI_BUFFER *))
267 {
268 
269 	buf->Pointer = NULL;
270 	buf->Length = ACPI_ALLOCATE_LOCAL_BUFFER;
271 
272 	return (*getit)(handle, buf);
273 }
274 
275 /*
276  * Return a complete pathname from a handle.
277  *
278  * Note that the function uses static data storage;
279  * if the data is needed for future use, it should be
280  * copied before any subsequent calls overwrite it.
281  */
282 const char *
acpi_name(ACPI_HANDLE handle)283 acpi_name(ACPI_HANDLE handle)
284 {
285 	static char name[80];
286 	ACPI_BUFFER buf;
287 	ACPI_STATUS rv;
288 
289 	if (handle == NULL)
290 		handle = ACPI_ROOT_OBJECT;
291 
292 	buf.Pointer = name;
293 	buf.Length = sizeof(name);
294 
295 	rv = AcpiGetName(handle, ACPI_FULL_PATHNAME, &buf);
296 
297 	if (ACPI_FAILURE(rv))
298 		return "UNKNOWN";
299 
300 	return name;
301 }
302 
303 /*
304  * Match given IDs against _HID and _CIDs.
305  */
306 int
acpi_match_hid(ACPI_DEVICE_INFO * ad,const char * const * ids)307 acpi_match_hid(ACPI_DEVICE_INFO *ad, const char * const *ids)
308 {
309 	uint32_t i, n;
310 	char *id;
311 
312 	while (*ids) {
313 
314 		if ((ad->Valid & ACPI_VALID_HID) != 0) {
315 
316 			if (pmatch(ad->HardwareId.String, *ids, NULL) == 2)
317 				return 1;
318 		}
319 
320 		if ((ad->Valid & ACPI_VALID_CID) != 0) {
321 
322 			n = ad->CompatibleIdList.Count;
323 
324 			for (i = 0; i < n; i++) {
325 
326 				id = ad->CompatibleIdList.Ids[i].String;
327 
328 				if (pmatch(id, *ids, NULL) == 2)
329 					return 1;
330 			}
331 		}
332 
333 		ids++;
334 	}
335 
336 	return 0;
337 }
338 
339 /*
340  * Match a device node from a handle.
341  */
342 struct acpi_devnode *
acpi_match_node(ACPI_HANDLE handle)343 acpi_match_node(ACPI_HANDLE handle)
344 {
345 	struct acpi_devnode *ad;
346 	ACPI_STATUS rv;
347 
348 	if (handle == NULL)
349 		return NULL;
350 
351 	rv = AcpiGetData(handle, acpi_clean_node, (void **)&ad);
352 
353 	if (ACPI_FAILURE(rv))
354 		return NULL;
355 
356 	return ad;
357 }
358 
359 /*
360  * Permanently associate a device node with a handle.
361  */
362 void
acpi_match_node_init(struct acpi_devnode * ad)363 acpi_match_node_init(struct acpi_devnode *ad)
364 {
365 	(void)AcpiAttachData(ad->ad_handle, acpi_clean_node, ad);
366 }
367 
368 static void
acpi_clean_node(ACPI_HANDLE handle,void * aux)369 acpi_clean_node(ACPI_HANDLE handle, void *aux)
370 {
371 	/* Nothing. */
372 }
373 
374 /*
375  * Match a handle from a cpu_info. Returns NULL on failure.
376  *
377  * Note that acpi_match_node() can be used if the device node
378  * is also required.
379  */
380 ACPI_HANDLE
acpi_match_cpu_info(struct cpu_info * ci)381 acpi_match_cpu_info(struct cpu_info *ci)
382 {
383 	struct acpi_softc *sc = acpi_softc;
384 	struct acpi_devnode *ad;
385 	ACPI_INTEGER val;
386 	ACPI_OBJECT *obj;
387 	ACPI_BUFFER buf;
388 	ACPI_HANDLE hdl;
389 	ACPI_STATUS rv;
390 
391 	if (sc == NULL || acpi_active == 0)
392 		return NULL;
393 
394 	/*
395 	 * CPUs are declared in the ACPI namespace
396 	 * either as a Processor() or as a Device().
397 	 * In both cases the MADT entries are used
398 	 * for the match (see ACPI 4.0, section 8.4).
399 	 */
400 	SIMPLEQ_FOREACH(ad, &sc->ad_head, ad_list) {
401 
402 		hdl = ad->ad_handle;
403 
404 		switch (ad->ad_type) {
405 
406 		case ACPI_TYPE_DEVICE:
407 
408 			if (acpi_match_hid(ad->ad_devinfo, acpicpu_ids) == 0)
409 				break;
410 
411 			rv = acpi_eval_integer(hdl, "_UID", &val);
412 
413 			if (ACPI_SUCCESS(rv) && val == ci->ci_acpiid)
414 				return hdl;
415 
416 			break;
417 
418 		case ACPI_TYPE_PROCESSOR:
419 
420 			rv = acpi_eval_struct(hdl, NULL, &buf);
421 
422 			if (ACPI_FAILURE(rv))
423 				break;
424 
425 			obj = buf.Pointer;
426 
427 			if (obj->Processor.ProcId == ci->ci_acpiid) {
428 				ACPI_FREE(buf.Pointer);
429 				return hdl;
430 			}
431 
432 			ACPI_FREE(buf.Pointer);
433 			break;
434 		}
435 	}
436 
437 	return NULL;
438 }
439 
440 /*
441  * Match a CPU from a handle. Returns NULL on failure.
442  */
443 struct cpu_info *
acpi_match_cpu_handle(ACPI_HANDLE hdl)444 acpi_match_cpu_handle(ACPI_HANDLE hdl)
445 {
446 	struct cpu_info *ci;
447 	ACPI_DEVICE_INFO *di;
448 	CPU_INFO_ITERATOR cii;
449 	ACPI_INTEGER val;
450 	ACPI_OBJECT *obj;
451 	ACPI_BUFFER buf;
452 	ACPI_STATUS rv;
453 
454 	ci = NULL;
455 	di = NULL;
456 	buf.Pointer = NULL;
457 
458 	rv = AcpiGetObjectInfo(hdl, &di);
459 
460 	if (ACPI_FAILURE(rv))
461 		return NULL;
462 
463 	switch (di->Type) {
464 
465 	case ACPI_TYPE_DEVICE:
466 
467 		if (acpi_match_hid(di, acpicpu_ids) == 0)
468 			goto out;
469 
470 		rv = acpi_eval_integer(hdl, "_UID", &val);
471 
472 		if (ACPI_FAILURE(rv))
473 			goto out;
474 
475 		break;
476 
477 	case ACPI_TYPE_PROCESSOR:
478 
479 		rv = acpi_eval_struct(hdl, NULL, &buf);
480 
481 		if (ACPI_FAILURE(rv))
482 			goto out;
483 
484 		obj = buf.Pointer;
485 		val = obj->Processor.ProcId;
486 		break;
487 
488 	default:
489 		goto out;
490 	}
491 
492 	for (CPU_INFO_FOREACH(cii, ci)) {
493 
494 		if (ci->ci_acpiid == val)
495 			goto out;
496 	}
497 
498 	ci = NULL;
499 
500 out:
501 	if (di != NULL)
502 		ACPI_FREE(di);
503 
504 	if (buf.Pointer != NULL)
505 		ACPI_FREE(buf.Pointer);
506 
507 	return ci;
508 }
509