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 struct fwnode_handle *parent);
42 static bool acpi_extract_properties(const union acpi_object *desc,
43 struct acpi_device_data *data);
45 static bool acpi_nondev_subnode_extract(const union acpi_object *desc,
47 const union acpi_object *link,
48 struct list_head *list,
49 struct fwnode_handle *parent)
51 struct acpi_data_node *dn;
54 dn = kzalloc(sizeof(*dn), GFP_KERNEL);
58 dn->name = link->package.elements[0].string.pointer;
59 dn->fwnode.type = FWNODE_ACPI_DATA;
60 dn->fwnode.ops = &acpi_fwnode_ops;
62 INIT_LIST_HEAD(&dn->data.subnodes);
64 result = acpi_extract_properties(desc, &dn->data);
71 * The scope for the subnode object lookup is the one of the
72 * namespace node (device) containing the object that has
73 * returned the package. That is, it's the scope of that
76 status = acpi_get_parent(handle, &scope);
77 if (ACPI_SUCCESS(status)
78 && acpi_enumerate_nondev_subnodes(scope, desc, &dn->data,
81 } else if (acpi_enumerate_nondev_subnodes(NULL, desc, &dn->data,
88 dn->data.pointer = desc;
89 list_add_tail(&dn->sibling, list);
94 acpi_handle_debug(handle, "Invalid properties/subnodes data, skipping\n");
98 static bool acpi_nondev_subnode_data_ok(acpi_handle handle,
99 const union acpi_object *link,
100 struct list_head *list,
101 struct fwnode_handle *parent)
103 struct acpi_buffer buf = { ACPI_ALLOCATE_BUFFER };
106 status = acpi_evaluate_object_typed(handle, NULL, NULL, &buf,
108 if (ACPI_FAILURE(status))
111 if (acpi_nondev_subnode_extract(buf.pointer, handle, link, list,
115 ACPI_FREE(buf.pointer);
119 static bool acpi_nondev_subnode_ok(acpi_handle scope,
120 const union acpi_object *link,
121 struct list_head *list,
122 struct fwnode_handle *parent)
130 status = acpi_get_handle(scope, link->package.elements[1].string.pointer,
132 if (ACPI_FAILURE(status))
135 return acpi_nondev_subnode_data_ok(handle, link, list, parent);
138 static int acpi_add_nondev_subnodes(acpi_handle scope,
139 const union acpi_object *links,
140 struct list_head *list,
141 struct fwnode_handle *parent)
146 for (i = 0; i < links->package.count; i++) {
147 const union acpi_object *link, *desc;
151 link = &links->package.elements[i];
152 /* Only two elements allowed. */
153 if (link->package.count != 2)
156 /* The first one must be a string. */
157 if (link->package.elements[0].type != ACPI_TYPE_STRING)
160 /* The second one may be a string, a reference or a package. */
161 switch (link->package.elements[1].type) {
162 case ACPI_TYPE_STRING:
163 result = acpi_nondev_subnode_ok(scope, link, list,
166 case ACPI_TYPE_LOCAL_REFERENCE:
167 handle = link->package.elements[1].reference.handle;
168 result = acpi_nondev_subnode_data_ok(handle, link, list,
171 case ACPI_TYPE_PACKAGE:
172 desc = &link->package.elements[1];
173 result = acpi_nondev_subnode_extract(desc, NULL, link,
186 static bool acpi_enumerate_nondev_subnodes(acpi_handle scope,
187 const union acpi_object *desc,
188 struct acpi_device_data *data,
189 struct fwnode_handle *parent)
193 /* Look for the ACPI data subnodes UUID. */
194 for (i = 0; i < desc->package.count; i += 2) {
195 const union acpi_object *uuid, *links;
197 uuid = &desc->package.elements[i];
198 links = &desc->package.elements[i + 1];
201 * The first element must be a UUID and the second one must be
204 if (uuid->type != ACPI_TYPE_BUFFER || uuid->buffer.length != 16
205 || links->type != ACPI_TYPE_PACKAGE)
208 if (memcmp(uuid->buffer.pointer, ads_uuid, sizeof(ads_uuid)))
211 return acpi_add_nondev_subnodes(scope, links, &data->subnodes,
218 static bool acpi_property_value_ok(const union acpi_object *value)
223 * The value must be an integer, a string, a reference, or a package
224 * whose every element must be an integer, a string, or a reference.
226 switch (value->type) {
227 case ACPI_TYPE_INTEGER:
228 case ACPI_TYPE_STRING:
229 case ACPI_TYPE_LOCAL_REFERENCE:
232 case ACPI_TYPE_PACKAGE:
233 for (j = 0; j < value->package.count; j++)
234 switch (value->package.elements[j].type) {
235 case ACPI_TYPE_INTEGER:
236 case ACPI_TYPE_STRING:
237 case ACPI_TYPE_LOCAL_REFERENCE:
249 static bool acpi_properties_format_valid(const union acpi_object *properties)
253 for (i = 0; i < properties->package.count; i++) {
254 const union acpi_object *property;
256 property = &properties->package.elements[i];
258 * Only two elements allowed, the first one must be a string and
259 * the second one has to satisfy certain conditions.
261 if (property->package.count != 2
262 || property->package.elements[0].type != ACPI_TYPE_STRING
263 || !acpi_property_value_ok(&property->package.elements[1]))
269 static void acpi_init_of_compatible(struct acpi_device *adev)
271 const union acpi_object *of_compatible;
274 ret = acpi_data_get_property_array(&adev->data, "compatible",
275 ACPI_TYPE_STRING, &of_compatible);
277 ret = acpi_dev_get_property(adev, "compatible",
278 ACPI_TYPE_STRING, &of_compatible);
281 && adev->parent->flags.of_compatible_ok)
287 adev->data.of_compatible = of_compatible;
290 adev->flags.of_compatible_ok = 1;
293 static bool acpi_extract_properties(const union acpi_object *desc,
294 struct acpi_device_data *data)
298 if (desc->package.count % 2)
301 /* Look for the device properties UUID. */
302 for (i = 0; i < desc->package.count; i += 2) {
303 const union acpi_object *uuid, *properties;
305 uuid = &desc->package.elements[i];
306 properties = &desc->package.elements[i + 1];
309 * The first element must be a UUID and the second one must be
312 if (uuid->type != ACPI_TYPE_BUFFER || uuid->buffer.length != 16
313 || properties->type != ACPI_TYPE_PACKAGE)
316 if (memcmp(uuid->buffer.pointer, prp_uuid, sizeof(prp_uuid)))
320 * We found the matching UUID. Now validate the format of the
321 * package immediately following it.
323 if (!acpi_properties_format_valid(properties))
326 data->properties = properties;
333 void acpi_init_properties(struct acpi_device *adev)
335 struct acpi_buffer buf = { ACPI_ALLOCATE_BUFFER };
336 struct acpi_hardware_id *hwid;
338 bool acpi_of = false;
340 INIT_LIST_HEAD(&adev->data.subnodes);
343 * Check if ACPI_DT_NAMESPACE_HID is present and inthat case we fill in
344 * Device Tree compatible properties for this device.
346 list_for_each_entry(hwid, &adev->pnp.ids, list) {
347 if (!strcmp(hwid->id, ACPI_DT_NAMESPACE_HID)) {
353 status = acpi_evaluate_object_typed(adev->handle, "_DSD", NULL, &buf,
355 if (ACPI_FAILURE(status))
358 if (acpi_extract_properties(buf.pointer, &adev->data)) {
359 adev->data.pointer = buf.pointer;
361 acpi_init_of_compatible(adev);
363 if (acpi_enumerate_nondev_subnodes(adev->handle, buf.pointer,
364 &adev->data, acpi_fwnode_handle(adev)))
365 adev->data.pointer = buf.pointer;
367 if (!adev->data.pointer) {
368 acpi_handle_debug(adev->handle, "Invalid _DSD data, skipping\n");
369 ACPI_FREE(buf.pointer);
373 if (acpi_of && !adev->flags.of_compatible_ok)
374 acpi_handle_info(adev->handle,
375 ACPI_DT_NAMESPACE_HID " requires 'compatible' property\n");
378 static void acpi_destroy_nondev_subnodes(struct list_head *list)
380 struct acpi_data_node *dn, *next;
382 if (list_empty(list))
385 list_for_each_entry_safe_reverse(dn, next, list, sibling) {
386 acpi_destroy_nondev_subnodes(&dn->data.subnodes);
387 wait_for_completion(&dn->kobj_done);
388 list_del(&dn->sibling);
389 ACPI_FREE((void *)dn->data.pointer);
394 void acpi_free_properties(struct acpi_device *adev)
396 acpi_destroy_nondev_subnodes(&adev->data.subnodes);
397 ACPI_FREE((void *)adev->data.pointer);
398 adev->data.of_compatible = NULL;
399 adev->data.pointer = NULL;
400 adev->data.properties = NULL;
404 * acpi_data_get_property - return an ACPI property with given name
405 * @data: ACPI device deta object to get the property from
406 * @name: Name of the property
407 * @type: Expected property type
408 * @obj: Location to store the property value (if not %NULL)
410 * Look up a property with @name and store a pointer to the resulting ACPI
411 * object at the location pointed to by @obj if found.
413 * Callers must not attempt to free the returned objects. These objects will be
414 * freed by the ACPI core automatically during the removal of @data.
416 * Return: %0 if property with @name has been found (success),
417 * %-EINVAL if the arguments are invalid,
418 * %-EINVAL if the property doesn't exist,
419 * %-EPROTO if the property value type doesn't match @type.
421 static int acpi_data_get_property(struct acpi_device_data *data,
422 const char *name, acpi_object_type type,
423 const union acpi_object **obj)
425 const union acpi_object *properties;
431 if (!data->pointer || !data->properties)
434 properties = data->properties;
435 for (i = 0; i < properties->package.count; i++) {
436 const union acpi_object *propname, *propvalue;
437 const union acpi_object *property;
439 property = &properties->package.elements[i];
441 propname = &property->package.elements[0];
442 propvalue = &property->package.elements[1];
444 if (!strcmp(name, propname->string.pointer)) {
445 if (type != ACPI_TYPE_ANY && propvalue->type != type)
457 * acpi_dev_get_property - return an ACPI property with given name.
458 * @adev: ACPI device to get the property from.
459 * @name: Name of the property.
460 * @type: Expected property type.
461 * @obj: Location to store the property value (if not %NULL).
463 int acpi_dev_get_property(struct acpi_device *adev, const char *name,
464 acpi_object_type type, const union acpi_object **obj)
466 return adev ? acpi_data_get_property(&adev->data, name, type, obj) : -EINVAL;
468 EXPORT_SYMBOL_GPL(acpi_dev_get_property);
470 static struct acpi_device_data *acpi_device_data_of_node(struct fwnode_handle *fwnode)
472 if (fwnode->type == FWNODE_ACPI) {
473 struct acpi_device *adev = to_acpi_device_node(fwnode);
475 } else if (fwnode->type == FWNODE_ACPI_DATA) {
476 struct acpi_data_node *dn = to_acpi_data_node(fwnode);
483 * acpi_node_prop_get - return an ACPI property with given name.
484 * @fwnode: Firmware node to get the property from.
485 * @propname: Name of the property.
486 * @valptr: Location to store a pointer to the property value (if not %NULL).
488 int acpi_node_prop_get(struct fwnode_handle *fwnode, const char *propname,
491 return acpi_data_get_property(acpi_device_data_of_node(fwnode),
492 propname, ACPI_TYPE_ANY,
493 (const union acpi_object **)valptr);
497 * acpi_data_get_property_array - return an ACPI array property with given name
498 * @adev: ACPI data object to get the property from
499 * @name: Name of the property
500 * @type: Expected type of array elements
501 * @obj: Location to store a pointer to the property value (if not NULL)
503 * Look up an array property with @name and store a pointer to the resulting
504 * ACPI object at the location pointed to by @obj if found.
506 * Callers must not attempt to free the returned objects. Those objects will be
507 * freed by the ACPI core automatically during the removal of @data.
509 * Return: %0 if array property (package) with @name has been found (success),
510 * %-EINVAL if the arguments are invalid,
511 * %-EINVAL if the property doesn't exist,
512 * %-EPROTO if the property is not a package or the type of its elements
513 * doesn't match @type.
515 static int acpi_data_get_property_array(struct acpi_device_data *data,
517 acpi_object_type type,
518 const union acpi_object **obj)
520 const union acpi_object *prop;
523 ret = acpi_data_get_property(data, name, ACPI_TYPE_PACKAGE, &prop);
527 if (type != ACPI_TYPE_ANY) {
528 /* Check that all elements are of correct type. */
529 for (i = 0; i < prop->package.count; i++)
530 if (prop->package.elements[i].type != type)
540 * __acpi_node_get_property_reference - returns handle to the referenced object
541 * @fwnode: Firmware node to get the property from
542 * @propname: Name of the property
543 * @index: Index of the reference to return
544 * @num_args: Maximum number of arguments after each reference
545 * @args: Location to store the returned reference with optional arguments
547 * Find property with @name, verifify that it is a package containing at least
548 * one object reference and if so, store the ACPI device object pointer to the
549 * target object in @args->adev. If the reference includes arguments, store
550 * them in the @args->args[] array.
552 * If there's more than one reference in the property value package, @index is
553 * used to select the one to return.
555 * It is possible to leave holes in the property value set like in the
568 * Calling this function with index %2 return %-ENOENT and with index %3
569 * returns the last entry. If the property does not contain any more values
570 * %-ENODATA is returned. The NULL entry must be single integer and
571 * preferably contain value %0.
573 * Return: %0 on success, negative error code on failure.
575 int __acpi_node_get_property_reference(struct fwnode_handle *fwnode,
576 const char *propname, size_t index, size_t num_args,
577 struct acpi_reference_args *args)
579 const union acpi_object *element, *end;
580 const union acpi_object *obj;
581 struct acpi_device_data *data;
582 struct acpi_device *device;
585 data = acpi_device_data_of_node(fwnode);
589 ret = acpi_data_get_property(data, propname, ACPI_TYPE_ANY, &obj);
594 * The simplest case is when the value is a single reference. Just
595 * return that reference then.
597 if (obj->type == ACPI_TYPE_LOCAL_REFERENCE) {
601 ret = acpi_bus_get_device(obj->reference.handle, &device);
611 * If it is not a single reference, then it is a package of
612 * references followed by number of ints as follows:
614 * Package () { REF, INT, REF, INT, INT }
616 * The index argument is then used to determine which reference
617 * the caller wants (along with the arguments).
619 if (obj->type != ACPI_TYPE_PACKAGE || index >= obj->package.count)
622 element = obj->package.elements;
623 end = element + obj->package.count;
625 while (element < end) {
628 if (element->type == ACPI_TYPE_LOCAL_REFERENCE) {
629 ret = acpi_bus_get_device(element->reference.handle,
637 /* assume following integer elements are all args */
638 for (i = 0; element + i < end && i < num_args; i++) {
639 int type = element[i].type;
641 if (type == ACPI_TYPE_INTEGER)
643 else if (type == ACPI_TYPE_LOCAL_REFERENCE)
649 if (nargs > MAX_ACPI_REFERENCE_ARGS)
655 for (i = 0; i < nargs; i++)
656 args->args[i] = element[i].integer.value;
662 } else if (element->type == ACPI_TYPE_INTEGER) {
675 EXPORT_SYMBOL_GPL(__acpi_node_get_property_reference);
677 static int acpi_data_prop_read_single(struct acpi_device_data *data,
678 const char *propname,
679 enum dev_prop_type proptype, void *val)
681 const union acpi_object *obj;
687 if (proptype >= DEV_PROP_U8 && proptype <= DEV_PROP_U64) {
688 ret = acpi_data_get_property(data, propname, ACPI_TYPE_INTEGER, &obj);
694 if (obj->integer.value > U8_MAX)
696 *(u8 *)val = obj->integer.value;
699 if (obj->integer.value > U16_MAX)
701 *(u16 *)val = obj->integer.value;
704 if (obj->integer.value > U32_MAX)
706 *(u32 *)val = obj->integer.value;
709 *(u64 *)val = obj->integer.value;
712 } else if (proptype == DEV_PROP_STRING) {
713 ret = acpi_data_get_property(data, propname, ACPI_TYPE_STRING, &obj);
717 *(char **)val = obj->string.pointer;
726 int acpi_dev_prop_read_single(struct acpi_device *adev, const char *propname,
727 enum dev_prop_type proptype, void *val)
734 ret = acpi_data_prop_read_single(&adev->data, propname, proptype, val);
735 if (ret < 0 || proptype != ACPI_TYPE_STRING)
740 static int acpi_copy_property_array_u8(const union acpi_object *items, u8 *val,
745 for (i = 0; i < nval; i++) {
746 if (items[i].type != ACPI_TYPE_INTEGER)
748 if (items[i].integer.value > U8_MAX)
751 val[i] = items[i].integer.value;
756 static int acpi_copy_property_array_u16(const union acpi_object *items,
757 u16 *val, size_t nval)
761 for (i = 0; i < nval; i++) {
762 if (items[i].type != ACPI_TYPE_INTEGER)
764 if (items[i].integer.value > U16_MAX)
767 val[i] = items[i].integer.value;
772 static int acpi_copy_property_array_u32(const union acpi_object *items,
773 u32 *val, size_t nval)
777 for (i = 0; i < nval; i++) {
778 if (items[i].type != ACPI_TYPE_INTEGER)
780 if (items[i].integer.value > U32_MAX)
783 val[i] = items[i].integer.value;
788 static int acpi_copy_property_array_u64(const union acpi_object *items,
789 u64 *val, size_t nval)
793 for (i = 0; i < nval; i++) {
794 if (items[i].type != ACPI_TYPE_INTEGER)
797 val[i] = items[i].integer.value;
802 static int acpi_copy_property_array_string(const union acpi_object *items,
803 char **val, size_t nval)
807 for (i = 0; i < nval; i++) {
808 if (items[i].type != ACPI_TYPE_STRING)
811 val[i] = items[i].string.pointer;
816 static int acpi_data_prop_read(struct acpi_device_data *data,
817 const char *propname,
818 enum dev_prop_type proptype,
819 void *val, size_t nval)
821 const union acpi_object *obj;
822 const union acpi_object *items;
825 if (val && nval == 1) {
826 ret = acpi_data_prop_read_single(data, propname, proptype, val);
831 ret = acpi_data_get_property_array(data, propname, ACPI_TYPE_ANY, &obj);
836 return obj->package.count;
838 if (proptype != DEV_PROP_STRING && nval > obj->package.count)
843 items = obj->package.elements;
847 ret = acpi_copy_property_array_u8(items, (u8 *)val, nval);
850 ret = acpi_copy_property_array_u16(items, (u16 *)val, nval);
853 ret = acpi_copy_property_array_u32(items, (u32 *)val, nval);
856 ret = acpi_copy_property_array_u64(items, (u64 *)val, nval);
858 case DEV_PROP_STRING:
859 ret = acpi_copy_property_array_string(
861 min_t(u32, nval, obj->package.count));
870 int acpi_dev_prop_read(struct acpi_device *adev, const char *propname,
871 enum dev_prop_type proptype, void *val, size_t nval)
873 return adev ? acpi_data_prop_read(&adev->data, propname, proptype, val, nval) : -EINVAL;
877 * acpi_node_prop_read - retrieve the value of an ACPI property with given name.
878 * @fwnode: Firmware node to get the property from.
879 * @propname: Name of the property.
880 * @proptype: Expected property type.
881 * @val: Location to store the property value (if not %NULL).
882 * @nval: Size of the array pointed to by @val.
884 * If @val is %NULL, return the number of array elements comprising the value
885 * of the property. Otherwise, read at most @nval values to the array at the
886 * location pointed to by @val.
888 int acpi_node_prop_read(struct fwnode_handle *fwnode, const char *propname,
889 enum dev_prop_type proptype, void *val, size_t nval)
891 return acpi_data_prop_read(acpi_device_data_of_node(fwnode),
892 propname, proptype, val, nval);
896 * acpi_get_next_subnode - Return the next child node handle for a fwnode
897 * @fwnode: Firmware node to find the next child node for.
898 * @child: Handle to one of the device's child nodes or a null handle.
900 struct fwnode_handle *acpi_get_next_subnode(struct fwnode_handle *fwnode,
901 struct fwnode_handle *child)
903 struct acpi_device *adev = to_acpi_device_node(fwnode);
904 struct list_head *head, *next;
906 if (!child || child->type == FWNODE_ACPI) {
908 head = &adev->children;
912 if (list_empty(head))
916 adev = to_acpi_device_node(child);
917 next = adev->node.next;
922 adev = list_entry(next, struct acpi_device, node);
924 adev = list_first_entry(head, struct acpi_device, node);
926 return acpi_fwnode_handle(adev);
930 if (!child || child->type == FWNODE_ACPI_DATA) {
931 struct acpi_data_node *data = to_acpi_data_node(fwnode);
932 struct acpi_data_node *dn;
935 head = &adev->data.subnodes;
937 head = &data->data.subnodes;
941 if (list_empty(head))
945 dn = to_acpi_data_node(child);
946 next = dn->sibling.next;
950 dn = list_entry(next, struct acpi_data_node, sibling);
952 dn = list_first_entry(head, struct acpi_data_node, sibling);
960 * acpi_node_get_parent - Return parent fwnode of this fwnode
961 * @fwnode: Firmware node whose parent to get
963 * Returns parent node of an ACPI device or data firmware node or %NULL if
966 struct fwnode_handle *acpi_node_get_parent(struct fwnode_handle *fwnode)
968 if (is_acpi_data_node(fwnode)) {
969 /* All data nodes have parent pointer so just return that */
970 return to_acpi_data_node(fwnode)->parent;
971 } else if (is_acpi_device_node(fwnode)) {
972 acpi_handle handle, parent_handle;
974 handle = to_acpi_device_node(fwnode)->handle;
975 if (ACPI_SUCCESS(acpi_get_parent(handle, &parent_handle))) {
976 struct acpi_device *adev;
978 if (!acpi_bus_get_device(parent_handle, &adev))
979 return acpi_fwnode_handle(adev);
987 * acpi_graph_get_next_endpoint - Get next endpoint ACPI firmware node
988 * @fwnode: Pointer to the parent firmware node
989 * @prev: Previous endpoint node or %NULL to get the first
991 * Looks up next endpoint ACPI firmware node below a given @fwnode. Returns
992 * %NULL if there is no next endpoint, ERR_PTR() in case of error. In case
993 * of success the next endpoint is returned.
995 struct fwnode_handle *acpi_graph_get_next_endpoint(struct fwnode_handle *fwnode,
996 struct fwnode_handle *prev)
998 struct fwnode_handle *port = NULL;
999 struct fwnode_handle *endpoint;
1003 port = fwnode_get_next_child_node(fwnode, port);
1004 /* Ports must have port property */
1005 if (fwnode_property_present(port, "port"))
1009 port = fwnode_get_parent(prev);
1015 endpoint = fwnode_get_next_child_node(port, prev);
1017 port = fwnode_get_next_child_node(fwnode, port);
1020 if (fwnode_property_present(port, "port"))
1021 endpoint = fwnode_get_next_child_node(port, NULL);
1025 /* Endpoints must have "endpoint" property */
1026 if (!fwnode_property_present(endpoint, "endpoint"))
1027 return ERR_PTR(-EPROTO);
1034 * acpi_graph_get_child_prop_value - Return a child with a given property value
1035 * @fwnode: device fwnode
1036 * @prop_name: The name of the property to look for
1037 * @val: the desired property value
1039 * Return the port node corresponding to a given port number. Returns
1040 * the child node on success, NULL otherwise.
1042 static struct fwnode_handle *acpi_graph_get_child_prop_value(
1043 struct fwnode_handle *fwnode, const char *prop_name, unsigned int val)
1045 struct fwnode_handle *child;
1047 fwnode_for_each_child_node(fwnode, child) {
1050 if (fwnode_property_read_u32(child, prop_name, &nr))
1062 * acpi_graph_get_remote_enpoint - Parses and returns remote end of an endpoint
1063 * @fwnode: Endpoint firmware node pointing to a remote device
1064 * @parent: Firmware node of remote port parent is filled here if not %NULL
1065 * @port: Firmware node of remote port is filled here if not %NULL
1066 * @endpoint: Firmware node of remote endpoint is filled here if not %NULL
1068 * Function parses remote end of ACPI firmware remote endpoint and fills in
1069 * fields requested by the caller. Returns %0 in case of success and
1070 * negative errno otherwise.
1072 int acpi_graph_get_remote_endpoint(struct fwnode_handle *fwnode,
1073 struct fwnode_handle **parent,
1074 struct fwnode_handle **port,
1075 struct fwnode_handle **endpoint)
1077 unsigned int port_nr, endpoint_nr;
1078 struct acpi_reference_args args;
1081 memset(&args, 0, sizeof(args));
1082 ret = acpi_node_get_property_reference(fwnode, "remote-endpoint", 0,
1088 * Always require two arguments with the reference: port and
1091 if (args.nargs != 2)
1094 fwnode = acpi_fwnode_handle(args.adev);
1095 port_nr = args.args[0];
1096 endpoint_nr = args.args[1];
1101 if (!port && !endpoint)
1104 fwnode = acpi_graph_get_child_prop_value(fwnode, "port", port_nr);
1114 fwnode = acpi_graph_get_child_prop_value(fwnode, "endpoint",
1124 static bool acpi_fwnode_device_is_available(struct fwnode_handle *fwnode)
1126 if (!is_acpi_device_node(fwnode))
1129 return acpi_device_is_present(to_acpi_device_node(fwnode));
1132 static bool acpi_fwnode_property_present(struct fwnode_handle *fwnode,
1133 const char *propname)
1135 return !acpi_node_prop_get(fwnode, propname, NULL);
1138 static int acpi_fwnode_property_read_int_array(struct fwnode_handle *fwnode,
1139 const char *propname,
1140 unsigned int elem_size,
1141 void *val, size_t nval)
1143 enum dev_prop_type type;
1145 switch (elem_size) {
1150 type = DEV_PROP_U16;
1153 type = DEV_PROP_U32;
1156 type = DEV_PROP_U64;
1162 return acpi_node_prop_read(fwnode, propname, type, val, nval);
1165 static int acpi_fwnode_property_read_string_array(struct fwnode_handle *fwnode,
1166 const char *propname,
1167 const char **val, size_t nval)
1169 return acpi_node_prop_read(fwnode, propname, DEV_PROP_STRING,
1173 static struct fwnode_handle *
1174 acpi_fwnode_get_named_child_node(struct fwnode_handle *fwnode,
1175 const char *childname)
1177 struct fwnode_handle *child;
1180 * Find first matching named child node of this fwnode.
1181 * For ACPI this will be a data only sub-node.
1183 fwnode_for_each_child_node(fwnode, child)
1184 if (acpi_data_node_match(child, childname))
1190 static struct fwnode_handle *
1191 acpi_fwnode_graph_get_next_endpoint(struct fwnode_handle *fwnode,
1192 struct fwnode_handle *prev)
1194 struct fwnode_handle *endpoint;
1196 endpoint = acpi_graph_get_next_endpoint(fwnode, prev);
1197 if (IS_ERR(endpoint))
1203 static struct fwnode_handle *
1204 acpi_fwnode_graph_get_remote_endpoint(struct fwnode_handle *fwnode)
1206 struct fwnode_handle *endpoint = NULL;
1208 acpi_graph_get_remote_endpoint(fwnode, NULL, NULL, &endpoint);
1213 static int acpi_fwnode_graph_parse_endpoint(struct fwnode_handle *fwnode,
1214 struct fwnode_endpoint *endpoint)
1216 struct fwnode_handle *port_fwnode = fwnode_get_parent(fwnode);
1218 endpoint->local_fwnode = fwnode;
1220 fwnode_property_read_u32(port_fwnode, "port", &endpoint->port);
1221 fwnode_property_read_u32(fwnode, "endpoint", &endpoint->id);
1226 const struct fwnode_operations acpi_fwnode_ops = {
1227 .device_is_available = acpi_fwnode_device_is_available,
1228 .property_present = acpi_fwnode_property_present,
1229 .property_read_int_array = acpi_fwnode_property_read_int_array,
1230 .property_read_string_array = acpi_fwnode_property_read_string_array,
1231 .get_parent = acpi_node_get_parent,
1232 .get_next_child_node = acpi_get_next_subnode,
1233 .get_named_child_node = acpi_fwnode_get_named_child_node,
1234 .graph_get_next_endpoint = acpi_fwnode_graph_get_next_endpoint,
1235 .graph_get_remote_endpoint = acpi_fwnode_graph_get_remote_endpoint,
1236 .graph_get_port_parent = acpi_node_get_parent,
1237 .graph_parse_endpoint = acpi_fwnode_graph_parse_endpoint,