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