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