drivers/acpi/property.c

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