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