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[] = {
 501         "Bus Check",
 502         "Device Check",
 503         "Device Wake",
 504         "Eject Request",
 505         "Device Check Light",
 506         "Frequency Mismatch",
 507         "Bus Mode Mismatch",
 508         "Power Fault",
 509         "Capabilities Check",
 510         "Device PLD Check",
 511         "Reserved",
 512         "System Locality Update"
 513 };
 514
 515 const char *acpi_ut_get_notify_name(u32 notify_value)
 516 {
 517
 518         if (notify_value <= ACPI_NOTIFY_MAX) {
 519                 return (acpi_gbl_notify_value_names[notify_value]);
 520         } else if (notify_value <= ACPI_MAX_SYS_NOTIFY) {
 521                 return ("Reserved");
 522         } else {                /* Greater or equal to 0x80 */
 523
 524                 return ("**Device Specific**");
 525         }
 526 }
 527 #endif
 528
 529 /*******************************************************************************
 530  *
 531  * FUNCTION:    acpi_ut_valid_object_type
 532  *
 533  * PARAMETERS:  Type            - Object type to be validated
 534  *
 535  * RETURN:      TRUE if valid object type, FALSE otherwise
 536  *
 537  * DESCRIPTION: Validate an object type
 538  *
 539  ******************************************************************************/
 540
 541 u8 acpi_ut_valid_object_type(acpi_object_type type)
 542 {
 543
 544         if (type > ACPI_TYPE_LOCAL_MAX) {
 545
 546                 /* Note: Assumes all TYPEs are contiguous (external/local) */
 547
 548                 return (FALSE);
 549         }
 550
 551         return (TRUE);
 552 }