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