]> git.proxmox.com Git - mirror_ubuntu-jammy-kernel.git/blame - drivers/acpi/property.c
driver core: Add helper device_find_child_by_name()
[mirror_ubuntu-jammy-kernel.git] / drivers / acpi / property.c
CommitLineData
ffdcd955
MW
1/*
2 * ACPI device specific properties support.
3 *
4 * Copyright (C) 2014, Intel Corporation
5 * All rights reserved.
6 *
7 * Authors: Mika Westerberg <mika.westerberg@linux.intel.com>
8 * Darren Hart <dvhart@linux.intel.com>
9 * Rafael J. Wysocki <rafael.j.wysocki@intel.com>
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License version 2 as
13 * published by the Free Software Foundation.
14 */
15
16#include <linux/acpi.h>
17#include <linux/device.h>
18#include <linux/export.h>
19
20#include "internal.h"
21
99a85464 22static int acpi_data_get_property_array(const struct acpi_device_data *data,
3a7a2ab8
RW
23 const char *name,
24 acpi_object_type type,
25 const union acpi_object **obj);
26
617654aa
MW
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 */
5f5e4890
MW
35static const guid_t prp_guids[] = {
36 /* ACPI _DSD device properties GUID: daffd814-6eba-4d8c-8a91-bc9bbf4aa301 */
3689d3d6 37 GUID_INIT(0xdaffd814, 0x6eba, 0x4d8c,
5f5e4890 38 0x8a, 0x91, 0xbc, 0x9b, 0xbf, 0x4a, 0xa3, 0x01),
26ad34d5
MW
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),
617654aa
MW
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),
5f5e4890
MW
45};
46
5f21f305 47/* ACPI _DSD data subnodes GUID: dbb8e3e6-5886-4ba6-8795-1319f52a966b */
3689d3d6
AS
48static const guid_t ads_guid =
49 GUID_INIT(0xdbb8e3e6, 0x5886, 0x4ba6,
50 0x87, 0x95, 0x13, 0x19, 0xf5, 0x2a, 0x96, 0x6b);
445b0eb0
RW
51
52static bool acpi_enumerate_nondev_subnodes(acpi_handle scope,
53 const union acpi_object *desc,
dfa672fb
MW
54 struct acpi_device_data *data,
55 struct fwnode_handle *parent);
445b0eb0
RW
56static bool acpi_extract_properties(const union acpi_object *desc,
57 struct acpi_device_data *data);
58
99db5ff7
RW
59static bool acpi_nondev_subnode_extract(const union acpi_object *desc,
60 acpi_handle handle,
61 const union acpi_object *link,
dfa672fb
MW
62 struct list_head *list,
63 struct fwnode_handle *parent)
445b0eb0 64{
445b0eb0 65 struct acpi_data_node *dn;
99db5ff7 66 bool result;
445b0eb0
RW
67
68 dn = kzalloc(sizeof(*dn), GFP_KERNEL);
69 if (!dn)
70 return false;
71
72 dn->name = link->package.elements[0].string.pointer;
db3e50f3 73 dn->fwnode.ops = &acpi_data_fwnode_ops;
dfa672fb 74 dn->parent = parent;
5f5e4890 75 INIT_LIST_HEAD(&dn->data.properties);
445b0eb0
RW
76 INIT_LIST_HEAD(&dn->data.subnodes);
77
99db5ff7 78 result = acpi_extract_properties(desc, &dn->data);
445b0eb0 79
99db5ff7
RW
80 if (handle) {
81 acpi_handle scope;
82 acpi_status status;
445b0eb0 83
99db5ff7
RW
84 /*
85 * The scope for the subnode object lookup is the one of the
86 * namespace node (device) containing the object that has
87 * returned the package. That is, it's the scope of that
88 * object's parent.
89 */
90 status = acpi_get_parent(handle, &scope);
91 if (ACPI_SUCCESS(status)
dfa672fb
MW
92 && acpi_enumerate_nondev_subnodes(scope, desc, &dn->data,
93 &dn->fwnode))
99db5ff7 94 result = true;
dfa672fb
MW
95 } else if (acpi_enumerate_nondev_subnodes(NULL, desc, &dn->data,
96 &dn->fwnode)) {
99db5ff7
RW
97 result = true;
98 }
445b0eb0 99
99db5ff7 100 if (result) {
263b4c1a 101 dn->handle = handle;
99db5ff7 102 dn->data.pointer = desc;
445b0eb0
RW
103 list_add_tail(&dn->sibling, list);
104 return true;
105 }
106
99db5ff7 107 kfree(dn);
445b0eb0 108 acpi_handle_debug(handle, "Invalid properties/subnodes data, skipping\n");
99db5ff7
RW
109 return false;
110}
111
112static bool acpi_nondev_subnode_data_ok(acpi_handle handle,
113 const union acpi_object *link,
dfa672fb
MW
114 struct list_head *list,
115 struct fwnode_handle *parent)
99db5ff7
RW
116{
117 struct acpi_buffer buf = { ACPI_ALLOCATE_BUFFER };
118 acpi_status status;
119
120 status = acpi_evaluate_object_typed(handle, NULL, NULL, &buf,
121 ACPI_TYPE_PACKAGE);
122 if (ACPI_FAILURE(status))
123 return false;
124
dfa672fb
MW
125 if (acpi_nondev_subnode_extract(buf.pointer, handle, link, list,
126 parent))
99db5ff7 127 return true;
445b0eb0 128
445b0eb0 129 ACPI_FREE(buf.pointer);
445b0eb0
RW
130 return false;
131}
132
99db5ff7
RW
133static bool acpi_nondev_subnode_ok(acpi_handle scope,
134 const union acpi_object *link,
dfa672fb
MW
135 struct list_head *list,
136 struct fwnode_handle *parent)
99db5ff7
RW
137{
138 acpi_handle handle;
139 acpi_status status;
140
141 if (!scope)
142 return false;
143
144 status = acpi_get_handle(scope, link->package.elements[1].string.pointer,
145 &handle);
146 if (ACPI_FAILURE(status))
147 return false;
148
dfa672fb 149 return acpi_nondev_subnode_data_ok(handle, link, list, parent);
99db5ff7
RW
150}
151
445b0eb0
RW
152static int acpi_add_nondev_subnodes(acpi_handle scope,
153 const union acpi_object *links,
dfa672fb
MW
154 struct list_head *list,
155 struct fwnode_handle *parent)
445b0eb0
RW
156{
157 bool ret = false;
158 int i;
159
160 for (i = 0; i < links->package.count; i++) {
99db5ff7
RW
161 const union acpi_object *link, *desc;
162 acpi_handle handle;
163 bool result;
445b0eb0
RW
164
165 link = &links->package.elements[i];
99db5ff7
RW
166 /* Only two elements allowed. */
167 if (link->package.count != 2)
168 continue;
169
170 /* The first one must be a string. */
171 if (link->package.elements[0].type != ACPI_TYPE_STRING)
172 continue;
173
174 /* The second one may be a string, a reference or a package. */
175 switch (link->package.elements[1].type) {
176 case ACPI_TYPE_STRING:
dfa672fb
MW
177 result = acpi_nondev_subnode_ok(scope, link, list,
178 parent);
99db5ff7
RW
179 break;
180 case ACPI_TYPE_LOCAL_REFERENCE:
181 handle = link->package.elements[1].reference.handle;
dfa672fb
MW
182 result = acpi_nondev_subnode_data_ok(handle, link, list,
183 parent);
99db5ff7
RW
184 break;
185 case ACPI_TYPE_PACKAGE:
186 desc = &link->package.elements[1];
dfa672fb
MW
187 result = acpi_nondev_subnode_extract(desc, NULL, link,
188 list, parent);
99db5ff7
RW
189 break;
190 default:
191 result = false;
192 break;
193 }
194 ret = ret || result;
445b0eb0
RW
195 }
196
197 return ret;
198}
199
200static bool acpi_enumerate_nondev_subnodes(acpi_handle scope,
201 const union acpi_object *desc,
dfa672fb
MW
202 struct acpi_device_data *data,
203 struct fwnode_handle *parent)
445b0eb0
RW
204{
205 int i;
206
3689d3d6 207 /* Look for the ACPI data subnodes GUID. */
445b0eb0 208 for (i = 0; i < desc->package.count; i += 2) {
3689d3d6 209 const union acpi_object *guid, *links;
445b0eb0 210
3689d3d6 211 guid = &desc->package.elements[i];
445b0eb0
RW
212 links = &desc->package.elements[i + 1];
213
214 /*
3689d3d6 215 * The first element must be a GUID and the second one must be
445b0eb0
RW
216 * a package.
217 */
3689d3d6
AS
218 if (guid->type != ACPI_TYPE_BUFFER ||
219 guid->buffer.length != 16 ||
220 links->type != ACPI_TYPE_PACKAGE)
445b0eb0
RW
221 break;
222
3689d3d6 223 if (!guid_equal((guid_t *)guid->buffer.pointer, &ads_guid))
445b0eb0
RW
224 continue;
225
dfa672fb
MW
226 return acpi_add_nondev_subnodes(scope, links, &data->subnodes,
227 parent);
445b0eb0
RW
228 }
229
230 return false;
231}
ffdcd955
MW
232
233static bool acpi_property_value_ok(const union acpi_object *value)
234{
235 int j;
236
237 /*
238 * The value must be an integer, a string, a reference, or a package
239 * whose every element must be an integer, a string, or a reference.
240 */
241 switch (value->type) {
242 case ACPI_TYPE_INTEGER:
243 case ACPI_TYPE_STRING:
244 case ACPI_TYPE_LOCAL_REFERENCE:
245 return true;
246
247 case ACPI_TYPE_PACKAGE:
248 for (j = 0; j < value->package.count; j++)
249 switch (value->package.elements[j].type) {
250 case ACPI_TYPE_INTEGER:
251 case ACPI_TYPE_STRING:
252 case ACPI_TYPE_LOCAL_REFERENCE:
253 continue;
254
255 default:
256 return false;
257 }
258
259 return true;
260 }
261 return false;
262}
263
264static bool acpi_properties_format_valid(const union acpi_object *properties)
265{
266 int i;
267
268 for (i = 0; i < properties->package.count; i++) {
269 const union acpi_object *property;
270
271 property = &properties->package.elements[i];
272 /*
273 * Only two elements allowed, the first one must be a string and
274 * the second one has to satisfy certain conditions.
275 */
276 if (property->package.count != 2
277 || property->package.elements[0].type != ACPI_TYPE_STRING
278 || !acpi_property_value_ok(&property->package.elements[1]))
279 return false;
280 }
281 return true;
282}
283
733e6251
MW
284static void acpi_init_of_compatible(struct acpi_device *adev)
285{
286 const union acpi_object *of_compatible;
733e6251
MW
287 int ret;
288
3a7a2ab8
RW
289 ret = acpi_data_get_property_array(&adev->data, "compatible",
290 ACPI_TYPE_STRING, &of_compatible);
733e6251
MW
291 if (ret) {
292 ret = acpi_dev_get_property(adev, "compatible",
293 ACPI_TYPE_STRING, &of_compatible);
294 if (ret) {
5c53b262
RW
295 if (adev->parent
296 && adev->parent->flags.of_compatible_ok)
297 goto out;
298
733e6251
MW
299 return;
300 }
301 }
302 adev->data.of_compatible = of_compatible;
5c53b262
RW
303
304 out:
305 adev->flags.of_compatible_ok = 1;
733e6251
MW
306}
307
5f5e4890
MW
308static bool acpi_is_property_guid(const guid_t *guid)
309{
310 int i;
311
312 for (i = 0; i < ARRAY_SIZE(prp_guids); i++) {
313 if (guid_equal(guid, &prp_guids[i]))
314 return true;
315 }
316
317 return false;
318}
319
320struct acpi_device_properties *
321acpi_data_add_props(struct acpi_device_data *data, const guid_t *guid,
322 const union acpi_object *properties)
323{
324 struct acpi_device_properties *props;
325
326 props = kzalloc(sizeof(*props), GFP_KERNEL);
327 if (props) {
328 INIT_LIST_HEAD(&props->list);
329 props->guid = guid;
330 props->properties = properties;
331 list_add_tail(&props->list, &data->properties);
332 }
333
334 return props;
335}
336
bd8191cc
RW
337static bool acpi_extract_properties(const union acpi_object *desc,
338 struct acpi_device_data *data)
ffdcd955 339{
ffdcd955
MW
340 int i;
341
ffdcd955 342 if (desc->package.count % 2)
bd8191cc 343 return false;
ffdcd955 344
3689d3d6 345 /* Look for the device properties GUID. */
ffdcd955 346 for (i = 0; i < desc->package.count; i += 2) {
3689d3d6 347 const union acpi_object *guid, *properties;
ffdcd955 348
3689d3d6 349 guid = &desc->package.elements[i];
ffdcd955
MW
350 properties = &desc->package.elements[i + 1];
351
352 /*
3689d3d6 353 * The first element must be a GUID and the second one must be
ffdcd955
MW
354 * a package.
355 */
3689d3d6
AS
356 if (guid->type != ACPI_TYPE_BUFFER ||
357 guid->buffer.length != 16 ||
358 properties->type != ACPI_TYPE_PACKAGE)
ffdcd955
MW
359 break;
360
5f5e4890 361 if (!acpi_is_property_guid((guid_t *)guid->buffer.pointer))
ffdcd955
MW
362 continue;
363
364 /*
3689d3d6 365 * We found the matching GUID. Now validate the format of the
ffdcd955
MW
366 * package immediately following it.
367 */
368 if (!acpi_properties_format_valid(properties))
5f5e4890 369 continue;
ffdcd955 370
5f5e4890
MW
371 acpi_data_add_props(data, (const guid_t *)guid->buffer.pointer,
372 properties);
bd8191cc 373 }
733e6251 374
5f5e4890 375 return !list_empty(&data->properties);
bd8191cc 376}
5c53b262 377
bd8191cc
RW
378void acpi_init_properties(struct acpi_device *adev)
379{
380 struct acpi_buffer buf = { ACPI_ALLOCATE_BUFFER };
381 struct acpi_hardware_id *hwid;
382 acpi_status status;
383 bool acpi_of = false;
384
5f5e4890 385 INIT_LIST_HEAD(&adev->data.properties);
445b0eb0
RW
386 INIT_LIST_HEAD(&adev->data.subnodes);
387
75fc70e0
LW
388 if (!adev->handle)
389 return;
390
bd8191cc
RW
391 /*
392 * Check if ACPI_DT_NAMESPACE_HID is present and inthat case we fill in
393 * Device Tree compatible properties for this device.
394 */
395 list_for_each_entry(hwid, &adev->pnp.ids, list) {
396 if (!strcmp(hwid->id, ACPI_DT_NAMESPACE_HID)) {
397 acpi_of = true;
398 break;
399 }
ffdcd955
MW
400 }
401
bd8191cc
RW
402 status = acpi_evaluate_object_typed(adev->handle, "_DSD", NULL, &buf,
403 ACPI_TYPE_PACKAGE);
404 if (ACPI_FAILURE(status))
405 goto out;
406
407 if (acpi_extract_properties(buf.pointer, &adev->data)) {
408 adev->data.pointer = buf.pointer;
409 if (acpi_of)
410 acpi_init_of_compatible(adev);
445b0eb0 411 }
dfa672fb
MW
412 if (acpi_enumerate_nondev_subnodes(adev->handle, buf.pointer,
413 &adev->data, acpi_fwnode_handle(adev)))
445b0eb0
RW
414 adev->data.pointer = buf.pointer;
415
416 if (!adev->data.pointer) {
bd8191cc
RW
417 acpi_handle_debug(adev->handle, "Invalid _DSD data, skipping\n");
418 ACPI_FREE(buf.pointer);
419 }
5c53b262
RW
420
421 out:
422 if (acpi_of && !adev->flags.of_compatible_ok)
423 acpi_handle_info(adev->handle,
ee892094 424 ACPI_DT_NAMESPACE_HID " requires 'compatible' property\n");
899596e0
LW
425
426 if (!adev->data.pointer)
427 acpi_extract_apple_properties(adev);
ffdcd955
MW
428}
429
445b0eb0
RW
430static void acpi_destroy_nondev_subnodes(struct list_head *list)
431{
432 struct acpi_data_node *dn, *next;
433
434 if (list_empty(list))
435 return;
436
437 list_for_each_entry_safe_reverse(dn, next, list, sibling) {
438 acpi_destroy_nondev_subnodes(&dn->data.subnodes);
263b4c1a 439 wait_for_completion(&dn->kobj_done);
445b0eb0
RW
440 list_del(&dn->sibling);
441 ACPI_FREE((void *)dn->data.pointer);
442 kfree(dn);
443 }
444}
445
ffdcd955
MW
446void acpi_free_properties(struct acpi_device *adev)
447{
5f5e4890
MW
448 struct acpi_device_properties *props, *tmp;
449
445b0eb0 450 acpi_destroy_nondev_subnodes(&adev->data.subnodes);
ffdcd955 451 ACPI_FREE((void *)adev->data.pointer);
733e6251 452 adev->data.of_compatible = NULL;
ffdcd955 453 adev->data.pointer = NULL;
5f5e4890
MW
454 list_for_each_entry_safe(props, tmp, &adev->data.properties, list) {
455 list_del(&props->list);
456 kfree(props);
457 }
ffdcd955
MW
458}
459
460/**
3a7a2ab8
RW
461 * acpi_data_get_property - return an ACPI property with given name
462 * @data: ACPI device deta object to get the property from
ffdcd955
MW
463 * @name: Name of the property
464 * @type: Expected property type
465 * @obj: Location to store the property value (if not %NULL)
466 *
467 * Look up a property with @name and store a pointer to the resulting ACPI
468 * object at the location pointed to by @obj if found.
469 *
470 * Callers must not attempt to free the returned objects. These objects will be
3a7a2ab8 471 * freed by the ACPI core automatically during the removal of @data.
ffdcd955
MW
472 *
473 * Return: %0 if property with @name has been found (success),
474 * %-EINVAL if the arguments are invalid,
3c60f114 475 * %-EINVAL if the property doesn't exist,
ffdcd955
MW
476 * %-EPROTO if the property value type doesn't match @type.
477 */
99a85464 478static int acpi_data_get_property(const struct acpi_device_data *data,
3a7a2ab8
RW
479 const char *name, acpi_object_type type,
480 const union acpi_object **obj)
ffdcd955 481{
5f5e4890 482 const struct acpi_device_properties *props;
ffdcd955 483
3a7a2ab8 484 if (!data || !name)
ffdcd955
MW
485 return -EINVAL;
486
5f5e4890 487 if (!data->pointer || list_empty(&data->properties))
3c60f114 488 return -EINVAL;
ffdcd955 489
5f5e4890
MW
490 list_for_each_entry(props, &data->properties, list) {
491 const union acpi_object *properties;
492 unsigned int i;
ffdcd955 493
5f5e4890
MW
494 properties = props->properties;
495 for (i = 0; i < properties->package.count; i++) {
496 const union acpi_object *propname, *propvalue;
497 const union acpi_object *property;
498
499 property = &properties->package.elements[i];
ffdcd955 500
5f5e4890
MW
501 propname = &property->package.elements[0];
502 propvalue = &property->package.elements[1];
ffdcd955 503
5f5e4890
MW
504 if (!strcmp(name, propname->string.pointer)) {
505 if (type != ACPI_TYPE_ANY &&
506 propvalue->type != type)
507 return -EPROTO;
508 if (obj)
509 *obj = propvalue;
ffdcd955 510
5f5e4890
MW
511 return 0;
512 }
ffdcd955
MW
513 }
514 }
3c60f114 515 return -EINVAL;
ffdcd955 516}
3a7a2ab8
RW
517
518/**
519 * acpi_dev_get_property - return an ACPI property with given name.
520 * @adev: ACPI device to get the property from.
521 * @name: Name of the property.
522 * @type: Expected property type.
523 * @obj: Location to store the property value (if not %NULL).
524 */
99a85464 525int acpi_dev_get_property(const struct acpi_device *adev, const char *name,
3a7a2ab8
RW
526 acpi_object_type type, const union acpi_object **obj)
527{
528 return adev ? acpi_data_get_property(&adev->data, name, type, obj) : -EINVAL;
529}
ffdcd955
MW
530EXPORT_SYMBOL_GPL(acpi_dev_get_property);
531
99a85464
SA
532static const struct acpi_device_data *
533acpi_device_data_of_node(const struct fwnode_handle *fwnode)
3a7a2ab8 534{
db3e50f3 535 if (is_acpi_device_node(fwnode)) {
99a85464 536 const struct acpi_device *adev = to_acpi_device_node(fwnode);
3a7a2ab8 537 return &adev->data;
db3e50f3 538 } else if (is_acpi_data_node(fwnode)) {
99a85464 539 const struct acpi_data_node *dn = to_acpi_data_node(fwnode);
3a7a2ab8
RW
540 return &dn->data;
541 }
542 return NULL;
543}
544
ffdcd955 545/**
3a7a2ab8
RW
546 * acpi_node_prop_get - return an ACPI property with given name.
547 * @fwnode: Firmware node to get the property from.
548 * @propname: Name of the property.
549 * @valptr: Location to store a pointer to the property value (if not %NULL).
550 */
99a85464
SA
551int acpi_node_prop_get(const struct fwnode_handle *fwnode,
552 const char *propname, void **valptr)
3a7a2ab8
RW
553{
554 return acpi_data_get_property(acpi_device_data_of_node(fwnode),
555 propname, ACPI_TYPE_ANY,
556 (const union acpi_object **)valptr);
557}
558
559/**
560 * acpi_data_get_property_array - return an ACPI array property with given name
561 * @adev: ACPI data object to get the property from
ffdcd955
MW
562 * @name: Name of the property
563 * @type: Expected type of array elements
564 * @obj: Location to store a pointer to the property value (if not NULL)
565 *
566 * Look up an array property with @name and store a pointer to the resulting
567 * ACPI object at the location pointed to by @obj if found.
568 *
569 * Callers must not attempt to free the returned objects. Those objects will be
3a7a2ab8 570 * freed by the ACPI core automatically during the removal of @data.
ffdcd955
MW
571 *
572 * Return: %0 if array property (package) with @name has been found (success),
573 * %-EINVAL if the arguments are invalid,
3c60f114 574 * %-EINVAL if the property doesn't exist,
ffdcd955
MW
575 * %-EPROTO if the property is not a package or the type of its elements
576 * doesn't match @type.
577 */
99a85464 578static int acpi_data_get_property_array(const struct acpi_device_data *data,
3a7a2ab8
RW
579 const char *name,
580 acpi_object_type type,
581 const union acpi_object **obj)
ffdcd955
MW
582{
583 const union acpi_object *prop;
584 int ret, i;
585
3a7a2ab8 586 ret = acpi_data_get_property(data, name, ACPI_TYPE_PACKAGE, &prop);
ffdcd955
MW
587 if (ret)
588 return ret;
589
590 if (type != ACPI_TYPE_ANY) {
591 /* Check that all elements are of correct type. */
592 for (i = 0; i < prop->package.count; i++)
593 if (prop->package.elements[i].type != type)
594 return -EPROTO;
595 }
596 if (obj)
597 *obj = prop;
598
599 return 0;
600}
ffdcd955 601
4eb0c3bf
SA
602static struct fwnode_handle *
603acpi_fwnode_get_named_child_node(const struct fwnode_handle *fwnode,
604 const char *childname)
605{
606 struct fwnode_handle *child;
607
608 /*
609 * Find first matching named child node of this fwnode.
610 * For ACPI this will be a data only sub-node.
611 */
612 fwnode_for_each_child_node(fwnode, child)
613 if (acpi_data_node_match(child, childname))
614 return child;
615
616 return NULL;
617}
618
ffdcd955 619/**
b60e4ea4
MW
620 * __acpi_node_get_property_reference - returns handle to the referenced object
621 * @fwnode: Firmware node to get the property from
504a3374 622 * @propname: Name of the property
ffdcd955 623 * @index: Index of the reference to return
b60e4ea4 624 * @num_args: Maximum number of arguments after each reference
ffdcd955
MW
625 * @args: Location to store the returned reference with optional arguments
626 *
627 * Find property with @name, verifify that it is a package containing at least
628 * one object reference and if so, store the ACPI device object pointer to the
60ba032e
RW
629 * target object in @args->adev. If the reference includes arguments, store
630 * them in the @args->args[] array.
ffdcd955 631 *
60ba032e
RW
632 * If there's more than one reference in the property value package, @index is
633 * used to select the one to return.
ffdcd955 634 *
b60e4ea4
MW
635 * It is possible to leave holes in the property value set like in the
636 * example below:
637 *
638 * Package () {
639 * "cs-gpios",
640 * Package () {
641 * ^GPIO, 19, 0, 0,
642 * ^GPIO, 20, 0, 0,
643 * 0,
644 * ^GPIO, 21, 0, 0,
645 * }
646 * }
647 *
c343bc2c
SA
648 * Calling this function with index %2 or index %3 return %-ENOENT. If the
649 * property does not contain any more values %-ENOENT is returned. The NULL
650 * entry must be single integer and preferably contain value %0.
b60e4ea4 651 *
ffdcd955
MW
652 * Return: %0 on success, negative error code on failure.
653 */
99a85464 654int __acpi_node_get_property_reference(const struct fwnode_handle *fwnode,
b60e4ea4 655 const char *propname, size_t index, size_t num_args,
977d5ad3 656 struct fwnode_reference_args *args)
ffdcd955
MW
657{
658 const union acpi_object *element, *end;
659 const union acpi_object *obj;
99a85464 660 const struct acpi_device_data *data;
ffdcd955
MW
661 struct acpi_device *device;
662 int ret, idx = 0;
663
b60e4ea4
MW
664 data = acpi_device_data_of_node(fwnode);
665 if (!data)
c343bc2c 666 return -ENOENT;
b60e4ea4 667
504a3374 668 ret = acpi_data_get_property(data, propname, ACPI_TYPE_ANY, &obj);
ffdcd955 669 if (ret)
51858a27 670 return ret == -EINVAL ? -ENOENT : -EINVAL;
ffdcd955
MW
671
672 /*
673 * The simplest case is when the value is a single reference. Just
674 * return that reference then.
675 */
676 if (obj->type == ACPI_TYPE_LOCAL_REFERENCE) {
60ba032e 677 if (index)
ffdcd955
MW
678 return -EINVAL;
679
680 ret = acpi_bus_get_device(obj->reference.handle, &device);
681 if (ret)
51858a27 682 return ret == -ENODEV ? -EINVAL : ret;
ffdcd955 683
977d5ad3 684 args->fwnode = acpi_fwnode_handle(device);
ffdcd955
MW
685 args->nargs = 0;
686 return 0;
687 }
688
689 /*
690 * If it is not a single reference, then it is a package of
691 * references followed by number of ints as follows:
692 *
693 * Package () { REF, INT, REF, INT, INT }
694 *
695 * The index argument is then used to determine which reference
696 * the caller wants (along with the arguments).
697 */
51858a27
SA
698 if (obj->type != ACPI_TYPE_PACKAGE)
699 return -EINVAL;
700 if (index >= obj->package.count)
701 return -ENOENT;
ffdcd955
MW
702
703 element = obj->package.elements;
704 end = element + obj->package.count;
705
706 while (element < end) {
707 u32 nargs, i;
708
b60e4ea4 709 if (element->type == ACPI_TYPE_LOCAL_REFERENCE) {
4eb0c3bf
SA
710 struct fwnode_handle *ref_fwnode;
711
b60e4ea4
MW
712 ret = acpi_bus_get_device(element->reference.handle,
713 &device);
714 if (ret)
c343bc2c 715 return -EINVAL;
b60e4ea4
MW
716
717 nargs = 0;
718 element++;
719
4eb0c3bf
SA
720 /*
721 * Find the referred data extension node under the
722 * referred device node.
723 */
724 for (ref_fwnode = acpi_fwnode_handle(device);
725 element < end && element->type == ACPI_TYPE_STRING;
726 element++) {
727 ref_fwnode = acpi_fwnode_get_named_child_node(
728 ref_fwnode, element->string.pointer);
729 if (!ref_fwnode)
730 return -EINVAL;
731 }
732
b60e4ea4
MW
733 /* assume following integer elements are all args */
734 for (i = 0; element + i < end && i < num_args; i++) {
735 int type = element[i].type;
736
737 if (type == ACPI_TYPE_INTEGER)
738 nargs++;
739 else if (type == ACPI_TYPE_LOCAL_REFERENCE)
740 break;
741 else
c343bc2c 742 return -EINVAL;
b60e4ea4 743 }
ffdcd955 744
977d5ad3 745 if (nargs > NR_FWNODE_REFERENCE_ARGS)
c343bc2c 746 return -EINVAL;
ffdcd955 747
b60e4ea4 748 if (idx == index) {
4eb0c3bf 749 args->fwnode = ref_fwnode;
b60e4ea4
MW
750 args->nargs = nargs;
751 for (i = 0; i < nargs; i++)
752 args->args[i] = element[i].integer.value;
ffdcd955 753
b60e4ea4
MW
754 return 0;
755 }
756
757 element += nargs;
758 } else if (element->type == ACPI_TYPE_INTEGER) {
759 if (idx == index)
760 return -ENOENT;
761 element++;
762 } else {
c343bc2c 763 return -EINVAL;
ffdcd955
MW
764 }
765
b60e4ea4 766 idx++;
ffdcd955
MW
767 }
768
c343bc2c 769 return -ENOENT;
504a3374 770}
b60e4ea4 771EXPORT_SYMBOL_GPL(__acpi_node_get_property_reference);
b31384fa 772
99a85464 773static int acpi_data_prop_read_single(const struct acpi_device_data *data,
3a7a2ab8
RW
774 const char *propname,
775 enum dev_prop_type proptype, void *val)
b31384fa
RW
776{
777 const union acpi_object *obj;
778 int ret;
779
780 if (!val)
781 return -EINVAL;
782
783 if (proptype >= DEV_PROP_U8 && proptype <= DEV_PROP_U64) {
3a7a2ab8 784 ret = acpi_data_get_property(data, propname, ACPI_TYPE_INTEGER, &obj);
b31384fa
RW
785 if (ret)
786 return ret;
787
788 switch (proptype) {
789 case DEV_PROP_U8:
790 if (obj->integer.value > U8_MAX)
791 return -EOVERFLOW;
792 *(u8 *)val = obj->integer.value;
793 break;
794 case DEV_PROP_U16:
795 if (obj->integer.value > U16_MAX)
796 return -EOVERFLOW;
797 *(u16 *)val = obj->integer.value;
798 break;
799 case DEV_PROP_U32:
800 if (obj->integer.value > U32_MAX)
801 return -EOVERFLOW;
802 *(u32 *)val = obj->integer.value;
803 break;
804 default:
805 *(u64 *)val = obj->integer.value;
806 break;
807 }
808 } else if (proptype == DEV_PROP_STRING) {
3a7a2ab8 809 ret = acpi_data_get_property(data, propname, ACPI_TYPE_STRING, &obj);
b31384fa
RW
810 if (ret)
811 return ret;
812
813 *(char **)val = obj->string.pointer;
b0b027ce
SA
814
815 return 1;
b31384fa
RW
816 } else {
817 ret = -EINVAL;
818 }
819 return ret;
820}
821
3a7a2ab8
RW
822int acpi_dev_prop_read_single(struct acpi_device *adev, const char *propname,
823 enum dev_prop_type proptype, void *val)
824{
b0b027ce
SA
825 int ret;
826
827 if (!adev)
828 return -EINVAL;
829
830 ret = acpi_data_prop_read_single(&adev->data, propname, proptype, val);
831 if (ret < 0 || proptype != ACPI_TYPE_STRING)
832 return ret;
833 return 0;
3a7a2ab8
RW
834}
835
b31384fa
RW
836static int acpi_copy_property_array_u8(const union acpi_object *items, u8 *val,
837 size_t nval)
838{
839 int i;
840
841 for (i = 0; i < nval; i++) {
842 if (items[i].type != ACPI_TYPE_INTEGER)
843 return -EPROTO;
844 if (items[i].integer.value > U8_MAX)
845 return -EOVERFLOW;
846
847 val[i] = items[i].integer.value;
848 }
849 return 0;
850}
851
852static int acpi_copy_property_array_u16(const union acpi_object *items,
853 u16 *val, size_t nval)
854{
855 int i;
856
857 for (i = 0; i < nval; i++) {
858 if (items[i].type != ACPI_TYPE_INTEGER)
859 return -EPROTO;
860 if (items[i].integer.value > U16_MAX)
861 return -EOVERFLOW;
862
863 val[i] = items[i].integer.value;
864 }
865 return 0;
866}
867
868static int acpi_copy_property_array_u32(const union acpi_object *items,
869 u32 *val, size_t nval)
870{
871 int i;
872
873 for (i = 0; i < nval; i++) {
874 if (items[i].type != ACPI_TYPE_INTEGER)
875 return -EPROTO;
876 if (items[i].integer.value > U32_MAX)
877 return -EOVERFLOW;
878
879 val[i] = items[i].integer.value;
880 }
881 return 0;
882}
883
884static int acpi_copy_property_array_u64(const union acpi_object *items,
885 u64 *val, size_t nval)
886{
887 int i;
888
889 for (i = 0; i < nval; i++) {
890 if (items[i].type != ACPI_TYPE_INTEGER)
891 return -EPROTO;
892
893 val[i] = items[i].integer.value;
894 }
895 return 0;
896}
897
898static int acpi_copy_property_array_string(const union acpi_object *items,
899 char **val, size_t nval)
900{
901 int i;
902
903 for (i = 0; i < nval; i++) {
904 if (items[i].type != ACPI_TYPE_STRING)
905 return -EPROTO;
906
907 val[i] = items[i].string.pointer;
908 }
b0b027ce 909 return nval;
b31384fa
RW
910}
911
99a85464 912static int acpi_data_prop_read(const struct acpi_device_data *data,
3a7a2ab8
RW
913 const char *propname,
914 enum dev_prop_type proptype,
915 void *val, size_t nval)
b31384fa
RW
916{
917 const union acpi_object *obj;
918 const union acpi_object *items;
919 int ret;
920
921 if (val && nval == 1) {
3a7a2ab8 922 ret = acpi_data_prop_read_single(data, propname, proptype, val);
b0b027ce 923 if (ret >= 0)
b31384fa
RW
924 return ret;
925 }
926
3a7a2ab8 927 ret = acpi_data_get_property_array(data, propname, ACPI_TYPE_ANY, &obj);
b31384fa
RW
928 if (ret)
929 return ret;
930
931 if (!val)
932 return obj->package.count;
b31384fa 933
b0b027ce 934 if (proptype != DEV_PROP_STRING && nval > obj->package.count)
b31384fa 935 return -EOVERFLOW;
7dc59dc9
AS
936 else if (nval <= 0)
937 return -EINVAL;
b31384fa
RW
938
939 items = obj->package.elements;
7dc59dc9 940
b31384fa
RW
941 switch (proptype) {
942 case DEV_PROP_U8:
943 ret = acpi_copy_property_array_u8(items, (u8 *)val, nval);
944 break;
945 case DEV_PROP_U16:
946 ret = acpi_copy_property_array_u16(items, (u16 *)val, nval);
947 break;
948 case DEV_PROP_U32:
949 ret = acpi_copy_property_array_u32(items, (u32 *)val, nval);
950 break;
951 case DEV_PROP_U64:
952 ret = acpi_copy_property_array_u64(items, (u64 *)val, nval);
953 break;
954 case DEV_PROP_STRING:
b0b027ce
SA
955 ret = acpi_copy_property_array_string(
956 items, (char **)val,
957 min_t(u32, nval, obj->package.count));
b31384fa
RW
958 break;
959 default:
960 ret = -EINVAL;
961 break;
962 }
963 return ret;
964}
3a7a2ab8 965
99a85464 966int acpi_dev_prop_read(const struct acpi_device *adev, const char *propname,
3a7a2ab8
RW
967 enum dev_prop_type proptype, void *val, size_t nval)
968{
969 return adev ? acpi_data_prop_read(&adev->data, propname, proptype, val, nval) : -EINVAL;
970}
971
972/**
973 * acpi_node_prop_read - retrieve the value of an ACPI property with given name.
974 * @fwnode: Firmware node to get the property from.
975 * @propname: Name of the property.
976 * @proptype: Expected property type.
977 * @val: Location to store the property value (if not %NULL).
978 * @nval: Size of the array pointed to by @val.
979 *
980 * If @val is %NULL, return the number of array elements comprising the value
981 * of the property. Otherwise, read at most @nval values to the array at the
982 * location pointed to by @val.
983 */
99a85464
SA
984int acpi_node_prop_read(const struct fwnode_handle *fwnode,
985 const char *propname, enum dev_prop_type proptype,
986 void *val, size_t nval)
3a7a2ab8
RW
987{
988 return acpi_data_prop_read(acpi_device_data_of_node(fwnode),
989 propname, proptype, val, nval);
990}
504a3374
RW
991
992/**
34055190
MW
993 * acpi_get_next_subnode - Return the next child node handle for a fwnode
994 * @fwnode: Firmware node to find the next child node for.
504a3374
RW
995 * @child: Handle to one of the device's child nodes or a null handle.
996 */
37ba983c 997struct fwnode_handle *acpi_get_next_subnode(const struct fwnode_handle *fwnode,
504a3374
RW
998 struct fwnode_handle *child)
999{
01c1da28 1000 const struct acpi_device *adev = to_acpi_device_node(fwnode);
01c1da28
SA
1001 const struct list_head *head;
1002 struct list_head *next;
504a3374 1003
db3e50f3 1004 if (!child || is_acpi_device_node(child)) {
0c0bceb7
SA
1005 struct acpi_device *child_adev;
1006
34055190
MW
1007 if (adev)
1008 head = &adev->children;
1009 else
1010 goto nondev;
1011
504a3374
RW
1012 if (list_empty(head))
1013 goto nondev;
1014
1015 if (child) {
0c0bceb7
SA
1016 adev = to_acpi_device_node(child);
1017 next = adev->node.next;
504a3374
RW
1018 if (next == head) {
1019 child = NULL;
1020 goto nondev;
1021 }
01c1da28 1022 child_adev = list_entry(next, struct acpi_device, node);
504a3374 1023 } else {
01c1da28
SA
1024 child_adev = list_first_entry(head, struct acpi_device,
1025 node);
504a3374 1026 }
01c1da28 1027 return acpi_fwnode_handle(child_adev);
504a3374
RW
1028 }
1029
1030 nondev:
db3e50f3 1031 if (!child || is_acpi_data_node(child)) {
01c1da28 1032 const struct acpi_data_node *data = to_acpi_data_node(fwnode);
504a3374
RW
1033 struct acpi_data_node *dn;
1034
23583f77
PLB
1035 /*
1036 * We can have a combination of device and data nodes, e.g. with
1037 * hierarchical _DSD properties. Make sure the adev pointer is
1038 * restored before going through data nodes, otherwise we will
1039 * be looking for data_nodes below the last device found instead
1040 * of the common fwnode shared by device_nodes and data_nodes.
1041 */
1042 adev = to_acpi_device_node(fwnode);
0c0bceb7
SA
1043 if (adev)
1044 head = &adev->data.subnodes;
34055190
MW
1045 else if (data)
1046 head = &data->data.subnodes;
1047 else
1048 return NULL;
1049
504a3374
RW
1050 if (list_empty(head))
1051 return NULL;
1052
1053 if (child) {
1054 dn = to_acpi_data_node(child);
1055 next = dn->sibling.next;
1056 if (next == head)
1057 return NULL;
1058
1059 dn = list_entry(next, struct acpi_data_node, sibling);
1060 } else {
1061 dn = list_first_entry(head, struct acpi_data_node, sibling);
1062 }
1063 return &dn->fwnode;
1064 }
1065 return NULL;
1066}
dfa672fb
MW
1067
1068/**
1069 * acpi_node_get_parent - Return parent fwnode of this fwnode
1070 * @fwnode: Firmware node whose parent to get
1071 *
1072 * Returns parent node of an ACPI device or data firmware node or %NULL if
1073 * not available.
1074 */
37ba983c 1075struct fwnode_handle *acpi_node_get_parent(const struct fwnode_handle *fwnode)
dfa672fb
MW
1076{
1077 if (is_acpi_data_node(fwnode)) {
1078 /* All data nodes have parent pointer so just return that */
1079 return to_acpi_data_node(fwnode)->parent;
1080 } else if (is_acpi_device_node(fwnode)) {
1081 acpi_handle handle, parent_handle;
1082
1083 handle = to_acpi_device_node(fwnode)->handle;
1084 if (ACPI_SUCCESS(acpi_get_parent(handle, &parent_handle))) {
1085 struct acpi_device *adev;
1086
1087 if (!acpi_bus_get_device(parent_handle, &adev))
1088 return acpi_fwnode_handle(adev);
1089 }
1090 }
1091
1092 return NULL;
1093}
79389a83 1094
18f1e58d
SA
1095/*
1096 * Return true if the node is an ACPI graph node. Called on either ports
1097 * or endpoints.
1098 */
1099static bool is_acpi_graph_node(struct fwnode_handle *fwnode,
1100 const char *str)
1101{
1102 unsigned int len = strlen(str);
1103 const char *name;
1104
1105 if (!len || !is_acpi_data_node(fwnode))
1106 return false;
1107
1108 name = to_acpi_data_node(fwnode)->name;
1109
1110 return (fwnode_property_present(fwnode, "reg") &&
1111 !strncmp(name, str, len) && name[len] == '@') ||
1112 fwnode_property_present(fwnode, str);
1113}
1114
79389a83
MW
1115/**
1116 * acpi_graph_get_next_endpoint - Get next endpoint ACPI firmware node
1117 * @fwnode: Pointer to the parent firmware node
1118 * @prev: Previous endpoint node or %NULL to get the first
1119 *
1120 * Looks up next endpoint ACPI firmware node below a given @fwnode. Returns
0ef74786
SA
1121 * %NULL if there is no next endpoint or in case of error. In case of success
1122 * the next endpoint is returned.
79389a83 1123 */
0ef74786 1124static struct fwnode_handle *acpi_graph_get_next_endpoint(
37ba983c 1125 const struct fwnode_handle *fwnode, struct fwnode_handle *prev)
79389a83
MW
1126{
1127 struct fwnode_handle *port = NULL;
1128 struct fwnode_handle *endpoint;
1129
1130 if (!prev) {
1131 do {
1132 port = fwnode_get_next_child_node(fwnode, port);
18f1e58d
SA
1133 /*
1134 * The names of the port nodes begin with "port@"
1135 * followed by the number of the port node and they also
1136 * have a "reg" property that also has the number of the
1137 * port node. For compatibility reasons a node is also
1138 * recognised as a port node from the "port" property.
1139 */
1140 if (is_acpi_graph_node(port, "port"))
79389a83
MW
1141 break;
1142 } while (port);
1143 } else {
1144 port = fwnode_get_parent(prev);
1145 }
1146
1147 if (!port)
1148 return NULL;
1149
1150 endpoint = fwnode_get_next_child_node(port, prev);
1151 while (!endpoint) {
1152 port = fwnode_get_next_child_node(fwnode, port);
1153 if (!port)
1154 break;
18f1e58d 1155 if (is_acpi_graph_node(port, "port"))
79389a83
MW
1156 endpoint = fwnode_get_next_child_node(port, NULL);
1157 }
1158
18f1e58d
SA
1159 /*
1160 * The names of the endpoint nodes begin with "endpoint@" followed by
1161 * the number of the endpoint node and they also have a "reg" property
1162 * that also has the number of the endpoint node. For compatibility
1163 * reasons a node is also recognised as an endpoint node from the
1164 * "endpoint" property.
1165 */
1166 if (!is_acpi_graph_node(endpoint, "endpoint"))
0ef74786 1167 return NULL;
79389a83
MW
1168
1169 return endpoint;
1170}
1171
1172/**
1173 * acpi_graph_get_child_prop_value - Return a child with a given property value
1174 * @fwnode: device fwnode
1175 * @prop_name: The name of the property to look for
1176 * @val: the desired property value
1177 *
1178 * Return the port node corresponding to a given port number. Returns
1179 * the child node on success, NULL otherwise.
1180 */
1181static struct fwnode_handle *acpi_graph_get_child_prop_value(
37ba983c
SA
1182 const struct fwnode_handle *fwnode, const char *prop_name,
1183 unsigned int val)
79389a83
MW
1184{
1185 struct fwnode_handle *child;
1186
1187 fwnode_for_each_child_node(fwnode, child) {
1188 u32 nr;
1189
b5212f57 1190 if (fwnode_property_read_u32(child, prop_name, &nr))
79389a83
MW
1191 continue;
1192
1193 if (val == nr)
1194 return child;
1195 }
1196
1197 return NULL;
1198}
1199
1200
1201/**
1202 * acpi_graph_get_remote_enpoint - Parses and returns remote end of an endpoint
1203 * @fwnode: Endpoint firmware node pointing to a remote device
79389a83
MW
1204 * @endpoint: Firmware node of remote endpoint is filled here if not %NULL
1205 *
0ef74786 1206 * Returns the remote endpoint corresponding to @__fwnode. NULL on error.
79389a83 1207 */
0ef74786
SA
1208static struct fwnode_handle *
1209acpi_graph_get_remote_endpoint(const struct fwnode_handle *__fwnode)
79389a83 1210{
37ba983c 1211 struct fwnode_handle *fwnode;
79389a83 1212 unsigned int port_nr, endpoint_nr;
977d5ad3 1213 struct fwnode_reference_args args;
79389a83
MW
1214 int ret;
1215
1216 memset(&args, 0, sizeof(args));
37ba983c 1217 ret = acpi_node_get_property_reference(__fwnode, "remote-endpoint", 0,
79389a83
MW
1218 &args);
1219 if (ret)
0ef74786 1220 return NULL;
79389a83 1221
6561eb3d 1222 /* Direct endpoint reference? */
977d5ad3 1223 if (!is_acpi_device_node(args.fwnode))
6561eb3d 1224 return args.nargs ? NULL : args.fwnode;
977d5ad3 1225
79389a83
MW
1226 /*
1227 * Always require two arguments with the reference: port and
1228 * endpoint indices.
1229 */
1230 if (args.nargs != 2)
0ef74786 1231 return NULL;
79389a83 1232
977d5ad3 1233 fwnode = args.fwnode;
79389a83
MW
1234 port_nr = args.args[0];
1235 endpoint_nr = args.args[1];
1236
79389a83 1237 fwnode = acpi_graph_get_child_prop_value(fwnode, "port", port_nr);
79389a83 1238
18f1e58d 1239 return acpi_graph_get_child_prop_value(fwnode, "endpoint", endpoint_nr);
79389a83 1240}
3708184a 1241
37ba983c 1242static bool acpi_fwnode_device_is_available(const struct fwnode_handle *fwnode)
2294b3af
SA
1243{
1244 if (!is_acpi_device_node(fwnode))
1245 return false;
1246
1247 return acpi_device_is_present(to_acpi_device_node(fwnode));
1248}
1249
37ba983c 1250static bool acpi_fwnode_property_present(const struct fwnode_handle *fwnode,
3708184a
SA
1251 const char *propname)
1252{
1253 return !acpi_node_prop_get(fwnode, propname, NULL);
1254}
1255
37ba983c
SA
1256static int
1257acpi_fwnode_property_read_int_array(const struct fwnode_handle *fwnode,
1258 const char *propname,
1259 unsigned int elem_size, void *val,
1260 size_t nval)
3708184a
SA
1261{
1262 enum dev_prop_type type;
1263
1264 switch (elem_size) {
1265 case sizeof(u8):
1266 type = DEV_PROP_U8;
1267 break;
1268 case sizeof(u16):
1269 type = DEV_PROP_U16;
1270 break;
1271 case sizeof(u32):
1272 type = DEV_PROP_U32;
1273 break;
1274 case sizeof(u64):
1275 type = DEV_PROP_U64;
1276 break;
1277 default:
1278 return -ENXIO;
1279 }
1280
1281 return acpi_node_prop_read(fwnode, propname, type, val, nval);
1282}
1283
37ba983c
SA
1284static int
1285acpi_fwnode_property_read_string_array(const struct fwnode_handle *fwnode,
1286 const char *propname, const char **val,
1287 size_t nval)
3708184a
SA
1288{
1289 return acpi_node_prop_read(fwnode, propname, DEV_PROP_STRING,
1290 val, nval);
1291}
1292
3e3119d3
SA
1293static int
1294acpi_fwnode_get_reference_args(const struct fwnode_handle *fwnode,
1295 const char *prop, const char *nargs_prop,
1296 unsigned int args_count, unsigned int index,
1297 struct fwnode_reference_args *args)
1298{
977d5ad3
SA
1299 return __acpi_node_get_property_reference(fwnode, prop, index,
1300 args_count, args);
3e3119d3
SA
1301}
1302
37ba983c
SA
1303static struct fwnode_handle *
1304acpi_fwnode_get_parent(struct fwnode_handle *fwnode)
1305{
1306 return acpi_node_get_parent(fwnode);
1307}
1308
1309static int acpi_fwnode_graph_parse_endpoint(const struct fwnode_handle *fwnode,
3b27d00e
SA
1310 struct fwnode_endpoint *endpoint)
1311{
1312 struct fwnode_handle *port_fwnode = fwnode_get_parent(fwnode);
1313
1314 endpoint->local_fwnode = fwnode;
1315
18f1e58d
SA
1316 if (fwnode_property_read_u32(port_fwnode, "reg", &endpoint->port))
1317 fwnode_property_read_u32(port_fwnode, "port", &endpoint->port);
1318 if (fwnode_property_read_u32(fwnode, "reg", &endpoint->id))
1319 fwnode_property_read_u32(fwnode, "endpoint", &endpoint->id);
3b27d00e
SA
1320
1321 return 0;
1322}
1323
67dcc26d 1324static const void *
146b4dbb
SK
1325acpi_fwnode_device_get_match_data(const struct fwnode_handle *fwnode,
1326 const struct device *dev)
1327{
29d5325a 1328 return acpi_device_get_match_data(dev);
146b4dbb
SK
1329}
1330
db3e50f3
SA
1331#define DECLARE_ACPI_FWNODE_OPS(ops) \
1332 const struct fwnode_operations ops = { \
1333 .device_is_available = acpi_fwnode_device_is_available, \
146b4dbb 1334 .device_get_match_data = acpi_fwnode_device_get_match_data, \
db3e50f3
SA
1335 .property_present = acpi_fwnode_property_present, \
1336 .property_read_int_array = \
1337 acpi_fwnode_property_read_int_array, \
1338 .property_read_string_array = \
1339 acpi_fwnode_property_read_string_array, \
1340 .get_parent = acpi_node_get_parent, \
1341 .get_next_child_node = acpi_get_next_subnode, \
1342 .get_named_child_node = acpi_fwnode_get_named_child_node, \
3e3119d3 1343 .get_reference_args = acpi_fwnode_get_reference_args, \
db3e50f3 1344 .graph_get_next_endpoint = \
0ef74786 1345 acpi_graph_get_next_endpoint, \
db3e50f3 1346 .graph_get_remote_endpoint = \
0ef74786 1347 acpi_graph_get_remote_endpoint, \
37ba983c 1348 .graph_get_port_parent = acpi_fwnode_get_parent, \
db3e50f3
SA
1349 .graph_parse_endpoint = acpi_fwnode_graph_parse_endpoint, \
1350 }; \
1351 EXPORT_SYMBOL_GPL(ops)
1352
1353DECLARE_ACPI_FWNODE_OPS(acpi_device_fwnode_ops);
1354DECLARE_ACPI_FWNODE_OPS(acpi_data_fwnode_ops);
1355const struct fwnode_operations acpi_static_fwnode_ops;
9e987b70
JH
1356
1357bool is_acpi_device_node(const struct fwnode_handle *fwnode)
1358{
1359 return !IS_ERR_OR_NULL(fwnode) &&
1360 fwnode->ops == &acpi_device_fwnode_ops;
1361}
1362EXPORT_SYMBOL(is_acpi_device_node);
1363
1364bool is_acpi_data_node(const struct fwnode_handle *fwnode)
1365{
1366 return !IS_ERR_OR_NULL(fwnode) && fwnode->ops == &acpi_data_fwnode_ops;
1367}
1368EXPORT_SYMBOL(is_acpi_data_node);