2 * ACPI device specific properties support.
4 * Copyright (C) 2014, Intel Corporation
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>
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.
16 #include <linux/acpi.h>
17 #include <linux/device.h>
18 #include <linux/export.h>
22 static int acpi_data_get_property_array(struct acpi_device_data *data,
24 acpi_object_type type,
25 const union acpi_object **obj);
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
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
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);
44 static bool acpi_nondev_subnode_ok(acpi_handle scope,
45 const union acpi_object *link,
46 struct list_head *list)
48 struct acpi_buffer buf = { ACPI_ALLOCATE_BUFFER };
49 struct acpi_data_node *dn;
53 dn = kzalloc(sizeof(*dn), GFP_KERNEL);
57 dn->name = link->package.elements[0].string.pointer;
58 dn->fwnode.type = FWNODE_ACPI_DATA;
59 INIT_LIST_HEAD(&dn->data.subnodes);
61 status = acpi_get_handle(scope, link->package.elements[1].string.pointer,
63 if (ACPI_FAILURE(status))
66 status = acpi_evaluate_object_typed(handle, NULL, NULL, &buf,
68 if (ACPI_FAILURE(status))
71 if (acpi_extract_properties(buf.pointer, &dn->data))
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.
79 status = acpi_get_parent(handle, &scope);
80 if (ACPI_SUCCESS(status)
81 && acpi_enumerate_nondev_subnodes(scope, buf.pointer, &dn->data))
85 dn->data.pointer = buf.pointer;
86 list_add_tail(&dn->sibling, list);
90 acpi_handle_debug(handle, "Invalid properties/subnodes data, skipping\n");
93 ACPI_FREE(buf.pointer);
98 static int acpi_add_nondev_subnodes(acpi_handle scope,
99 const union acpi_object *links,
100 struct list_head *list)
105 for (i = 0; i < links->package.count; i++) {
106 const union acpi_object *link;
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))
120 static bool acpi_enumerate_nondev_subnodes(acpi_handle scope,
121 const union acpi_object *desc,
122 struct acpi_device_data *data)
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;
130 uuid = &desc->package.elements[i];
131 links = &desc->package.elements[i + 1];
134 * The first element must be a UUID and the second one must be
137 if (uuid->type != ACPI_TYPE_BUFFER || uuid->buffer.length != 16
138 || links->type != ACPI_TYPE_PACKAGE)
141 if (memcmp(uuid->buffer.pointer, ads_uuid, sizeof(ads_uuid)))
144 return acpi_add_nondev_subnodes(scope, links, &data->subnodes);
150 static bool acpi_property_value_ok(const union acpi_object *value)
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.
158 switch (value->type) {
159 case ACPI_TYPE_INTEGER:
160 case ACPI_TYPE_STRING:
161 case ACPI_TYPE_LOCAL_REFERENCE:
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:
181 static bool acpi_properties_format_valid(const union acpi_object *properties)
185 for (i = 0; i < properties->package.count; i++) {
186 const union acpi_object *property;
188 property = &properties->package.elements[i];
190 * Only two elements allowed, the first one must be a string and
191 * the second one has to satisfy certain conditions.
193 if (property->package.count != 2
194 || property->package.elements[0].type != ACPI_TYPE_STRING
195 || !acpi_property_value_ok(&property->package.elements[1]))
201 static void acpi_init_of_compatible(struct acpi_device *adev)
203 const union acpi_object *of_compatible;
206 ret = acpi_data_get_property_array(&adev->data, "compatible",
207 ACPI_TYPE_STRING, &of_compatible);
209 ret = acpi_dev_get_property(adev, "compatible",
210 ACPI_TYPE_STRING, &of_compatible);
213 && adev->parent->flags.of_compatible_ok)
219 adev->data.of_compatible = of_compatible;
222 adev->flags.of_compatible_ok = 1;
225 static bool acpi_extract_properties(const union acpi_object *desc,
226 struct acpi_device_data *data)
230 if (desc->package.count % 2)
233 /* Look for the device properties UUID. */
234 for (i = 0; i < desc->package.count; i += 2) {
235 const union acpi_object *uuid, *properties;
237 uuid = &desc->package.elements[i];
238 properties = &desc->package.elements[i + 1];
241 * The first element must be a UUID and the second one must be
244 if (uuid->type != ACPI_TYPE_BUFFER || uuid->buffer.length != 16
245 || properties->type != ACPI_TYPE_PACKAGE)
248 if (memcmp(uuid->buffer.pointer, prp_uuid, sizeof(prp_uuid)))
252 * We found the matching UUID. Now validate the format of the
253 * package immediately following it.
255 if (!acpi_properties_format_valid(properties))
258 data->properties = properties;
265 void acpi_init_properties(struct acpi_device *adev)
267 struct acpi_buffer buf = { ACPI_ALLOCATE_BUFFER };
268 struct acpi_hardware_id *hwid;
270 bool acpi_of = false;
272 INIT_LIST_HEAD(&adev->data.subnodes);
275 * Check if ACPI_DT_NAMESPACE_HID is present and inthat case we fill in
276 * Device Tree compatible properties for this device.
278 list_for_each_entry(hwid, &adev->pnp.ids, list) {
279 if (!strcmp(hwid->id, ACPI_DT_NAMESPACE_HID)) {
285 status = acpi_evaluate_object_typed(adev->handle, "_DSD", NULL, &buf,
287 if (ACPI_FAILURE(status))
290 if (acpi_extract_properties(buf.pointer, &adev->data)) {
291 adev->data.pointer = buf.pointer;
293 acpi_init_of_compatible(adev);
295 if (acpi_enumerate_nondev_subnodes(adev->handle, buf.pointer, &adev->data))
296 adev->data.pointer = buf.pointer;
298 if (!adev->data.pointer) {
299 acpi_handle_debug(adev->handle, "Invalid _DSD data, skipping\n");
300 ACPI_FREE(buf.pointer);
304 if (acpi_of && !adev->flags.of_compatible_ok)
305 acpi_handle_info(adev->handle,
306 ACPI_DT_NAMESPACE_HID " requires 'compatible' property\n");
309 static void acpi_destroy_nondev_subnodes(struct list_head *list)
311 struct acpi_data_node *dn, *next;
313 if (list_empty(list))
316 list_for_each_entry_safe_reverse(dn, next, list, sibling) {
317 acpi_destroy_nondev_subnodes(&dn->data.subnodes);
318 wait_for_completion(&dn->kobj_done);
319 list_del(&dn->sibling);
320 ACPI_FREE((void *)dn->data.pointer);
325 void acpi_free_properties(struct acpi_device *adev)
327 acpi_destroy_nondev_subnodes(&adev->data.subnodes);
328 ACPI_FREE((void *)adev->data.pointer);
329 adev->data.of_compatible = NULL;
330 adev->data.pointer = NULL;
331 adev->data.properties = NULL;
335 * acpi_data_get_property - return an ACPI property with given name
336 * @data: ACPI device deta object to get the property from
337 * @name: Name of the property
338 * @type: Expected property type
339 * @obj: Location to store the property value (if not %NULL)
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.
344 * Callers must not attempt to free the returned objects. These objects will be
345 * freed by the ACPI core automatically during the removal of @data.
347 * Return: %0 if property with @name has been found (success),
348 * %-EINVAL if the arguments are invalid,
349 * %-EINVAL if the property doesn't exist,
350 * %-EPROTO if the property value type doesn't match @type.
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)
356 const union acpi_object *properties;
362 if (!data->pointer || !data->properties)
365 properties = data->properties;
366 for (i = 0; i < properties->package.count; i++) {
367 const union acpi_object *propname, *propvalue;
368 const union acpi_object *property;
370 property = &properties->package.elements[i];
372 propname = &property->package.elements[0];
373 propvalue = &property->package.elements[1];
375 if (!strcmp(name, propname->string.pointer)) {
376 if (type != ACPI_TYPE_ANY && propvalue->type != type)
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).
394 int acpi_dev_get_property(struct acpi_device *adev, const char *name,
395 acpi_object_type type, const union acpi_object **obj)
397 return adev ? acpi_data_get_property(&adev->data, name, type, obj) : -EINVAL;
399 EXPORT_SYMBOL_GPL(acpi_dev_get_property);
401 static struct acpi_device_data *acpi_device_data_of_node(struct fwnode_handle *fwnode)
403 if (fwnode->type == FWNODE_ACPI) {
404 struct acpi_device *adev = to_acpi_device_node(fwnode);
406 } else if (fwnode->type == FWNODE_ACPI_DATA) {
407 struct acpi_data_node *dn = to_acpi_data_node(fwnode);
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).
419 int acpi_node_prop_get(struct fwnode_handle *fwnode, const char *propname,
422 return acpi_data_get_property(acpi_device_data_of_node(fwnode),
423 propname, ACPI_TYPE_ANY,
424 (const union acpi_object **)valptr);
428 * acpi_data_get_property_array - return an ACPI array property with given name
429 * @adev: ACPI data object to get the property from
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)
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.
437 * Callers must not attempt to free the returned objects. Those objects will be
438 * freed by the ACPI core automatically during the removal of @data.
440 * Return: %0 if array property (package) with @name has been found (success),
441 * %-EINVAL if the arguments are invalid,
442 * %-EINVAL if the property doesn't exist,
443 * %-EPROTO if the property is not a package or the type of its elements
444 * doesn't match @type.
446 static int acpi_data_get_property_array(struct acpi_device_data *data,
448 acpi_object_type type,
449 const union acpi_object **obj)
451 const union acpi_object *prop;
454 ret = acpi_data_get_property(data, name, ACPI_TYPE_PACKAGE, &prop);
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)
471 * __acpi_node_get_property_reference - returns handle to the referenced object
472 * @fwnode: Firmware node to get the property from
473 * @propname: Name of the property
474 * @index: Index of the reference to return
475 * @num_args: Maximum number of arguments after each reference
476 * @args: Location to store the returned reference with optional arguments
478 * Find property with @name, verifify that it is a package containing at least
479 * one object reference and if so, store the ACPI device object pointer to the
480 * target object in @args->adev. If the reference includes arguments, store
481 * them in the @args->args[] array.
483 * If there's more than one reference in the property value package, @index is
484 * used to select the one to return.
486 * It is possible to leave holes in the property value set like in the
499 * Calling this function with index %2 return %-ENOENT and with index %3
500 * returns the last entry. If the property does not contain any more values
501 * %-ENODATA is returned. The NULL entry must be single integer and
502 * preferably contain value %0.
504 * Return: %0 on success, negative error code on failure.
506 int __acpi_node_get_property_reference(struct fwnode_handle *fwnode,
507 const char *propname, size_t index, size_t num_args,
508 struct acpi_reference_args *args)
510 const union acpi_object *element, *end;
511 const union acpi_object *obj;
512 struct acpi_device_data *data;
513 struct acpi_device *device;
516 data = acpi_device_data_of_node(fwnode);
520 ret = acpi_data_get_property(data, propname, ACPI_TYPE_ANY, &obj);
525 * The simplest case is when the value is a single reference. Just
526 * return that reference then.
528 if (obj->type == ACPI_TYPE_LOCAL_REFERENCE) {
532 ret = acpi_bus_get_device(obj->reference.handle, &device);
542 * If it is not a single reference, then it is a package of
543 * references followed by number of ints as follows:
545 * Package () { REF, INT, REF, INT, INT }
547 * The index argument is then used to determine which reference
548 * the caller wants (along with the arguments).
550 if (obj->type != ACPI_TYPE_PACKAGE || index >= obj->package.count)
553 element = obj->package.elements;
554 end = element + obj->package.count;
556 while (element < end) {
559 if (element->type == ACPI_TYPE_LOCAL_REFERENCE) {
560 ret = acpi_bus_get_device(element->reference.handle,
568 /* assume following integer elements are all args */
569 for (i = 0; element + i < end && i < num_args; i++) {
570 int type = element[i].type;
572 if (type == ACPI_TYPE_INTEGER)
574 else if (type == ACPI_TYPE_LOCAL_REFERENCE)
580 if (nargs > MAX_ACPI_REFERENCE_ARGS)
586 for (i = 0; i < nargs; i++)
587 args->args[i] = element[i].integer.value;
593 } else if (element->type == ACPI_TYPE_INTEGER) {
606 EXPORT_SYMBOL_GPL(__acpi_node_get_property_reference);
608 static int acpi_data_prop_read_single(struct acpi_device_data *data,
609 const char *propname,
610 enum dev_prop_type proptype, void *val)
612 const union acpi_object *obj;
618 if (proptype >= DEV_PROP_U8 && proptype <= DEV_PROP_U64) {
619 ret = acpi_data_get_property(data, propname, ACPI_TYPE_INTEGER, &obj);
625 if (obj->integer.value > U8_MAX)
627 *(u8 *)val = obj->integer.value;
630 if (obj->integer.value > U16_MAX)
632 *(u16 *)val = obj->integer.value;
635 if (obj->integer.value > U32_MAX)
637 *(u32 *)val = obj->integer.value;
640 *(u64 *)val = obj->integer.value;
643 } else if (proptype == DEV_PROP_STRING) {
644 ret = acpi_data_get_property(data, propname, ACPI_TYPE_STRING, &obj);
648 *(char **)val = obj->string.pointer;
655 int acpi_dev_prop_read_single(struct acpi_device *adev, const char *propname,
656 enum dev_prop_type proptype, void *val)
658 return adev ? acpi_data_prop_read_single(&adev->data, propname, proptype, val) : -EINVAL;
661 static int acpi_copy_property_array_u8(const union acpi_object *items, u8 *val,
666 for (i = 0; i < nval; i++) {
667 if (items[i].type != ACPI_TYPE_INTEGER)
669 if (items[i].integer.value > U8_MAX)
672 val[i] = items[i].integer.value;
677 static int acpi_copy_property_array_u16(const union acpi_object *items,
678 u16 *val, size_t nval)
682 for (i = 0; i < nval; i++) {
683 if (items[i].type != ACPI_TYPE_INTEGER)
685 if (items[i].integer.value > U16_MAX)
688 val[i] = items[i].integer.value;
693 static int acpi_copy_property_array_u32(const union acpi_object *items,
694 u32 *val, size_t nval)
698 for (i = 0; i < nval; i++) {
699 if (items[i].type != ACPI_TYPE_INTEGER)
701 if (items[i].integer.value > U32_MAX)
704 val[i] = items[i].integer.value;
709 static int acpi_copy_property_array_u64(const union acpi_object *items,
710 u64 *val, size_t nval)
714 for (i = 0; i < nval; i++) {
715 if (items[i].type != ACPI_TYPE_INTEGER)
718 val[i] = items[i].integer.value;
723 static int acpi_copy_property_array_string(const union acpi_object *items,
724 char **val, size_t nval)
728 for (i = 0; i < nval; i++) {
729 if (items[i].type != ACPI_TYPE_STRING)
732 val[i] = items[i].string.pointer;
737 static int acpi_data_prop_read(struct acpi_device_data *data,
738 const char *propname,
739 enum dev_prop_type proptype,
740 void *val, size_t nval)
742 const union acpi_object *obj;
743 const union acpi_object *items;
746 if (val && nval == 1) {
747 ret = acpi_data_prop_read_single(data, propname, proptype, val);
752 ret = acpi_data_get_property_array(data, propname, ACPI_TYPE_ANY, &obj);
757 return obj->package.count;
759 if (nval > obj->package.count)
764 items = obj->package.elements;
768 ret = acpi_copy_property_array_u8(items, (u8 *)val, nval);
771 ret = acpi_copy_property_array_u16(items, (u16 *)val, nval);
774 ret = acpi_copy_property_array_u32(items, (u32 *)val, nval);
777 ret = acpi_copy_property_array_u64(items, (u64 *)val, nval);
779 case DEV_PROP_STRING:
780 ret = acpi_copy_property_array_string(items, (char **)val, nval);
789 int acpi_dev_prop_read(struct acpi_device *adev, const char *propname,
790 enum dev_prop_type proptype, void *val, size_t nval)
792 return adev ? acpi_data_prop_read(&adev->data, propname, proptype, val, nval) : -EINVAL;
796 * acpi_node_prop_read - retrieve the value of an ACPI property with given name.
797 * @fwnode: Firmware node to get the property from.
798 * @propname: Name of the property.
799 * @proptype: Expected property type.
800 * @val: Location to store the property value (if not %NULL).
801 * @nval: Size of the array pointed to by @val.
803 * If @val is %NULL, return the number of array elements comprising the value
804 * of the property. Otherwise, read at most @nval values to the array at the
805 * location pointed to by @val.
807 int acpi_node_prop_read(struct fwnode_handle *fwnode, const char *propname,
808 enum dev_prop_type proptype, void *val, size_t nval)
810 return acpi_data_prop_read(acpi_device_data_of_node(fwnode),
811 propname, proptype, val, nval);
815 * acpi_get_next_subnode - Return the next child node handle for a device.
816 * @dev: Device to find the next child node for.
817 * @child: Handle to one of the device's child nodes or a null handle.
819 struct fwnode_handle *acpi_get_next_subnode(struct device *dev,
820 struct fwnode_handle *child)
822 struct acpi_device *adev = ACPI_COMPANION(dev);
823 struct list_head *head, *next;
828 if (!child || child->type == FWNODE_ACPI) {
829 head = &adev->children;
830 if (list_empty(head))
834 adev = to_acpi_device_node(child);
835 next = adev->node.next;
838 adev = ACPI_COMPANION(dev);
841 adev = list_entry(next, struct acpi_device, node);
843 adev = list_first_entry(head, struct acpi_device, node);
845 return acpi_fwnode_handle(adev);
849 if (!child || child->type == FWNODE_ACPI_DATA) {
850 struct acpi_data_node *dn;
852 head = &adev->data.subnodes;
853 if (list_empty(head))
857 dn = to_acpi_data_node(child);
858 next = dn->sibling.next;
862 dn = list_entry(next, struct acpi_data_node, sibling);
864 dn = list_first_entry(head, struct acpi_data_node, sibling);