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 <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 };
 176
 177 char *acpi_ut_get_region_name(u8 space_id)
 178 {
 179
 180         if (space_id >= ACPI_USER_REGION_BEGIN) {
 181                 return ("UserDefinedRegion");
 182         } else if (space_id == ACPI_ADR_SPACE_DATA_TABLE) {
 183                 return ("DataTable");
 184         } else if (space_id == ACPI_ADR_SPACE_FIXED_HARDWARE) {
 185                 return ("FunctionalFixedHW");
 186         } else if (space_id >= ACPI_NUM_PREDEFINED_REGIONS) {
 187                 return ("InvalidSpaceId");
 188         }
 189
 190         return (ACPI_CAST_PTR(char, acpi_gbl_region_types[space_id]));
 191 }
 192
 193 /*******************************************************************************
 194  *
 195  * FUNCTION:    acpi_ut_get_event_name
 196  *
 197  * PARAMETERS:  event_id            - Fixed event ID
 198  *
 199  * RETURN:      Decoded event ID name
 200  *
 201  * DESCRIPTION: Translate a Event ID into a name string (Debug only)
 202  *
 203  ******************************************************************************/
 204
 205 /* Event type decoding */
 206
 207 static const char *acpi_gbl_event_types[ACPI_NUM_FIXED_EVENTS] = {
 208         "PM_Timer",
 209         "GlobalLock",
 210         "PowerButton",
 211         "SleepButton",
 212         "RealTimeClock",
 213 };
 214
 215 char *acpi_ut_get_event_name(u32 event_id)
 216 {
 217
 218         if (event_id > ACPI_EVENT_MAX) {
 219                 return ("InvalidEventID");
 220         }
 221
 222         return (ACPI_CAST_PTR(char, acpi_gbl_event_types[event_id]));
 223 }
 224
 225 /*******************************************************************************
 226  *
 227  * FUNCTION:    acpi_ut_get_type_name
 228  *
 229  * PARAMETERS:  Type                - An ACPI object type
 230  *
 231  * RETURN:      Decoded ACPI object type name
 232  *
 233  * DESCRIPTION: Translate a Type ID into a name string (Debug only)
 234  *
 235  ******************************************************************************/
 236
 237 /*
 238  * Elements of acpi_gbl_ns_type_names below must match
 239  * one-to-one with values of acpi_object_type
 240  *
 241  * The type ACPI_TYPE_ANY (Untyped) is used as a "don't care" when searching;
 242  * when stored in a table it really means that we have thus far seen no
 243  * evidence to indicate what type is actually going to be stored for this entry.
 244  */
 245 static const char acpi_gbl_bad_type[] = "UNDEFINED";
 246
 247 /* Printable names of the ACPI object types */
 248
 249 static const char *acpi_gbl_ns_type_names[] = {
 250         /* 00 */ "Untyped",
 251         /* 01 */ "Integer",
 252         /* 02 */ "String",
 253         /* 03 */ "Buffer",
 254         /* 04 */ "Package",
 255         /* 05 */ "FieldUnit",
 256         /* 06 */ "Device",
 257         /* 07 */ "Event",
 258         /* 08 */ "Method",
 259         /* 09 */ "Mutex",
 260         /* 10 */ "Region",
 261         /* 11 */ "Power",
 262         /* 12 */ "Processor",
 263         /* 13 */ "Thermal",
 264         /* 14 */ "BufferField",
 265         /* 15 */ "DdbHandle",
 266         /* 16 */ "DebugObject",
 267         /* 17 */ "RegionField",
 268         /* 18 */ "BankField",
 269         /* 19 */ "IndexField",
 270         /* 20 */ "Reference",
 271         /* 21 */ "Alias",
 272         /* 22 */ "MethodAlias",
 273         /* 23 */ "Notify",
 274         /* 24 */ "AddrHandler",
 275         /* 25 */ "ResourceDesc",
 276         /* 26 */ "ResourceFld",
 277         /* 27 */ "Scope",
 278         /* 28 */ "Extra",
 279         /* 29 */ "Data",
 280         /* 30 */ "Invalid"
 281 };
 282
 283 char *acpi_ut_get_type_name(acpi_object_type type)
 284 {
 285
 286         if (type > ACPI_TYPE_INVALID) {
 287                 return (ACPI_CAST_PTR(char, acpi_gbl_bad_type));
 288         }
 289
 290         return (ACPI_CAST_PTR(char, acpi_gbl_ns_type_names[type]));
 291 }
 292
 293 char *acpi_ut_get_object_type_name(union acpi_operand_object *obj_desc)
 294 {
 295
 296         if (!obj_desc) {
 297                 return ("[NULL Object Descriptor]");
 298         }
 299
 300         return (acpi_ut_get_type_name(obj_desc->common.type));
 301 }
 302
 303 /*******************************************************************************
 304  *
 305  * FUNCTION:    acpi_ut_get_node_name
 306  *
 307  * PARAMETERS:  Object               - A namespace node
 308  *
 309  * RETURN:      ASCII name of the node
 310  *
 311  * DESCRIPTION: Validate the node and return the node's ACPI name.
 312  *
 313  ******************************************************************************/
 314
 315 char *acpi_ut_get_node_name(void *object)
 316 {
 317         struct acpi_namespace_node *node = (struct acpi_namespace_node *)object;
 318
 319         /* Must return a string of exactly 4 characters == ACPI_NAME_SIZE */
 320
 321         if (!object) {
 322                 return ("NULL");
 323         }
 324
 325         /* Check for Root node */
 326
 327         if ((object == ACPI_ROOT_OBJECT) || (object == acpi_gbl_root_node)) {
 328                 return ("\"\\\" ");
 329         }
 330
 331         /* Descriptor must be a namespace node */
 332
 333         if (ACPI_GET_DESCRIPTOR_TYPE(node) != ACPI_DESC_TYPE_NAMED) {
 334                 return ("####");
 335         }
 336
 337         /*
 338          * Ensure name is valid. The name was validated/repaired when the node
 339          * was created, but make sure it has not been corrupted.
 340          */
 341         acpi_ut_repair_name(node->name.ascii);
 342
 343         /* Return the name */
 344
 345         return (node->name.ascii);
 346 }
 347
 348 /*******************************************************************************
 349  *
 350  * FUNCTION:    acpi_ut_get_descriptor_name
 351  *
 352  * PARAMETERS:  Object               - An ACPI object
 353  *
 354  * RETURN:      Decoded name of the descriptor type
 355  *
 356  * DESCRIPTION: Validate object and return the descriptor type
 357  *
 358  ******************************************************************************/
 359
 360 /* Printable names of object descriptor types */
 361
 362 static const char *acpi_gbl_desc_type_names[] = {
 363         /* 00 */ "Not a Descriptor",
 364         /* 01 */ "Cached",
 365         /* 02 */ "State-Generic",
 366         /* 03 */ "State-Update",
 367         /* 04 */ "State-Package",
 368         /* 05 */ "State-Control",
 369         /* 06 */ "State-RootParseScope",
 370         /* 07 */ "State-ParseScope",
 371         /* 08 */ "State-WalkScope",
 372         /* 09 */ "State-Result",
 373         /* 10 */ "State-Notify",
 374         /* 11 */ "State-Thread",
 375         /* 12 */ "Walk",
 376         /* 13 */ "Parser",
 377         /* 14 */ "Operand",
 378         /* 15 */ "Node"
 379 };
 380
 381 char *acpi_ut_get_descriptor_name(void *object)
 382 {
 383
 384         if (!object) {
 385                 return ("NULL OBJECT");
 386         }
 387
 388         if (ACPI_GET_DESCRIPTOR_TYPE(object) > ACPI_DESC_TYPE_MAX) {
 389                 return ("Not a Descriptor");
 390         }
 391
 392         return (ACPI_CAST_PTR(char,
 393                               acpi_gbl_desc_type_names[ACPI_GET_DESCRIPTOR_TYPE
 394                                                        (object)]));
 395
 396 }
 397
 398 /*******************************************************************************
 399  *
 400  * FUNCTION:    acpi_ut_get_reference_name
 401  *
 402  * PARAMETERS:  Object               - An ACPI reference object
 403  *
 404  * RETURN:      Decoded name of the type of reference
 405  *
 406  * DESCRIPTION: Decode a reference object sub-type to a string.
 407  *
 408  ******************************************************************************/
 409
 410 /* Printable names of reference object sub-types */
 411
 412 static const char *acpi_gbl_ref_class_names[] = {
 413         /* 00 */ "Local",
 414         /* 01 */ "Argument",
 415         /* 02 */ "RefOf",
 416         /* 03 */ "Index",
 417         /* 04 */ "DdbHandle",
 418         /* 05 */ "Named Object",
 419         /* 06 */ "Debug"
 420 };
 421
 422 const char *acpi_ut_get_reference_name(union acpi_operand_object *object)
 423 {
 424
 425         if (!object) {
 426                 return ("NULL Object");
 427         }
 428
 429         if (ACPI_GET_DESCRIPTOR_TYPE(object) != ACPI_DESC_TYPE_OPERAND) {
 430                 return ("Not an Operand object");
 431         }
 432
 433         if (object->common.type != ACPI_TYPE_LOCAL_REFERENCE) {
 434                 return ("Not a Reference object");
 435         }
 436
 437         if (object->reference.class > ACPI_REFCLASS_MAX) {
 438                 return ("Unknown Reference class");
 439         }
 440
 441         return (acpi_gbl_ref_class_names[object->reference.class]);
 442 }
 443
 444 #if defined(ACPI_DEBUG_OUTPUT) || defined(ACPI_DEBUGGER)
 445 /*
 446  * Strings and procedures used for debug only
 447  */
 448
 449 /*******************************************************************************
 450  *
 451  * FUNCTION:    acpi_ut_get_mutex_name
 452  *
 453  * PARAMETERS:  mutex_id        - The predefined ID for this mutex.
 454  *
 455  * RETURN:      Decoded name of the internal mutex
 456  *
 457  * DESCRIPTION: Translate a mutex ID into a name string (Debug only)
 458  *
 459  ******************************************************************************/
 460
 461 /* Names for internal mutex objects, used for debug output */
 462
 463 static char *acpi_gbl_mutex_names[ACPI_NUM_MUTEX] = {
 464         "ACPI_MTX_Interpreter",
 465         "ACPI_MTX_Namespace",
 466         "ACPI_MTX_Tables",
 467         "ACPI_MTX_Events",
 468         "ACPI_MTX_Caches",
 469         "ACPI_MTX_Memory",
 470         "ACPI_MTX_CommandComplete",
 471         "ACPI_MTX_CommandReady"
 472 };
 473
 474 char *acpi_ut_get_mutex_name(u32 mutex_id)
 475 {
 476
 477         if (mutex_id > ACPI_MAX_MUTEX) {
 478                 return ("Invalid Mutex ID");
 479         }
 480
 481         return (acpi_gbl_mutex_names[mutex_id]);
 482 }
 483
 484 /*******************************************************************************
 485  *
 486  * FUNCTION:    acpi_ut_get_notify_name
 487  *
 488  * PARAMETERS:  notify_value    - Value from the Notify() request
 489  *
 490  * RETURN:      Decoded name for the notify value
 491  *
 492  * DESCRIPTION: Translate a Notify Value to a notify namestring.
 493  *
 494  ******************************************************************************/
 495
 496 /* Names for Notify() values, used for debug output */
 497
 498 static const char *acpi_gbl_notify_value_names[] = {
 499         "Bus Check",
 500         "Device Check",
 501         "Device Wake",
 502         "Eject Request",
 503         "Device Check Light",
 504         "Frequency Mismatch",
 505         "Bus Mode Mismatch",
 506         "Power Fault",
 507         "Capabilities Check",
 508         "Device PLD Check",
 509         "Reserved",
 510         "System Locality Update"
 511 };
 512
 513 const char *acpi_ut_get_notify_name(u32 notify_value)
 514 {
 515
 516         if (notify_value <= ACPI_NOTIFY_MAX) {
 517                 return (acpi_gbl_notify_value_names[notify_value]);
 518         } else if (notify_value <= ACPI_MAX_SYS_NOTIFY) {
 519                 return ("Reserved");
 520         } else {                /* Greater or equal to 0x80 */
 521
 522                 return ("**Device Specific**");
 523         }
 524 }
 525 #endif
 526
 527 /*******************************************************************************
 528  *
 529  * FUNCTION:    acpi_ut_valid_object_type
 530  *
 531  * PARAMETERS:  Type            - Object type to be validated
 532  *
 533  * RETURN:      TRUE if valid object type, FALSE otherwise
 534  *
 535  * DESCRIPTION: Validate an object type
 536  *
 537  ******************************************************************************/
 538
 539 u8 acpi_ut_valid_object_type(acpi_object_type type)
 540 {
 541
 542         if (type > ACPI_TYPE_LOCAL_MAX) {
 543
 544                 /* Note: Assumes all TYPEs are contiguous (external/local) */
 545
 546                 return (FALSE);
 547         }
 548
 549         return (TRUE);
 550 }