kernel/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 - 2015, 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
  48 #define _COMPONENT          ACPI_UTILITIES
  49 ACPI_MODULE_NAME("utdecode")
  50
  51 /*
  52  * Properties of the ACPI Object Types, both internal and external.
  53  * The table is indexed by values of acpi_object_type
  54  */
  55 const u8 acpi_gbl_ns_properties[ACPI_NUM_NS_TYPES] = {
  56         ACPI_NS_NORMAL,         /* 00 Any              */
  57         ACPI_NS_NORMAL,         /* 01 Number           */
  58         ACPI_NS_NORMAL,         /* 02 String           */
  59         ACPI_NS_NORMAL,         /* 03 Buffer           */
  60         ACPI_NS_NORMAL,         /* 04 Package          */
  61         ACPI_NS_NORMAL,         /* 05 field_unit       */
  62         ACPI_NS_NEWSCOPE,       /* 06 Device           */
  63         ACPI_NS_NORMAL,         /* 07 Event            */
  64         ACPI_NS_NEWSCOPE,       /* 08 Method           */
  65         ACPI_NS_NORMAL,         /* 09 Mutex            */
  66         ACPI_NS_NORMAL,         /* 10 Region           */
  67         ACPI_NS_NEWSCOPE,       /* 11 Power            */
  68         ACPI_NS_NEWSCOPE,       /* 12 Processor        */
  69         ACPI_NS_NEWSCOPE,       /* 13 Thermal          */
  70         ACPI_NS_NORMAL,         /* 14 buffer_field     */
  71         ACPI_NS_NORMAL,         /* 15 ddb_handle       */
  72         ACPI_NS_NORMAL,         /* 16 Debug Object     */
  73         ACPI_NS_NORMAL,         /* 17 def_field        */
  74         ACPI_NS_NORMAL,         /* 18 bank_field       */
  75         ACPI_NS_NORMAL,         /* 19 index_field      */
  76         ACPI_NS_NORMAL,         /* 20 Reference        */
  77         ACPI_NS_NORMAL,         /* 21 Alias            */
  78         ACPI_NS_NORMAL,         /* 22 method_alias     */
  79         ACPI_NS_NORMAL,         /* 23 Notify           */
  80         ACPI_NS_NORMAL,         /* 24 Address Handler  */
  81         ACPI_NS_NEWSCOPE | ACPI_NS_LOCAL,       /* 25 Resource Desc    */
  82         ACPI_NS_NEWSCOPE | ACPI_NS_LOCAL,       /* 26 Resource Field   */
  83         ACPI_NS_NEWSCOPE,       /* 27 Scope            */
  84         ACPI_NS_NORMAL,         /* 28 Extra            */
  85         ACPI_NS_NORMAL,         /* 29 Data             */
  86         ACPI_NS_NORMAL          /* 30 Invalid          */
  87 };
  88
  89 /*******************************************************************************
  90  *
  91  * FUNCTION:    acpi_ut_get_region_name
  92  *
  93  * PARAMETERS:  Space ID            - ID for the region
  94  *
  95  * RETURN:      Decoded region space_id name
  96  *
  97  * DESCRIPTION: Translate a Space ID into a name string (Debug only)
  98  *
  99  ******************************************************************************/
 100
 101 /* Region type decoding */
 102
 103 const char *acpi_gbl_region_types[ACPI_NUM_PREDEFINED_REGIONS] = {
 104         "SystemMemory",         /* 0x00 */
 105         "SystemIO",             /* 0x01 */
 106         "PCI_Config",           /* 0x02 */
 107         "EmbeddedControl",      /* 0x03 */
 108         "SMBus",                /* 0x04 */
 109         "SystemCMOS",           /* 0x05 */
 110         "PCIBARTarget",         /* 0x06 */
 111         "IPMI",                 /* 0x07 */
 112         "GeneralPurposeIo",     /* 0x08 */
 113         "GenericSerialBus",     /* 0x09 */
 114         "PCC"                   /* 0x0A */
 115 };
 116
 117 char *acpi_ut_get_region_name(u8 space_id)
 118 {
 119
 120         if (space_id >= ACPI_USER_REGION_BEGIN) {
 121                 return ("UserDefinedRegion");
 122         } else if (space_id == ACPI_ADR_SPACE_DATA_TABLE) {
 123                 return ("DataTable");
 124         } else if (space_id == ACPI_ADR_SPACE_FIXED_HARDWARE) {
 125                 return ("FunctionalFixedHW");
 126         } else if (space_id >= ACPI_NUM_PREDEFINED_REGIONS) {
 127                 return ("InvalidSpaceId");
 128         }
 129
 130         return (ACPI_CAST_PTR(char, acpi_gbl_region_types[space_id]));
 131 }
 132
 133 /*******************************************************************************
 134  *
 135  * FUNCTION:    acpi_ut_get_event_name
 136  *
 137  * PARAMETERS:  event_id            - Fixed event ID
 138  *
 139  * RETURN:      Decoded event ID name
 140  *
 141  * DESCRIPTION: Translate a Event ID into a name string (Debug only)
 142  *
 143  ******************************************************************************/
 144
 145 /* Event type decoding */
 146
 147 static const char *acpi_gbl_event_types[ACPI_NUM_FIXED_EVENTS] = {
 148         "PM_Timer",
 149         "GlobalLock",
 150         "PowerButton",
 151         "SleepButton",
 152         "RealTimeClock",
 153 };
 154
 155 char *acpi_ut_get_event_name(u32 event_id)
 156 {
 157
 158         if (event_id > ACPI_EVENT_MAX) {
 159                 return ("InvalidEventID");
 160         }
 161
 162         return (ACPI_CAST_PTR(char, acpi_gbl_event_types[event_id]));
 163 }
 164
 165 /*******************************************************************************
 166  *
 167  * FUNCTION:    acpi_ut_get_type_name
 168  *
 169  * PARAMETERS:  type                - An ACPI object type
 170  *
 171  * RETURN:      Decoded ACPI object type name
 172  *
 173  * DESCRIPTION: Translate a Type ID into a name string (Debug only)
 174  *
 175  ******************************************************************************/
 176
 177 /*
 178  * Elements of acpi_gbl_ns_type_names below must match
 179  * one-to-one with values of acpi_object_type
 180  *
 181  * The type ACPI_TYPE_ANY (Untyped) is used as a "don't care" when searching;
 182  * when stored in a table it really means that we have thus far seen no
 183  * evidence to indicate what type is actually going to be stored for this entry.
 184  */
 185 static const char acpi_gbl_bad_type[] = "UNDEFINED";
 186
 187 /* Printable names of the ACPI object types */
 188
 189 static const char *acpi_gbl_ns_type_names[] = {
 190         /* 00 */ "Untyped",
 191         /* 01 */ "Integer",
 192         /* 02 */ "String",
 193         /* 03 */ "Buffer",
 194         /* 04 */ "Package",
 195         /* 05 */ "FieldUnit",
 196         /* 06 */ "Device",
 197         /* 07 */ "Event",
 198         /* 08 */ "Method",
 199         /* 09 */ "Mutex",
 200         /* 10 */ "Region",
 201         /* 11 */ "Power",
 202         /* 12 */ "Processor",
 203         /* 13 */ "Thermal",
 204         /* 14 */ "BufferField",
 205         /* 15 */ "DdbHandle",
 206         /* 16 */ "DebugObject",
 207         /* 17 */ "RegionField",
 208         /* 18 */ "BankField",
 209         /* 19 */ "IndexField",
 210         /* 20 */ "Reference",
 211         /* 21 */ "Alias",
 212         /* 22 */ "MethodAlias",
 213         /* 23 */ "Notify",
 214         /* 24 */ "AddrHandler",
 215         /* 25 */ "ResourceDesc",
 216         /* 26 */ "ResourceFld",
 217         /* 27 */ "Scope",
 218         /* 28 */ "Extra",
 219         /* 29 */ "Data",
 220         /* 30 */ "Invalid"
 221 };
 222
 223 char *acpi_ut_get_type_name(acpi_object_type type)
 224 {
 225
 226         if (type > ACPI_TYPE_INVALID) {
 227                 return (ACPI_CAST_PTR(char, acpi_gbl_bad_type));
 228         }
 229
 230         return (ACPI_CAST_PTR(char, acpi_gbl_ns_type_names[type]));
 231 }
 232
 233 char *acpi_ut_get_object_type_name(union acpi_operand_object *obj_desc)
 234 {
 235
 236         if (!obj_desc) {
 237                 return ("[NULL Object Descriptor]");
 238         }
 239
 240         return (acpi_ut_get_type_name(obj_desc->common.type));
 241 }
 242
 243 /*******************************************************************************
 244  *
 245  * FUNCTION:    acpi_ut_get_node_name
 246  *
 247  * PARAMETERS:  object               - A namespace node
 248  *
 249  * RETURN:      ASCII name of the node
 250  *
 251  * DESCRIPTION: Validate the node and return the node's ACPI name.
 252  *
 253  ******************************************************************************/
 254
 255 char *acpi_ut_get_node_name(void *object)
 256 {
 257         struct acpi_namespace_node *node = (struct acpi_namespace_node *)object;
 258
 259         /* Must return a string of exactly 4 characters == ACPI_NAME_SIZE */
 260
 261         if (!object) {
 262                 return ("NULL");
 263         }
 264
 265         /* Check for Root node */
 266
 267         if ((object == ACPI_ROOT_OBJECT) || (object == acpi_gbl_root_node)) {
 268                 return ("\"\\\" ");
 269         }
 270
 271         /* Descriptor must be a namespace node */
 272
 273         if (ACPI_GET_DESCRIPTOR_TYPE(node) != ACPI_DESC_TYPE_NAMED) {
 274                 return ("####");
 275         }
 276
 277         /*
 278          * Ensure name is valid. The name was validated/repaired when the node
 279          * was created, but make sure it has not been corrupted.
 280          */
 281         acpi_ut_repair_name(node->name.ascii);
 282
 283         /* Return the name */
 284
 285         return (node->name.ascii);
 286 }
 287
 288 /*******************************************************************************
 289  *
 290  * FUNCTION:    acpi_ut_get_descriptor_name
 291  *
 292  * PARAMETERS:  object               - An ACPI object
 293  *
 294  * RETURN:      Decoded name of the descriptor type
 295  *
 296  * DESCRIPTION: Validate object and return the descriptor type
 297  *
 298  ******************************************************************************/
 299
 300 /* Printable names of object descriptor types */
 301
 302 static const char *acpi_gbl_desc_type_names[] = {
 303         /* 00 */ "Not a Descriptor",
 304         /* 01 */ "Cached",
 305         /* 02 */ "State-Generic",
 306         /* 03 */ "State-Update",
 307         /* 04 */ "State-Package",
 308         /* 05 */ "State-Control",
 309         /* 06 */ "State-RootParseScope",
 310         /* 07 */ "State-ParseScope",
 311         /* 08 */ "State-WalkScope",
 312         /* 09 */ "State-Result",
 313         /* 10 */ "State-Notify",
 314         /* 11 */ "State-Thread",
 315         /* 12 */ "Walk",
 316         /* 13 */ "Parser",
 317         /* 14 */ "Operand",
 318         /* 15 */ "Node"
 319 };
 320
 321 char *acpi_ut_get_descriptor_name(void *object)
 322 {
 323
 324         if (!object) {
 325                 return ("NULL OBJECT");
 326         }
 327
 328         if (ACPI_GET_DESCRIPTOR_TYPE(object) > ACPI_DESC_TYPE_MAX) {
 329                 return ("Not a Descriptor");
 330         }
 331
 332         return (ACPI_CAST_PTR(char,
 333                               acpi_gbl_desc_type_names[ACPI_GET_DESCRIPTOR_TYPE
 334                                                        (object)]));
 335
 336 }
 337
 338 /*******************************************************************************
 339  *
 340  * FUNCTION:    acpi_ut_get_reference_name
 341  *
 342  * PARAMETERS:  object               - An ACPI reference object
 343  *
 344  * RETURN:      Decoded name of the type of reference
 345  *
 346  * DESCRIPTION: Decode a reference object sub-type to a string.
 347  *
 348  ******************************************************************************/
 349
 350 /* Printable names of reference object sub-types */
 351
 352 static const char *acpi_gbl_ref_class_names[] = {
 353         /* 00 */ "Local",
 354         /* 01 */ "Argument",
 355         /* 02 */ "RefOf",
 356         /* 03 */ "Index",
 357         /* 04 */ "DdbHandle",
 358         /* 05 */ "Named Object",
 359         /* 06 */ "Debug"
 360 };
 361
 362 const char *acpi_ut_get_reference_name(union acpi_operand_object *object)
 363 {
 364
 365         if (!object) {
 366                 return ("NULL Object");
 367         }
 368
 369         if (ACPI_GET_DESCRIPTOR_TYPE(object) != ACPI_DESC_TYPE_OPERAND) {
 370                 return ("Not an Operand object");
 371         }
 372
 373         if (object->common.type != ACPI_TYPE_LOCAL_REFERENCE) {
 374                 return ("Not a Reference object");
 375         }
 376
 377         if (object->reference.class > ACPI_REFCLASS_MAX) {
 378                 return ("Unknown Reference class");
 379         }
 380
 381         return (acpi_gbl_ref_class_names[object->reference.class]);
 382 }
 383
 384 #if defined(ACPI_DEBUG_OUTPUT) || defined(ACPI_DEBUGGER)
 385 /*
 386  * Strings and procedures used for debug only
 387  */
 388
 389 /*******************************************************************************
 390  *
 391  * FUNCTION:    acpi_ut_get_mutex_name
 392  *
 393  * PARAMETERS:  mutex_id        - The predefined ID for this mutex.
 394  *
 395  * RETURN:      Decoded name of the internal mutex
 396  *
 397  * DESCRIPTION: Translate a mutex ID into a name string (Debug only)
 398  *
 399  ******************************************************************************/
 400
 401 /* Names for internal mutex objects, used for debug output */
 402
 403 static char *acpi_gbl_mutex_names[ACPI_NUM_MUTEX] = {
 404         "ACPI_MTX_Interpreter",
 405         "ACPI_MTX_Namespace",
 406         "ACPI_MTX_Tables",
 407         "ACPI_MTX_Events",
 408         "ACPI_MTX_Caches",
 409         "ACPI_MTX_Memory",
 410         "ACPI_MTX_CommandComplete",
 411         "ACPI_MTX_CommandReady"
 412 };
 413
 414 char *acpi_ut_get_mutex_name(u32 mutex_id)
 415 {
 416
 417         if (mutex_id > ACPI_MAX_MUTEX) {
 418                 return ("Invalid Mutex ID");
 419         }
 420
 421         return (acpi_gbl_mutex_names[mutex_id]);
 422 }
 423
 424 /*******************************************************************************
 425  *
 426  * FUNCTION:    acpi_ut_get_notify_name
 427  *
 428  * PARAMETERS:  notify_value    - Value from the Notify() request
 429  *
 430  * RETURN:      Decoded name for the notify value
 431  *
 432  * DESCRIPTION: Translate a Notify Value to a notify namestring.
 433  *
 434  ******************************************************************************/
 435
 436 /* Names for Notify() values, used for debug output */
 437
 438 static const char *acpi_gbl_generic_notify[ACPI_NOTIFY_MAX + 1] = {
 439         /* 00 */ "Bus Check",
 440         /* 01 */ "Device Check",
 441         /* 02 */ "Device Wake",
 442         /* 03 */ "Eject Request",
 443         /* 04 */ "Device Check Light",
 444         /* 05 */ "Frequency Mismatch",
 445         /* 06 */ "Bus Mode Mismatch",
 446         /* 07 */ "Power Fault",
 447         /* 08 */ "Capabilities Check",
 448         /* 09 */ "Device PLD Check",
 449         /* 0A */ "Reserved",
 450         /* 0B */ "System Locality Update",
 451         /* 0C */ "Shutdown Request",
 452         /* 0D */ "System Resource Affinity Update"
 453 };
 454
 455 static const char *acpi_gbl_device_notify[4] = {
 456         /* 80 */ "Status Change",
 457         /* 81 */ "Information Change",
 458         /* 82 */ "Device-Specific Change",
 459         /* 83 */ "Device-Specific Change"
 460 };
 461
 462 static const char *acpi_gbl_processor_notify[4] = {
 463         /* 80 */ "Performance Capability Change",
 464         /* 81 */ "C-State Change",
 465         /* 82 */ "Throttling Capability Change",
 466         /* 83 */ "Device-Specific Change"
 467 };
 468
 469 static const char *acpi_gbl_thermal_notify[4] = {
 470         /* 80 */ "Thermal Status Change",
 471         /* 81 */ "Thermal Trip Point Change",
 472         /* 82 */ "Thermal Device List Change",
 473         /* 83 */ "Thermal Relationship Change"
 474 };
 475
 476 const char *acpi_ut_get_notify_name(u32 notify_value, acpi_object_type type)
 477 {
 478
 479         /* 00 - 0D are common to all object types */
 480
 481         if (notify_value <= ACPI_NOTIFY_MAX) {
 482                 return (acpi_gbl_generic_notify[notify_value]);
 483         }
 484
 485         /* 0D - 7F are reserved */
 486
 487         if (notify_value <= ACPI_MAX_SYS_NOTIFY) {
 488                 return ("Reserved");
 489         }
 490
 491         /* 80 - 83 are per-object-type */
 492
 493         if (notify_value <= 0x83) {
 494                 switch (type) {
 495                 case ACPI_TYPE_ANY:
 496                 case ACPI_TYPE_DEVICE:
 497                         return (acpi_gbl_device_notify[notify_value - 0x80]);
 498
 499                 case ACPI_TYPE_PROCESSOR:
 500                         return (acpi_gbl_processor_notify[notify_value - 0x80]);
 501
 502                 case ACPI_TYPE_THERMAL:
 503                         return (acpi_gbl_thermal_notify[notify_value - 0x80]);
 504
 505                 default:
 506                         return ("Target object type does not support notifies");
 507                 }
 508         }
 509
 510         /* 84 - BF are device-specific */
 511
 512         if (notify_value <= ACPI_MAX_DEVICE_SPECIFIC_NOTIFY) {
 513                 return ("Device-Specific");
 514         }
 515
 516         /* C0 and above are hardware-specific */
 517
 518         return ("Hardware-Specific");
 519 }
 520 #endif
 521
 522 /*******************************************************************************
 523  *
 524  * FUNCTION:    acpi_ut_valid_object_type
 525  *
 526  * PARAMETERS:  type            - Object type to be validated
 527  *
 528  * RETURN:      TRUE if valid object type, FALSE otherwise
 529  *
 530  * DESCRIPTION: Validate an object type
 531  *
 532  ******************************************************************************/
 533
 534 u8 acpi_ut_valid_object_type(acpi_object_type type)
 535 {
 536
 537         if (type > ACPI_TYPE_LOCAL_MAX) {
 538
 539                 /* Note: Assumes all TYPEs are contiguous (external/local) */
 540
 541                 return (FALSE);
 542         }
 543
 544         return (TRUE);
 545 }