drivers/acpi/property.c

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