drivers/acpi/property.c

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