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