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