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 /* ACPI _DSD device properties UUID: daffd814-6eba-4d8c-8a91-bc9bbf4aa301 */
  23 static const u8 prp_uuid[16] = {
  24         0x14, 0xd8, 0xff, 0xda, 0xba, 0x6e, 0x8c, 0x4d,
  25         0x8a, 0x91, 0xbc, 0x9b, 0xbf, 0x4a, 0xa3, 0x01
  26 };
  27
  28 static bool acpi_property_value_ok(const union acpi_object *value)
  29 {
  30         int j;
  31
  32         /*
  33          * The value must be an integer, a string, a reference, or a package
  34          * whose every element must be an integer, a string, or a reference.
  35          */
  36         switch (value->type) {
  37         case ACPI_TYPE_INTEGER:
  38         case ACPI_TYPE_STRING:
  39         case ACPI_TYPE_LOCAL_REFERENCE:
  40                 return true;
  41
  42         case ACPI_TYPE_PACKAGE:
  43                 for (j = 0; j < value->package.count; j++)
  44                         switch (value->package.elements[j].type) {
  45                         case ACPI_TYPE_INTEGER:
  46                         case ACPI_TYPE_STRING:
  47                         case ACPI_TYPE_LOCAL_REFERENCE:
  48                                 continue;
  49
  50                         default:
  51                                 return false;
  52                         }
  53
  54                 return true;
  55         }
  56         return false;
  57 }
  58
  59 static bool acpi_properties_format_valid(const union acpi_object *properties)
  60 {
  61         int i;
  62
  63         for (i = 0; i < properties->package.count; i++) {
  64                 const union acpi_object *property;
  65
  66                 property = &properties->package.elements[i];
  67                 /*
  68                  * Only two elements allowed, the first one must be a string and
  69                  * the second one has to satisfy certain conditions.
  70                  */
  71                 if (property->package.count != 2
  72                     || property->package.elements[0].type != ACPI_TYPE_STRING
  73                     || !acpi_property_value_ok(&property->package.elements[1]))
  74                         return false;
  75         }
  76         return true;
  77 }
  78
  79 static void acpi_init_of_compatible(struct acpi_device *adev)
  80 {
  81         const union acpi_object *of_compatible;
  82         int ret;
  83
  84         ret = acpi_dev_get_property_array(adev, "compatible", ACPI_TYPE_STRING,
  85                                           &of_compatible);
  86         if (ret) {
  87                 ret = acpi_dev_get_property(adev, "compatible",
  88                                             ACPI_TYPE_STRING, &of_compatible);
  89                 if (ret) {
  90                         if (adev->parent
  91                             && adev->parent->flags.of_compatible_ok)
  92                                 goto out;
  93
  94                         return;
  95                 }
  96         }
  97         adev->data.of_compatible = of_compatible;
  98
  99  out:
 100         adev->flags.of_compatible_ok = 1;
 101 }
 102
 103 void acpi_init_properties(struct acpi_device *adev)
 104 {
 105         struct acpi_buffer buf = { ACPI_ALLOCATE_BUFFER };
 106         bool acpi_of = false;
 107         struct acpi_hardware_id *hwid;
 108         const union acpi_object *desc;
 109         acpi_status status;
 110         int i;
 111
 112         /*
 113          * Check if ACPI_DT_NAMESPACE_HID is present and inthat case we fill in
 114          * Device Tree compatible properties for this device.
 115          */
 116         list_for_each_entry(hwid, &adev->pnp.ids, list) {
 117                 if (!strcmp(hwid->id, ACPI_DT_NAMESPACE_HID)) {
 118                         acpi_of = true;
 119                         break;
 120                 }
 121         }
 122
 123         status = acpi_evaluate_object_typed(adev->handle, "_DSD", NULL, &buf,
 124                                             ACPI_TYPE_PACKAGE);
 125         if (ACPI_FAILURE(status))
 126                 goto out;
 127
 128         desc = buf.pointer;
 129         if (desc->package.count % 2)
 130                 goto fail;
 131
 132         /* Look for the device properties UUID. */
 133         for (i = 0; i < desc->package.count; i += 2) {
 134                 const union acpi_object *uuid, *properties;
 135
 136                 uuid = &desc->package.elements[i];
 137                 properties = &desc->package.elements[i + 1];
 138
 139                 /*
 140                  * The first element must be a UUID and the second one must be
 141                  * a package.
 142                  */
 143                 if (uuid->type != ACPI_TYPE_BUFFER || uuid->buffer.length != 16
 144                     || properties->type != ACPI_TYPE_PACKAGE)
 145                         break;
 146
 147                 if (memcmp(uuid->buffer.pointer, prp_uuid, sizeof(prp_uuid)))
 148                         continue;
 149
 150                 /*
 151                  * We found the matching UUID. Now validate the format of the
 152                  * package immediately following it.
 153                  */
 154                 if (!acpi_properties_format_valid(properties))
 155                         break;
 156
 157                 adev->data.pointer = buf.pointer;
 158                 adev->data.properties = properties;
 159
 160                 if (acpi_of)
 161                         acpi_init_of_compatible(adev);
 162
 163                 goto out;
 164         }
 165
 166  fail:
 167         dev_dbg(&adev->dev, "Returned _DSD data is not valid, skipping\n");
 168         ACPI_FREE(buf.pointer);
 169
 170  out:
 171         if (acpi_of && !adev->flags.of_compatible_ok)
 172                 acpi_handle_info(adev->handle,
 173                          ACPI_DT_NAMESPACE_HID " requires 'compatible' property\n");
 174 }
 175
 176 void acpi_free_properties(struct acpi_device *adev)
 177 {
 178         ACPI_FREE((void *)adev->data.pointer);
 179         adev->data.of_compatible = NULL;
 180         adev->data.pointer = NULL;
 181         adev->data.properties = NULL;
 182 }
 183
 184 /**
 185  * acpi_dev_get_property - return an ACPI property with given name
 186  * @adev: ACPI device to get property
 187  * @name: Name of the property
 188  * @type: Expected property type
 189  * @obj: Location to store the property value (if not %NULL)
 190  *
 191  * Look up a property with @name and store a pointer to the resulting ACPI
 192  * object at the location pointed to by @obj if found.
 193  *
 194  * Callers must not attempt to free the returned objects.  These objects will be
 195  * freed by the ACPI core automatically during the removal of @adev.
 196  *
 197  * Return: %0 if property with @name has been found (success),
 198  *         %-EINVAL if the arguments are invalid,
 199  *         %-ENODATA if the property doesn't exist,
 200  *         %-EPROTO if the property value type doesn't match @type.
 201  */
 202 int acpi_dev_get_property(struct acpi_device *adev, const char *name,
 203                           acpi_object_type type, const union acpi_object **obj)
 204 {
 205         const union acpi_object *properties;
 206         int i;
 207
 208         if (!adev || !name)
 209                 return -EINVAL;
 210
 211         if (!adev->data.pointer || !adev->data.properties)
 212                 return -ENODATA;
 213
 214         properties = adev->data.properties;
 215         for (i = 0; i < properties->package.count; i++) {
 216                 const union acpi_object *propname, *propvalue;
 217                 const union acpi_object *property;
 218
 219                 property = &properties->package.elements[i];
 220
 221                 propname = &property->package.elements[0];
 222                 propvalue = &property->package.elements[1];
 223
 224                 if (!strcmp(name, propname->string.pointer)) {
 225                         if (type != ACPI_TYPE_ANY && propvalue->type != type)
 226                                 return -EPROTO;
 227                         else if (obj)
 228                                 *obj = propvalue;
 229
 230                         return 0;
 231                 }
 232         }
 233         return -ENODATA;
 234 }
 235 EXPORT_SYMBOL_GPL(acpi_dev_get_property);
 236
 237 /**
 238  * acpi_dev_get_property_array - return an ACPI array property with given name
 239  * @adev: ACPI device to get property
 240  * @name: Name of the property
 241  * @type: Expected type of array elements
 242  * @obj: Location to store a pointer to the property value (if not NULL)
 243  *
 244  * Look up an array property with @name and store a pointer to the resulting
 245  * ACPI object at the location pointed to by @obj if found.
 246  *
 247  * Callers must not attempt to free the returned objects.  Those objects will be
 248  * freed by the ACPI core automatically during the removal of @adev.
 249  *
 250  * Return: %0 if array property (package) with @name has been found (success),
 251  *         %-EINVAL if the arguments are invalid,
 252  *         %-ENODATA if the property doesn't exist,
 253  *         %-EPROTO if the property is not a package or the type of its elements
 254  *           doesn't match @type.
 255  */
 256 int acpi_dev_get_property_array(struct acpi_device *adev, const char *name,
 257                                 acpi_object_type type,
 258                                 const union acpi_object **obj)
 259 {
 260         const union acpi_object *prop;
 261         int ret, i;
 262
 263         ret = acpi_dev_get_property(adev, name, ACPI_TYPE_PACKAGE, &prop);
 264         if (ret)
 265                 return ret;
 266
 267         if (type != ACPI_TYPE_ANY) {
 268                 /* Check that all elements are of correct type. */
 269                 for (i = 0; i < prop->package.count; i++)
 270                         if (prop->package.elements[i].type != type)
 271                                 return -EPROTO;
 272         }
 273         if (obj)
 274                 *obj = prop;
 275
 276         return 0;
 277 }
 278 EXPORT_SYMBOL_GPL(acpi_dev_get_property_array);
 279
 280 /**
 281  * acpi_dev_get_property_reference - returns handle to the referenced object
 282  * @adev: ACPI device to get property
 283  * @name: Name of the property
 284  * @index: Index of the reference to return
 285  * @args: Location to store the returned reference with optional arguments
 286  *
 287  * Find property with @name, verifify that it is a package containing at least
 288  * one object reference and if so, store the ACPI device object pointer to the
 289  * target object in @args->adev.  If the reference includes arguments, store
 290  * them in the @args->args[] array.
 291  *
 292  * If there's more than one reference in the property value package, @index is
 293  * used to select the one to return.
 294  *
 295  * Return: %0 on success, negative error code on failure.
 296  */
 297 int acpi_dev_get_property_reference(struct acpi_device *adev,
 298                                     const char *name, size_t index,
 299                                     struct acpi_reference_args *args)
 300 {
 301         const union acpi_object *element, *end;
 302         const union acpi_object *obj;
 303         struct acpi_device *device;
 304         int ret, idx = 0;
 305
 306         ret = acpi_dev_get_property(adev, name, ACPI_TYPE_ANY, &obj);
 307         if (ret)
 308                 return ret;
 309
 310         /*
 311          * The simplest case is when the value is a single reference.  Just
 312          * return that reference then.
 313          */
 314         if (obj->type == ACPI_TYPE_LOCAL_REFERENCE) {
 315                 if (index)
 316                         return -EINVAL;
 317
 318                 ret = acpi_bus_get_device(obj->reference.handle, &device);
 319                 if (ret)
 320                         return ret;
 321
 322                 args->adev = device;
 323                 args->nargs = 0;
 324                 return 0;
 325         }
 326
 327         /*
 328          * If it is not a single reference, then it is a package of
 329          * references followed by number of ints as follows:
 330          *
 331          *  Package () { REF, INT, REF, INT, INT }
 332          *
 333          * The index argument is then used to determine which reference
 334          * the caller wants (along with the arguments).
 335          */
 336         if (obj->type != ACPI_TYPE_PACKAGE || index >= obj->package.count)
 337                 return -EPROTO;
 338
 339         element = obj->package.elements;
 340         end = element + obj->package.count;
 341
 342         while (element < end) {
 343                 u32 nargs, i;
 344
 345                 if (element->type != ACPI_TYPE_LOCAL_REFERENCE)
 346                         return -EPROTO;
 347
 348                 ret = acpi_bus_get_device(element->reference.handle, &device);
 349                 if (ret)
 350                         return -ENODEV;
 351
 352                 element++;
 353                 nargs = 0;
 354
 355                 /* assume following integer elements are all args */
 356                 for (i = 0; element + i < end; i++) {
 357                         int type = element[i].type;
 358
 359                         if (type == ACPI_TYPE_INTEGER)
 360                                 nargs++;
 361                         else if (type == ACPI_TYPE_LOCAL_REFERENCE)
 362                                 break;
 363                         else
 364                                 return -EPROTO;
 365                 }
 366
 367                 if (idx++ == index) {
 368                         args->adev = device;
 369                         args->nargs = nargs;
 370                         for (i = 0; i < nargs; i++)
 371                                 args->args[i] = element[i].integer.value;
 372
 373                         return 0;
 374                 }
 375
 376                 element += nargs;
 377         }
 378
 379         return -EPROTO;
 380 }
 381 EXPORT_SYMBOL_GPL(acpi_dev_get_property_reference);
 382
 383 int acpi_dev_prop_get(struct acpi_device *adev, const char *propname,
 384                       void **valptr)
 385 {
 386         return acpi_dev_get_property(adev, propname, ACPI_TYPE_ANY,
 387                                      (const union acpi_object **)valptr);
 388 }
 389
 390 int acpi_dev_prop_read_single(struct acpi_device *adev, const char *propname,
 391                               enum dev_prop_type proptype, void *val)
 392 {
 393         const union acpi_object *obj;
 394         int ret;
 395
 396         if (!val)
 397                 return -EINVAL;
 398
 399         if (proptype >= DEV_PROP_U8 && proptype <= DEV_PROP_U64) {
 400                 ret = acpi_dev_get_property(adev, propname, ACPI_TYPE_INTEGER, &obj);
 401                 if (ret)
 402                         return ret;
 403
 404                 switch (proptype) {
 405                 case DEV_PROP_U8:
 406                         if (obj->integer.value > U8_MAX)
 407                                 return -EOVERFLOW;
 408                         *(u8 *)val = obj->integer.value;
 409                         break;
 410                 case DEV_PROP_U16:
 411                         if (obj->integer.value > U16_MAX)
 412                                 return -EOVERFLOW;
 413                         *(u16 *)val = obj->integer.value;
 414                         break;
 415                 case DEV_PROP_U32:
 416                         if (obj->integer.value > U32_MAX)
 417                                 return -EOVERFLOW;
 418                         *(u32 *)val = obj->integer.value;
 419                         break;
 420                 default:
 421                         *(u64 *)val = obj->integer.value;
 422                         break;
 423                 }
 424         } else if (proptype == DEV_PROP_STRING) {
 425                 ret = acpi_dev_get_property(adev, propname, ACPI_TYPE_STRING, &obj);
 426                 if (ret)
 427                         return ret;
 428
 429                 *(char **)val = obj->string.pointer;
 430         } else {
 431                 ret = -EINVAL;
 432         }
 433         return ret;
 434 }
 435
 436 static int acpi_copy_property_array_u8(const union acpi_object *items, u8 *val,
 437                                        size_t nval)
 438 {
 439         int i;
 440
 441         for (i = 0; i < nval; i++) {
 442                 if (items[i].type != ACPI_TYPE_INTEGER)
 443                         return -EPROTO;
 444                 if (items[i].integer.value > U8_MAX)
 445                         return -EOVERFLOW;
 446
 447                 val[i] = items[i].integer.value;
 448         }
 449         return 0;
 450 }
 451
 452 static int acpi_copy_property_array_u16(const union acpi_object *items,
 453                                         u16 *val, size_t nval)
 454 {
 455         int i;
 456
 457         for (i = 0; i < nval; i++) {
 458                 if (items[i].type != ACPI_TYPE_INTEGER)
 459                         return -EPROTO;
 460                 if (items[i].integer.value > U16_MAX)
 461                         return -EOVERFLOW;
 462
 463                 val[i] = items[i].integer.value;
 464         }
 465         return 0;
 466 }
 467
 468 static int acpi_copy_property_array_u32(const union acpi_object *items,
 469                                         u32 *val, size_t nval)
 470 {
 471         int i;
 472
 473         for (i = 0; i < nval; i++) {
 474                 if (items[i].type != ACPI_TYPE_INTEGER)
 475                         return -EPROTO;
 476                 if (items[i].integer.value > U32_MAX)
 477                         return -EOVERFLOW;
 478
 479                 val[i] = items[i].integer.value;
 480         }
 481         return 0;
 482 }
 483
 484 static int acpi_copy_property_array_u64(const union acpi_object *items,
 485                                         u64 *val, size_t nval)
 486 {
 487         int i;
 488
 489         for (i = 0; i < nval; i++) {
 490                 if (items[i].type != ACPI_TYPE_INTEGER)
 491                         return -EPROTO;
 492
 493                 val[i] = items[i].integer.value;
 494         }
 495         return 0;
 496 }
 497
 498 static int acpi_copy_property_array_string(const union acpi_object *items,
 499                                            char **val, size_t nval)
 500 {
 501         int i;
 502
 503         for (i = 0; i < nval; i++) {
 504                 if (items[i].type != ACPI_TYPE_STRING)
 505                         return -EPROTO;
 506
 507                 val[i] = items[i].string.pointer;
 508         }
 509         return 0;
 510 }
 511
 512 int acpi_dev_prop_read(struct acpi_device *adev, const char *propname,
 513                        enum dev_prop_type proptype, void *val, size_t nval)
 514 {
 515         const union acpi_object *obj;
 516         const union acpi_object *items;
 517         int ret;
 518
 519         if (val && nval == 1) {
 520                 ret = acpi_dev_prop_read_single(adev, propname, proptype, val);
 521                 if (!ret)
 522                         return ret;
 523         }
 524
 525         ret = acpi_dev_get_property_array(adev, propname, ACPI_TYPE_ANY, &obj);
 526         if (ret)
 527                 return ret;
 528
 529         if (!val)
 530                 return obj->package.count;
 531
 532         if (nval > obj->package.count)
 533                 return -EOVERFLOW;
 534         else if (nval <= 0)
 535                 return -EINVAL;
 536
 537         items = obj->package.elements;
 538
 539         switch (proptype) {
 540         case DEV_PROP_U8:
 541                 ret = acpi_copy_property_array_u8(items, (u8 *)val, nval);
 542                 break;
 543         case DEV_PROP_U16:
 544                 ret = acpi_copy_property_array_u16(items, (u16 *)val, nval);
 545                 break;
 546         case DEV_PROP_U32:
 547                 ret = acpi_copy_property_array_u32(items, (u32 *)val, nval);
 548                 break;
 549         case DEV_PROP_U64:
 550                 ret = acpi_copy_property_array_u64(items, (u64 *)val, nval);
 551                 break;
 552         case DEV_PROP_STRING:
 553                 ret = acpi_copy_property_array_string(items, (char **)val, nval);
 554                 break;
 555         default:
 556                 ret = -EINVAL;
 557                 break;
 558         }
 559         return ret;
 560 }