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