]>
Commit | Line | Data |
---|---|---|
ffdcd955 MW |
1 | /* |
2 | * ACPI device specific properties support. | |
3 | * | |
4 | * Copyright (C) 2014, Intel Corporation | |
5 | * All rights reserved. | |
6 | * | |
7 | * Authors: Mika Westerberg <mika.westerberg@linux.intel.com> | |
8 | * Darren Hart <dvhart@linux.intel.com> | |
9 | * Rafael J. Wysocki <rafael.j.wysocki@intel.com> | |
10 | * | |
11 | * This program is free software; you can redistribute it and/or modify | |
12 | * it under the terms of the GNU General Public License version 2 as | |
13 | * published by the Free Software Foundation. | |
14 | */ | |
15 | ||
16 | #include <linux/acpi.h> | |
17 | #include <linux/device.h> | |
18 | #include <linux/export.h> | |
19 | ||
20 | #include "internal.h" | |
21 | ||
22 | /* ACPI _DSD device properties UUID: daffd814-6eba-4d8c-8a91-bc9bbf4aa301 */ | |
23 | static const u8 prp_uuid[16] = { | |
24 | 0x14, 0xd8, 0xff, 0xda, 0xba, 0x6e, 0x8c, 0x4d, | |
25 | 0x8a, 0x91, 0xbc, 0x9b, 0xbf, 0x4a, 0xa3, 0x01 | |
26 | }; | |
27 | ||
28 | static bool acpi_property_value_ok(const union acpi_object *value) | |
29 | { | |
30 | int j; | |
31 | ||
32 | /* | |
33 | * The value must be an integer, a string, a reference, or a package | |
34 | * whose every element must be an integer, a string, or a reference. | |
35 | */ | |
36 | switch (value->type) { | |
37 | case ACPI_TYPE_INTEGER: | |
38 | case ACPI_TYPE_STRING: | |
39 | case ACPI_TYPE_LOCAL_REFERENCE: | |
40 | return true; | |
41 | ||
42 | case ACPI_TYPE_PACKAGE: | |
43 | for (j = 0; j < value->package.count; j++) | |
44 | switch (value->package.elements[j].type) { | |
45 | case ACPI_TYPE_INTEGER: | |
46 | case ACPI_TYPE_STRING: | |
47 | case ACPI_TYPE_LOCAL_REFERENCE: | |
48 | continue; | |
49 | ||
50 | default: | |
51 | return false; | |
52 | } | |
53 | ||
54 | return true; | |
55 | } | |
56 | return false; | |
57 | } | |
58 | ||
59 | static bool acpi_properties_format_valid(const union acpi_object *properties) | |
60 | { | |
61 | int i; | |
62 | ||
63 | for (i = 0; i < properties->package.count; i++) { | |
64 | const union acpi_object *property; | |
65 | ||
66 | property = &properties->package.elements[i]; | |
67 | /* | |
68 | * Only two elements allowed, the first one must be a string and | |
69 | * the second one has to satisfy certain conditions. | |
70 | */ | |
71 | if (property->package.count != 2 | |
72 | || property->package.elements[0].type != ACPI_TYPE_STRING | |
73 | || !acpi_property_value_ok(&property->package.elements[1])) | |
74 | return false; | |
75 | } | |
76 | return true; | |
77 | } | |
78 | ||
733e6251 MW |
79 | static void acpi_init_of_compatible(struct acpi_device *adev) |
80 | { | |
81 | const union acpi_object *of_compatible; | |
82 | struct acpi_hardware_id *hwid; | |
83 | bool acpi_of = false; | |
84 | int ret; | |
85 | ||
86 | /* | |
87 | * Check if the special PRP0001 ACPI ID is present and in that | |
88 | * case we fill in Device Tree compatible properties for this | |
89 | * device. | |
90 | */ | |
91 | list_for_each_entry(hwid, &adev->pnp.ids, list) { | |
92 | if (!strcmp(hwid->id, "PRP0001")) { | |
93 | acpi_of = true; | |
94 | break; | |
95 | } | |
96 | } | |
97 | ||
98 | if (!acpi_of) | |
99 | return; | |
100 | ||
101 | ret = acpi_dev_get_property_array(adev, "compatible", ACPI_TYPE_STRING, | |
102 | &of_compatible); | |
103 | if (ret) { | |
104 | ret = acpi_dev_get_property(adev, "compatible", | |
105 | ACPI_TYPE_STRING, &of_compatible); | |
106 | if (ret) { | |
107 | acpi_handle_warn(adev->handle, | |
108 | "PRP0001 requires compatible property\n"); | |
109 | return; | |
110 | } | |
111 | } | |
112 | adev->data.of_compatible = of_compatible; | |
113 | } | |
114 | ||
ffdcd955 MW |
115 | void acpi_init_properties(struct acpi_device *adev) |
116 | { | |
117 | struct acpi_buffer buf = { ACPI_ALLOCATE_BUFFER }; | |
118 | const union acpi_object *desc; | |
119 | acpi_status status; | |
120 | int i; | |
121 | ||
122 | status = acpi_evaluate_object_typed(adev->handle, "_DSD", NULL, &buf, | |
123 | ACPI_TYPE_PACKAGE); | |
124 | if (ACPI_FAILURE(status)) | |
125 | return; | |
126 | ||
127 | desc = buf.pointer; | |
128 | if (desc->package.count % 2) | |
129 | goto fail; | |
130 | ||
131 | /* Look for the device properties UUID. */ | |
132 | for (i = 0; i < desc->package.count; i += 2) { | |
133 | const union acpi_object *uuid, *properties; | |
134 | ||
135 | uuid = &desc->package.elements[i]; | |
136 | properties = &desc->package.elements[i + 1]; | |
137 | ||
138 | /* | |
139 | * The first element must be a UUID and the second one must be | |
140 | * a package. | |
141 | */ | |
142 | if (uuid->type != ACPI_TYPE_BUFFER || uuid->buffer.length != 16 | |
143 | || properties->type != ACPI_TYPE_PACKAGE) | |
144 | break; | |
145 | ||
146 | if (memcmp(uuid->buffer.pointer, prp_uuid, sizeof(prp_uuid))) | |
147 | continue; | |
148 | ||
149 | /* | |
150 | * We found the matching UUID. Now validate the format of the | |
151 | * package immediately following it. | |
152 | */ | |
153 | if (!acpi_properties_format_valid(properties)) | |
154 | break; | |
155 | ||
156 | adev->data.pointer = buf.pointer; | |
157 | adev->data.properties = properties; | |
733e6251 MW |
158 | |
159 | acpi_init_of_compatible(adev); | |
ffdcd955 MW |
160 | return; |
161 | } | |
162 | ||
163 | fail: | |
164 | dev_warn(&adev->dev, "Returned _DSD data is not valid, skipping\n"); | |
165 | ACPI_FREE(buf.pointer); | |
166 | } | |
167 | ||
168 | void acpi_free_properties(struct acpi_device *adev) | |
169 | { | |
170 | ACPI_FREE((void *)adev->data.pointer); | |
733e6251 | 171 | adev->data.of_compatible = NULL; |
ffdcd955 MW |
172 | adev->data.pointer = NULL; |
173 | adev->data.properties = NULL; | |
174 | } | |
175 | ||
176 | /** | |
177 | * acpi_dev_get_property - return an ACPI property with given name | |
178 | * @adev: ACPI device to get property | |
179 | * @name: Name of the property | |
180 | * @type: Expected property type | |
181 | * @obj: Location to store the property value (if not %NULL) | |
182 | * | |
183 | * Look up a property with @name and store a pointer to the resulting ACPI | |
184 | * object at the location pointed to by @obj if found. | |
185 | * | |
186 | * Callers must not attempt to free the returned objects. These objects will be | |
187 | * freed by the ACPI core automatically during the removal of @adev. | |
188 | * | |
189 | * Return: %0 if property with @name has been found (success), | |
190 | * %-EINVAL if the arguments are invalid, | |
191 | * %-ENODATA if the property doesn't exist, | |
192 | * %-EPROTO if the property value type doesn't match @type. | |
193 | */ | |
194 | int acpi_dev_get_property(struct acpi_device *adev, const char *name, | |
195 | acpi_object_type type, const union acpi_object **obj) | |
196 | { | |
197 | const union acpi_object *properties; | |
198 | int i; | |
199 | ||
200 | if (!adev || !name) | |
201 | return -EINVAL; | |
202 | ||
203 | if (!adev->data.pointer || !adev->data.properties) | |
204 | return -ENODATA; | |
205 | ||
206 | properties = adev->data.properties; | |
207 | for (i = 0; i < properties->package.count; i++) { | |
208 | const union acpi_object *propname, *propvalue; | |
209 | const union acpi_object *property; | |
210 | ||
211 | property = &properties->package.elements[i]; | |
212 | ||
213 | propname = &property->package.elements[0]; | |
214 | propvalue = &property->package.elements[1]; | |
215 | ||
216 | if (!strcmp(name, propname->string.pointer)) { | |
217 | if (type != ACPI_TYPE_ANY && propvalue->type != type) | |
218 | return -EPROTO; | |
219 | else if (obj) | |
220 | *obj = propvalue; | |
221 | ||
222 | return 0; | |
223 | } | |
224 | } | |
225 | return -ENODATA; | |
226 | } | |
227 | EXPORT_SYMBOL_GPL(acpi_dev_get_property); | |
228 | ||
229 | /** | |
230 | * acpi_dev_get_property_array - return an ACPI array property with given name | |
231 | * @adev: ACPI device to get property | |
232 | * @name: Name of the property | |
233 | * @type: Expected type of array elements | |
234 | * @obj: Location to store a pointer to the property value (if not NULL) | |
235 | * | |
236 | * Look up an array property with @name and store a pointer to the resulting | |
237 | * ACPI object at the location pointed to by @obj if found. | |
238 | * | |
239 | * Callers must not attempt to free the returned objects. Those objects will be | |
240 | * freed by the ACPI core automatically during the removal of @adev. | |
241 | * | |
242 | * Return: %0 if array property (package) with @name has been found (success), | |
243 | * %-EINVAL if the arguments are invalid, | |
244 | * %-ENODATA if the property doesn't exist, | |
245 | * %-EPROTO if the property is not a package or the type of its elements | |
246 | * doesn't match @type. | |
247 | */ | |
248 | int acpi_dev_get_property_array(struct acpi_device *adev, const char *name, | |
249 | acpi_object_type type, | |
250 | const union acpi_object **obj) | |
251 | { | |
252 | const union acpi_object *prop; | |
253 | int ret, i; | |
254 | ||
255 | ret = acpi_dev_get_property(adev, name, ACPI_TYPE_PACKAGE, &prop); | |
256 | if (ret) | |
257 | return ret; | |
258 | ||
259 | if (type != ACPI_TYPE_ANY) { | |
260 | /* Check that all elements are of correct type. */ | |
261 | for (i = 0; i < prop->package.count; i++) | |
262 | if (prop->package.elements[i].type != type) | |
263 | return -EPROTO; | |
264 | } | |
265 | if (obj) | |
266 | *obj = prop; | |
267 | ||
268 | return 0; | |
269 | } | |
270 | EXPORT_SYMBOL_GPL(acpi_dev_get_property_array); | |
271 | ||
272 | /** | |
273 | * acpi_dev_get_property_reference - returns handle to the referenced object | |
274 | * @adev: ACPI device to get property | |
275 | * @name: Name of the property | |
ffdcd955 MW |
276 | * @index: Index of the reference to return |
277 | * @args: Location to store the returned reference with optional arguments | |
278 | * | |
279 | * Find property with @name, verifify that it is a package containing at least | |
280 | * one object reference and if so, store the ACPI device object pointer to the | |
60ba032e RW |
281 | * target object in @args->adev. If the reference includes arguments, store |
282 | * them in the @args->args[] array. | |
ffdcd955 | 283 | * |
60ba032e RW |
284 | * If there's more than one reference in the property value package, @index is |
285 | * used to select the one to return. | |
ffdcd955 MW |
286 | * |
287 | * Return: %0 on success, negative error code on failure. | |
288 | */ | |
60ba032e RW |
289 | int acpi_dev_get_property_reference(struct acpi_device *adev, |
290 | const char *name, size_t index, | |
ffdcd955 MW |
291 | struct acpi_reference_args *args) |
292 | { | |
293 | const union acpi_object *element, *end; | |
294 | const union acpi_object *obj; | |
295 | struct acpi_device *device; | |
296 | int ret, idx = 0; | |
297 | ||
298 | ret = acpi_dev_get_property(adev, name, ACPI_TYPE_ANY, &obj); | |
299 | if (ret) | |
300 | return ret; | |
301 | ||
302 | /* | |
303 | * The simplest case is when the value is a single reference. Just | |
304 | * return that reference then. | |
305 | */ | |
306 | if (obj->type == ACPI_TYPE_LOCAL_REFERENCE) { | |
60ba032e | 307 | if (index) |
ffdcd955 MW |
308 | return -EINVAL; |
309 | ||
310 | ret = acpi_bus_get_device(obj->reference.handle, &device); | |
311 | if (ret) | |
312 | return ret; | |
313 | ||
314 | args->adev = device; | |
315 | args->nargs = 0; | |
316 | return 0; | |
317 | } | |
318 | ||
319 | /* | |
320 | * If it is not a single reference, then it is a package of | |
321 | * references followed by number of ints as follows: | |
322 | * | |
323 | * Package () { REF, INT, REF, INT, INT } | |
324 | * | |
325 | * The index argument is then used to determine which reference | |
326 | * the caller wants (along with the arguments). | |
327 | */ | |
328 | if (obj->type != ACPI_TYPE_PACKAGE || index >= obj->package.count) | |
329 | return -EPROTO; | |
330 | ||
331 | element = obj->package.elements; | |
332 | end = element + obj->package.count; | |
333 | ||
334 | while (element < end) { | |
335 | u32 nargs, i; | |
336 | ||
337 | if (element->type != ACPI_TYPE_LOCAL_REFERENCE) | |
338 | return -EPROTO; | |
339 | ||
340 | ret = acpi_bus_get_device(element->reference.handle, &device); | |
341 | if (ret) | |
342 | return -ENODEV; | |
343 | ||
344 | element++; | |
345 | nargs = 0; | |
346 | ||
60ba032e RW |
347 | /* assume following integer elements are all args */ |
348 | for (i = 0; element + i < end; i++) { | |
349 | int type = element[i].type; | |
ffdcd955 | 350 | |
60ba032e RW |
351 | if (type == ACPI_TYPE_INTEGER) |
352 | nargs++; | |
353 | else if (type == ACPI_TYPE_LOCAL_REFERENCE) | |
354 | break; | |
355 | else | |
356 | return -EPROTO; | |
ffdcd955 MW |
357 | } |
358 | ||
359 | if (idx++ == index) { | |
360 | args->adev = device; | |
361 | args->nargs = nargs; | |
362 | for (i = 0; i < nargs; i++) | |
363 | args->args[i] = element[i].integer.value; | |
364 | ||
365 | return 0; | |
366 | } | |
367 | ||
368 | element += nargs; | |
369 | } | |
370 | ||
371 | return -EPROTO; | |
372 | } | |
373 | EXPORT_SYMBOL_GPL(acpi_dev_get_property_reference); | |
b31384fa RW |
374 | |
375 | int acpi_dev_prop_get(struct acpi_device *adev, const char *propname, | |
376 | void **valptr) | |
377 | { | |
378 | return acpi_dev_get_property(adev, propname, ACPI_TYPE_ANY, | |
379 | (const union acpi_object **)valptr); | |
380 | } | |
381 | ||
382 | int acpi_dev_prop_read_single(struct acpi_device *adev, const char *propname, | |
383 | enum dev_prop_type proptype, void *val) | |
384 | { | |
385 | const union acpi_object *obj; | |
386 | int ret; | |
387 | ||
388 | if (!val) | |
389 | return -EINVAL; | |
390 | ||
391 | if (proptype >= DEV_PROP_U8 && proptype <= DEV_PROP_U64) { | |
392 | ret = acpi_dev_get_property(adev, propname, ACPI_TYPE_INTEGER, &obj); | |
393 | if (ret) | |
394 | return ret; | |
395 | ||
396 | switch (proptype) { | |
397 | case DEV_PROP_U8: | |
398 | if (obj->integer.value > U8_MAX) | |
399 | return -EOVERFLOW; | |
400 | *(u8 *)val = obj->integer.value; | |
401 | break; | |
402 | case DEV_PROP_U16: | |
403 | if (obj->integer.value > U16_MAX) | |
404 | return -EOVERFLOW; | |
405 | *(u16 *)val = obj->integer.value; | |
406 | break; | |
407 | case DEV_PROP_U32: | |
408 | if (obj->integer.value > U32_MAX) | |
409 | return -EOVERFLOW; | |
410 | *(u32 *)val = obj->integer.value; | |
411 | break; | |
412 | default: | |
413 | *(u64 *)val = obj->integer.value; | |
414 | break; | |
415 | } | |
416 | } else if (proptype == DEV_PROP_STRING) { | |
417 | ret = acpi_dev_get_property(adev, propname, ACPI_TYPE_STRING, &obj); | |
418 | if (ret) | |
419 | return ret; | |
420 | ||
421 | *(char **)val = obj->string.pointer; | |
422 | } else { | |
423 | ret = -EINVAL; | |
424 | } | |
425 | return ret; | |
426 | } | |
427 | ||
428 | static int acpi_copy_property_array_u8(const union acpi_object *items, u8 *val, | |
429 | size_t nval) | |
430 | { | |
431 | int i; | |
432 | ||
433 | for (i = 0; i < nval; i++) { | |
434 | if (items[i].type != ACPI_TYPE_INTEGER) | |
435 | return -EPROTO; | |
436 | if (items[i].integer.value > U8_MAX) | |
437 | return -EOVERFLOW; | |
438 | ||
439 | val[i] = items[i].integer.value; | |
440 | } | |
441 | return 0; | |
442 | } | |
443 | ||
444 | static int acpi_copy_property_array_u16(const union acpi_object *items, | |
445 | u16 *val, size_t nval) | |
446 | { | |
447 | int i; | |
448 | ||
449 | for (i = 0; i < nval; i++) { | |
450 | if (items[i].type != ACPI_TYPE_INTEGER) | |
451 | return -EPROTO; | |
452 | if (items[i].integer.value > U16_MAX) | |
453 | return -EOVERFLOW; | |
454 | ||
455 | val[i] = items[i].integer.value; | |
456 | } | |
457 | return 0; | |
458 | } | |
459 | ||
460 | static int acpi_copy_property_array_u32(const union acpi_object *items, | |
461 | u32 *val, size_t nval) | |
462 | { | |
463 | int i; | |
464 | ||
465 | for (i = 0; i < nval; i++) { | |
466 | if (items[i].type != ACPI_TYPE_INTEGER) | |
467 | return -EPROTO; | |
468 | if (items[i].integer.value > U32_MAX) | |
469 | return -EOVERFLOW; | |
470 | ||
471 | val[i] = items[i].integer.value; | |
472 | } | |
473 | return 0; | |
474 | } | |
475 | ||
476 | static int acpi_copy_property_array_u64(const union acpi_object *items, | |
477 | u64 *val, size_t nval) | |
478 | { | |
479 | int i; | |
480 | ||
481 | for (i = 0; i < nval; i++) { | |
482 | if (items[i].type != ACPI_TYPE_INTEGER) | |
483 | return -EPROTO; | |
484 | ||
485 | val[i] = items[i].integer.value; | |
486 | } | |
487 | return 0; | |
488 | } | |
489 | ||
490 | static int acpi_copy_property_array_string(const union acpi_object *items, | |
491 | char **val, size_t nval) | |
492 | { | |
493 | int i; | |
494 | ||
495 | for (i = 0; i < nval; i++) { | |
496 | if (items[i].type != ACPI_TYPE_STRING) | |
497 | return -EPROTO; | |
498 | ||
499 | val[i] = items[i].string.pointer; | |
500 | } | |
501 | return 0; | |
502 | } | |
503 | ||
504 | int acpi_dev_prop_read(struct acpi_device *adev, const char *propname, | |
505 | enum dev_prop_type proptype, void *val, size_t nval) | |
506 | { | |
507 | const union acpi_object *obj; | |
508 | const union acpi_object *items; | |
509 | int ret; | |
510 | ||
511 | if (val && nval == 1) { | |
512 | ret = acpi_dev_prop_read_single(adev, propname, proptype, val); | |
513 | if (!ret) | |
514 | return ret; | |
515 | } | |
516 | ||
517 | ret = acpi_dev_get_property_array(adev, propname, ACPI_TYPE_ANY, &obj); | |
518 | if (ret) | |
519 | return ret; | |
520 | ||
521 | if (!val) | |
522 | return obj->package.count; | |
523 | else if (nval <= 0) | |
524 | return -EINVAL; | |
525 | ||
526 | if (nval > obj->package.count) | |
527 | return -EOVERFLOW; | |
528 | ||
529 | items = obj->package.elements; | |
530 | switch (proptype) { | |
531 | case DEV_PROP_U8: | |
532 | ret = acpi_copy_property_array_u8(items, (u8 *)val, nval); | |
533 | break; | |
534 | case DEV_PROP_U16: | |
535 | ret = acpi_copy_property_array_u16(items, (u16 *)val, nval); | |
536 | break; | |
537 | case DEV_PROP_U32: | |
538 | ret = acpi_copy_property_array_u32(items, (u32 *)val, nval); | |
539 | break; | |
540 | case DEV_PROP_U64: | |
541 | ret = acpi_copy_property_array_u64(items, (u64 *)val, nval); | |
542 | break; | |
543 | case DEV_PROP_STRING: | |
544 | ret = acpi_copy_property_array_string(items, (char **)val, nval); | |
545 | break; | |
546 | default: | |
547 | ret = -EINVAL; | |
548 | break; | |
549 | } | |
550 | return ret; | |
551 | } |