drivers/acpi/acpica/utdecode.c

   1 /******************************************************************************
   2  *
   3  * Module Name: utdecode - Utility decoding routines (value-to-string)
   4  *
   5  *****************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2016, Intel Corp.
   9  * All rights reserved.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions, and the following disclaimer,
  16  *    without modification.
  17  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  18  *    substantially similar to the "NO WARRANTY" disclaimer below
  19  *    ("Disclaimer") and any redistribution must be conditioned upon
  20  *    including a substantially similar Disclaimer requirement for further
  21  *    binary redistribution.
  22  * 3. Neither the names of the above-listed copyright holders nor the names
  23  *    of any contributors may be used to endorse or promote products derived
  24  *    from this software without specific prior written permission.
  25  *
  26  * Alternatively, this software may be distributed under the terms of the
  27  * GNU General Public License ("GPL") version 2 as published by the Free
  28  * Software Foundation.
  29  *
  30  * NO WARRANTY
  31  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  32  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  33  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
  34  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  35  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  36  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  37  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  38  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  39  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  40  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  41  * POSSIBILITY OF SUCH DAMAGES.
  42  */
  43
  44 #include <acpi/acpi.h>
  45 #include "accommon.h"
  46 #include "acnamesp.h"
  47 #include "amlcode.h"
  48
  49 #define _COMPONENT          ACPI_UTILITIES
  50 ACPI_MODULE_NAME("utdecode")
  51
  52 /*
  53  * Properties of the ACPI Object Types, both internal and external.
  54  * The table is indexed by values of acpi_object_type
  55  */
  56 const u8 acpi_gbl_ns_properties[ACPI_NUM_NS_TYPES] = {
  57         ACPI_NS_NORMAL,         /* 00 Any              */
  58         ACPI_NS_NORMAL,         /* 01 Number           */
  59         ACPI_NS_NORMAL,         /* 02 String           */
  60         ACPI_NS_NORMAL,         /* 03 Buffer           */
  61         ACPI_NS_NORMAL,         /* 04 Package          */
  62         ACPI_NS_NORMAL,         /* 05 field_unit       */
  63         ACPI_NS_NEWSCOPE,       /* 06 Device           */
  64         ACPI_NS_NORMAL,         /* 07 Event            */
  65         ACPI_NS_NEWSCOPE,       /* 08 Method           */
  66         ACPI_NS_NORMAL,         /* 09 Mutex            */
  67         ACPI_NS_NORMAL,         /* 10 Region           */
  68         ACPI_NS_NEWSCOPE,       /* 11 Power            */
  69         ACPI_NS_NEWSCOPE,       /* 12 Processor        */
  70         ACPI_NS_NEWSCOPE,       /* 13 Thermal          */
  71         ACPI_NS_NORMAL,         /* 14 buffer_field     */
  72         ACPI_NS_NORMAL,         /* 15 ddb_handle       */
  73         ACPI_NS_NORMAL,         /* 16 Debug Object     */
  74         ACPI_NS_NORMAL,         /* 17 def_field        */
  75         ACPI_NS_NORMAL,         /* 18 bank_field       */
  76         ACPI_NS_NORMAL,         /* 19 index_field      */
  77         ACPI_NS_NORMAL,         /* 20 Reference        */
  78         ACPI_NS_NORMAL,         /* 21 Alias            */
  79         ACPI_NS_NORMAL,         /* 22 method_alias     */
  80         ACPI_NS_NORMAL,         /* 23 Notify           */
  81         ACPI_NS_NORMAL,         /* 24 Address Handler  */
  82         ACPI_NS_NEWSCOPE | ACPI_NS_LOCAL,       /* 25 Resource Desc    */
  83         ACPI_NS_NEWSCOPE | ACPI_NS_LOCAL,       /* 26 Resource Field   */
  84         ACPI_NS_NEWSCOPE,       /* 27 Scope            */
  85         ACPI_NS_NORMAL,         /* 28 Extra            */
  86         ACPI_NS_NORMAL,         /* 29 Data             */
  87         ACPI_NS_NORMAL          /* 30 Invalid          */
  88 };
  89
  90 /*******************************************************************************
  91  *
  92  * FUNCTION:    acpi_ut_get_region_name
  93  *
  94  * PARAMETERS:  Space ID            - ID for the region
  95  *
  96  * RETURN:      Decoded region space_id name
  97  *
  98  * DESCRIPTION: Translate a Space ID into a name string (Debug only)
  99  *
 100  ******************************************************************************/
 101
 102 /* Region type decoding */
 103
 104 const char *acpi_gbl_region_types[ACPI_NUM_PREDEFINED_REGIONS] = {
 105         "SystemMemory",         /* 0x00 */
 106         "SystemIO",             /* 0x01 */
 107         "PCI_Config",           /* 0x02 */
 108         "EmbeddedControl",      /* 0x03 */
 109         "SMBus",                /* 0x04 */
 110         "SystemCMOS",           /* 0x05 */
 111         "PCIBARTarget",         /* 0x06 */
 112         "IPMI",                 /* 0x07 */
 113         "GeneralPurposeIo",     /* 0x08 */
 114         "GenericSerialBus",     /* 0x09 */
 115         "PCC"                   /* 0x0A */
 116 };
 117
 118 const char *acpi_ut_get_region_name(u8 space_id)
 119 {
 120
 121         if (space_id >= ACPI_USER_REGION_BEGIN) {
 122                 return ("UserDefinedRegion");
 123         } else if (space_id == ACPI_ADR_SPACE_DATA_TABLE) {
 124                 return ("DataTable");
 125         } else if (space_id == ACPI_ADR_SPACE_FIXED_HARDWARE) {
 126                 return ("FunctionalFixedHW");
 127         } else if (space_id >= ACPI_NUM_PREDEFINED_REGIONS) {
 128                 return ("InvalidSpaceId");
 129         }
 130
 131         return (acpi_gbl_region_types[space_id]);
 132 }
 133
 134 /*******************************************************************************
 135  *
 136  * FUNCTION:    acpi_ut_get_event_name
 137  *
 138  * PARAMETERS:  event_id            - Fixed event ID
 139  *
 140  * RETURN:      Decoded event ID name
 141  *
 142  * DESCRIPTION: Translate a Event ID into a name string (Debug only)
 143  *
 144  ******************************************************************************/
 145
 146 /* Event type decoding */
 147
 148 static const char *acpi_gbl_event_types[ACPI_NUM_FIXED_EVENTS] = {
 149         "PM_Timer",
 150         "GlobalLock",
 151         "PowerButton",
 152         "SleepButton",
 153         "RealTimeClock",
 154 };
 155
 156 const char *acpi_ut_get_event_name(u32 event_id)
 157 {
 158
 159         if (event_id > ACPI_EVENT_MAX) {
 160                 return ("InvalidEventID");
 161         }
 162
 163         return (acpi_gbl_event_types[event_id]);
 164 }
 165
 166 /*******************************************************************************
 167  *
 168  * FUNCTION:    acpi_ut_get_type_name
 169  *
 170  * PARAMETERS:  type                - An ACPI object type
 171  *
 172  * RETURN:      Decoded ACPI object type name
 173  *
 174  * DESCRIPTION: Translate a Type ID into a name string (Debug only)
 175  *
 176  ******************************************************************************/
 177
 178 /*
 179  * Elements of acpi_gbl_ns_type_names below must match
 180  * one-to-one with values of acpi_object_type
 181  *
 182  * The type ACPI_TYPE_ANY (Untyped) is used as a "don't care" when searching;
 183  * when stored in a table it really means that we have thus far seen no
 184  * evidence to indicate what type is actually going to be stored for this
 185  & entry.
 186  */
 187 static const char acpi_gbl_bad_type[] = "UNDEFINED";
 188
 189 /* Printable names of the ACPI object types */
 190
 191 static const char *acpi_gbl_ns_type_names[] = {
 192         /* 00 */ "Untyped",
 193         /* 01 */ "Integer",
 194         /* 02 */ "String",
 195         /* 03 */ "Buffer",
 196         /* 04 */ "Package",
 197         /* 05 */ "FieldUnit",
 198         /* 06 */ "Device",
 199         /* 07 */ "Event",
 200         /* 08 */ "Method",
 201         /* 09 */ "Mutex",
 202         /* 10 */ "Region",
 203         /* 11 */ "Power",
 204         /* 12 */ "Processor",
 205         /* 13 */ "Thermal",
 206         /* 14 */ "BufferField",
 207         /* 15 */ "DdbHandle",
 208         /* 16 */ "DebugObject",
 209         /* 17 */ "RegionField",
 210         /* 18 */ "BankField",
 211         /* 19 */ "IndexField",
 212         /* 20 */ "Reference",
 213         /* 21 */ "Alias",
 214         /* 22 */ "MethodAlias",
 215         /* 23 */ "Notify",
 216         /* 24 */ "AddrHandler",
 217         /* 25 */ "ResourceDesc",
 218         /* 26 */ "ResourceFld",
 219         /* 27 */ "Scope",
 220         /* 28 */ "Extra",
 221         /* 29 */ "Data",
 222         /* 30 */ "Invalid"
 223 };
 224
 225 const char *acpi_ut_get_type_name(acpi_object_type type)
 226 {
 227
 228         if (type > ACPI_TYPE_INVALID) {
 229                 return (acpi_gbl_bad_type);
 230         }
 231
 232         return (acpi_gbl_ns_type_names[type]);
 233 }
 234
 235 const char *acpi_ut_get_object_type_name(union acpi_operand_object *obj_desc)
 236 {
 237         ACPI_FUNCTION_TRACE(ut_get_object_type_name);
 238
 239         if (!obj_desc) {
 240                 ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "Null Object Descriptor\n"));
 241                 return_PTR("[NULL Object Descriptor]");
 242         }
 243
 244         /* These descriptor types share a common area */
 245
 246         if ((ACPI_GET_DESCRIPTOR_TYPE(obj_desc) != ACPI_DESC_TYPE_OPERAND) &&
 247             (ACPI_GET_DESCRIPTOR_TYPE(obj_desc) != ACPI_DESC_TYPE_NAMED)) {
 248                 ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
 249                                   "Invalid object descriptor type: 0x%2.2X [%s] (%p)\n",
 250                                   ACPI_GET_DESCRIPTOR_TYPE(obj_desc),
 251                                   acpi_ut_get_descriptor_name(obj_desc),
 252                                   obj_desc));
 253
 254                 return_PTR("Invalid object");
 255         }
 256
 257         return_STR(acpi_ut_get_type_name(obj_desc->common.type));
 258 }
 259
 260 /*******************************************************************************
 261  *
 262  * FUNCTION:    acpi_ut_get_node_name
 263  *
 264  * PARAMETERS:  object               - A namespace node
 265  *
 266  * RETURN:      ASCII name of the node
 267  *
 268  * DESCRIPTION: Validate the node and return the node's ACPI name.
 269  *
 270  ******************************************************************************/
 271
 272 const char *acpi_ut_get_node_name(void *object)
 273 {
 274         struct acpi_namespace_node *node = (struct acpi_namespace_node *)object;
 275
 276         /* Must return a string of exactly 4 characters == ACPI_NAME_SIZE */
 277
 278         if (!object) {
 279                 return ("NULL");
 280         }
 281
 282         /* Check for Root node */
 283
 284         if ((object == ACPI_ROOT_OBJECT) || (object == acpi_gbl_root_node)) {
 285                 return ("\"\\\" ");
 286         }
 287
 288         /* Descriptor must be a namespace node */
 289
 290         if (ACPI_GET_DESCRIPTOR_TYPE(node) != ACPI_DESC_TYPE_NAMED) {
 291                 return ("####");
 292         }
 293
 294         /*
 295          * Ensure name is valid. The name was validated/repaired when the node
 296          * was created, but make sure it has not been corrupted.
 297          */
 298         acpi_ut_repair_name(node->name.ascii);
 299
 300         /* Return the name */
 301
 302         return (node->name.ascii);
 303 }
 304
 305 /*******************************************************************************
 306  *
 307  * FUNCTION:    acpi_ut_get_descriptor_name
 308  *
 309  * PARAMETERS:  object               - An ACPI object
 310  *
 311  * RETURN:      Decoded name of the descriptor type
 312  *
 313  * DESCRIPTION: Validate object and return the descriptor type
 314  *
 315  ******************************************************************************/
 316
 317 /* Printable names of object descriptor types */
 318
 319 static const char *acpi_gbl_desc_type_names[] = {
 320         /* 00 */ "Not a Descriptor",
 321         /* 01 */ "Cached",
 322         /* 02 */ "State-Generic",
 323         /* 03 */ "State-Update",
 324         /* 04 */ "State-Package",
 325         /* 05 */ "State-Control",
 326         /* 06 */ "State-RootParseScope",
 327         /* 07 */ "State-ParseScope",
 328         /* 08 */ "State-WalkScope",
 329         /* 09 */ "State-Result",
 330         /* 10 */ "State-Notify",
 331         /* 11 */ "State-Thread",
 332         /* 12 */ "Walk",
 333         /* 13 */ "Parser",
 334         /* 14 */ "Operand",
 335         /* 15 */ "Node"
 336 };
 337
 338 const char *acpi_ut_get_descriptor_name(void *object)
 339 {
 340
 341         if (!object) {
 342                 return ("NULL OBJECT");
 343         }
 344
 345         if (ACPI_GET_DESCRIPTOR_TYPE(object) > ACPI_DESC_TYPE_MAX) {
 346                 return ("Not a Descriptor");
 347         }
 348
 349         return (acpi_gbl_desc_type_names[ACPI_GET_DESCRIPTOR_TYPE(object)]);
 350 }
 351
 352 /*******************************************************************************
 353  *
 354  * FUNCTION:    acpi_ut_get_reference_name
 355  *
 356  * PARAMETERS:  object               - An ACPI reference object
 357  *
 358  * RETURN:      Decoded name of the type of reference
 359  *
 360  * DESCRIPTION: Decode a reference object sub-type to a string.
 361  *
 362  ******************************************************************************/
 363
 364 /* Printable names of reference object sub-types */
 365
 366 static const char *acpi_gbl_ref_class_names[] = {
 367         /* 00 */ "Local",
 368         /* 01 */ "Argument",
 369         /* 02 */ "RefOf",
 370         /* 03 */ "Index",
 371         /* 04 */ "DdbHandle",
 372         /* 05 */ "Named Object",
 373         /* 06 */ "Debug"
 374 };
 375
 376 const char *acpi_ut_get_reference_name(union acpi_operand_object *object)
 377 {
 378
 379         if (!object) {
 380                 return ("NULL Object");
 381         }
 382
 383         if (ACPI_GET_DESCRIPTOR_TYPE(object) != ACPI_DESC_TYPE_OPERAND) {
 384                 return ("Not an Operand object");
 385         }
 386
 387         if (object->common.type != ACPI_TYPE_LOCAL_REFERENCE) {
 388                 return ("Not a Reference object");
 389         }
 390
 391         if (object->reference.class > ACPI_REFCLASS_MAX) {
 392                 return ("Unknown Reference class");
 393         }
 394
 395         return (acpi_gbl_ref_class_names[object->reference.class]);
 396 }
 397
 398 #if defined(ACPI_DEBUG_OUTPUT) || defined(ACPI_DEBUGGER)
 399 /*
 400  * Strings and procedures used for debug only
 401  */
 402
 403 /*******************************************************************************
 404  *
 405  * FUNCTION:    acpi_ut_get_mutex_name
 406  *
 407  * PARAMETERS:  mutex_id        - The predefined ID for this mutex.
 408  *
 409  * RETURN:      Decoded name of the internal mutex
 410  *
 411  * DESCRIPTION: Translate a mutex ID into a name string (Debug only)
 412  *
 413  ******************************************************************************/
 414
 415 /* Names for internal mutex objects, used for debug output */
 416
 417 static const char *acpi_gbl_mutex_names[ACPI_NUM_MUTEX] = {
 418         "ACPI_MTX_Interpreter",
 419         "ACPI_MTX_Namespace",
 420         "ACPI_MTX_Tables",
 421         "ACPI_MTX_Events",
 422         "ACPI_MTX_Caches",
 423         "ACPI_MTX_Memory",
 424 };
 425
 426 const char *acpi_ut_get_mutex_name(u32 mutex_id)
 427 {
 428
 429         if (mutex_id > ACPI_MAX_MUTEX) {
 430                 return ("Invalid Mutex ID");
 431         }
 432
 433         return (acpi_gbl_mutex_names[mutex_id]);
 434 }
 435
 436 /*******************************************************************************
 437  *
 438  * FUNCTION:    acpi_ut_get_notify_name
 439  *
 440  * PARAMETERS:  notify_value    - Value from the Notify() request
 441  *
 442  * RETURN:      Decoded name for the notify value
 443  *
 444  * DESCRIPTION: Translate a Notify Value to a notify namestring.
 445  *
 446  ******************************************************************************/
 447
 448 /* Names for Notify() values, used for debug output */
 449
 450 static const char *acpi_gbl_generic_notify[ACPI_GENERIC_NOTIFY_MAX + 1] = {
 451         /* 00 */ "Bus Check",
 452         /* 01 */ "Device Check",
 453         /* 02 */ "Device Wake",
 454         /* 03 */ "Eject Request",
 455         /* 04 */ "Device Check Light",
 456         /* 05 */ "Frequency Mismatch",
 457         /* 06 */ "Bus Mode Mismatch",
 458         /* 07 */ "Power Fault",
 459         /* 08 */ "Capabilities Check",
 460         /* 09 */ "Device PLD Check",
 461         /* 0A */ "Reserved",
 462         /* 0B */ "System Locality Update",
 463                                         /* 0C */ "Shutdown Request",
 464                                         /* Reserved in ACPI 6.0 */
 465         /* 0D */ "System Resource Affinity Update"
 466 };
 467
 468 static const char *acpi_gbl_device_notify[5] = {
 469         /* 80 */ "Status Change",
 470         /* 81 */ "Information Change",
 471         /* 82 */ "Device-Specific Change",
 472         /* 83 */ "Device-Specific Change",
 473         /* 84 */ "Reserved"
 474 };
 475
 476 static const char *acpi_gbl_processor_notify[5] = {
 477         /* 80 */ "Performance Capability Change",
 478         /* 81 */ "C-State Change",
 479         /* 82 */ "Throttling Capability Change",
 480         /* 83 */ "Guaranteed Change",
 481         /* 84 */ "Minimum Excursion"
 482 };
 483
 484 static const char *acpi_gbl_thermal_notify[5] = {
 485         /* 80 */ "Thermal Status Change",
 486         /* 81 */ "Thermal Trip Point Change",
 487         /* 82 */ "Thermal Device List Change",
 488         /* 83 */ "Thermal Relationship Change",
 489         /* 84 */ "Reserved"
 490 };
 491
 492 const char *acpi_ut_get_notify_name(u32 notify_value, acpi_object_type type)
 493 {
 494
 495         /* 00 - 0D are "common to all object types" (from ACPI Spec) */
 496
 497         if (notify_value <= ACPI_GENERIC_NOTIFY_MAX) {
 498                 return (acpi_gbl_generic_notify[notify_value]);
 499         }
 500
 501         /* 0E - 7F are reserved */
 502
 503         if (notify_value <= ACPI_MAX_SYS_NOTIFY) {
 504                 return ("Reserved");
 505         }
 506
 507         /* 80 - 84 are per-object-type */
 508
 509         if (notify_value <= ACPI_SPECIFIC_NOTIFY_MAX) {
 510                 switch (type) {
 511                 case ACPI_TYPE_ANY:
 512                 case ACPI_TYPE_DEVICE:
 513                         return (acpi_gbl_device_notify[notify_value - 0x80]);
 514
 515                 case ACPI_TYPE_PROCESSOR:
 516                         return (acpi_gbl_processor_notify[notify_value - 0x80]);
 517
 518                 case ACPI_TYPE_THERMAL:
 519                         return (acpi_gbl_thermal_notify[notify_value - 0x80]);
 520
 521                 default:
 522                         return ("Target object type does not support notifies");
 523                 }
 524         }
 525
 526         /* 84 - BF are device-specific */
 527
 528         if (notify_value <= ACPI_MAX_DEVICE_SPECIFIC_NOTIFY) {
 529                 return ("Device-Specific");
 530         }
 531
 532         /* C0 and above are hardware-specific */
 533
 534         return ("Hardware-Specific");
 535 }
 536
 537 /*******************************************************************************
 538  *
 539  * FUNCTION:    acpi_ut_get_argument_type_name
 540  *
 541  * PARAMETERS:  arg_type            - an ARGP_* parser argument type
 542  *
 543  * RETURN:      Decoded ARGP_* type
 544  *
 545  * DESCRIPTION: Decode an ARGP_* parser type, as defined in the amlcode.h file,
 546  *              and used in the acopcode.h file. For example, ARGP_TERMARG.
 547  *              Used for debug only.
 548  *
 549  ******************************************************************************/
 550
 551 static const char *acpi_gbl_argument_type[20] = {
 552         /* 00 */ "Unknown ARGP",
 553         /* 01 */ "ByteData",
 554         /* 02 */ "ByteList",
 555         /* 03 */ "CharList",
 556         /* 04 */ "DataObject",
 557         /* 05 */ "DataObjectList",
 558         /* 06 */ "DWordData",
 559         /* 07 */ "FieldList",
 560         /* 08 */ "Name",
 561         /* 09 */ "NameString",
 562         /* 0A */ "ObjectList",
 563         /* 0B */ "PackageLength",
 564         /* 0C */ "SuperName",
 565         /* 0D */ "Target",
 566         /* 0E */ "TermArg",
 567         /* 0F */ "TermList",
 568         /* 10 */ "WordData",
 569         /* 11 */ "QWordData",
 570         /* 12 */ "SimpleName",
 571         /* 13 */ "NameOrRef"
 572 };
 573
 574 const char *acpi_ut_get_argument_type_name(u32 arg_type)
 575 {
 576
 577         if (arg_type > ARGP_MAX) {
 578                 return ("Unknown ARGP");
 579         }
 580
 581         return (acpi_gbl_argument_type[arg_type]);
 582 }
 583
 584 #endif
 585
 586 /*******************************************************************************
 587  *
 588  * FUNCTION:    acpi_ut_valid_object_type
 589  *
 590  * PARAMETERS:  type            - Object type to be validated
 591  *
 592  * RETURN:      TRUE if valid object type, FALSE otherwise
 593  *
 594  * DESCRIPTION: Validate an object type
 595  *
 596  ******************************************************************************/
 597
 598 u8 acpi_ut_valid_object_type(acpi_object_type type)
 599 {
 600
 601         if (type > ACPI_TYPE_LOCAL_MAX) {
 602
 603                 /* Note: Assumes all TYPEs are contiguous (external/local) */
 604
 605                 return (FALSE);
 606         }
 607
 608         return (TRUE);
 609 }