drivers/acpi/property.c

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