usr/src/uts/intel/io/acpica/utilities/utdecode.c

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