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