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 | ||
3a7a2ab8 RW |
22 | static int acpi_data_get_property_array(struct acpi_device_data *data, |
23 | const char *name, | |
24 | acpi_object_type type, | |
25 | const union acpi_object **obj); | |
26 | ||
ffdcd955 MW |
27 | /* ACPI _DSD device properties UUID: daffd814-6eba-4d8c-8a91-bc9bbf4aa301 */ |
28 | static const u8 prp_uuid[16] = { | |
29 | 0x14, 0xd8, 0xff, 0xda, 0xba, 0x6e, 0x8c, 0x4d, | |
30 | 0x8a, 0x91, 0xbc, 0x9b, 0xbf, 0x4a, 0xa3, 0x01 | |
31 | }; | |
445b0eb0 RW |
32 | /* ACPI _DSD data subnodes UUID: dbb8e3e6-5886-4ba6-8795-1319f52a966b */ |
33 | static const u8 ads_uuid[16] = { | |
34 | 0xe6, 0xe3, 0xb8, 0xdb, 0x86, 0x58, 0xa6, 0x4b, | |
35 | 0x87, 0x95, 0x13, 0x19, 0xf5, 0x2a, 0x96, 0x6b | |
36 | }; | |
37 | ||
38 | static bool acpi_enumerate_nondev_subnodes(acpi_handle scope, | |
39 | const union acpi_object *desc, | |
40 | struct acpi_device_data *data); | |
41 | static bool acpi_extract_properties(const union acpi_object *desc, | |
42 | struct acpi_device_data *data); | |
43 | ||
44 | static bool acpi_nondev_subnode_ok(acpi_handle scope, | |
45 | const union acpi_object *link, | |
46 | struct list_head *list) | |
47 | { | |
48 | struct acpi_buffer buf = { ACPI_ALLOCATE_BUFFER }; | |
49 | struct acpi_data_node *dn; | |
50 | acpi_handle handle; | |
51 | acpi_status status; | |
52 | ||
53 | dn = kzalloc(sizeof(*dn), GFP_KERNEL); | |
54 | if (!dn) | |
55 | return false; | |
56 | ||
57 | dn->name = link->package.elements[0].string.pointer; | |
58 | dn->fwnode.type = FWNODE_ACPI_DATA; | |
59 | INIT_LIST_HEAD(&dn->data.subnodes); | |
60 | ||
61 | status = acpi_get_handle(scope, link->package.elements[1].string.pointer, | |
62 | &handle); | |
63 | if (ACPI_FAILURE(status)) | |
64 | goto fail; | |
65 | ||
66 | status = acpi_evaluate_object_typed(handle, NULL, NULL, &buf, | |
67 | ACPI_TYPE_PACKAGE); | |
68 | if (ACPI_FAILURE(status)) | |
69 | goto fail; | |
70 | ||
71 | if (acpi_extract_properties(buf.pointer, &dn->data)) | |
263b4c1a | 72 | dn->handle = handle; |
445b0eb0 | 73 | |
205ad97f RW |
74 | /* |
75 | * The scope for the subnode object lookup is the one of the namespace | |
76 | * node (device) containing the object that has returned the package. | |
77 | * That is, it's the scope of that object's parent. | |
78 | */ | |
79 | status = acpi_get_parent(handle, &scope); | |
80 | if (ACPI_SUCCESS(status) | |
81 | && acpi_enumerate_nondev_subnodes(scope, buf.pointer, &dn->data)) | |
263b4c1a | 82 | dn->handle = handle; |
445b0eb0 | 83 | |
263b4c1a RW |
84 | if (dn->handle) { |
85 | dn->data.pointer = buf.pointer; | |
445b0eb0 RW |
86 | list_add_tail(&dn->sibling, list); |
87 | return true; | |
88 | } | |
89 | ||
90 | acpi_handle_debug(handle, "Invalid properties/subnodes data, skipping\n"); | |
91 | ||
92 | fail: | |
93 | ACPI_FREE(buf.pointer); | |
94 | kfree(dn); | |
95 | return false; | |
96 | } | |
97 | ||
98 | static int acpi_add_nondev_subnodes(acpi_handle scope, | |
99 | const union acpi_object *links, | |
100 | struct list_head *list) | |
101 | { | |
102 | bool ret = false; | |
103 | int i; | |
104 | ||
105 | for (i = 0; i < links->package.count; i++) { | |
106 | const union acpi_object *link; | |
107 | ||
108 | link = &links->package.elements[i]; | |
109 | /* Only two elements allowed, both must be strings. */ | |
110 | if (link->package.count == 2 | |
111 | && link->package.elements[0].type == ACPI_TYPE_STRING | |
112 | && link->package.elements[1].type == ACPI_TYPE_STRING | |
113 | && acpi_nondev_subnode_ok(scope, link, list)) | |
114 | ret = true; | |
115 | } | |
116 | ||
117 | return ret; | |
118 | } | |
119 | ||
120 | static bool acpi_enumerate_nondev_subnodes(acpi_handle scope, | |
121 | const union acpi_object *desc, | |
122 | struct acpi_device_data *data) | |
123 | { | |
124 | int i; | |
125 | ||
126 | /* Look for the ACPI data subnodes UUID. */ | |
127 | for (i = 0; i < desc->package.count; i += 2) { | |
128 | const union acpi_object *uuid, *links; | |
129 | ||
130 | uuid = &desc->package.elements[i]; | |
131 | links = &desc->package.elements[i + 1]; | |
132 | ||
133 | /* | |
134 | * The first element must be a UUID and the second one must be | |
135 | * a package. | |
136 | */ | |
137 | if (uuid->type != ACPI_TYPE_BUFFER || uuid->buffer.length != 16 | |
138 | || links->type != ACPI_TYPE_PACKAGE) | |
139 | break; | |
140 | ||
141 | if (memcmp(uuid->buffer.pointer, ads_uuid, sizeof(ads_uuid))) | |
142 | continue; | |
143 | ||
144 | return acpi_add_nondev_subnodes(scope, links, &data->subnodes); | |
145 | } | |
146 | ||
147 | return false; | |
148 | } | |
ffdcd955 MW |
149 | |
150 | static bool acpi_property_value_ok(const union acpi_object *value) | |
151 | { | |
152 | int j; | |
153 | ||
154 | /* | |
155 | * The value must be an integer, a string, a reference, or a package | |
156 | * whose every element must be an integer, a string, or a reference. | |
157 | */ | |
158 | switch (value->type) { | |
159 | case ACPI_TYPE_INTEGER: | |
160 | case ACPI_TYPE_STRING: | |
161 | case ACPI_TYPE_LOCAL_REFERENCE: | |
162 | return true; | |
163 | ||
164 | case ACPI_TYPE_PACKAGE: | |
165 | for (j = 0; j < value->package.count; j++) | |
166 | switch (value->package.elements[j].type) { | |
167 | case ACPI_TYPE_INTEGER: | |
168 | case ACPI_TYPE_STRING: | |
169 | case ACPI_TYPE_LOCAL_REFERENCE: | |
170 | continue; | |
171 | ||
172 | default: | |
173 | return false; | |
174 | } | |
175 | ||
176 | return true; | |
177 | } | |
178 | return false; | |
179 | } | |
180 | ||
181 | static bool acpi_properties_format_valid(const union acpi_object *properties) | |
182 | { | |
183 | int i; | |
184 | ||
185 | for (i = 0; i < properties->package.count; i++) { | |
186 | const union acpi_object *property; | |
187 | ||
188 | property = &properties->package.elements[i]; | |
189 | /* | |
190 | * Only two elements allowed, the first one must be a string and | |
191 | * the second one has to satisfy certain conditions. | |
192 | */ | |
193 | if (property->package.count != 2 | |
194 | || property->package.elements[0].type != ACPI_TYPE_STRING | |
195 | || !acpi_property_value_ok(&property->package.elements[1])) | |
196 | return false; | |
197 | } | |
198 | return true; | |
199 | } | |
200 | ||
733e6251 MW |
201 | static void acpi_init_of_compatible(struct acpi_device *adev) |
202 | { | |
203 | const union acpi_object *of_compatible; | |
733e6251 MW |
204 | int ret; |
205 | ||
3a7a2ab8 RW |
206 | ret = acpi_data_get_property_array(&adev->data, "compatible", |
207 | ACPI_TYPE_STRING, &of_compatible); | |
733e6251 MW |
208 | if (ret) { |
209 | ret = acpi_dev_get_property(adev, "compatible", | |
210 | ACPI_TYPE_STRING, &of_compatible); | |
211 | if (ret) { | |
5c53b262 RW |
212 | if (adev->parent |
213 | && adev->parent->flags.of_compatible_ok) | |
214 | goto out; | |
215 | ||
733e6251 MW |
216 | return; |
217 | } | |
218 | } | |
219 | adev->data.of_compatible = of_compatible; | |
5c53b262 RW |
220 | |
221 | out: | |
222 | adev->flags.of_compatible_ok = 1; | |
733e6251 MW |
223 | } |
224 | ||
bd8191cc RW |
225 | static bool acpi_extract_properties(const union acpi_object *desc, |
226 | struct acpi_device_data *data) | |
ffdcd955 | 227 | { |
ffdcd955 MW |
228 | int i; |
229 | ||
ffdcd955 | 230 | if (desc->package.count % 2) |
bd8191cc | 231 | return false; |
ffdcd955 MW |
232 | |
233 | /* Look for the device properties UUID. */ | |
234 | for (i = 0; i < desc->package.count; i += 2) { | |
235 | const union acpi_object *uuid, *properties; | |
236 | ||
237 | uuid = &desc->package.elements[i]; | |
238 | properties = &desc->package.elements[i + 1]; | |
239 | ||
240 | /* | |
241 | * The first element must be a UUID and the second one must be | |
242 | * a package. | |
243 | */ | |
244 | if (uuid->type != ACPI_TYPE_BUFFER || uuid->buffer.length != 16 | |
245 | || properties->type != ACPI_TYPE_PACKAGE) | |
246 | break; | |
247 | ||
248 | if (memcmp(uuid->buffer.pointer, prp_uuid, sizeof(prp_uuid))) | |
249 | continue; | |
250 | ||
251 | /* | |
252 | * We found the matching UUID. Now validate the format of the | |
253 | * package immediately following it. | |
254 | */ | |
255 | if (!acpi_properties_format_valid(properties)) | |
256 | break; | |
257 | ||
bd8191cc RW |
258 | data->properties = properties; |
259 | return true; | |
260 | } | |
733e6251 | 261 | |
bd8191cc RW |
262 | return false; |
263 | } | |
5c53b262 | 264 | |
bd8191cc RW |
265 | void acpi_init_properties(struct acpi_device *adev) |
266 | { | |
267 | struct acpi_buffer buf = { ACPI_ALLOCATE_BUFFER }; | |
268 | struct acpi_hardware_id *hwid; | |
269 | acpi_status status; | |
270 | bool acpi_of = false; | |
271 | ||
445b0eb0 RW |
272 | INIT_LIST_HEAD(&adev->data.subnodes); |
273 | ||
bd8191cc RW |
274 | /* |
275 | * Check if ACPI_DT_NAMESPACE_HID is present and inthat case we fill in | |
276 | * Device Tree compatible properties for this device. | |
277 | */ | |
278 | list_for_each_entry(hwid, &adev->pnp.ids, list) { | |
279 | if (!strcmp(hwid->id, ACPI_DT_NAMESPACE_HID)) { | |
280 | acpi_of = true; | |
281 | break; | |
282 | } | |
ffdcd955 MW |
283 | } |
284 | ||
bd8191cc RW |
285 | status = acpi_evaluate_object_typed(adev->handle, "_DSD", NULL, &buf, |
286 | ACPI_TYPE_PACKAGE); | |
287 | if (ACPI_FAILURE(status)) | |
288 | goto out; | |
289 | ||
290 | if (acpi_extract_properties(buf.pointer, &adev->data)) { | |
291 | adev->data.pointer = buf.pointer; | |
292 | if (acpi_of) | |
293 | acpi_init_of_compatible(adev); | |
445b0eb0 RW |
294 | } |
295 | if (acpi_enumerate_nondev_subnodes(adev->handle, buf.pointer, &adev->data)) | |
296 | adev->data.pointer = buf.pointer; | |
297 | ||
298 | if (!adev->data.pointer) { | |
bd8191cc RW |
299 | acpi_handle_debug(adev->handle, "Invalid _DSD data, skipping\n"); |
300 | ACPI_FREE(buf.pointer); | |
301 | } | |
5c53b262 RW |
302 | |
303 | out: | |
304 | if (acpi_of && !adev->flags.of_compatible_ok) | |
305 | acpi_handle_info(adev->handle, | |
ee892094 | 306 | ACPI_DT_NAMESPACE_HID " requires 'compatible' property\n"); |
ffdcd955 MW |
307 | } |
308 | ||
445b0eb0 RW |
309 | static void acpi_destroy_nondev_subnodes(struct list_head *list) |
310 | { | |
311 | struct acpi_data_node *dn, *next; | |
312 | ||
313 | if (list_empty(list)) | |
314 | return; | |
315 | ||
316 | list_for_each_entry_safe_reverse(dn, next, list, sibling) { | |
317 | acpi_destroy_nondev_subnodes(&dn->data.subnodes); | |
263b4c1a | 318 | wait_for_completion(&dn->kobj_done); |
445b0eb0 RW |
319 | list_del(&dn->sibling); |
320 | ACPI_FREE((void *)dn->data.pointer); | |
321 | kfree(dn); | |
322 | } | |
323 | } | |
324 | ||
ffdcd955 MW |
325 | void acpi_free_properties(struct acpi_device *adev) |
326 | { | |
445b0eb0 | 327 | acpi_destroy_nondev_subnodes(&adev->data.subnodes); |
ffdcd955 | 328 | ACPI_FREE((void *)adev->data.pointer); |
733e6251 | 329 | adev->data.of_compatible = NULL; |
ffdcd955 MW |
330 | adev->data.pointer = NULL; |
331 | adev->data.properties = NULL; | |
332 | } | |
333 | ||
334 | /** | |
3a7a2ab8 RW |
335 | * acpi_data_get_property - return an ACPI property with given name |
336 | * @data: ACPI device deta object to get the property from | |
ffdcd955 MW |
337 | * @name: Name of the property |
338 | * @type: Expected property type | |
339 | * @obj: Location to store the property value (if not %NULL) | |
340 | * | |
341 | * Look up a property with @name and store a pointer to the resulting ACPI | |
342 | * object at the location pointed to by @obj if found. | |
343 | * | |
344 | * Callers must not attempt to free the returned objects. These objects will be | |
3a7a2ab8 | 345 | * freed by the ACPI core automatically during the removal of @data. |
ffdcd955 MW |
346 | * |
347 | * Return: %0 if property with @name has been found (success), | |
348 | * %-EINVAL if the arguments are invalid, | |
3c60f114 | 349 | * %-EINVAL if the property doesn't exist, |
ffdcd955 MW |
350 | * %-EPROTO if the property value type doesn't match @type. |
351 | */ | |
3a7a2ab8 RW |
352 | static int acpi_data_get_property(struct acpi_device_data *data, |
353 | const char *name, acpi_object_type type, | |
354 | const union acpi_object **obj) | |
ffdcd955 MW |
355 | { |
356 | const union acpi_object *properties; | |
357 | int i; | |
358 | ||
3a7a2ab8 | 359 | if (!data || !name) |
ffdcd955 MW |
360 | return -EINVAL; |
361 | ||
3a7a2ab8 | 362 | if (!data->pointer || !data->properties) |
3c60f114 | 363 | return -EINVAL; |
ffdcd955 | 364 | |
3a7a2ab8 | 365 | properties = data->properties; |
ffdcd955 MW |
366 | for (i = 0; i < properties->package.count; i++) { |
367 | const union acpi_object *propname, *propvalue; | |
368 | const union acpi_object *property; | |
369 | ||
370 | property = &properties->package.elements[i]; | |
371 | ||
372 | propname = &property->package.elements[0]; | |
373 | propvalue = &property->package.elements[1]; | |
374 | ||
375 | if (!strcmp(name, propname->string.pointer)) { | |
376 | if (type != ACPI_TYPE_ANY && propvalue->type != type) | |
377 | return -EPROTO; | |
3c60f114 | 378 | if (obj) |
ffdcd955 MW |
379 | *obj = propvalue; |
380 | ||
381 | return 0; | |
382 | } | |
383 | } | |
3c60f114 | 384 | return -EINVAL; |
ffdcd955 | 385 | } |
3a7a2ab8 RW |
386 | |
387 | /** | |
388 | * acpi_dev_get_property - return an ACPI property with given name. | |
389 | * @adev: ACPI device to get the property from. | |
390 | * @name: Name of the property. | |
391 | * @type: Expected property type. | |
392 | * @obj: Location to store the property value (if not %NULL). | |
393 | */ | |
394 | int acpi_dev_get_property(struct acpi_device *adev, const char *name, | |
395 | acpi_object_type type, const union acpi_object **obj) | |
396 | { | |
397 | return adev ? acpi_data_get_property(&adev->data, name, type, obj) : -EINVAL; | |
398 | } | |
ffdcd955 MW |
399 | EXPORT_SYMBOL_GPL(acpi_dev_get_property); |
400 | ||
3a7a2ab8 RW |
401 | static struct acpi_device_data *acpi_device_data_of_node(struct fwnode_handle *fwnode) |
402 | { | |
403 | if (fwnode->type == FWNODE_ACPI) { | |
404 | struct acpi_device *adev = to_acpi_device_node(fwnode); | |
405 | return &adev->data; | |
406 | } else if (fwnode->type == FWNODE_ACPI_DATA) { | |
407 | struct acpi_data_node *dn = to_acpi_data_node(fwnode); | |
408 | return &dn->data; | |
409 | } | |
410 | return NULL; | |
411 | } | |
412 | ||
ffdcd955 | 413 | /** |
3a7a2ab8 RW |
414 | * acpi_node_prop_get - return an ACPI property with given name. |
415 | * @fwnode: Firmware node to get the property from. | |
416 | * @propname: Name of the property. | |
417 | * @valptr: Location to store a pointer to the property value (if not %NULL). | |
418 | */ | |
419 | int acpi_node_prop_get(struct fwnode_handle *fwnode, const char *propname, | |
420 | void **valptr) | |
421 | { | |
422 | return acpi_data_get_property(acpi_device_data_of_node(fwnode), | |
423 | propname, ACPI_TYPE_ANY, | |
424 | (const union acpi_object **)valptr); | |
425 | } | |
426 | ||
427 | /** | |
428 | * acpi_data_get_property_array - return an ACPI array property with given name | |
429 | * @adev: ACPI data object to get the property from | |
ffdcd955 MW |
430 | * @name: Name of the property |
431 | * @type: Expected type of array elements | |
432 | * @obj: Location to store a pointer to the property value (if not NULL) | |
433 | * | |
434 | * Look up an array property with @name and store a pointer to the resulting | |
435 | * ACPI object at the location pointed to by @obj if found. | |
436 | * | |
437 | * Callers must not attempt to free the returned objects. Those objects will be | |
3a7a2ab8 | 438 | * freed by the ACPI core automatically during the removal of @data. |
ffdcd955 MW |
439 | * |
440 | * Return: %0 if array property (package) with @name has been found (success), | |
441 | * %-EINVAL if the arguments are invalid, | |
3c60f114 | 442 | * %-EINVAL if the property doesn't exist, |
ffdcd955 MW |
443 | * %-EPROTO if the property is not a package or the type of its elements |
444 | * doesn't match @type. | |
445 | */ | |
3a7a2ab8 RW |
446 | static int acpi_data_get_property_array(struct acpi_device_data *data, |
447 | const char *name, | |
448 | acpi_object_type type, | |
449 | const union acpi_object **obj) | |
ffdcd955 MW |
450 | { |
451 | const union acpi_object *prop; | |
452 | int ret, i; | |
453 | ||
3a7a2ab8 | 454 | ret = acpi_data_get_property(data, name, ACPI_TYPE_PACKAGE, &prop); |
ffdcd955 MW |
455 | if (ret) |
456 | return ret; | |
457 | ||
458 | if (type != ACPI_TYPE_ANY) { | |
459 | /* Check that all elements are of correct type. */ | |
460 | for (i = 0; i < prop->package.count; i++) | |
461 | if (prop->package.elements[i].type != type) | |
462 | return -EPROTO; | |
463 | } | |
464 | if (obj) | |
465 | *obj = prop; | |
466 | ||
467 | return 0; | |
468 | } | |
ffdcd955 MW |
469 | |
470 | /** | |
504a3374 RW |
471 | * acpi_data_get_property_reference - returns handle to the referenced object |
472 | * @data: ACPI device data object containing the property | |
473 | * @propname: Name of the property | |
ffdcd955 MW |
474 | * @index: Index of the reference to return |
475 | * @args: Location to store the returned reference with optional arguments | |
476 | * | |
477 | * Find property with @name, verifify that it is a package containing at least | |
478 | * one object reference and if so, store the ACPI device object pointer to the | |
60ba032e RW |
479 | * target object in @args->adev. If the reference includes arguments, store |
480 | * them in the @args->args[] array. | |
ffdcd955 | 481 | * |
60ba032e RW |
482 | * If there's more than one reference in the property value package, @index is |
483 | * used to select the one to return. | |
ffdcd955 MW |
484 | * |
485 | * Return: %0 on success, negative error code on failure. | |
486 | */ | |
504a3374 RW |
487 | static int acpi_data_get_property_reference(struct acpi_device_data *data, |
488 | const char *propname, size_t index, | |
489 | struct acpi_reference_args *args) | |
ffdcd955 MW |
490 | { |
491 | const union acpi_object *element, *end; | |
492 | const union acpi_object *obj; | |
493 | struct acpi_device *device; | |
494 | int ret, idx = 0; | |
495 | ||
504a3374 | 496 | ret = acpi_data_get_property(data, propname, ACPI_TYPE_ANY, &obj); |
ffdcd955 MW |
497 | if (ret) |
498 | return ret; | |
499 | ||
500 | /* | |
501 | * The simplest case is when the value is a single reference. Just | |
502 | * return that reference then. | |
503 | */ | |
504 | if (obj->type == ACPI_TYPE_LOCAL_REFERENCE) { | |
60ba032e | 505 | if (index) |
ffdcd955 MW |
506 | return -EINVAL; |
507 | ||
508 | ret = acpi_bus_get_device(obj->reference.handle, &device); | |
509 | if (ret) | |
510 | return ret; | |
511 | ||
512 | args->adev = device; | |
513 | args->nargs = 0; | |
514 | return 0; | |
515 | } | |
516 | ||
517 | /* | |
518 | * If it is not a single reference, then it is a package of | |
519 | * references followed by number of ints as follows: | |
520 | * | |
521 | * Package () { REF, INT, REF, INT, INT } | |
522 | * | |
523 | * The index argument is then used to determine which reference | |
524 | * the caller wants (along with the arguments). | |
525 | */ | |
526 | if (obj->type != ACPI_TYPE_PACKAGE || index >= obj->package.count) | |
527 | return -EPROTO; | |
528 | ||
529 | element = obj->package.elements; | |
530 | end = element + obj->package.count; | |
531 | ||
532 | while (element < end) { | |
533 | u32 nargs, i; | |
534 | ||
535 | if (element->type != ACPI_TYPE_LOCAL_REFERENCE) | |
536 | return -EPROTO; | |
537 | ||
538 | ret = acpi_bus_get_device(element->reference.handle, &device); | |
539 | if (ret) | |
540 | return -ENODEV; | |
541 | ||
542 | element++; | |
543 | nargs = 0; | |
544 | ||
60ba032e RW |
545 | /* assume following integer elements are all args */ |
546 | for (i = 0; element + i < end; i++) { | |
547 | int type = element[i].type; | |
ffdcd955 | 548 | |
60ba032e RW |
549 | if (type == ACPI_TYPE_INTEGER) |
550 | nargs++; | |
551 | else if (type == ACPI_TYPE_LOCAL_REFERENCE) | |
552 | break; | |
553 | else | |
554 | return -EPROTO; | |
ffdcd955 MW |
555 | } |
556 | ||
557 | if (idx++ == index) { | |
558 | args->adev = device; | |
559 | args->nargs = nargs; | |
560 | for (i = 0; i < nargs; i++) | |
561 | args->args[i] = element[i].integer.value; | |
562 | ||
563 | return 0; | |
564 | } | |
565 | ||
566 | element += nargs; | |
567 | } | |
568 | ||
569 | return -EPROTO; | |
570 | } | |
504a3374 RW |
571 | |
572 | /** | |
573 | * acpi_node_get_property_reference - get a handle to the referenced object. | |
574 | * @fwnode: Firmware node to get the property from. | |
575 | * @propname: Name of the property. | |
576 | * @index: Index of the reference to return. | |
577 | * @args: Location to store the returned reference with optional arguments. | |
578 | */ | |
579 | int acpi_node_get_property_reference(struct fwnode_handle *fwnode, | |
580 | const char *name, size_t index, | |
581 | struct acpi_reference_args *args) | |
582 | { | |
583 | struct acpi_device_data *data = acpi_device_data_of_node(fwnode); | |
584 | ||
585 | return data ? acpi_data_get_property_reference(data, name, index, args) : -EINVAL; | |
586 | } | |
587 | EXPORT_SYMBOL_GPL(acpi_node_get_property_reference); | |
b31384fa | 588 | |
3a7a2ab8 RW |
589 | static int acpi_data_prop_read_single(struct acpi_device_data *data, |
590 | const char *propname, | |
591 | enum dev_prop_type proptype, void *val) | |
b31384fa RW |
592 | { |
593 | const union acpi_object *obj; | |
594 | int ret; | |
595 | ||
596 | if (!val) | |
597 | return -EINVAL; | |
598 | ||
599 | if (proptype >= DEV_PROP_U8 && proptype <= DEV_PROP_U64) { | |
3a7a2ab8 | 600 | ret = acpi_data_get_property(data, propname, ACPI_TYPE_INTEGER, &obj); |
b31384fa RW |
601 | if (ret) |
602 | return ret; | |
603 | ||
604 | switch (proptype) { | |
605 | case DEV_PROP_U8: | |
606 | if (obj->integer.value > U8_MAX) | |
607 | return -EOVERFLOW; | |
608 | *(u8 *)val = obj->integer.value; | |
609 | break; | |
610 | case DEV_PROP_U16: | |
611 | if (obj->integer.value > U16_MAX) | |
612 | return -EOVERFLOW; | |
613 | *(u16 *)val = obj->integer.value; | |
614 | break; | |
615 | case DEV_PROP_U32: | |
616 | if (obj->integer.value > U32_MAX) | |
617 | return -EOVERFLOW; | |
618 | *(u32 *)val = obj->integer.value; | |
619 | break; | |
620 | default: | |
621 | *(u64 *)val = obj->integer.value; | |
622 | break; | |
623 | } | |
624 | } else if (proptype == DEV_PROP_STRING) { | |
3a7a2ab8 | 625 | ret = acpi_data_get_property(data, propname, ACPI_TYPE_STRING, &obj); |
b31384fa RW |
626 | if (ret) |
627 | return ret; | |
628 | ||
629 | *(char **)val = obj->string.pointer; | |
630 | } else { | |
631 | ret = -EINVAL; | |
632 | } | |
633 | return ret; | |
634 | } | |
635 | ||
3a7a2ab8 RW |
636 | int acpi_dev_prop_read_single(struct acpi_device *adev, const char *propname, |
637 | enum dev_prop_type proptype, void *val) | |
638 | { | |
639 | return adev ? acpi_data_prop_read_single(&adev->data, propname, proptype, val) : -EINVAL; | |
640 | } | |
641 | ||
b31384fa RW |
642 | static int acpi_copy_property_array_u8(const union acpi_object *items, u8 *val, |
643 | size_t nval) | |
644 | { | |
645 | int i; | |
646 | ||
647 | for (i = 0; i < nval; i++) { | |
648 | if (items[i].type != ACPI_TYPE_INTEGER) | |
649 | return -EPROTO; | |
650 | if (items[i].integer.value > U8_MAX) | |
651 | return -EOVERFLOW; | |
652 | ||
653 | val[i] = items[i].integer.value; | |
654 | } | |
655 | return 0; | |
656 | } | |
657 | ||
658 | static int acpi_copy_property_array_u16(const union acpi_object *items, | |
659 | u16 *val, size_t nval) | |
660 | { | |
661 | int i; | |
662 | ||
663 | for (i = 0; i < nval; i++) { | |
664 | if (items[i].type != ACPI_TYPE_INTEGER) | |
665 | return -EPROTO; | |
666 | if (items[i].integer.value > U16_MAX) | |
667 | return -EOVERFLOW; | |
668 | ||
669 | val[i] = items[i].integer.value; | |
670 | } | |
671 | return 0; | |
672 | } | |
673 | ||
674 | static int acpi_copy_property_array_u32(const union acpi_object *items, | |
675 | u32 *val, size_t nval) | |
676 | { | |
677 | int i; | |
678 | ||
679 | for (i = 0; i < nval; i++) { | |
680 | if (items[i].type != ACPI_TYPE_INTEGER) | |
681 | return -EPROTO; | |
682 | if (items[i].integer.value > U32_MAX) | |
683 | return -EOVERFLOW; | |
684 | ||
685 | val[i] = items[i].integer.value; | |
686 | } | |
687 | return 0; | |
688 | } | |
689 | ||
690 | static int acpi_copy_property_array_u64(const union acpi_object *items, | |
691 | u64 *val, size_t nval) | |
692 | { | |
693 | int i; | |
694 | ||
695 | for (i = 0; i < nval; i++) { | |
696 | if (items[i].type != ACPI_TYPE_INTEGER) | |
697 | return -EPROTO; | |
698 | ||
699 | val[i] = items[i].integer.value; | |
700 | } | |
701 | return 0; | |
702 | } | |
703 | ||
704 | static int acpi_copy_property_array_string(const union acpi_object *items, | |
705 | char **val, size_t nval) | |
706 | { | |
707 | int i; | |
708 | ||
709 | for (i = 0; i < nval; i++) { | |
710 | if (items[i].type != ACPI_TYPE_STRING) | |
711 | return -EPROTO; | |
712 | ||
713 | val[i] = items[i].string.pointer; | |
714 | } | |
715 | return 0; | |
716 | } | |
717 | ||
3a7a2ab8 RW |
718 | static int acpi_data_prop_read(struct acpi_device_data *data, |
719 | const char *propname, | |
720 | enum dev_prop_type proptype, | |
721 | void *val, size_t nval) | |
b31384fa RW |
722 | { |
723 | const union acpi_object *obj; | |
724 | const union acpi_object *items; | |
725 | int ret; | |
726 | ||
727 | if (val && nval == 1) { | |
3a7a2ab8 | 728 | ret = acpi_data_prop_read_single(data, propname, proptype, val); |
b31384fa RW |
729 | if (!ret) |
730 | return ret; | |
731 | } | |
732 | ||
3a7a2ab8 | 733 | ret = acpi_data_get_property_array(data, propname, ACPI_TYPE_ANY, &obj); |
b31384fa RW |
734 | if (ret) |
735 | return ret; | |
736 | ||
737 | if (!val) | |
738 | return obj->package.count; | |
b31384fa RW |
739 | |
740 | if (nval > obj->package.count) | |
741 | return -EOVERFLOW; | |
7dc59dc9 AS |
742 | else if (nval <= 0) |
743 | return -EINVAL; | |
b31384fa RW |
744 | |
745 | items = obj->package.elements; | |
7dc59dc9 | 746 | |
b31384fa RW |
747 | switch (proptype) { |
748 | case DEV_PROP_U8: | |
749 | ret = acpi_copy_property_array_u8(items, (u8 *)val, nval); | |
750 | break; | |
751 | case DEV_PROP_U16: | |
752 | ret = acpi_copy_property_array_u16(items, (u16 *)val, nval); | |
753 | break; | |
754 | case DEV_PROP_U32: | |
755 | ret = acpi_copy_property_array_u32(items, (u32 *)val, nval); | |
756 | break; | |
757 | case DEV_PROP_U64: | |
758 | ret = acpi_copy_property_array_u64(items, (u64 *)val, nval); | |
759 | break; | |
760 | case DEV_PROP_STRING: | |
761 | ret = acpi_copy_property_array_string(items, (char **)val, nval); | |
762 | break; | |
763 | default: | |
764 | ret = -EINVAL; | |
765 | break; | |
766 | } | |
767 | return ret; | |
768 | } | |
3a7a2ab8 RW |
769 | |
770 | int acpi_dev_prop_read(struct acpi_device *adev, const char *propname, | |
771 | enum dev_prop_type proptype, void *val, size_t nval) | |
772 | { | |
773 | return adev ? acpi_data_prop_read(&adev->data, propname, proptype, val, nval) : -EINVAL; | |
774 | } | |
775 | ||
776 | /** | |
777 | * acpi_node_prop_read - retrieve the value of an ACPI property with given name. | |
778 | * @fwnode: Firmware node to get the property from. | |
779 | * @propname: Name of the property. | |
780 | * @proptype: Expected property type. | |
781 | * @val: Location to store the property value (if not %NULL). | |
782 | * @nval: Size of the array pointed to by @val. | |
783 | * | |
784 | * If @val is %NULL, return the number of array elements comprising the value | |
785 | * of the property. Otherwise, read at most @nval values to the array at the | |
786 | * location pointed to by @val. | |
787 | */ | |
788 | int acpi_node_prop_read(struct fwnode_handle *fwnode, const char *propname, | |
789 | enum dev_prop_type proptype, void *val, size_t nval) | |
790 | { | |
791 | return acpi_data_prop_read(acpi_device_data_of_node(fwnode), | |
792 | propname, proptype, val, nval); | |
793 | } | |
504a3374 RW |
794 | |
795 | /** | |
796 | * acpi_get_next_subnode - Return the next child node handle for a device. | |
797 | * @dev: Device to find the next child node for. | |
798 | * @child: Handle to one of the device's child nodes or a null handle. | |
799 | */ | |
800 | struct fwnode_handle *acpi_get_next_subnode(struct device *dev, | |
801 | struct fwnode_handle *child) | |
802 | { | |
803 | struct acpi_device *adev = ACPI_COMPANION(dev); | |
804 | struct list_head *head, *next; | |
805 | ||
806 | if (!adev) | |
807 | return NULL; | |
808 | ||
809 | if (!child || child->type == FWNODE_ACPI) { | |
810 | head = &adev->children; | |
811 | if (list_empty(head)) | |
812 | goto nondev; | |
813 | ||
814 | if (child) { | |
815 | adev = to_acpi_device_node(child); | |
816 | next = adev->node.next; | |
817 | if (next == head) { | |
818 | child = NULL; | |
bf4703fd | 819 | adev = ACPI_COMPANION(dev); |
504a3374 RW |
820 | goto nondev; |
821 | } | |
822 | adev = list_entry(next, struct acpi_device, node); | |
823 | } else { | |
824 | adev = list_first_entry(head, struct acpi_device, node); | |
825 | } | |
826 | return acpi_fwnode_handle(adev); | |
827 | } | |
828 | ||
829 | nondev: | |
830 | if (!child || child->type == FWNODE_ACPI_DATA) { | |
831 | struct acpi_data_node *dn; | |
832 | ||
833 | head = &adev->data.subnodes; | |
834 | if (list_empty(head)) | |
835 | return NULL; | |
836 | ||
837 | if (child) { | |
838 | dn = to_acpi_data_node(child); | |
839 | next = dn->sibling.next; | |
840 | if (next == head) | |
841 | return NULL; | |
842 | ||
843 | dn = list_entry(next, struct acpi_data_node, sibling); | |
844 | } else { | |
845 | dn = list_first_entry(head, struct acpi_data_node, sibling); | |
846 | } | |
847 | return &dn->fwnode; | |
848 | } | |
849 | return NULL; | |
850 | } |