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

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