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