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
,