1	// SPDX-License-Identifier: GPL-2.0-only
2	/*
3	* ACPI device specific properties support.
4	*
5	* Copyright (C) 2014 - 2023, Intel Corporation
6	* All rights reserved.
7	*
8	* Authors: Mika Westerberg <mika.westerberg@linux.intel.com>
9	* Darren Hart <dvhart@linux.intel.com>
10	* Rafael J. Wysocki <rafael.j.wysocki@intel.com>
11	* Sakari Ailus <sakari.ailus@linux.intel.com>
12	*/
13
14	#define pr_fmt(fmt) "ACPI: " fmt
15
16	#include <linux/acpi.h>
17	#include <linux/device.h>
18	#include <linux/export.h>
19
20	#include "internal.h"
21
22	static int acpi_data_get_property_array(const struct acpi_device_data *data,
23	const char *name,
24	acpi_object_type type,
25	const union acpi_object **obj);
26
27	/*
28	* The GUIDs here are made equivalent to each other in order to avoid extra
29	* complexity in the properties handling code, with the caveat that the
30	* kernel will accept certain combinations of GUID and properties that are
31	* not defined without a warning. For instance if any of the properties
32	* from different GUID appear in a property list of another, it will be
33	* accepted by the kernel. Firmware validation tools should catch these.
34	*/
35	static const guid_t prp_guids[] = {
36	/* ACPI _DSD device properties GUID: daffd814-6eba-4d8c-8a91-bc9bbf4aa301 */
37	GUID_INIT(0xdaffd814, 0x6eba, 0x4d8c,
38	0x8a, 0x91, 0xbc, 0x9b, 0xbf, 0x4a, 0xa3, 0x01),
39	/* Hotplug in D3 GUID: 6211e2c0-58a3-4af3-90e1-927a4e0c55a4 */
40	GUID_INIT(0x6211e2c0, 0x58a3, 0x4af3,
41	0x90, 0xe1, 0x92, 0x7a, 0x4e, 0x0c, 0x55, 0xa4),
42	/* External facing port GUID: efcc06cc-73ac-4bc3-bff0-76143807c389 */
43	GUID_INIT(0xefcc06cc, 0x73ac, 0x4bc3,
44	0xbf, 0xf0, 0x76, 0x14, 0x38, 0x07, 0xc3, 0x89),
45	/* Thunderbolt GUID for IMR_VALID: c44d002f-69f9-4e7d-a904-a7baabdf43f7 */
46	GUID_INIT(0xc44d002f, 0x69f9, 0x4e7d,
47	0xa9, 0x04, 0xa7, 0xba, 0xab, 0xdf, 0x43, 0xf7),
48	/* Thunderbolt GUID for WAKE_SUPPORTED: 6c501103-c189-4296-ba72-9bf5a26ebe5d */
49	GUID_INIT(0x6c501103, 0xc189, 0x4296,
50	0xba, 0x72, 0x9b, 0xf5, 0xa2, 0x6e, 0xbe, 0x5d),
51	/* Storage device needs D3 GUID: 5025030f-842f-4ab4-a561-99a5189762d0 */
52	GUID_INIT(0x5025030f, 0x842f, 0x4ab4,
53	0xa5, 0x61, 0x99, 0xa5, 0x18, 0x97, 0x62, 0xd0),
54	};
55
56	/* ACPI _DSD data subnodes GUID: dbb8e3e6-5886-4ba6-8795-1319f52a966b */
57	static const guid_t ads_guid =
58	GUID_INIT(0xdbb8e3e6, 0x5886, 0x4ba6,
59	0x87, 0x95, 0x13, 0x19, 0xf5, 0x2a, 0x96, 0x6b);
60
61	/* ACPI _DSD data buffer GUID: edb12dd0-363d-4085-a3d2-49522ca160c4 */
62	static const guid_t buffer_prop_guid =
63	GUID_INIT(0xedb12dd0, 0x363d, 0x4085,
64	0xa3, 0xd2, 0x49, 0x52, 0x2c, 0xa1, 0x60, 0xc4);
65
66	static bool acpi_enumerate_nondev_subnodes(acpi_handle scope,
67	union acpi_object *desc,
68	struct acpi_device_data *data,
69	struct fwnode_handle *parent);
70	static bool acpi_extract_properties(acpi_handle handle,
71	union acpi_object *desc,
72	struct acpi_device_data *data);
73
74	static bool acpi_nondev_subnode_extract(union acpi_object *desc,
75	acpi_handle handle,
76	const union acpi_object *link,
77	struct list_head *list,
78	struct fwnode_handle *parent)
79	{
80	struct acpi_data_node *dn;
81	bool result;
82
83	if (acpi_graph_ignore_port(handle))
84	return false;
85
86	dn = kzalloc(size: sizeof(*dn), GFP_KERNEL);
87	if (!dn)
88	return false;
89
90	dn->name = link->package.elements[0].string.pointer;
91	fwnode_init(fwnode: &dn->fwnode, ops: &acpi_data_fwnode_ops);
92	dn->parent = parent;
93	INIT_LIST_HEAD(list: &dn->data.properties);
94	INIT_LIST_HEAD(list: &dn->data.subnodes);
95
96	result = acpi_extract_properties(handle, desc, data: &dn->data);
97
98	if (handle) {
99	acpi_handle scope;
100	acpi_status status;
101
102	/*
103	* The scope for the subnode object lookup is the one of the
104	* namespace node (device) containing the object that has
105	* returned the package. That is, it's the scope of that
106	* object's parent.
107	*/
108	status = acpi_get_parent(object: handle, out_handle: &scope);
109	if (ACPI_SUCCESS(status)
110	&& acpi_enumerate_nondev_subnodes(scope, desc, data: &dn->data,
111	parent: &dn->fwnode))
112	result = true;
113	} else if (acpi_enumerate_nondev_subnodes(NULL, desc, data: &dn->data,
114	parent: &dn->fwnode)) {
115	result = true;
116	}
117
118	if (result) {
119	dn->handle = handle;
120	dn->data.pointer = desc;
121	list_add_tail(new: &dn->sibling, head: list);
122	return true;
123	}
124
125	kfree(objp: dn);
126	acpi_handle_debug(handle, "Invalid properties/subnodes data, skipping\n");
127	return false;
128	}
129
130	static bool acpi_nondev_subnode_data_ok(acpi_handle handle,
131	const union acpi_object *link,
132	struct list_head *list,
133	struct fwnode_handle *parent)
134	{
135	struct acpi_buffer buf = { ACPI_ALLOCATE_BUFFER };
136	acpi_status status;
137
138	status = acpi_evaluate_object_typed(object: handle, NULL, NULL, return_buffer: &buf,
139	ACPI_TYPE_PACKAGE);
140	if (ACPI_FAILURE(status))
141	return false;
142
143	if (acpi_nondev_subnode_extract(desc: buf.pointer, handle, link, list,
144	parent))
145	return true;
146
147	ACPI_FREE(buf.pointer);
148	return false;
149	}
150
151	static bool acpi_nondev_subnode_ok(acpi_handle scope,
152	const union acpi_object *link,
153	struct list_head *list,
154	struct fwnode_handle *parent)
155	{
156	acpi_handle handle;
157	acpi_status status;
158
159	if (!scope)
160	return false;
161
162	status = acpi_get_handle(parent: scope, pathname: link->package.elements[1].string.pointer,
163	ret_handle: &handle);
164	if (ACPI_FAILURE(status))
165	return false;
166
167	return acpi_nondev_subnode_data_ok(handle, link, list, parent);
168	}
169
170	static bool acpi_add_nondev_subnodes(acpi_handle scope,
171	union acpi_object *links,
172	struct list_head *list,
173	struct fwnode_handle *parent)
174	{
175	bool ret = false;
176	int i;
177
178	for (i = 0; i < links->package.count; i++) {
179	union acpi_object *link, *desc;
180	acpi_handle handle;
181	bool result;
182
183	link = &links->package.elements[i];
184	/* Only two elements allowed. */
185	if (link->package.count != 2)
186	continue;
187
188	/* The first one must be a string. */
189	if (link->package.elements[0].type != ACPI_TYPE_STRING)
190	continue;
191
192	/* The second one may be a string, a reference or a package. */
193	switch (link->package.elements[1].type) {
194	case ACPI_TYPE_STRING:
195	result = acpi_nondev_subnode_ok(scope, link, list,
196	parent);
197	break;
198	case ACPI_TYPE_LOCAL_REFERENCE:
199	handle = link->package.elements[1].reference.handle;
200	result = acpi_nondev_subnode_data_ok(handle, link, list,
201	parent);
202	break;
203	case ACPI_TYPE_PACKAGE:
204	desc = &link->package.elements[1];
205	result = acpi_nondev_subnode_extract(desc, NULL, link,
206	list, parent);
207	break;
208	default:
209	result = false;
210	break;
211	}
212	ret = ret || result;
213	}
214
215	return ret;
216	}
217
218	static bool acpi_enumerate_nondev_subnodes(acpi_handle scope,
219	union acpi_object *desc,
220	struct acpi_device_data *data,
221	struct fwnode_handle *parent)
222	{
223	int i;
224
225	/* Look for the ACPI data subnodes GUID. */
226	for (i = 0; i < desc->package.count; i += 2) {
227	const union acpi_object *guid;
228	union acpi_object *links;
229
230	guid = &desc->package.elements[i];
231	links = &desc->package.elements[i + 1];
232
233	/*
234	* The first element must be a GUID and the second one must be
235	* a package.
236	*/
237	if (guid->type != ACPI_TYPE_BUFFER ||
238	guid->buffer.length != 16 ||
239	links->type != ACPI_TYPE_PACKAGE)
240	break;
241
242	if (!guid_equal(u1: (guid_t *)guid->buffer.pointer, u2: &ads_guid))
243	continue;
244
245	return acpi_add_nondev_subnodes(scope, links, list: &data->subnodes,
246	parent);
247	}
248
249	return false;
250	}
251
252	static bool acpi_property_value_ok(const union acpi_object *value)
253	{
254	int j;
255
256	/*
257	* The value must be an integer, a string, a reference, or a package
258	* whose every element must be an integer, a string, or a reference.
259	*/
260	switch (value->type) {
261	case ACPI_TYPE_INTEGER:
262	case ACPI_TYPE_STRING:
263	case ACPI_TYPE_LOCAL_REFERENCE:
264	return true;
265
266	case ACPI_TYPE_PACKAGE:
267	for (j = 0; j < value->package.count; j++)
268	switch (value->package.elements[j].type) {
269	case ACPI_TYPE_INTEGER:
270	case ACPI_TYPE_STRING:
271	case ACPI_TYPE_LOCAL_REFERENCE:
272	continue;
273
274	default:
275	return false;
276	}
277
278	return true;
279	}
280	return false;
281	}
282
283	static bool acpi_properties_format_valid(const union acpi_object *properties)
284	{
285	int i;
286
287	for (i = 0; i < properties->package.count; i++) {
288	const union acpi_object *property;
289
290	property = &properties->package.elements[i];
291	/*
292	* Only two elements allowed, the first one must be a string and
293	* the second one has to satisfy certain conditions.
294	*/
295	if (property->package.count != 2
296	|| property->package.elements[0].type != ACPI_TYPE_STRING
297	|| !acpi_property_value_ok(value: &property->package.elements[1]))
298	return false;
299	}
300	return true;
301	}
302
303	static void acpi_init_of_compatible(struct acpi_device *adev)
304	{
305	const union acpi_object *of_compatible;
306	int ret;
307
308	ret = acpi_data_get_property_array(data: &adev->data, name: "compatible",
309	ACPI_TYPE_STRING, obj: &of_compatible);
310	if (ret) {
311	ret = acpi_dev_get_property(adev, name: "compatible",
312	ACPI_TYPE_STRING, obj: &of_compatible);
313	if (ret) {
314	struct acpi_device *parent;
315
316	parent = acpi_dev_parent(adev);
317	if (parent && parent->flags.of_compatible_ok)
318	goto out;
319
320	return;
321	}
322	}
323	adev->data.of_compatible = of_compatible;
324
325	out:
326	adev->flags.of_compatible_ok = 1;
327	}
328
329	static bool acpi_is_property_guid(const guid_t *guid)
330	{
331	int i;
332
333	for (i = 0; i < ARRAY_SIZE(prp_guids); i++) {
334	if (guid_equal(u1: guid, u2: &prp_guids[i]))
335	return true;
336	}
337
338	return false;
339	}
340
341	struct acpi_device_properties *
342	acpi_data_add_props(struct acpi_device_data *data, const guid_t *guid,
343	union acpi_object *properties)
344	{
345	struct acpi_device_properties *props;
346
347	props = kzalloc(size: sizeof(*props), GFP_KERNEL);
348	if (props) {
349	INIT_LIST_HEAD(list: &props->list);
350	props->guid = guid;
351	props->properties = properties;
352	list_add_tail(new: &props->list, head: &data->properties);
353	}
354
355	return props;
356	}
357
358	static void acpi_nondev_subnode_tag(acpi_handle handle, void *context)
359	{
360	}
361
362	static void acpi_untie_nondev_subnodes(struct acpi_device_data *data)
363	{
364	struct acpi_data_node *dn;
365
366	list_for_each_entry(dn, &data->subnodes, sibling) {
367	acpi_detach_data(object: dn->handle, handler: acpi_nondev_subnode_tag);
368
369	acpi_untie_nondev_subnodes(data: &dn->data);
370	}
371	}
372
373	static bool acpi_tie_nondev_subnodes(struct acpi_device_data *data)
374	{
375	struct acpi_data_node *dn;
376
377	list_for_each_entry(dn, &data->subnodes, sibling) {
378	acpi_status status;
379	bool ret;
380
381	status = acpi_attach_data(object: dn->handle, handler: acpi_nondev_subnode_tag, data: dn);
382	if (ACPI_FAILURE(status) && status != AE_ALREADY_EXISTS) {
383	acpi_handle_err(dn->handle, "Can't tag data node\n");
384	return false;
385	}
386
387	ret = acpi_tie_nondev_subnodes(data: &dn->data);
388	if (!ret)
389	return ret;
390	}
391
392	return true;
393	}
394
395	static void acpi_data_add_buffer_props(acpi_handle handle,
396	struct acpi_device_data *data,
397	union acpi_object *properties)
398	{
399	struct acpi_device_properties *props;
400	union acpi_object *package;
401	size_t alloc_size;
402	unsigned int i;
403	u32 *count;
404
405	if (check_mul_overflow((size_t)properties->package.count,
406	sizeof(*package) + sizeof(void *),
407	&alloc_size) ||
408	check_add_overflow(sizeof(*props) + sizeof(*package), alloc_size,
409	&alloc_size)) {
410	acpi_handle_warn(handle,
411	"can't allocate memory for %u buffer props",
412	properties->package.count);
413	return;
414	}
415
416	props = kvzalloc(size: alloc_size, GFP_KERNEL);
417	if (!props)
418	return;
419
420	props->guid = &buffer_prop_guid;
421	props->bufs = (void *)(props + 1);
422	props->properties = (void *)(props->bufs + properties->package.count);
423
424	/* Outer package */
425	package = props->properties;
426	package->type = ACPI_TYPE_PACKAGE;
427	package->package.elements = package + 1;
428	count = &package->package.count;
429	*count = 0;
430
431	/* Inner packages */
432	package++;
433
434	for (i = 0; i < properties->package.count; i++) {
435	struct acpi_buffer buf = { ACPI_ALLOCATE_BUFFER };
436	union acpi_object *property = &properties->package.elements[i];
437	union acpi_object *prop, *obj, *buf_obj;
438	acpi_status status;
439
440	if (property->type != ACPI_TYPE_PACKAGE ||
441	property->package.count != 2) {
442	acpi_handle_warn(handle,
443	"buffer property %u has %u entries\n",
444	i, property->package.count);
445	continue;
446	}
447
448	prop = &property->package.elements[0];
449	obj = &property->package.elements[1];
450
451	if (prop->type != ACPI_TYPE_STRING ||
452	obj->type != ACPI_TYPE_STRING) {
453	acpi_handle_warn(handle,
454	"wrong object types %u and %u\n",
455	prop->type, obj->type);
456	continue;
457	}
458
459	status = acpi_evaluate_object_typed(object: handle, pathname: obj->string.pointer,
460	NULL, return_buffer: &buf,
461	ACPI_TYPE_BUFFER);
462	if (ACPI_FAILURE(status)) {
463	acpi_handle_warn(handle,
464	"can't evaluate \"%*pE\" as buffer\n",
465	obj->string.length,
466	obj->string.pointer);
467	continue;
468	}
469
470	package->type = ACPI_TYPE_PACKAGE;
471	package->package.elements = prop;
472	package->package.count = 2;
473
474	buf_obj = buf.pointer;
475
476	/* Replace the string object with a buffer object */
477	obj->type = ACPI_TYPE_BUFFER;
478	obj->buffer.length = buf_obj->buffer.length;
479	obj->buffer.pointer = buf_obj->buffer.pointer;
480
481	props->bufs[i] = buf.pointer;
482	package++;
483	(*count)++;
484	}
485
486	if (*count)
487	list_add(new: &props->list, head: &data->properties);
488	else
489	kvfree(addr: props);
490	}
491
492	static bool acpi_extract_properties(acpi_handle scope, union acpi_object *desc,
493	struct acpi_device_data *data)
494	{
495	int i;
496
497	if (desc->package.count % 2)
498	return false;
499
500	/* Look for the device properties GUID. */
501	for (i = 0; i < desc->package.count; i += 2) {
502	const union acpi_object *guid;
503	union acpi_object *properties;
504
505	guid = &desc->package.elements[i];
506	properties = &desc->package.elements[i + 1];
507
508	/*
509	* The first element must be a GUID and the second one must be
510	* a package.
511	*/
512	if (guid->type != ACPI_TYPE_BUFFER ||
513	guid->buffer.length != 16 ||
514	properties->type != ACPI_TYPE_PACKAGE)
515	break;
516
517	if (guid_equal(u1: (guid_t *)guid->buffer.pointer,
518	u2: &buffer_prop_guid)) {
519	acpi_data_add_buffer_props(handle: scope, data, properties);
520	continue;
521	}
522
523	if (!acpi_is_property_guid(guid: (guid_t *)guid->buffer.pointer))
524	continue;
525
526	/*
527	* We found the matching GUID. Now validate the format of the
528	* package immediately following it.
529	*/
530	if (!acpi_properties_format_valid(properties))
531	continue;
532
533	acpi_data_add_props(data, guid: (const guid_t *)guid->buffer.pointer,
534	properties);
535	}
536
537	return !list_empty(head: &data->properties);
538	}
539
540	void acpi_init_properties(struct acpi_device *adev)
541	{
542	struct acpi_buffer buf = { ACPI_ALLOCATE_BUFFER };
543	struct acpi_hardware_id *hwid;
544	acpi_status status;
545	bool acpi_of = false;
546
547	INIT_LIST_HEAD(list: &adev->data.properties);
548	INIT_LIST_HEAD(list: &adev->data.subnodes);
549
550	if (!adev->handle)
551	return;
552
553	/*
554	* Check if ACPI_DT_NAMESPACE_HID is present and inthat case we fill in
555	* Device Tree compatible properties for this device.
556	*/
557	list_for_each_entry(hwid, &adev->pnp.ids, list) {
558	if (!strcmp(hwid->id, ACPI_DT_NAMESPACE_HID)) {
559	acpi_of = true;
560	break;
561	}
562	}
563
564	status = acpi_evaluate_object_typed(object: adev->handle, pathname: "_DSD", NULL, return_buffer: &buf,
565	ACPI_TYPE_PACKAGE);
566	if (ACPI_FAILURE(status))
567	goto out;
568
569	if (acpi_extract_properties(scope: adev->handle, desc: buf.pointer, data: &adev->data)) {
570	adev->data.pointer = buf.pointer;
571	if (acpi_of)
572	acpi_init_of_compatible(adev);
573	}
574	if (acpi_enumerate_nondev_subnodes(scope: adev->handle, desc: buf.pointer,
575	data: &adev->data, parent: acpi_fwnode_handle(adev)))
576	adev->data.pointer = buf.pointer;
577
578	if (!adev->data.pointer) {
579	acpi_handle_debug(adev->handle, "Invalid _DSD data, skipping\n");
580	ACPI_FREE(buf.pointer);
581	} else {
582	if (!acpi_tie_nondev_subnodes(data: &adev->data))
583	acpi_untie_nondev_subnodes(data: &adev->data);
584	}
585
586	out:
587	if (acpi_of && !adev->flags.of_compatible_ok)
588	acpi_handle_info(adev->handle,
589	ACPI_DT_NAMESPACE_HID " requires 'compatible' property\n");
590
591	if (!adev->data.pointer)
592	acpi_extract_apple_properties(adev);
593	}
594
595	static void acpi_free_device_properties(struct list_head *list)
596	{
597	struct acpi_device_properties *props, *tmp;
598
599	list_for_each_entry_safe(props, tmp, list, list) {
600	u32 i;
601
602	list_del(entry: &props->list);
603	/* Buffer data properties were separately allocated */
604	if (props->bufs)
605	for (i = 0; i < props->properties->package.count; i++)
606	ACPI_FREE(props->bufs[i]);
607	kvfree(addr: props);
608	}
609	}
610
611	static void acpi_destroy_nondev_subnodes(struct list_head *list)
612	{
613	struct acpi_data_node *dn, *next;
614
615	if (list_empty(head: list))
616	return;
617
618	list_for_each_entry_safe_reverse(dn, next, list, sibling) {
619	acpi_destroy_nondev_subnodes(list: &dn->data.subnodes);
620	wait_for_completion(&dn->kobj_done);
621	list_del(entry: &dn->sibling);
622	ACPI_FREE((void *)dn->data.pointer);
623	acpi_free_device_properties(list: &dn->data.properties);
624	kfree(objp: dn);
625	}
626	}
627
628	void acpi_free_properties(struct acpi_device *adev)
629	{
630	acpi_untie_nondev_subnodes(data: &adev->data);
631	acpi_destroy_nondev_subnodes(list: &adev->data.subnodes);
632	ACPI_FREE((void *)adev->data.pointer);
633	adev->data.of_compatible = NULL;
634	adev->data.pointer = NULL;
635	acpi_free_device_properties(list: &adev->data.properties);
636	}
637
638	/**
639	* acpi_data_get_property - return an ACPI property with given name
640	* @data: ACPI device deta object to get the property from
641	* @name: Name of the property
642	* @type: Expected property type
643	* @obj: Location to store the property value (if not %NULL)
644	*
645	* Look up a property with @name and store a pointer to the resulting ACPI
646	* object at the location pointed to by @obj if found.
647	*
648	* Callers must not attempt to free the returned objects. These objects will be
649	* freed by the ACPI core automatically during the removal of @data.
650	*
651	* Return: %0 if property with @name has been found (success),
652	* %-EINVAL if the arguments are invalid,
653	* %-EINVAL if the property doesn't exist,
654	* %-EPROTO if the property value type doesn't match @type.
655	*/
656	static int acpi_data_get_property(const struct acpi_device_data *data,
657	const char *name, acpi_object_type type,
658	const union acpi_object **obj)
659	{
660	const struct acpi_device_properties *props;
661
662	if (!data || !name)
663	return -EINVAL;
664
665	if (!data->pointer || list_empty(head: &data->properties))
666	return -EINVAL;
667
668	list_for_each_entry(props, &data->properties, list) {
669	const union acpi_object *properties;
670	unsigned int i;
671
672	properties = props->properties;
673	for (i = 0; i < properties->package.count; i++) {
674	const union acpi_object *propname, *propvalue;
675	const union acpi_object *property;
676
677	property = &properties->package.elements[i];
678
679	propname = &property->package.elements[0];
680	propvalue = &property->package.elements[1];
681
682	if (!strcmp(name, propname->string.pointer)) {
683	if (type != ACPI_TYPE_ANY &&
684	propvalue->type != type)
685	return -EPROTO;
686	if (obj)
687	*obj = propvalue;
688
689	return 0;
690	}
691	}
692	}
693	return -EINVAL;
694	}
695
696	/**
697	* acpi_dev_get_property - return an ACPI property with given name.
698	* @adev: ACPI device to get the property from.
699	* @name: Name of the property.
700	* @type: Expected property type.
701	* @obj: Location to store the property value (if not %NULL).
702	*/
703	int acpi_dev_get_property(const struct acpi_device *adev, const char *name,
704	acpi_object_type type, const union acpi_object **obj)
705	{
706	return adev ? acpi_data_get_property(data: &adev->data, name, type, obj) : -EINVAL;
707	}
708	EXPORT_SYMBOL_GPL(acpi_dev_get_property);
709
710	static const struct acpi_device_data *
711	acpi_device_data_of_node(const struct fwnode_handle *fwnode)
712	{
713	if (is_acpi_device_node(fwnode)) {
714	const struct acpi_device *adev = to_acpi_device_node(fwnode);
715	return &adev->data;
716	}
717	if (is_acpi_data_node(fwnode)) {
718	const struct acpi_data_node *dn = to_acpi_data_node(fwnode);
719	return &dn->data;
720	}
721	return NULL;
722	}
723
724	/**
725	* acpi_node_prop_get - return an ACPI property with given name.
726	* @fwnode: Firmware node to get the property from.
727	* @propname: Name of the property.
728	* @valptr: Location to store a pointer to the property value (if not %NULL).
729	*/
730	int acpi_node_prop_get(const struct fwnode_handle *fwnode,
731	const char *propname, void **valptr)
732	{
733	return acpi_data_get_property(data: acpi_device_data_of_node(fwnode),
734	name: propname, ACPI_TYPE_ANY,
735	obj: (const union acpi_object **)valptr);
736	}
737
738	/**
739	* acpi_data_get_property_array - return an ACPI array property with given name
740	* @data: ACPI data object to get the property from
741	* @name: Name of the property
742	* @type: Expected type of array elements
743	* @obj: Location to store a pointer to the property value (if not NULL)
744	*
745	* Look up an array property with @name and store a pointer to the resulting
746	* ACPI object at the location pointed to by @obj if found.
747	*
748	* Callers must not attempt to free the returned objects. Those objects will be
749	* freed by the ACPI core automatically during the removal of @data.
750	*
751	* Return: %0 if array property (package) with @name has been found (success),
752	* %-EINVAL if the arguments are invalid,
753	* %-EINVAL if the property doesn't exist,
754	* %-EPROTO if the property is not a package or the type of its elements
755	* doesn't match @type.
756	*/
757	static int acpi_data_get_property_array(const struct acpi_device_data *data,
758	const char *name,
759	acpi_object_type type,
760	const union acpi_object **obj)
761	{
762	const union acpi_object *prop;
763	int ret, i;
764
765	ret = acpi_data_get_property(data, name, ACPI_TYPE_PACKAGE, obj: &prop);
766	if (ret)
767	return ret;
768
769	if (type != ACPI_TYPE_ANY) {
770	/* Check that all elements are of correct type. */
771	for (i = 0; i < prop->package.count; i++)
772	if (prop->package.elements[i].type != type)
773	return -EPROTO;
774	}
775	if (obj)
776	*obj = prop;
777
778	return 0;
779	}
780
781	static struct fwnode_handle *
782	acpi_fwnode_get_named_child_node(const struct fwnode_handle *fwnode,
783	const char *childname)
784	{
785	struct fwnode_handle *child;
786
787	fwnode_for_each_child_node(fwnode, child) {
788	if (is_acpi_data_node(fwnode: child)) {
789	if (acpi_data_node_match(fwnode: child, name: childname))
790	return child;
791	continue;
792	}
793
794	if (!strncmp(acpi_device_bid(to_acpi_device_node(child)),
795	childname, ACPI_NAMESEG_SIZE))
796	return child;
797	}
798
799	return NULL;
800	}
801
802	static int acpi_get_ref_args(struct fwnode_reference_args *args,
803	struct fwnode_handle *ref_fwnode,
804	const union acpi_object **element,
805	const union acpi_object *end, size_t num_args)
806	{
807	u32 nargs = 0, i;
808
809	/*
810	* Assume the following integer elements are all args. Stop counting on
811	* the first reference (possibly represented as a string) or end of the
812	* package arguments. In case of neither reference, nor integer, return
813	* an error, we can't parse it.
814	*/
815	for (i = 0; (*element) + i < end && i < num_args; i++) {
816	acpi_object_type type = (*element)[i].type;
817
818	if (type == ACPI_TYPE_LOCAL_REFERENCE || type == ACPI_TYPE_STRING)
819	break;
820
821	if (type == ACPI_TYPE_INTEGER)
822	nargs++;
823	else
824	return -EINVAL;
825	}
826
827	if (nargs > NR_FWNODE_REFERENCE_ARGS)
828	return -EINVAL;
829
830	if (args) {
831	args->fwnode = ref_fwnode;
832	args->nargs = nargs;
833	for (i = 0; i < nargs; i++)
834	args->args[i] = (*element)[i].integer.value;
835	}
836
837	(*element) += nargs;
838
839	return 0;
840	}
841
842	static struct fwnode_handle *acpi_parse_string_ref(const struct fwnode_handle *fwnode,
843	const char *refstring)
844	{
845	acpi_handle scope, handle;
846	struct acpi_data_node *dn;
847	struct acpi_device *device;
848	acpi_status status;
849
850	if (is_acpi_device_node(fwnode)) {
851	scope = to_acpi_device_node(fwnode)->handle;
852	} else if (is_acpi_data_node(fwnode)) {
853	scope = to_acpi_data_node(fwnode)->handle;
854	} else {
855	pr_debug("Bad node type for node %pfw\n", fwnode);
856	return NULL;
857	}
858
859	status = acpi_get_handle(parent: scope, pathname: refstring, ret_handle: &handle);
860	if (ACPI_FAILURE(status)) {
861	acpi_handle_debug(scope, "Unable to get an ACPI handle for %s\n",
862	refstring);
863	return NULL;
864	}
865
866	device = acpi_fetch_acpi_dev(handle);
867	if (device)
868	return acpi_fwnode_handle(adev: device);
869
870	status = acpi_get_data_full(object: handle, handler: acpi_nondev_subnode_tag,
871	data: (void **)&dn, NULL);
872	if (ACPI_FAILURE(status) || !dn) {
873	acpi_handle_debug(handle, "Subnode not found\n");
874	return NULL;
875	}
876
877	return &dn->fwnode;
878	}
879
880	/**
881	* __acpi_node_get_property_reference - returns handle to the referenced object
882	* @fwnode: Firmware node to get the property from
883	* @propname: Name of the property
884	* @index: Index of the reference to return
885	* @num_args: Maximum number of arguments after each reference
886	* @args: Location to store the returned reference with optional arguments
887	* (may be NULL)
888	*
889	* Find property with @name, verifify that it is a package containing at least
890	* one object reference and if so, store the ACPI device object pointer to the
891	* target object in @args->adev. If the reference includes arguments, store
892	* them in the @args->args[] array.
893	*
894	* If there's more than one reference in the property value package, @index is
895	* used to select the one to return.
896	*
897	* It is possible to leave holes in the property value set like in the
898	* example below:
899	*
900	* Package () {
901	* "cs-gpios",
902	* Package () {
903	* ^GPIO, 19, 0, 0,
904	* ^GPIO, 20, 0, 0,
905	* 0,
906	* ^GPIO, 21, 0, 0,
907	* }
908	* }
909	*
910	* Calling this function with index %2 or index %3 return %-ENOENT. If the
911	* property does not contain any more values %-ENOENT is returned. The NULL
912	* entry must be single integer and preferably contain value %0.
913	*
914	* Return: %0 on success, negative error code on failure.
915	*/
916	int __acpi_node_get_property_reference(const struct fwnode_handle *fwnode,
917	const char *propname, size_t index, size_t num_args,
918	struct fwnode_reference_args *args)
919	{
920	const union acpi_object *element, *end;
921	const union acpi_object *obj;
922	const struct acpi_device_data *data;
923	struct fwnode_handle *ref_fwnode;
924	struct acpi_device *device;
925	int ret, idx = 0;
926
927	data = acpi_device_data_of_node(fwnode);
928	if (!data)
929	return -ENOENT;
930
931	ret = acpi_data_get_property(data, name: propname, ACPI_TYPE_ANY, obj: &obj);
932	if (ret)
933	return ret == -EINVAL ? -ENOENT : -EINVAL;
934
935	switch (obj->type) {
936	case ACPI_TYPE_LOCAL_REFERENCE:
937	/* Plain single reference without arguments. */
938	if (index)
939	return -ENOENT;
940
941	device = acpi_fetch_acpi_dev(handle: obj->reference.handle);
942	if (!device)
943	return -EINVAL;
944
945	if (!args)
946	return 0;
947
948	args->fwnode = acpi_fwnode_handle(adev: device);
949	args->nargs = 0;
950
951	return 0;
952	case ACPI_TYPE_STRING:
953	if (index)
954	return -ENOENT;
955
956	ref_fwnode = acpi_parse_string_ref(fwnode, refstring: obj->string.pointer);
957	if (!ref_fwnode)
958	return -EINVAL;
959
960	args->fwnode = ref_fwnode;
961	args->nargs = 0;
962
963	return 0;
964	case ACPI_TYPE_PACKAGE:
965	/*
966	* If it is not a single reference, then it is a package of
967	* references, followed by number of ints as follows:
968	*
969	* Package () { REF, INT, REF, INT, INT }
970	*
971	* Here, REF may be either a local reference or a string. The
972	* index argument is then used to determine which reference the
973	* caller wants (along with the arguments).
974	*/
975	break;
976	default:
977	return -EINVAL;
978	}
979
980	if (index >= obj->package.count)
981	return -ENOENT;
982
983	element = obj->package.elements;
984	end = element + obj->package.count;
985
986	while (element < end) {
987	switch (element->type) {
988	case ACPI_TYPE_LOCAL_REFERENCE:
989	device = acpi_fetch_acpi_dev(handle: element->reference.handle);
990	if (!device)
991	return -EINVAL;
992
993	element++;
994
995	ret = acpi_get_ref_args(args: idx == index ? args : NULL,
996	ref_fwnode: acpi_fwnode_handle(adev: device),
997	element: &element, end, num_args);
998	if (ret < 0)
999	return ret;
1000
1001	if (idx == index)
1002	return 0;
1003
1004	break;
1005	case ACPI_TYPE_STRING:
1006	ref_fwnode = acpi_parse_string_ref(fwnode,
1007	refstring: element->string.pointer);
1008	if (!ref_fwnode)
1009	return -EINVAL;
1010
1011	element++;
1012
1013	ret = acpi_get_ref_args(args: idx == index ? args : NULL,
1014	ref_fwnode, element: &element, end,
1015	num_args);
1016	if (ret < 0)
1017	return ret;
1018
1019	if (idx == index)
1020	return 0;
1021
1022	break;
1023	case ACPI_TYPE_INTEGER:
1024	if (idx == index)
1025	return -ENOENT;
1026	element++;
1027	break;
1028	default:
1029	return -EINVAL;
1030	}
1031
1032	idx++;
1033	}
1034
1035	return -ENOENT;
1036	}
1037	EXPORT_SYMBOL_GPL(__acpi_node_get_property_reference);
1038
1039	static int acpi_data_prop_read_single(const struct acpi_device_data *data,
1040	const char *propname,
1041	enum dev_prop_type proptype, void *val)
1042	{
1043	const union acpi_object *obj;
1044	int ret = 0;
1045
1046	if (proptype >= DEV_PROP_U8 && proptype <= DEV_PROP_U64)
1047	ret = acpi_data_get_property(data, name: propname, ACPI_TYPE_INTEGER, obj: &obj);
1048	else if (proptype == DEV_PROP_STRING)
1049	ret = acpi_data_get_property(data, name: propname, ACPI_TYPE_STRING, obj: &obj);
1050	if (ret)
1051	return ret;
1052
1053	switch (proptype) {
1054	case DEV_PROP_U8:
1055	if (obj->integer.value > U8_MAX)
1056	return -EOVERFLOW;
1057	if (val)
1058	*(u8 *)val = obj->integer.value;
1059	break;
1060	case DEV_PROP_U16:
1061	if (obj->integer.value > U16_MAX)
1062	return -EOVERFLOW;
1063	if (val)
1064	*(u16 *)val = obj->integer.value;
1065	break;
1066	case DEV_PROP_U32:
1067	if (obj->integer.value > U32_MAX)
1068	return -EOVERFLOW;
1069	if (val)
1070	*(u32 *)val = obj->integer.value;
1071	break;
1072	case DEV_PROP_U64:
1073	if (val)
1074	*(u64 *)val = obj->integer.value;
1075	break;
1076	case DEV_PROP_STRING:
1077	if (val)
1078	*(char **)val = obj->string.pointer;
1079	return 1;
1080	default:
1081	return -EINVAL;
1082	}
1083
1084	/* When no storage provided return number of available values */
1085	return val ? 0 : 1;
1086	}
1087
1088	#define acpi_copy_property_array_uint(items, val, nval) \
1089	({ \
1090	typeof(items) __items = items; \
1091	typeof(val) __val = val; \
1092	typeof(nval) __nval = nval; \
1093	size_t i; \
1094	int ret = 0; \
1095	\
1096	for (i = 0; i < __nval; i++) { \
1097	if (__items->type == ACPI_TYPE_BUFFER) { \
1098	__val[i] = __items->buffer.pointer[i]; \
1099	continue; \
1100	} \
1101	if (__items[i].type != ACPI_TYPE_INTEGER) { \
1102	ret = -EPROTO; \
1103	break; \
1104	} \
1105	if (__items[i].integer.value > _Generic(__val, \
1106	u8 *: U8_MAX, \
1107	u16 *: U16_MAX, \
1108	u32 *: U32_MAX, \
1109	u64 *: U64_MAX)) { \
1110	ret = -EOVERFLOW; \
1111	break; \
1112	} \
1113	\
1114	__val[i] = __items[i].integer.value; \
1115	} \
1116	ret; \
1117	})
1118
1119	static int acpi_copy_property_array_string(const union acpi_object *items,
1120	char **val, size_t nval)
1121	{
1122	int i;
1123
1124	for (i = 0; i < nval; i++) {
1125	if (items[i].type != ACPI_TYPE_STRING)
1126	return -EPROTO;
1127
1128	val[i] = items[i].string.pointer;
1129	}
1130	return nval;
1131	}
1132
1133	static int acpi_data_prop_read(const struct acpi_device_data *data,
1134	const char *propname,
1135	enum dev_prop_type proptype,
1136	void *val, size_t nval)
1137	{
1138	const union acpi_object *obj;
1139	const union acpi_object *items;
1140	int ret;
1141
1142	if (nval == 1 || !val) {
1143	ret = acpi_data_prop_read_single(data, propname, proptype, val);
1144	/*
1145	* The overflow error means that the property is there and it is
1146	* single-value, but its type does not match, so return.
1147	*/
1148	if (ret >= 0 || ret == -EOVERFLOW)
1149	return ret;
1150
1151	/*
1152	* Reading this property as a single-value one failed, but its
1153	* value may still be represented as one-element array, so
1154	* continue.
1155	*/
1156	}
1157
1158	ret = acpi_data_get_property_array(data, name: propname, ACPI_TYPE_ANY, obj: &obj);
1159	if (ret && proptype >= DEV_PROP_U8 && proptype <= DEV_PROP_U64)
1160	ret = acpi_data_get_property(data, name: propname, ACPI_TYPE_BUFFER,
1161	obj: &obj);
1162	if (ret)
1163	return ret;
1164
1165	if (!val) {
1166	if (obj->type == ACPI_TYPE_BUFFER)
1167	return obj->buffer.length;
1168
1169	return obj->package.count;
1170	}
1171
1172	switch (proptype) {
1173	case DEV_PROP_STRING:
1174	break;
1175	default:
1176	if (obj->type == ACPI_TYPE_BUFFER) {
1177	if (nval > obj->buffer.length)
1178	return -EOVERFLOW;
1179	} else {
1180	if (nval > obj->package.count)
1181	return -EOVERFLOW;
1182	}
1183	break;
1184	}
1185	if (nval == 0)
1186	return -EINVAL;
1187
1188	if (obj->type == ACPI_TYPE_BUFFER) {
1189	if (proptype != DEV_PROP_U8)
1190	return -EPROTO;
1191	items = obj;
1192	} else {
1193	items = obj->package.elements;
1194	}
1195
1196	switch (proptype) {
1197	case DEV_PROP_U8:
1198	ret = acpi_copy_property_array_uint(items, (u8 *)val, nval);
1199	break;
1200	case DEV_PROP_U16:
1201	ret = acpi_copy_property_array_uint(items, (u16 *)val, nval);
1202	break;
1203	case DEV_PROP_U32:
1204	ret = acpi_copy_property_array_uint(items, (u32 *)val, nval);
1205	break;
1206	case DEV_PROP_U64:
1207	ret = acpi_copy_property_array_uint(items, (u64 *)val, nval);
1208	break;
1209	case DEV_PROP_STRING:
1210	ret = acpi_copy_property_array_string(
1211	items, val: (char **)val,
1212	min_t(u32, nval, obj->package.count));
1213	break;
1214	default:
1215	ret = -EINVAL;
1216	break;
1217	}
1218	return ret;
1219	}
1220
1221	/**
1222	* acpi_node_prop_read - retrieve the value of an ACPI property with given name.
1223	* @fwnode: Firmware node to get the property from.
1224	* @propname: Name of the property.
1225	* @proptype: Expected property type.
1226	* @val: Location to store the property value (if not %NULL).
1227	* @nval: Size of the array pointed to by @val.
1228	*
1229	* If @val is %NULL, return the number of array elements comprising the value
1230	* of the property. Otherwise, read at most @nval values to the array at the
1231	* location pointed to by @val.
1232	*/
1233	static int acpi_node_prop_read(const struct fwnode_handle *fwnode,
1234	const char *propname, enum dev_prop_type proptype,
1235	void *val, size_t nval)
1236	{
1237	return acpi_data_prop_read(data: acpi_device_data_of_node(fwnode),
1238	propname, proptype, val, nval);
1239	}
1240
1241	static int stop_on_next(struct acpi_device *adev, void *data)
1242	{
1243	struct acpi_device **ret_p = data;
1244
1245	if (!*ret_p) {
1246	*ret_p = adev;
1247	return 1;
1248	}
1249
1250	/* Skip until the "previous" object is found. */
1251	if (*ret_p == adev)
1252	*ret_p = NULL;
1253
1254	return 0;
1255	}
1256
1257	/**
1258	* acpi_get_next_subnode - Return the next child node handle for a fwnode
1259	* @fwnode: Firmware node to find the next child node for.
1260	* @child: Handle to one of the device's child nodes or a null handle.
1261	*/
1262	struct fwnode_handle *acpi_get_next_subnode(const struct fwnode_handle *fwnode,
1263	struct fwnode_handle *child)
1264	{
1265	struct acpi_device *adev = to_acpi_device_node(fwnode);
1266
1267	if ((!child || is_acpi_device_node(fwnode: child)) && adev) {
1268	struct acpi_device *child_adev = to_acpi_device_node(child);
1269
1270	acpi_dev_for_each_child(adev, fn: stop_on_next, data: &child_adev);
1271	if (child_adev)
1272	return acpi_fwnode_handle(adev: child_adev);
1273
1274	child = NULL;
1275	}
1276
1277	if (!child || is_acpi_data_node(fwnode: child)) {
1278	const struct acpi_data_node *data = to_acpi_data_node(fwnode);
1279	const struct list_head *head;
1280	struct list_head *next;
1281	struct acpi_data_node *dn;
1282
1283	/*
1284	* We can have a combination of device and data nodes, e.g. with
1285	* hierarchical _DSD properties. Make sure the adev pointer is
1286	* restored before going through data nodes, otherwise we will
1287	* be looking for data_nodes below the last device found instead
1288	* of the common fwnode shared by device_nodes and data_nodes.
1289	*/
1290	adev = to_acpi_device_node(fwnode);
1291	if (adev)
1292	head = &adev->data.subnodes;
1293	else if (data)
1294	head = &data->data.subnodes;
1295	else
1296	return NULL;
1297
1298	if (list_empty(head))
1299	return NULL;
1300
1301	if (child) {
1302	dn = to_acpi_data_node(child);
1303	next = dn->sibling.next;
1304	if (next == head)
1305	return NULL;
1306
1307	dn = list_entry(next, struct acpi_data_node, sibling);
1308	} else {
1309	dn = list_first_entry(head, struct acpi_data_node, sibling);
1310	}
1311	return &dn->fwnode;
1312	}
1313	return NULL;
1314	}
1315
1316	/**
1317	* acpi_node_get_parent - Return parent fwnode of this fwnode
1318	* @fwnode: Firmware node whose parent to get
1319	*
1320	* Returns parent node of an ACPI device or data firmware node or %NULL if
1321	* not available.
1322	*/
1323	static struct fwnode_handle *
1324	acpi_node_get_parent(const struct fwnode_handle *fwnode)
1325	{
1326	if (is_acpi_data_node(fwnode)) {
1327	/* All data nodes have parent pointer so just return that */
1328	return to_acpi_data_node(fwnode)->parent;
1329	}
1330	if (is_acpi_device_node(fwnode)) {
1331	struct acpi_device *parent;
1332
1333	parent = acpi_dev_parent(to_acpi_device_node(fwnode));
1334	if (parent)
1335	return acpi_fwnode_handle(adev: parent);
1336	}
1337
1338	return NULL;
1339	}
1340
1341	/*
1342	* Return true if the node is an ACPI graph node. Called on either ports
1343	* or endpoints.
1344	*/
1345	static bool is_acpi_graph_node(struct fwnode_handle *fwnode,
1346	const char *str)
1347	{
1348	unsigned int len = strlen(str);
1349	const char *name;
1350
1351	if (!len || !is_acpi_data_node(fwnode))
1352	return false;
1353
1354	name = to_acpi_data_node(fwnode)->name;
1355
1356	return (fwnode_property_present(fwnode, propname: "reg") &&
1357	!strncmp(name, str, len) && name[len] == '@') ||
1358	fwnode_property_present(fwnode, propname: str);
1359	}
1360
1361	/**
1362	* acpi_graph_get_next_endpoint - Get next endpoint ACPI firmware node
1363	* @fwnode: Pointer to the parent firmware node
1364	* @prev: Previous endpoint node or %NULL to get the first
1365	*
1366	* Looks up next endpoint ACPI firmware node below a given @fwnode. Returns
1367	* %NULL if there is no next endpoint or in case of error. In case of success
1368	* the next endpoint is returned.
1369	*/
1370	static struct fwnode_handle *acpi_graph_get_next_endpoint(
1371	const struct fwnode_handle *fwnode, struct fwnode_handle *prev)
1372	{
1373	struct fwnode_handle *port = NULL;
1374	struct fwnode_handle *endpoint;
1375
1376	if (!prev) {
1377	do {
1378	port = fwnode_get_next_child_node(fwnode, child: port);
1379	/*
1380	* The names of the port nodes begin with "port@"
1381	* followed by the number of the port node and they also
1382	* have a "reg" property that also has the number of the
1383	* port node. For compatibility reasons a node is also
1384	* recognised as a port node from the "port" property.
1385	*/
1386	if (is_acpi_graph_node(fwnode: port, str: "port"))
1387	break;
1388	} while (port);
1389	} else {
1390	port = fwnode_get_parent(fwnode: prev);
1391	}
1392
1393	if (!port)
1394	return NULL;
1395
1396	endpoint = fwnode_get_next_child_node(fwnode: port, child: prev);
1397	while (!endpoint) {
1398	port = fwnode_get_next_child_node(fwnode, child: port);
1399	if (!port)
1400	break;
1401	if (is_acpi_graph_node(fwnode: port, str: "port"))
1402	endpoint = fwnode_get_next_child_node(fwnode: port, NULL);
1403	}
1404
1405	/*
1406	* The names of the endpoint nodes begin with "endpoint@" followed by
1407	* the number of the endpoint node and they also have a "reg" property
1408	* that also has the number of the endpoint node. For compatibility
1409	* reasons a node is also recognised as an endpoint node from the
1410	* "endpoint" property.
1411	*/
1412	if (!is_acpi_graph_node(fwnode: endpoint, str: "endpoint"))
1413	return NULL;
1414
1415	return endpoint;
1416	}
1417
1418	/**
1419	* acpi_graph_get_child_prop_value - Return a child with a given property value
1420	* @fwnode: device fwnode
1421	* @prop_name: The name of the property to look for
1422	* @val: the desired property value
1423	*
1424	* Return the port node corresponding to a given port number. Returns
1425	* the child node on success, NULL otherwise.
1426	*/
1427	static struct fwnode_handle *acpi_graph_get_child_prop_value(
1428	const struct fwnode_handle *fwnode, const char *prop_name,
1429	unsigned int val)
1430	{
1431	struct fwnode_handle *child;
1432
1433	fwnode_for_each_child_node(fwnode, child) {
1434	u32 nr;
1435
1436	if (fwnode_property_read_u32(fwnode: child, propname: prop_name, val: &nr))
1437	continue;
1438
1439	if (val == nr)
1440	return child;
1441	}
1442
1443	return NULL;
1444	}
1445
1446
1447	/**
1448	* acpi_graph_get_remote_endpoint - Parses and returns remote end of an endpoint
1449	* @__fwnode: Endpoint firmware node pointing to a remote device
1450	*
1451	* Returns the remote endpoint corresponding to @__fwnode. NULL on error.
1452	*/
1453	static struct fwnode_handle *
1454	acpi_graph_get_remote_endpoint(const struct fwnode_handle *__fwnode)
1455	{
1456	struct fwnode_handle *fwnode;
1457	unsigned int port_nr, endpoint_nr;
1458	struct fwnode_reference_args args;
1459	int ret;
1460
1461	memset(&args, 0, sizeof(args));
1462	ret = acpi_node_get_property_reference(fwnode: __fwnode, name: "remote-endpoint", index: 0,
1463	args: &args);
1464	if (ret)
1465	return NULL;
1466
1467	/* Direct endpoint reference? */
1468	if (!is_acpi_device_node(fwnode: args.fwnode))
1469	return args.nargs ? NULL : args.fwnode;
1470
1471	/*
1472	* Always require two arguments with the reference: port and
1473	* endpoint indices.
1474	*/
1475	if (args.nargs != 2)
1476	return NULL;
1477
1478	fwnode = args.fwnode;
1479	port_nr = args.args[0];
1480	endpoint_nr = args.args[1];
1481
1482	fwnode = acpi_graph_get_child_prop_value(fwnode, prop_name: "port", val: port_nr);
1483
1484	return acpi_graph_get_child_prop_value(fwnode, prop_name: "endpoint", val: endpoint_nr);
1485	}
1486
1487	static bool acpi_fwnode_device_is_available(const struct fwnode_handle *fwnode)
1488	{
1489	if (!is_acpi_device_node(fwnode))
1490	return false;
1491
1492	return acpi_device_is_present(to_acpi_device_node(fwnode));
1493	}
1494
1495	static const void *
1496	acpi_fwnode_device_get_match_data(const struct fwnode_handle *fwnode,
1497	const struct device *dev)
1498	{
1499	return acpi_device_get_match_data(dev);
1500	}
1501
1502	static bool acpi_fwnode_device_dma_supported(const struct fwnode_handle *fwnode)
1503	{
1504	return acpi_dma_supported(to_acpi_device_node(fwnode));
1505	}
1506
1507	static enum dev_dma_attr
1508	acpi_fwnode_device_get_dma_attr(const struct fwnode_handle *fwnode)
1509	{
1510	return acpi_get_dma_attr(to_acpi_device_node(fwnode));
1511	}
1512
1513	static bool acpi_fwnode_property_present(const struct fwnode_handle *fwnode,
1514	const char *propname)
1515	{
1516	return !acpi_node_prop_get(fwnode, propname, NULL);
1517	}
1518
1519	static int
1520	acpi_fwnode_property_read_int_array(const struct fwnode_handle *fwnode,
1521	const char *propname,
1522	unsigned int elem_size, void *val,
1523	size_t nval)
1524	{
1525	enum dev_prop_type type;
1526
1527	switch (elem_size) {
1528	case sizeof(u8):
1529	type = DEV_PROP_U8;
1530	break;
1531	case sizeof(u16):
1532	type = DEV_PROP_U16;
1533	break;
1534	case sizeof(u32):
1535	type = DEV_PROP_U32;
1536	break;
1537	case sizeof(u64):
1538	type = DEV_PROP_U64;
1539	break;
1540	default:
1541	return -ENXIO;
1542	}
1543
1544	return acpi_node_prop_read(fwnode, propname, proptype: type, val, nval);
1545	}
1546
1547	static int
1548	acpi_fwnode_property_read_string_array(const struct fwnode_handle *fwnode,
1549	const char *propname, const char **val,
1550	size_t nval)
1551	{
1552	return acpi_node_prop_read(fwnode, propname, proptype: DEV_PROP_STRING,
1553	val, nval);
1554	}
1555
1556	static int
1557	acpi_fwnode_get_reference_args(const struct fwnode_handle *fwnode,
1558	const char *prop, const char *nargs_prop,
1559	unsigned int args_count, unsigned int index,
1560	struct fwnode_reference_args *args)
1561	{
1562	return __acpi_node_get_property_reference(fwnode, prop, index,
1563	args_count, args);
1564	}
1565
1566	static const char *acpi_fwnode_get_name(const struct fwnode_handle *fwnode)
1567	{
1568	const struct acpi_device *adev;
1569	struct fwnode_handle *parent;
1570
1571	/* Is this the root node? */
1572	parent = fwnode_get_parent(fwnode);
1573	if (!parent)
1574	return "\\";
1575
1576	fwnode_handle_put(fwnode: parent);
1577
1578	if (is_acpi_data_node(fwnode)) {
1579	const struct acpi_data_node *dn = to_acpi_data_node(fwnode);
1580
1581	return dn->name;
1582	}
1583
1584	adev = to_acpi_device_node(fwnode);
1585	if (WARN_ON(!adev))
1586	return NULL;
1587
1588	return acpi_device_bid(adev);
1589	}
1590
1591	static const char *
1592	acpi_fwnode_get_name_prefix(const struct fwnode_handle *fwnode)
1593	{
1594	struct fwnode_handle *parent;
1595
1596	/* Is this the root node? */
1597	parent = fwnode_get_parent(fwnode);
1598	if (!parent)
1599	return "";
1600
1601	/* Is this 2nd node from the root? */
1602	parent = fwnode_get_next_parent(fwnode: parent);
1603	if (!parent)
1604	return "";
1605
1606	fwnode_handle_put(fwnode: parent);
1607
1608	/* ACPI device or data node. */
1609	return ".";
1610	}
1611
1612	static struct fwnode_handle *
1613	acpi_fwnode_get_parent(struct fwnode_handle *fwnode)
1614	{
1615	return acpi_node_get_parent(fwnode);
1616	}
1617
1618	static int acpi_fwnode_graph_parse_endpoint(const struct fwnode_handle *fwnode,
1619	struct fwnode_endpoint *endpoint)
1620	{
1621	struct fwnode_handle *port_fwnode = fwnode_get_parent(fwnode);
1622
1623	endpoint->local_fwnode = fwnode;
1624
1625	if (fwnode_property_read_u32(fwnode: port_fwnode, propname: "reg", val: &endpoint->port))
1626	fwnode_property_read_u32(fwnode: port_fwnode, propname: "port", val: &endpoint->port);
1627	if (fwnode_property_read_u32(fwnode, propname: "reg", val: &endpoint->id))
1628	fwnode_property_read_u32(fwnode, propname: "endpoint", val: &endpoint->id);
1629
1630	return 0;
1631	}
1632
1633	static int acpi_fwnode_irq_get(const struct fwnode_handle *fwnode,
1634	unsigned int index)
1635	{
1636	struct resource res;
1637	int ret;
1638
1639	ret = acpi_irq_get(ACPI_HANDLE_FWNODE(fwnode), index, res: &res);
1640	if (ret)
1641	return ret;
1642
1643	return res.start;
1644	}
1645
1646	#define DECLARE_ACPI_FWNODE_OPS(ops) \
1647	const struct fwnode_operations ops = { \
1648	.device_is_available = acpi_fwnode_device_is_available, \
1649	.device_get_match_data = acpi_fwnode_device_get_match_data, \
1650	.device_dma_supported = \
1651	acpi_fwnode_device_dma_supported, \
1652	.device_get_dma_attr = acpi_fwnode_device_get_dma_attr, \
1653	.property_present = acpi_fwnode_property_present, \
1654	.property_read_int_array = \
1655	acpi_fwnode_property_read_int_array, \
1656	.property_read_string_array = \
1657	acpi_fwnode_property_read_string_array, \
1658	.get_parent = acpi_node_get_parent, \
1659	.get_next_child_node = acpi_get_next_subnode, \
1660	.get_named_child_node = acpi_fwnode_get_named_child_node, \
1661	.get_name = acpi_fwnode_get_name, \
1662	.get_name_prefix = acpi_fwnode_get_name_prefix, \
1663	.get_reference_args = acpi_fwnode_get_reference_args, \
1664	.graph_get_next_endpoint = \
1665	acpi_graph_get_next_endpoint, \
1666	.graph_get_remote_endpoint = \
1667	acpi_graph_get_remote_endpoint, \
1668	.graph_get_port_parent = acpi_fwnode_get_parent, \
1669	.graph_parse_endpoint = acpi_fwnode_graph_parse_endpoint, \
1670	.irq_get = acpi_fwnode_irq_get, \
1671	}; \
1672	EXPORT_SYMBOL_GPL(ops)
1673
1674	DECLARE_ACPI_FWNODE_OPS(acpi_device_fwnode_ops);
1675	DECLARE_ACPI_FWNODE_OPS(acpi_data_fwnode_ops);
1676	const struct fwnode_operations acpi_static_fwnode_ops;
1677
1678	bool is_acpi_device_node(const struct fwnode_handle *fwnode)
1679	{
1680	return !IS_ERR_OR_NULL(ptr: fwnode) &&
1681	fwnode->ops == &acpi_device_fwnode_ops;
1682	}
1683	EXPORT_SYMBOL(is_acpi_device_node);
1684
1685	bool is_acpi_data_node(const struct fwnode_handle *fwnode)
1686	{
1687	return !IS_ERR_OR_NULL(ptr: fwnode) && fwnode->ops == &acpi_data_fwnode_ops;
1688	}
1689	EXPORT_SYMBOL(is_acpi_data_node);
1690