arch/all-pc/acpica/source/components/utilities/utdecode.c

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