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