sys/contrib/dev/acpica/utilities/utglobal.c

   1 /******************************************************************************
   2  *
   3  * Module Name: utglobal - Global variables for the ACPI subsystem
   4  *
   5  *****************************************************************************/
   6
   7 /******************************************************************************
   8  *
   9  * 1. Copyright Notice
  10  *
  11  * Some or all of this work - Copyright (c) 1999 - 2009, Intel Corp.
  12  * All rights reserved.
  13  *
  14  * 2. License
  15  *
  16  * 2.1. This is your license from Intel Corp. under its intellectual property
  17  * rights.  You may have additional license terms from the party that provided
  18  * you this software, covering your right to use that party's intellectual
  19  * property rights.
  20  *
  21  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
  22  * copy of the source code appearing in this file ("Covered Code") an
  23  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
  24  * base code distributed originally by Intel ("Original Intel Code") to copy,
  25  * make derivatives, distribute, use and display any portion of the Covered
  26  * Code in any form, with the right to sublicense such rights; and
  27  *
  28  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
  29  * license (with the right to sublicense), under only those claims of Intel
  30  * patents that are infringed by the Original Intel Code, to make, use, sell,
  31  * offer to sell, and import the Covered Code and derivative works thereof
  32  * solely to the minimum extent necessary to exercise the above copyright
  33  * license, and in no event shall the patent license extend to any additions
  34  * to or modifications of the Original Intel Code.  No other license or right
  35  * is granted directly or by implication, estoppel or otherwise;
  36  *
  37  * The above copyright and patent license is granted only if the following
  38  * conditions are met:
  39  *
  40  * 3. Conditions
  41  *
  42  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
  43  * Redistribution of source code of any substantial portion of the Covered
  44  * Code or modification with rights to further distribute source must include
  45  * the above Copyright Notice, the above License, this list of Conditions,
  46  * and the following Disclaimer and Export Compliance provision.  In addition,
  47  * Licensee must cause all Covered Code to which Licensee contributes to
  48  * contain a file documenting the changes Licensee made to create that Covered
  49  * Code and the date of any change.  Licensee must include in that file the
  50  * documentation of any changes made by any predecessor Licensee.  Licensee
  51  * must include a prominent statement that the modification is derived,
  52  * directly or indirectly, from Original Intel Code.
  53  *
  54  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
  55  * Redistribution of source code of any substantial portion of the Covered
  56  * Code or modification without rights to further distribute source must
  57  * include the following Disclaimer and Export Compliance provision in the
  58  * documentation and/or other materials provided with distribution.  In
  59  * addition, Licensee may not authorize further sublicense of source of any
  60  * portion of the Covered Code, and must include terms to the effect that the
  61  * license from Licensee to its licensee is limited to the intellectual
  62  * property embodied in the software Licensee provides to its licensee, and
  63  * not to intellectual property embodied in modifications its licensee may
  64  * make.
  65  *
  66  * 3.3. Redistribution of Executable. Redistribution in executable form of any
  67  * substantial portion of the Covered Code or modification must reproduce the
  68  * above Copyright Notice, and the following Disclaimer and Export Compliance
  69  * provision in the documentation and/or other materials provided with the
  70  * distribution.
  71  *
  72  * 3.4. Intel retains all right, title, and interest in and to the Original
  73  * Intel Code.
  74  *
  75  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
  76  * Intel shall be used in advertising or otherwise to promote the sale, use or
  77  * other dealings in products derived from or relating to the Covered Code
  78  * without prior written authorization from Intel.
  79  *
  80  * 4. Disclaimer and Export Compliance
  81  *
  82  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
  83  * HERE.  ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
  84  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT,  ASSISTANCE,
  85  * INSTALLATION, TRAINING OR OTHER SERVICES.  INTEL WILL NOT PROVIDE ANY
  86  * UPDATES, ENHANCEMENTS OR EXTENSIONS.  INTEL SPECIFICALLY DISCLAIMS ANY
  87  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
  88  * PARTICULAR PURPOSE.
  89  *
  90  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
  91  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
  92  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
  93  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
  94  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
  95  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.  THESE LIMITATIONS
  96  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
  97  * LIMITED REMEDY.
  98  *
  99  * 4.3. Licensee shall not export, either directly or indirectly, any of this
 100  * software or system incorporating such software without first obtaining any
 101  * required license or other approval from the U. S. Department of Commerce or
 102  * any other agency or department of the United States Government.  In the
 103  * event Licensee exports any such software from the United States or
 104  * re-exports any such software from a foreign destination, Licensee shall
 105  * ensure that the distribution and export/re-export of the software is in
 106  * compliance with all laws, regulations, orders, or other restrictions of the
 107  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
 108  * any of its subsidiaries will export/re-export any technical data, process,
 109  * software, or service, directly or indirectly, to any country for which the
 110  * United States government or any agency thereof requires an export license,
 111  * other governmental approval, or letter of assurance, without first obtaining
 112  * such license, approval or letter.
 113  *
 114  *****************************************************************************/
 115
 116 #define __UTGLOBAL_C__
 117 #define DEFINE_ACPI_GLOBALS
 118
 119 #include <contrib/dev/acpica/include/acpi.h>
 120 #include <contrib/dev/acpica/include/accommon.h>
 121 #include <contrib/dev/acpica/include/acnamesp.h>
 122
 123 #define _COMPONENT          ACPI_UTILITIES
 124         ACPI_MODULE_NAME    ("utglobal")
 125
 126
 127 /*******************************************************************************
 128  *
 129  * Static global variable initialization.
 130  *
 131  ******************************************************************************/
 132
 133 /*
 134  * We want the debug switches statically initialized so they
 135  * are already set when the debugger is entered.
 136  */
 137
 138 /* Debug switch - level and trace mask */
 139
 140 #ifdef ACPI_DEBUG_OUTPUT
 141 UINT32                      AcpiDbgLevel = ACPI_DEBUG_DEFAULT;
 142 #else
 143 UINT32                      AcpiDbgLevel = ACPI_NORMAL_DEFAULT;
 144 #endif
 145
 146 /* Debug switch - layer (component) mask */
 147
 148 UINT32                      AcpiDbgLayer = ACPI_COMPONENT_DEFAULT;
 149 UINT32                      AcpiGbl_NestingLevel = 0;
 150
 151 /* Debugger globals */
 152
 153 BOOLEAN                     AcpiGbl_DbTerminateThreads = FALSE;
 154 BOOLEAN                     AcpiGbl_AbortMethod = FALSE;
 155 BOOLEAN                     AcpiGbl_MethodExecuting = FALSE;
 156
 157 /* System flags */
 158
 159 UINT32                      AcpiGbl_StartupFlags = 0;
 160
 161 /* System starts uninitialized */
 162
 163 BOOLEAN                     AcpiGbl_Shutdown = TRUE;
 164
 165 const char                  *AcpiGbl_SleepStateNames[ACPI_S_STATE_COUNT] =
 166 {
 167     "\\_S0_",
 168     "\\_S1_",
 169     "\\_S2_",
 170     "\\_S3_",
 171     "\\_S4_",
 172     "\\_S5_"
 173 };
 174
 175 const char                  *AcpiGbl_HighestDstateNames[4] =
 176 {
 177     "_S1D",
 178     "_S2D",
 179     "_S3D",
 180     "_S4D"
 181 };
 182
 183
 184 /*******************************************************************************
 185  *
 186  * FUNCTION:    AcpiFormatException
 187  *
 188  * PARAMETERS:  Status       - The ACPI_STATUS code to be formatted
 189  *
 190  * RETURN:      A string containing the exception text. A valid pointer is
 191  *              always returned.
 192  *
 193  * DESCRIPTION: This function translates an ACPI exception into an ASCII string
 194  *              It is here instead of utxface.c so it is always present.
 195  *
 196  ******************************************************************************/
 197
 198 const char *
 199 AcpiFormatException (
 200     ACPI_STATUS             Status)
 201 {
 202     const char              *Exception = NULL;
 203
 204
 205     ACPI_FUNCTION_ENTRY ();
 206
 207
 208     Exception = AcpiUtValidateException (Status);
 209     if (!Exception)
 210     {
 211         /* Exception code was not recognized */
 212
 213         ACPI_ERROR ((AE_INFO,
 214             "Unknown exception code: 0x%8.8X", Status));
 215
 216         Exception = "UNKNOWN_STATUS_CODE";
 217     }
 218
 219     return (ACPI_CAST_PTR (const char, Exception));
 220 }
 221
 222 ACPI_EXPORT_SYMBOL (AcpiFormatException)
 223
 224
 225 /*******************************************************************************
 226  *
 227  * Namespace globals
 228  *
 229  ******************************************************************************/
 230
 231 /*
 232  * Predefined ACPI Names (Built-in to the Interpreter)
 233  *
 234  * NOTES:
 235  * 1) _SB_ is defined to be a device to allow \_SB_._INI to be run
 236  *    during the initialization sequence.
 237  * 2) _TZ_ is defined to be a thermal zone in order to allow ASL code to
 238  *    perform a Notify() operation on it.
 239  */
 240 const ACPI_PREDEFINED_NAMES     AcpiGbl_PreDefinedNames[] =
 241 {
 242     {"_GPE",    ACPI_TYPE_LOCAL_SCOPE,      NULL},
 243     {"_PR_",    ACPI_TYPE_LOCAL_SCOPE,      NULL},
 244     {"_SB_",    ACPI_TYPE_DEVICE,           NULL},
 245     {"_SI_",    ACPI_TYPE_LOCAL_SCOPE,      NULL},
 246     {"_TZ_",    ACPI_TYPE_THERMAL,          NULL},
 247     {"_REV",    ACPI_TYPE_INTEGER,          (char *) ACPI_CA_SUPPORT_LEVEL},
 248     {"_OS_",    ACPI_TYPE_STRING,           ACPI_OS_NAME},
 249     {"_GL_",    ACPI_TYPE_MUTEX,            (char *) 1},
 250
 251 #if !defined (ACPI_NO_METHOD_EXECUTION) || defined (ACPI_CONSTANT_EVAL_ONLY)
 252     {"_OSI",    ACPI_TYPE_METHOD,           (char *) 1},
 253 #endif
 254
 255     /* Table terminator */
 256
 257     {NULL,      ACPI_TYPE_ANY,              NULL}
 258 };
 259
 260 /*
 261  * Properties of the ACPI Object Types, both internal and external.
 262  * The table is indexed by values of ACPI_OBJECT_TYPE
 263  */
 264 const UINT8                     AcpiGbl_NsProperties[ACPI_NUM_NS_TYPES] =
 265 {
 266     ACPI_NS_NORMAL,                     /* 00 Any              */
 267     ACPI_NS_NORMAL,                     /* 01 Number           */
 268     ACPI_NS_NORMAL,                     /* 02 String           */
 269     ACPI_NS_NORMAL,                     /* 03 Buffer           */
 270     ACPI_NS_NORMAL,                     /* 04 Package          */
 271     ACPI_NS_NORMAL,                     /* 05 FieldUnit        */
 272     ACPI_NS_NEWSCOPE,                   /* 06 Device           */
 273     ACPI_NS_NORMAL,                     /* 07 Event            */
 274     ACPI_NS_NEWSCOPE,                   /* 08 Method           */
 275     ACPI_NS_NORMAL,                     /* 09 Mutex            */
 276     ACPI_NS_NORMAL,                     /* 10 Region           */
 277     ACPI_NS_NEWSCOPE,                   /* 11 Power            */
 278     ACPI_NS_NEWSCOPE,                   /* 12 Processor        */
 279     ACPI_NS_NEWSCOPE,                   /* 13 Thermal          */
 280     ACPI_NS_NORMAL,                     /* 14 BufferField      */
 281     ACPI_NS_NORMAL,                     /* 15 DdbHandle        */
 282     ACPI_NS_NORMAL,                     /* 16 Debug Object     */
 283     ACPI_NS_NORMAL,                     /* 17 DefField         */
 284     ACPI_NS_NORMAL,                     /* 18 BankField        */
 285     ACPI_NS_NORMAL,                     /* 19 IndexField       */
 286     ACPI_NS_NORMAL,                     /* 20 Reference        */
 287     ACPI_NS_NORMAL,                     /* 21 Alias            */
 288     ACPI_NS_NORMAL,                     /* 22 MethodAlias      */
 289     ACPI_NS_NORMAL,                     /* 23 Notify           */
 290     ACPI_NS_NORMAL,                     /* 24 Address Handler  */
 291     ACPI_NS_NEWSCOPE | ACPI_NS_LOCAL,   /* 25 Resource Desc    */
 292     ACPI_NS_NEWSCOPE | ACPI_NS_LOCAL,   /* 26 Resource Field   */
 293     ACPI_NS_NEWSCOPE,                   /* 27 Scope            */
 294     ACPI_NS_NORMAL,                     /* 28 Extra            */
 295     ACPI_NS_NORMAL,                     /* 29 Data             */
 296     ACPI_NS_NORMAL                      /* 30 Invalid          */
 297 };
 298
 299
 300 /* Hex to ASCII conversion table */
 301
 302 static const char           AcpiGbl_HexToAscii[] =
 303 {
 304     '0','1','2','3','4','5','6','7',
 305     '8','9','A','B','C','D','E','F'
 306 };
 307
 308
 309 /*******************************************************************************
 310  *
 311  * FUNCTION:    AcpiUtHexToAsciiChar
 312  *
 313  * PARAMETERS:  Integer             - Contains the hex digit
 314  *              Position            - bit position of the digit within the
 315  *                                    integer (multiple of 4)
 316  *
 317  * RETURN:      The converted Ascii character
 318  *
 319  * DESCRIPTION: Convert a hex digit to an Ascii character
 320  *
 321  ******************************************************************************/
 322
 323 char
 324 AcpiUtHexToAsciiChar (
 325     ACPI_INTEGER            Integer,
 326     UINT32                  Position)
 327 {
 328
 329     return (AcpiGbl_HexToAscii[(Integer >> Position) & 0xF]);
 330 }
 331
 332
 333 /******************************************************************************
 334  *
 335  * Event and Hardware globals
 336  *
 337  ******************************************************************************/
 338
 339 ACPI_BIT_REGISTER_INFO      AcpiGbl_BitRegisterInfo[ACPI_NUM_BITREG] =
 340 {
 341     /* Name                                     Parent Register             Register Bit Position                   Register Bit Mask       */
 342
 343     /* ACPI_BITREG_TIMER_STATUS         */   {ACPI_REGISTER_PM1_STATUS,   ACPI_BITPOSITION_TIMER_STATUS,          ACPI_BITMASK_TIMER_STATUS},
 344     /* ACPI_BITREG_BUS_MASTER_STATUS    */   {ACPI_REGISTER_PM1_STATUS,   ACPI_BITPOSITION_BUS_MASTER_STATUS,     ACPI_BITMASK_BUS_MASTER_STATUS},
 345     /* ACPI_BITREG_GLOBAL_LOCK_STATUS   */   {ACPI_REGISTER_PM1_STATUS,   ACPI_BITPOSITION_GLOBAL_LOCK_STATUS,    ACPI_BITMASK_GLOBAL_LOCK_STATUS},
 346     /* ACPI_BITREG_POWER_BUTTON_STATUS  */   {ACPI_REGISTER_PM1_STATUS,   ACPI_BITPOSITION_POWER_BUTTON_STATUS,   ACPI_BITMASK_POWER_BUTTON_STATUS},
 347     /* ACPI_BITREG_SLEEP_BUTTON_STATUS  */   {ACPI_REGISTER_PM1_STATUS,   ACPI_BITPOSITION_SLEEP_BUTTON_STATUS,   ACPI_BITMASK_SLEEP_BUTTON_STATUS},
 348     /* ACPI_BITREG_RT_CLOCK_STATUS      */   {ACPI_REGISTER_PM1_STATUS,   ACPI_BITPOSITION_RT_CLOCK_STATUS,       ACPI_BITMASK_RT_CLOCK_STATUS},
 349     /* ACPI_BITREG_WAKE_STATUS          */   {ACPI_REGISTER_PM1_STATUS,   ACPI_BITPOSITION_WAKE_STATUS,           ACPI_BITMASK_WAKE_STATUS},
 350     /* ACPI_BITREG_PCIEXP_WAKE_STATUS   */   {ACPI_REGISTER_PM1_STATUS,   ACPI_BITPOSITION_PCIEXP_WAKE_STATUS,    ACPI_BITMASK_PCIEXP_WAKE_STATUS},
 351
 352     /* ACPI_BITREG_TIMER_ENABLE         */   {ACPI_REGISTER_PM1_ENABLE,   ACPI_BITPOSITION_TIMER_ENABLE,          ACPI_BITMASK_TIMER_ENABLE},
 353     /* ACPI_BITREG_GLOBAL_LOCK_ENABLE   */   {ACPI_REGISTER_PM1_ENABLE,   ACPI_BITPOSITION_GLOBAL_LOCK_ENABLE,    ACPI_BITMASK_GLOBAL_LOCK_ENABLE},
 354     /* ACPI_BITREG_POWER_BUTTON_ENABLE  */   {ACPI_REGISTER_PM1_ENABLE,   ACPI_BITPOSITION_POWER_BUTTON_ENABLE,   ACPI_BITMASK_POWER_BUTTON_ENABLE},
 355     /* ACPI_BITREG_SLEEP_BUTTON_ENABLE  */   {ACPI_REGISTER_PM1_ENABLE,   ACPI_BITPOSITION_SLEEP_BUTTON_ENABLE,   ACPI_BITMASK_SLEEP_BUTTON_ENABLE},
 356     /* ACPI_BITREG_RT_CLOCK_ENABLE      */   {ACPI_REGISTER_PM1_ENABLE,   ACPI_BITPOSITION_RT_CLOCK_ENABLE,       ACPI_BITMASK_RT_CLOCK_ENABLE},
 357     /* ACPI_BITREG_PCIEXP_WAKE_DISABLE  */   {ACPI_REGISTER_PM1_ENABLE,   ACPI_BITPOSITION_PCIEXP_WAKE_DISABLE,   ACPI_BITMASK_PCIEXP_WAKE_DISABLE},
 358
 359     /* ACPI_BITREG_SCI_ENABLE           */   {ACPI_REGISTER_PM1_CONTROL,  ACPI_BITPOSITION_SCI_ENABLE,            ACPI_BITMASK_SCI_ENABLE},
 360     /* ACPI_BITREG_BUS_MASTER_RLD       */   {ACPI_REGISTER_PM1_CONTROL,  ACPI_BITPOSITION_BUS_MASTER_RLD,        ACPI_BITMASK_BUS_MASTER_RLD},
 361     /* ACPI_BITREG_GLOBAL_LOCK_RELEASE  */   {ACPI_REGISTER_PM1_CONTROL,  ACPI_BITPOSITION_GLOBAL_LOCK_RELEASE,   ACPI_BITMASK_GLOBAL_LOCK_RELEASE},
 362     /* ACPI_BITREG_SLEEP_TYPE           */   {ACPI_REGISTER_PM1_CONTROL,  ACPI_BITPOSITION_SLEEP_TYPE,            ACPI_BITMASK_SLEEP_TYPE},
 363     /* ACPI_BITREG_SLEEP_ENABLE         */   {ACPI_REGISTER_PM1_CONTROL,  ACPI_BITPOSITION_SLEEP_ENABLE,          ACPI_BITMASK_SLEEP_ENABLE},
 364
 365     /* ACPI_BITREG_ARB_DIS              */   {ACPI_REGISTER_PM2_CONTROL,  ACPI_BITPOSITION_ARB_DISABLE,           ACPI_BITMASK_ARB_DISABLE}
 366 };
 367
 368
 369 ACPI_FIXED_EVENT_INFO       AcpiGbl_FixedEventInfo[ACPI_NUM_FIXED_EVENTS] =
 370 {
 371     /* ACPI_EVENT_PMTIMER       */  {ACPI_BITREG_TIMER_STATUS,          ACPI_BITREG_TIMER_ENABLE,        ACPI_BITMASK_TIMER_STATUS,          ACPI_BITMASK_TIMER_ENABLE},
 372     /* ACPI_EVENT_GLOBAL        */  {ACPI_BITREG_GLOBAL_LOCK_STATUS,    ACPI_BITREG_GLOBAL_LOCK_ENABLE,  ACPI_BITMASK_GLOBAL_LOCK_STATUS,    ACPI_BITMASK_GLOBAL_LOCK_ENABLE},
 373     /* ACPI_EVENT_POWER_BUTTON  */  {ACPI_BITREG_POWER_BUTTON_STATUS,   ACPI_BITREG_POWER_BUTTON_ENABLE, ACPI_BITMASK_POWER_BUTTON_STATUS,   ACPI_BITMASK_POWER_BUTTON_ENABLE},
 374     /* ACPI_EVENT_SLEEP_BUTTON  */  {ACPI_BITREG_SLEEP_BUTTON_STATUS,   ACPI_BITREG_SLEEP_BUTTON_ENABLE, ACPI_BITMASK_SLEEP_BUTTON_STATUS,   ACPI_BITMASK_SLEEP_BUTTON_ENABLE},
 375     /* ACPI_EVENT_RTC           */  {ACPI_BITREG_RT_CLOCK_STATUS,       ACPI_BITREG_RT_CLOCK_ENABLE,     ACPI_BITMASK_RT_CLOCK_STATUS,       ACPI_BITMASK_RT_CLOCK_ENABLE},
 376 };
 377
 378 /*******************************************************************************
 379  *
 380  * FUNCTION:    AcpiUtGetRegionName
 381  *
 382  * PARAMETERS:  None.
 383  *
 384  * RETURN:      Status
 385  *
 386  * DESCRIPTION: Translate a Space ID into a name string (Debug only)
 387  *
 388  ******************************************************************************/
 389
 390 /* Region type decoding */
 391
 392 const char        *AcpiGbl_RegionTypes[ACPI_NUM_PREDEFINED_REGIONS] =
 393 {
 394     "SystemMemory",
 395     "SystemIO",
 396     "PCI_Config",
 397     "EmbeddedControl",
 398     "SMBus",
 399     "SystemCMOS",
 400     "PCIBARTarget",
 401     "DataTable"
 402 };
 403
 404
 405 char *
 406 AcpiUtGetRegionName (
 407     UINT8                   SpaceId)
 408 {
 409
 410     if (SpaceId >= ACPI_USER_REGION_BEGIN)
 411     {
 412         return ("UserDefinedRegion");
 413     }
 414     else if (SpaceId >= ACPI_NUM_PREDEFINED_REGIONS)
 415     {
 416         return ("InvalidSpaceId");
 417     }
 418
 419     return (ACPI_CAST_PTR (char, AcpiGbl_RegionTypes[SpaceId]));
 420 }
 421
 422
 423 /*******************************************************************************
 424  *
 425  * FUNCTION:    AcpiUtGetEventName
 426  *
 427  * PARAMETERS:  None.
 428  *
 429  * RETURN:      Status
 430  *
 431  * DESCRIPTION: Translate a Event ID into a name string (Debug only)
 432  *
 433  ******************************************************************************/
 434
 435 /* Event type decoding */
 436
 437 static const char        *AcpiGbl_EventTypes[ACPI_NUM_FIXED_EVENTS] =
 438 {
 439     "PM_Timer",
 440     "GlobalLock",
 441     "PowerButton",
 442     "SleepButton",
 443     "RealTimeClock",
 444 };
 445
 446
 447 char *
 448 AcpiUtGetEventName (
 449     UINT32                  EventId)
 450 {
 451
 452     if (EventId > ACPI_EVENT_MAX)
 453     {
 454         return ("InvalidEventID");
 455     }
 456
 457     return (ACPI_CAST_PTR (char, AcpiGbl_EventTypes[EventId]));
 458 }
 459
 460
 461 /*******************************************************************************
 462  *
 463  * FUNCTION:    AcpiUtGetTypeName
 464  *
 465  * PARAMETERS:  None.
 466  *
 467  * RETURN:      Status
 468  *
 469  * DESCRIPTION: Translate a Type ID into a name string (Debug only)
 470  *
 471  ******************************************************************************/
 472
 473 /*
 474  * Elements of AcpiGbl_NsTypeNames below must match
 475  * one-to-one with values of ACPI_OBJECT_TYPE
 476  *
 477  * The type ACPI_TYPE_ANY (Untyped) is used as a "don't care" when searching;
 478  * when stored in a table it really means that we have thus far seen no
 479  * evidence to indicate what type is actually going to be stored for this entry.
 480  */
 481 static const char           AcpiGbl_BadType[] = "UNDEFINED";
 482
 483 /* Printable names of the ACPI object types */
 484
 485 static const char           *AcpiGbl_NsTypeNames[] =
 486 {
 487     /* 00 */ "Untyped",
 488     /* 01 */ "Integer",
 489     /* 02 */ "String",
 490     /* 03 */ "Buffer",
 491     /* 04 */ "Package",
 492     /* 05 */ "FieldUnit",
 493     /* 06 */ "Device",
 494     /* 07 */ "Event",
 495     /* 08 */ "Method",
 496     /* 09 */ "Mutex",
 497     /* 10 */ "Region",
 498     /* 11 */ "Power",
 499     /* 12 */ "Processor",
 500     /* 13 */ "Thermal",
 501     /* 14 */ "BufferField",
 502     /* 15 */ "DdbHandle",
 503     /* 16 */ "DebugObject",
 504     /* 17 */ "RegionField",
 505     /* 18 */ "BankField",
 506     /* 19 */ "IndexField",
 507     /* 20 */ "Reference",
 508     /* 21 */ "Alias",
 509     /* 22 */ "MethodAlias",
 510     /* 23 */ "Notify",
 511     /* 24 */ "AddrHandler",
 512     /* 25 */ "ResourceDesc",
 513     /* 26 */ "ResourceFld",
 514     /* 27 */ "Scope",
 515     /* 28 */ "Extra",
 516     /* 29 */ "Data",
 517     /* 30 */ "Invalid"
 518 };
 519
 520
 521 char *
 522 AcpiUtGetTypeName (
 523     ACPI_OBJECT_TYPE        Type)
 524 {
 525
 526     if (Type > ACPI_TYPE_INVALID)
 527     {
 528         return (ACPI_CAST_PTR (char, AcpiGbl_BadType));
 529     }
 530
 531     return (ACPI_CAST_PTR (char, AcpiGbl_NsTypeNames[Type]));
 532 }
 533
 534
 535 char *
 536 AcpiUtGetObjectTypeName (
 537     ACPI_OPERAND_OBJECT     *ObjDesc)
 538 {
 539
 540     if (!ObjDesc)
 541     {
 542         return ("[NULL Object Descriptor]");
 543     }
 544
 545     return (AcpiUtGetTypeName (ObjDesc->Common.Type));
 546 }
 547
 548
 549 /*******************************************************************************
 550  *
 551  * FUNCTION:    AcpiUtGetNodeName
 552  *
 553  * PARAMETERS:  Object               - A namespace node
 554  *
 555  * RETURN:      Pointer to a string
 556  *
 557  * DESCRIPTION: Validate the node and return the node's ACPI name.
 558  *
 559  ******************************************************************************/
 560
 561 char *
 562 AcpiUtGetNodeName (
 563     void                    *Object)
 564 {
 565     ACPI_NAMESPACE_NODE     *Node = (ACPI_NAMESPACE_NODE *) Object;
 566
 567
 568     /* Must return a string of exactly 4 characters == ACPI_NAME_SIZE */
 569
 570     if (!Object)
 571     {
 572         return ("NULL");
 573     }
 574
 575     /* Check for Root node */
 576
 577     if ((Object == ACPI_ROOT_OBJECT) ||
 578         (Object == AcpiGbl_RootNode))
 579     {
 580         return ("\"\\\" ");
 581     }
 582
 583     /* Descriptor must be a namespace node */
 584
 585     if (ACPI_GET_DESCRIPTOR_TYPE (Node) != ACPI_DESC_TYPE_NAMED)
 586     {
 587         return ("####");
 588     }
 589
 590     /*
 591      * Ensure name is valid. The name was validated/repaired when the node
 592      * was created, but make sure it has not been corrupted.
 593      */
 594     AcpiUtRepairName (Node->Name.Ascii);
 595
 596     /* Return the name */
 597
 598     return (Node->Name.Ascii);
 599 }
 600
 601
 602 /*******************************************************************************
 603  *
 604  * FUNCTION:    AcpiUtGetDescriptorName
 605  *
 606  * PARAMETERS:  Object               - An ACPI object
 607  *
 608  * RETURN:      Pointer to a string
 609  *
 610  * DESCRIPTION: Validate object and return the descriptor type
 611  *
 612  ******************************************************************************/
 613
 614 /* Printable names of object descriptor types */
 615
 616 static const char           *AcpiGbl_DescTypeNames[] =
 617 {
 618     /* 00 */ "Invalid",
 619     /* 01 */ "Cached",
 620     /* 02 */ "State-Generic",
 621     /* 03 */ "State-Update",
 622     /* 04 */ "State-Package",
 623     /* 05 */ "State-Control",
 624     /* 06 */ "State-RootParseScope",
 625     /* 07 */ "State-ParseScope",
 626     /* 08 */ "State-WalkScope",
 627     /* 09 */ "State-Result",
 628     /* 10 */ "State-Notify",
 629     /* 11 */ "State-Thread",
 630     /* 12 */ "Walk",
 631     /* 13 */ "Parser",
 632     /* 14 */ "Operand",
 633     /* 15 */ "Node"
 634 };
 635
 636
 637 char *
 638 AcpiUtGetDescriptorName (
 639     void                    *Object)
 640 {
 641
 642     if (!Object)
 643     {
 644         return ("NULL OBJECT");
 645     }
 646
 647     if (ACPI_GET_DESCRIPTOR_TYPE (Object) > ACPI_DESC_TYPE_MAX)
 648     {
 649         return (ACPI_CAST_PTR (char, AcpiGbl_BadType));
 650     }
 651
 652     return (ACPI_CAST_PTR (char,
 653         AcpiGbl_DescTypeNames[ACPI_GET_DESCRIPTOR_TYPE (Object)]));
 654
 655 }
 656
 657
 658 /*******************************************************************************
 659  *
 660  * FUNCTION:    AcpiUtGetReferenceName
 661  *
 662  * PARAMETERS:  Object               - An ACPI reference object
 663  *
 664  * RETURN:      Pointer to a string
 665  *
 666  * DESCRIPTION: Decode a reference object sub-type to a string.
 667  *
 668  ******************************************************************************/
 669
 670 /* Printable names of reference object sub-types */
 671
 672 static const char           *AcpiGbl_RefClassNames[] =
 673 {
 674     /* 00 */ "Local",
 675     /* 01 */ "Argument",
 676     /* 02 */ "RefOf",
 677     /* 03 */ "Index",
 678     /* 04 */ "DdbHandle",
 679     /* 05 */ "Named Object",
 680     /* 06 */ "Debug"
 681 };
 682
 683 const char *
 684 AcpiUtGetReferenceName (
 685     ACPI_OPERAND_OBJECT     *Object)
 686 {
 687
 688     if (!Object)
 689     {
 690         return ("NULL Object");
 691     }
 692
 693     if (ACPI_GET_DESCRIPTOR_TYPE (Object) != ACPI_DESC_TYPE_OPERAND)
 694     {
 695         return ("Not an Operand object");
 696     }
 697
 698     if (Object->Common.Type != ACPI_TYPE_LOCAL_REFERENCE)
 699     {
 700         return ("Not a Reference object");
 701     }
 702
 703     if (Object->Reference.Class > ACPI_REFCLASS_MAX)
 704     {
 705         return ("Unknown Reference class");
 706     }
 707
 708     return (AcpiGbl_RefClassNames[Object->Reference.Class]);
 709 }
 710
 711
 712 #if defined(ACPI_DEBUG_OUTPUT) || defined(ACPI_DEBUGGER)
 713 /*
 714  * Strings and procedures used for debug only
 715  */
 716
 717 /*******************************************************************************
 718  *
 719  * FUNCTION:    AcpiUtGetMutexName
 720  *
 721  * PARAMETERS:  MutexId         - The predefined ID for this mutex.
 722  *
 723  * RETURN:      String containing the name of the mutex. Always returns a valid
 724  *              pointer.
 725  *
 726  * DESCRIPTION: Translate a mutex ID into a name string (Debug only)
 727  *
 728  ******************************************************************************/
 729
 730 char *
 731 AcpiUtGetMutexName (
 732     UINT32                  MutexId)
 733 {
 734
 735     if (MutexId > ACPI_MAX_MUTEX)
 736     {
 737         return ("Invalid Mutex ID");
 738     }
 739
 740     return (AcpiGbl_MutexNames[MutexId]);
 741 }
 742
 743
 744 /*******************************************************************************
 745  *
 746  * FUNCTION:    AcpiUtGetNotifyName
 747  *
 748  * PARAMETERS:  NotifyValue     - Value from the Notify() request
 749  *
 750  * RETURN:      String corresponding to the Notify Value.
 751  *
 752  * DESCRIPTION: Translate a Notify Value to a notify namestring.
 753  *
 754  ******************************************************************************/
 755
 756 /* Names for Notify() values, used for debug output */
 757
 758 static const char        *AcpiGbl_NotifyValueNames[] =
 759 {
 760     "Bus Check",
 761     "Device Check",
 762     "Device Wake",
 763     "Eject Request",
 764     "Device Check Light",
 765     "Frequency Mismatch",
 766     "Bus Mode Mismatch",
 767     "Power Fault",
 768     "Capabilities Check",
 769     "Device PLD Check",
 770     "Reserved",
 771     "System Locality Update"
 772 };
 773
 774 const char *
 775 AcpiUtGetNotifyName (
 776     UINT32                  NotifyValue)
 777 {
 778
 779     if (NotifyValue <= ACPI_NOTIFY_MAX)
 780     {
 781         return (AcpiGbl_NotifyValueNames[NotifyValue]);
 782     }
 783     else if (NotifyValue <= ACPI_MAX_SYS_NOTIFY)
 784     {
 785         return ("Reserved");
 786     }
 787     else /* Greater or equal to 0x80 */
 788     {
 789         return ("**Device Specific**");
 790     }
 791 }
 792 #endif
 793
 794
 795 /*******************************************************************************
 796  *
 797  * FUNCTION:    AcpiUtValidObjectType
 798  *
 799  * PARAMETERS:  Type            - Object type to be validated
 800  *
 801  * RETURN:      TRUE if valid object type, FALSE otherwise
 802  *
 803  * DESCRIPTION: Validate an object type
 804  *
 805  ******************************************************************************/
 806
 807 BOOLEAN
 808 AcpiUtValidObjectType (
 809     ACPI_OBJECT_TYPE        Type)
 810 {
 811
 812     if (Type > ACPI_TYPE_LOCAL_MAX)
 813     {
 814         /* Note: Assumes all TYPEs are contiguous (external/local) */
 815
 816         return (FALSE);
 817     }
 818
 819     return (TRUE);
 820 }
 821
 822
 823 /*******************************************************************************
 824  *
 825  * FUNCTION:    AcpiUtInitGlobals
 826  *
 827  * PARAMETERS:  None
 828  *
 829  * RETURN:      Status
 830  *
 831  * DESCRIPTION: Init library globals.  All globals that require specific
 832  *              initialization should be initialized here!
 833  *
 834  ******************************************************************************/
 835
 836 ACPI_STATUS
 837 AcpiUtInitGlobals (
 838     void)
 839 {
 840     ACPI_STATUS             Status;
 841     UINT32                  i;
 842
 843
 844     ACPI_FUNCTION_TRACE (UtInitGlobals);
 845
 846
 847     /* Create all memory caches */
 848
 849     Status = AcpiUtCreateCaches ();
 850     if (ACPI_FAILURE (Status))
 851     {
 852         return_ACPI_STATUS (Status);
 853     }
 854
 855     /* Mutex locked flags */
 856
 857     for (i = 0; i < ACPI_NUM_MUTEX; i++)
 858     {
 859         AcpiGbl_MutexInfo[i].Mutex          = NULL;
 860         AcpiGbl_MutexInfo[i].ThreadId       = ACPI_MUTEX_NOT_ACQUIRED;
 861         AcpiGbl_MutexInfo[i].UseCount       = 0;
 862     }
 863
 864     for (i = 0; i < ACPI_NUM_OWNERID_MASKS; i++)
 865     {
 866         AcpiGbl_OwnerIdMask[i]              = 0;
 867     }
 868
 869     /* Last OwnerID is never valid */
 870
 871     AcpiGbl_OwnerIdMask[ACPI_NUM_OWNERID_MASKS - 1] = 0x80000000;
 872
 873     /* Event counters */
 874
 875     AcpiMethodCount                     = 0;
 876     AcpiSciCount                        = 0;
 877     AcpiGpeCount                        = 0;
 878
 879     for (i = 0; i < ACPI_NUM_FIXED_EVENTS; i++)
 880     {
 881         AcpiFixedEventCount[i]              = 0;
 882     }
 883
 884     /* GPE support */
 885
 886     AcpiGbl_GpeXruptListHead            = NULL;
 887     AcpiGbl_GpeFadtBlocks[0]            = NULL;
 888     AcpiGbl_GpeFadtBlocks[1]            = NULL;
 889     AcpiCurrentGpeCount                 = 0;
 890
 891     /* Global handlers */
 892
 893     AcpiGbl_SystemNotify.Handler        = NULL;
 894     AcpiGbl_DeviceNotify.Handler        = NULL;
 895     AcpiGbl_ExceptionHandler            = NULL;
 896     AcpiGbl_InitHandler                 = NULL;
 897     AcpiGbl_TableHandler                = NULL;
 898
 899     /* Global Lock support */
 900
 901     AcpiGbl_GlobalLockSemaphore         = NULL;
 902     AcpiGbl_GlobalLockMutex             = NULL;
 903     AcpiGbl_GlobalLockAcquired          = FALSE;
 904     AcpiGbl_GlobalLockHandle            = 0;
 905     AcpiGbl_GlobalLockPresent           = FALSE;
 906
 907     /* Miscellaneous variables */
 908
 909     AcpiGbl_CmSingleStep                = FALSE;
 910     AcpiGbl_DbTerminateThreads          = FALSE;
 911     AcpiGbl_Shutdown                    = FALSE;
 912     AcpiGbl_NsLookupCount               = 0;
 913     AcpiGbl_PsFindCount                 = 0;
 914     AcpiGbl_AcpiHardwarePresent         = TRUE;
 915     AcpiGbl_LastOwnerIdIndex            = 0;
 916     AcpiGbl_NextOwnerIdOffset           = 0;
 917     AcpiGbl_TraceMethodName             = 0;
 918     AcpiGbl_TraceDbgLevel               = 0;
 919     AcpiGbl_TraceDbgLayer               = 0;
 920     AcpiGbl_DebuggerConfiguration       = DEBUGGER_THREADING;
 921     AcpiGbl_DbOutputFlags               = ACPI_DB_CONSOLE_OUTPUT;
 922     AcpiGbl_OsiData                     = 0;
 923
 924     /* Hardware oriented */
 925
 926     AcpiGbl_EventsInitialized           = FALSE;
 927     AcpiGbl_SystemAwakeAndRunning       = TRUE;
 928
 929     /* Namespace */
 930
 931     AcpiGbl_RootNode                    = NULL;
 932     AcpiGbl_RootNodeStruct.Name.Integer = ACPI_ROOT_NAME;
 933     AcpiGbl_RootNodeStruct.DescriptorType = ACPI_DESC_TYPE_NAMED;
 934     AcpiGbl_RootNodeStruct.Type         = ACPI_TYPE_DEVICE;
 935     AcpiGbl_RootNodeStruct.Child        = NULL;
 936     AcpiGbl_RootNodeStruct.Peer         = NULL;
 937     AcpiGbl_RootNodeStruct.Object       = NULL;
 938     AcpiGbl_RootNodeStruct.Flags        = ANOBJ_END_OF_PEER_LIST;
 939
 940
 941 #ifdef ACPI_DEBUG_OUTPUT
 942     AcpiGbl_LowestStackPointer          = ACPI_CAST_PTR (ACPI_SIZE, ACPI_SIZE_MAX);
 943 #endif
 944
 945 #ifdef ACPI_DBG_TRACK_ALLOCATIONS
 946     AcpiGbl_DisplayFinalMemStats        = FALSE;
 947 #endif
 948
 949     return_ACPI_STATUS (AE_OK);
 950 }
 951
 952 /* Public globals */
 953
 954 ACPI_EXPORT_SYMBOL (AcpiGbl_FADT)
 955 ACPI_EXPORT_SYMBOL (AcpiDbgLevel)
 956 ACPI_EXPORT_SYMBOL (AcpiDbgLayer)
 957 ACPI_EXPORT_SYMBOL (AcpiGpeCount)
 958 ACPI_EXPORT_SYMBOL (AcpiCurrentGpeCount)
 959
 960