drivers/acpi/utilities/utglobal.c

   1 /******************************************************************************
   2  *
   3  * Module Name: utglobal - Global variables for the ACPI subsystem
   4  *
   5  *****************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2005, R. Byron Moore
   9  * All rights reserved.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions, and the following disclaimer,
  16  *    without modification.
  17  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  18  *    substantially similar to the "NO WARRANTY" disclaimer below
  19  *    ("Disclaimer") and any redistribution must be conditioned upon
  20  *    including a substantially similar Disclaimer requirement for further
  21  *    binary redistribution.
  22  * 3. Neither the names of the above-listed copyright holders nor the names
  23  *    of any contributors may be used to endorse or promote products derived
  24  *    from this software without specific prior written permission.
  25  *
  26  * Alternatively, this software may be distributed under the terms of the
  27  * GNU General Public License ("GPL") version 2 as published by the Free
  28  * Software Foundation.
  29  *
  30  * NO WARRANTY
  31  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  32  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  33  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
  34  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  35  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  36  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  37  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  38  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  39  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  40  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  41  * POSSIBILITY OF SUCH DAMAGES.
  42  */
  43
  44 #define DEFINE_ACPI_GLOBALS
  45
  46 #include <linux/module.h>
  47
  48 #include <acpi/acpi.h>
  49 #include <acpi/acnamesp.h>
  50
  51 #define _COMPONENT          ACPI_UTILITIES
  52          ACPI_MODULE_NAME    ("utglobal")
  53
  54
  55 /******************************************************************************
  56  *
  57  * FUNCTION:    acpi_format_exception
  58  *
  59  * PARAMETERS:  Status       - The acpi_status code to be formatted
  60  *
  61  * RETURN:      A string containing the exception  text
  62  *
  63  * DESCRIPTION: This function translates an ACPI exception into an ASCII string.
  64  *
  65  ******************************************************************************/
  66
  67 const char *
  68 acpi_format_exception (
  69         acpi_status                     status)
  70 {
  71         const char                      *exception = "UNKNOWN_STATUS_CODE";
  72         acpi_status                     sub_status;
  73
  74
  75         ACPI_FUNCTION_NAME ("format_exception");
  76
  77
  78         sub_status = (status & ~AE_CODE_MASK);
  79
  80         switch (status & AE_CODE_MASK) {
  81         case AE_CODE_ENVIRONMENTAL:
  82
  83                 if (sub_status <= AE_CODE_ENV_MAX) {
  84                         exception = acpi_gbl_exception_names_env [sub_status];
  85                         break;
  86                 }
  87                 goto unknown;
  88
  89         case AE_CODE_PROGRAMMER:
  90
  91                 if (sub_status <= AE_CODE_PGM_MAX) {
  92                         exception = acpi_gbl_exception_names_pgm [sub_status -1];
  93                         break;
  94                 }
  95                 goto unknown;
  96
  97         case AE_CODE_ACPI_TABLES:
  98
  99                 if (sub_status <= AE_CODE_TBL_MAX) {
 100                         exception = acpi_gbl_exception_names_tbl [sub_status -1];
 101                         break;
 102                 }
 103                 goto unknown;
 104
 105         case AE_CODE_AML:
 106
 107                 if (sub_status <= AE_CODE_AML_MAX) {
 108                         exception = acpi_gbl_exception_names_aml [sub_status -1];
 109                         break;
 110                 }
 111                 goto unknown;
 112
 113         case AE_CODE_CONTROL:
 114
 115                 if (sub_status <= AE_CODE_CTRL_MAX) {
 116                         exception = acpi_gbl_exception_names_ctrl [sub_status -1];
 117                         break;
 118                 }
 119                 goto unknown;
 120
 121         default:
 122                 goto unknown;
 123         }
 124
 125
 126         return ((const char *) exception);
 127
 128 unknown:
 129
 130         ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Unknown exception code: 0x%8.8X\n", status));
 131         return ((const char *) exception);
 132 }
 133
 134
 135 /******************************************************************************
 136  *
 137  * Static global variable initialization.
 138  *
 139  ******************************************************************************/
 140
 141 /*
 142  * We want the debug switches statically initialized so they
 143  * are already set when the debugger is entered.
 144  */
 145
 146 /* Debug switch - level and trace mask */
 147 u32                                 acpi_dbg_level = ACPI_DEBUG_DEFAULT;
 148 EXPORT_SYMBOL(acpi_dbg_level);
 149
 150 /* Debug switch - layer (component) mask */
 151
 152 u32                                 acpi_dbg_layer = ACPI_COMPONENT_DEFAULT | ACPI_ALL_DRIVERS;
 153 EXPORT_SYMBOL(acpi_dbg_layer);
 154 u32                                 acpi_gbl_nesting_level = 0;
 155
 156
 157 /* Debugger globals */
 158
 159 u8                                  acpi_gbl_db_terminate_threads = FALSE;
 160 u8                                  acpi_gbl_abort_method = FALSE;
 161 u8                                  acpi_gbl_method_executing = FALSE;
 162
 163 /* System flags */
 164
 165 u32                                 acpi_gbl_startup_flags = 0;
 166
 167 /* System starts uninitialized */
 168
 169 u8                                  acpi_gbl_shutdown = TRUE;
 170
 171 const u8                            acpi_gbl_decode_to8bit [8] = {1,2,4,8,16,32,64,128};
 172
 173 const char                          *acpi_gbl_sleep_state_names[ACPI_S_STATE_COUNT] =
 174 {
 175         "\\_S0_",
 176         "\\_S1_",
 177         "\\_S2_",
 178         "\\_S3_",
 179         "\\_S4_",
 180         "\\_S5_"
 181 };
 182
 183 const char                          *acpi_gbl_highest_dstate_names[4] =
 184 {
 185         "_S1D",
 186         "_S2D",
 187         "_S3D",
 188         "_S4D"
 189 };
 190
 191 /*
 192  * Strings supported by the _OSI predefined (internal) method.
 193  * When adding strings, be sure to update ACPI_NUM_OSI_STRINGS.
 194  */
 195 const char                          *acpi_gbl_valid_osi_strings[ACPI_NUM_OSI_STRINGS] =
 196 {
 197         "Linux",
 198         "Windows 2000",
 199         "Windows 2001",
 200         "Windows 2001.1",
 201         "Windows 2001 SP0",
 202         "Windows 2001 SP1",
 203         "Windows 2001 SP2",
 204         "Windows 2001 SP3",
 205         "Windows 2001 SP4"
 206 };
 207
 208
 209 /******************************************************************************
 210  *
 211  * Namespace globals
 212  *
 213  ******************************************************************************/
 214
 215
 216 /*
 217  * Predefined ACPI Names (Built-in to the Interpreter)
 218  *
 219  * NOTES:
 220  * 1) _SB_ is defined to be a device to allow \_SB_._INI to be run
 221  *    during the initialization sequence.
 222  * 2) _TZ_ is defined to be a thermal zone in order to allow ASL code to
 223  *    perform a Notify() operation on it.
 224  */
 225 const struct acpi_predefined_names      acpi_gbl_pre_defined_names[] =
 226 { {"_GPE",    ACPI_TYPE_LOCAL_SCOPE,      NULL},
 227         {"_PR_",    ACPI_TYPE_LOCAL_SCOPE,      NULL},
 228         {"_SB_",    ACPI_TYPE_DEVICE,           NULL},
 229         {"_SI_",    ACPI_TYPE_LOCAL_SCOPE,      NULL},
 230         {"_TZ_",    ACPI_TYPE_THERMAL,          NULL},
 231         {"_REV",    ACPI_TYPE_INTEGER,          (char *) ACPI_CA_SUPPORT_LEVEL},
 232         {"_OS_",    ACPI_TYPE_STRING,           ACPI_OS_NAME},
 233         {"_GL_",    ACPI_TYPE_MUTEX,            (char *) 1},
 234
 235 #if !defined (ACPI_NO_METHOD_EXECUTION) || defined (ACPI_CONSTANT_EVAL_ONLY)
 236         {"_OSI",    ACPI_TYPE_METHOD,           (char *) 1},
 237 #endif
 238         {NULL,      ACPI_TYPE_ANY,              NULL}              /* Table terminator */
 239 };
 240
 241
 242 /*
 243  * Properties of the ACPI Object Types, both internal and external.
 244  * The table is indexed by values of acpi_object_type
 245  */
 246 const u8                                acpi_gbl_ns_properties[] =
 247 {
 248         ACPI_NS_NORMAL,                     /* 00 Any              */
 249         ACPI_NS_NORMAL,                     /* 01 Number           */
 250         ACPI_NS_NORMAL,                     /* 02 String           */
 251         ACPI_NS_NORMAL,                     /* 03 Buffer           */
 252         ACPI_NS_NORMAL,                     /* 04 Package          */
 253         ACPI_NS_NORMAL,                     /* 05 field_unit       */
 254         ACPI_NS_NEWSCOPE,                   /* 06 Device           */
 255         ACPI_NS_NORMAL,                     /* 07 Event            */
 256         ACPI_NS_NEWSCOPE,                   /* 08 Method           */
 257         ACPI_NS_NORMAL,                     /* 09 Mutex            */
 258         ACPI_NS_NORMAL,                     /* 10 Region           */
 259         ACPI_NS_NEWSCOPE,                   /* 11 Power            */
 260         ACPI_NS_NEWSCOPE,                   /* 12 Processor        */
 261         ACPI_NS_NEWSCOPE,                   /* 13 Thermal          */
 262         ACPI_NS_NORMAL,                     /* 14 buffer_field     */
 263         ACPI_NS_NORMAL,                     /* 15 ddb_handle       */
 264         ACPI_NS_NORMAL,                     /* 16 Debug Object     */
 265         ACPI_NS_NORMAL,                     /* 17 def_field        */
 266         ACPI_NS_NORMAL,                     /* 18 bank_field       */
 267         ACPI_NS_NORMAL,                     /* 19 index_field      */
 268         ACPI_NS_NORMAL,                     /* 20 Reference        */
 269         ACPI_NS_NORMAL,                     /* 21 Alias            */
 270         ACPI_NS_NORMAL,                     /* 22 method_alias     */
 271         ACPI_NS_NORMAL,                     /* 23 Notify           */
 272         ACPI_NS_NORMAL,                     /* 24 Address Handler  */
 273         ACPI_NS_NEWSCOPE | ACPI_NS_LOCAL,   /* 25 Resource Desc    */
 274         ACPI_NS_NEWSCOPE | ACPI_NS_LOCAL,   /* 26 Resource Field   */
 275         ACPI_NS_NEWSCOPE,                   /* 27 Scope            */
 276         ACPI_NS_NORMAL,                     /* 28 Extra            */
 277         ACPI_NS_NORMAL,                     /* 29 Data             */
 278         ACPI_NS_NORMAL                      /* 30 Invalid          */
 279 };
 280
 281
 282 /* Hex to ASCII conversion table */
 283
 284 static const char                   acpi_gbl_hex_to_ascii[] =
 285                           {'0','1','2','3','4','5','6','7',
 286                                          '8','9','A','B','C','D','E','F'};
 287
 288 /*****************************************************************************
 289  *
 290  * FUNCTION:    acpi_ut_hex_to_ascii_char
 291  *
 292  * PARAMETERS:  Integer             - Contains the hex digit
 293  *              Position            - bit position of the digit within the
 294  *                                    integer
 295  *
 296  * RETURN:      Ascii character
 297  *
 298  * DESCRIPTION: Convert a hex digit to an ascii character
 299  *
 300  ****************************************************************************/
 301
 302 char
 303 acpi_ut_hex_to_ascii_char (
 304         acpi_integer                    integer,
 305         u32                             position)
 306 {
 307
 308         return (acpi_gbl_hex_to_ascii[(integer >> position) & 0xF]);
 309 }
 310
 311
 312 /******************************************************************************
 313  *
 314  * Table name globals
 315  *
 316  * NOTE: This table includes ONLY the ACPI tables that the subsystem consumes.
 317  * it is NOT an exhaustive list of all possible ACPI tables.  All ACPI tables
 318  * that are not used by the subsystem are simply ignored.
 319  *
 320  * Do NOT add any table to this list that is not consumed directly by this
 321  * subsystem.
 322  *
 323  ******************************************************************************/
 324
 325 struct acpi_table_list              acpi_gbl_table_lists[NUM_ACPI_TABLE_TYPES];
 326
 327 struct acpi_table_support           acpi_gbl_table_data[NUM_ACPI_TABLE_TYPES] =
 328 {
 329         /***********    Name,   Signature, Global typed pointer     Signature size,      Type                  How many allowed?,    Contains valid AML? */
 330
 331         /* RSDP 0 */ {RSDP_NAME, RSDP_SIG, NULL,                    sizeof (RSDP_SIG)-1, ACPI_TABLE_ROOT     | ACPI_TABLE_SINGLE},
 332         /* DSDT 1 */ {DSDT_SIG,  DSDT_SIG, (void *) &acpi_gbl_DSDT, sizeof (DSDT_SIG)-1, ACPI_TABLE_SECONDARY| ACPI_TABLE_SINGLE   | ACPI_TABLE_EXECUTABLE},
 333         /* FADT 2 */ {FADT_SIG,  FADT_SIG, (void *) &acpi_gbl_FADT, sizeof (FADT_SIG)-1, ACPI_TABLE_PRIMARY  | ACPI_TABLE_SINGLE},
 334         /* FACS 3 */ {FACS_SIG,  FACS_SIG, (void *) &acpi_gbl_FACS, sizeof (FACS_SIG)-1, ACPI_TABLE_SECONDARY| ACPI_TABLE_SINGLE},
 335         /* PSDT 4 */ {PSDT_SIG,  PSDT_SIG, NULL,                    sizeof (PSDT_SIG)-1, ACPI_TABLE_PRIMARY  | ACPI_TABLE_MULTIPLE | ACPI_TABLE_EXECUTABLE},
 336         /* SSDT 5 */ {SSDT_SIG,  SSDT_SIG, NULL,                    sizeof (SSDT_SIG)-1, ACPI_TABLE_PRIMARY  | ACPI_TABLE_MULTIPLE | ACPI_TABLE_EXECUTABLE},
 337         /* XSDT 6 */ {XSDT_SIG,  XSDT_SIG, NULL,                    sizeof (RSDT_SIG)-1, ACPI_TABLE_ROOT     | ACPI_TABLE_SINGLE},
 338 };
 339
 340
 341 /******************************************************************************
 342  *
 343  * Event and Hardware globals
 344  *
 345  ******************************************************************************/
 346
 347 struct acpi_bit_register_info       acpi_gbl_bit_register_info[ACPI_NUM_BITREG] =
 348 {
 349         /* Name                                     Parent Register             Register Bit Position                   Register Bit Mask       */
 350
 351         /* ACPI_BITREG_TIMER_STATUS         */   {ACPI_REGISTER_PM1_STATUS,   ACPI_BITPOSITION_TIMER_STATUS,          ACPI_BITMASK_TIMER_STATUS},
 352         /* ACPI_BITREG_BUS_MASTER_STATUS    */   {ACPI_REGISTER_PM1_STATUS,   ACPI_BITPOSITION_BUS_MASTER_STATUS,     ACPI_BITMASK_BUS_MASTER_STATUS},
 353         /* ACPI_BITREG_GLOBAL_LOCK_STATUS   */   {ACPI_REGISTER_PM1_STATUS,   ACPI_BITPOSITION_GLOBAL_LOCK_STATUS,    ACPI_BITMASK_GLOBAL_LOCK_STATUS},
 354         /* ACPI_BITREG_POWER_BUTTON_STATUS  */   {ACPI_REGISTER_PM1_STATUS,   ACPI_BITPOSITION_POWER_BUTTON_STATUS,   ACPI_BITMASK_POWER_BUTTON_STATUS},
 355         /* ACPI_BITREG_SLEEP_BUTTON_STATUS  */   {ACPI_REGISTER_PM1_STATUS,   ACPI_BITPOSITION_SLEEP_BUTTON_STATUS,   ACPI_BITMASK_SLEEP_BUTTON_STATUS},
 356         /* ACPI_BITREG_RT_CLOCK_STATUS      */   {ACPI_REGISTER_PM1_STATUS,   ACPI_BITPOSITION_RT_CLOCK_STATUS,       ACPI_BITMASK_RT_CLOCK_STATUS},
 357         /* ACPI_BITREG_WAKE_STATUS          */   {ACPI_REGISTER_PM1_STATUS,   ACPI_BITPOSITION_WAKE_STATUS,           ACPI_BITMASK_WAKE_STATUS},
 358
 359         /* ACPI_BITREG_TIMER_ENABLE         */   {ACPI_REGISTER_PM1_ENABLE,   ACPI_BITPOSITION_TIMER_ENABLE,          ACPI_BITMASK_TIMER_ENABLE},
 360         /* ACPI_BITREG_GLOBAL_LOCK_ENABLE   */   {ACPI_REGISTER_PM1_ENABLE,   ACPI_BITPOSITION_GLOBAL_LOCK_ENABLE,    ACPI_BITMASK_GLOBAL_LOCK_ENABLE},
 361         /* ACPI_BITREG_POWER_BUTTON_ENABLE  */   {ACPI_REGISTER_PM1_ENABLE,   ACPI_BITPOSITION_POWER_BUTTON_ENABLE,   ACPI_BITMASK_POWER_BUTTON_ENABLE},
 362         /* ACPI_BITREG_SLEEP_BUTTON_ENABLE  */   {ACPI_REGISTER_PM1_ENABLE,   ACPI_BITPOSITION_SLEEP_BUTTON_ENABLE,   ACPI_BITMASK_SLEEP_BUTTON_ENABLE},
 363         /* ACPI_BITREG_RT_CLOCK_ENABLE      */   {ACPI_REGISTER_PM1_ENABLE,   ACPI_BITPOSITION_RT_CLOCK_ENABLE,       ACPI_BITMASK_RT_CLOCK_ENABLE},
 364         /* ACPI_BITREG_WAKE_ENABLE          */   {ACPI_REGISTER_PM1_ENABLE,   0,                                      0},
 365
 366         /* ACPI_BITREG_SCI_ENABLE           */   {ACPI_REGISTER_PM1_CONTROL,  ACPI_BITPOSITION_SCI_ENABLE,            ACPI_BITMASK_SCI_ENABLE},
 367         /* ACPI_BITREG_BUS_MASTER_RLD       */   {ACPI_REGISTER_PM1_CONTROL,  ACPI_BITPOSITION_BUS_MASTER_RLD,        ACPI_BITMASK_BUS_MASTER_RLD},
 368         /* ACPI_BITREG_GLOBAL_LOCK_RELEASE  */   {ACPI_REGISTER_PM1_CONTROL,  ACPI_BITPOSITION_GLOBAL_LOCK_RELEASE,   ACPI_BITMASK_GLOBAL_LOCK_RELEASE},
 369         /* ACPI_BITREG_SLEEP_TYPE_A         */   {ACPI_REGISTER_PM1_CONTROL,  ACPI_BITPOSITION_SLEEP_TYPE_X,          ACPI_BITMASK_SLEEP_TYPE_X},
 370         /* ACPI_BITREG_SLEEP_TYPE_B         */   {ACPI_REGISTER_PM1_CONTROL,  ACPI_BITPOSITION_SLEEP_TYPE_X,          ACPI_BITMASK_SLEEP_TYPE_X},
 371         /* ACPI_BITREG_SLEEP_ENABLE         */   {ACPI_REGISTER_PM1_CONTROL,  ACPI_BITPOSITION_SLEEP_ENABLE,          ACPI_BITMASK_SLEEP_ENABLE},
 372
 373         /* ACPI_BITREG_ARB_DIS              */   {ACPI_REGISTER_PM2_CONTROL,  ACPI_BITPOSITION_ARB_DISABLE,           ACPI_BITMASK_ARB_DISABLE}
 374 };
 375
 376
 377 struct acpi_fixed_event_info        acpi_gbl_fixed_event_info[ACPI_NUM_FIXED_EVENTS] =
 378 {
 379         /* ACPI_EVENT_PMTIMER       */  {ACPI_BITREG_TIMER_STATUS,          ACPI_BITREG_TIMER_ENABLE,        ACPI_BITMASK_TIMER_STATUS,          ACPI_BITMASK_TIMER_ENABLE},
 380         /* ACPI_EVENT_GLOBAL        */  {ACPI_BITREG_GLOBAL_LOCK_STATUS,    ACPI_BITREG_GLOBAL_LOCK_ENABLE,  ACPI_BITMASK_GLOBAL_LOCK_STATUS,    ACPI_BITMASK_GLOBAL_LOCK_ENABLE},
 381         /* ACPI_EVENT_POWER_BUTTON  */  {ACPI_BITREG_POWER_BUTTON_STATUS,   ACPI_BITREG_POWER_BUTTON_ENABLE, ACPI_BITMASK_POWER_BUTTON_STATUS,   ACPI_BITMASK_POWER_BUTTON_ENABLE},
 382         /* ACPI_EVENT_SLEEP_BUTTON  */  {ACPI_BITREG_SLEEP_BUTTON_STATUS,   ACPI_BITREG_SLEEP_BUTTON_ENABLE, ACPI_BITMASK_SLEEP_BUTTON_STATUS,   ACPI_BITMASK_SLEEP_BUTTON_ENABLE},
 383         /* ACPI_EVENT_RTC           */  {ACPI_BITREG_RT_CLOCK_STATUS,       ACPI_BITREG_RT_CLOCK_ENABLE,     ACPI_BITMASK_RT_CLOCK_STATUS,       ACPI_BITMASK_RT_CLOCK_ENABLE},
 384 };
 385
 386 /*****************************************************************************
 387  *
 388  * FUNCTION:    acpi_ut_get_region_name
 389  *
 390  * PARAMETERS:  None.
 391  *
 392  * RETURN:      Status
 393  *
 394  * DESCRIPTION: Translate a Space ID into a name string (Debug only)
 395  *
 396  ****************************************************************************/
 397
 398 /* Region type decoding */
 399
 400 const char                *acpi_gbl_region_types[ACPI_NUM_PREDEFINED_REGIONS] =
 401 {
 402 /*! [Begin] no source code translation (keep these ASL Keywords as-is) */
 403         "SystemMemory",
 404         "SystemIO",
 405         "PCI_Config",
 406         "EmbeddedControl",
 407         "SMBus",
 408         "CMOS",
 409         "PCIBARTarget",
 410         "DataTable"
 411 /*! [End] no source code translation !*/
 412 };
 413
 414
 415 char *
 416 acpi_ut_get_region_name (
 417         u8                              space_id)
 418 {
 419
 420         if (space_id >= ACPI_USER_REGION_BEGIN)
 421         {
 422                 return ("user_defined_region");
 423         }
 424
 425         else if (space_id >= ACPI_NUM_PREDEFINED_REGIONS)
 426         {
 427                 return ("invalid_space_id");
 428         }
 429
 430         return ((char *) acpi_gbl_region_types[space_id]);
 431 }
 432
 433
 434 /*****************************************************************************
 435  *
 436  * FUNCTION:    acpi_ut_get_event_name
 437  *
 438  * PARAMETERS:  None.
 439  *
 440  * RETURN:      Status
 441  *
 442  * DESCRIPTION: Translate a Event ID into a name string (Debug only)
 443  *
 444  ****************************************************************************/
 445
 446 /* Event type decoding */
 447
 448 static const char                *acpi_gbl_event_types[ACPI_NUM_FIXED_EVENTS] =
 449 {
 450         "PM_Timer",
 451         "global_lock",
 452         "power_button",
 453         "sleep_button",
 454         "real_time_clock",
 455 };
 456
 457
 458 char *
 459 acpi_ut_get_event_name (
 460         u32                             event_id)
 461 {
 462
 463         if (event_id > ACPI_EVENT_MAX)
 464         {
 465                 return ("invalid_event_iD");
 466         }
 467
 468         return ((char *) acpi_gbl_event_types[event_id]);
 469 }
 470
 471
 472 /*****************************************************************************
 473  *
 474  * FUNCTION:    acpi_ut_get_type_name
 475  *
 476  * PARAMETERS:  None.
 477  *
 478  * RETURN:      Status
 479  *
 480  * DESCRIPTION: Translate a Type ID into a name string (Debug only)
 481  *
 482  ****************************************************************************/
 483
 484 /*
 485  * Elements of acpi_gbl_ns_type_names below must match
 486  * one-to-one with values of acpi_object_type
 487  *
 488  * The type ACPI_TYPE_ANY (Untyped) is used as a "don't care" when searching; when
 489  * stored in a table it really means that we have thus far seen no evidence to
 490  * indicate what type is actually going to be stored for this entry.
 491  */
 492 static const char                   acpi_gbl_bad_type[] = "UNDEFINED";
 493 #define TYPE_NAME_LENGTH    12                           /* Maximum length of each string */
 494
 495 static const char                   *acpi_gbl_ns_type_names[] = /* printable names of ACPI types */
 496 {
 497         /* 00 */ "Untyped",
 498         /* 01 */ "Integer",
 499         /* 02 */ "String",
 500         /* 03 */ "Buffer",
 501         /* 04 */ "Package",
 502         /* 05 */ "field_unit",
 503         /* 06 */ "Device",
 504         /* 07 */ "Event",
 505         /* 08 */ "Method",
 506         /* 09 */ "Mutex",
 507         /* 10 */ "Region",
 508         /* 11 */ "Power",
 509         /* 12 */ "Processor",
 510         /* 13 */ "Thermal",
 511         /* 14 */ "buffer_field",
 512         /* 15 */ "ddb_handle",
 513         /* 16 */ "debug_object",
 514         /* 17 */ "region_field",
 515         /* 18 */ "bank_field",
 516         /* 19 */ "index_field",
 517         /* 20 */ "Reference",
 518         /* 21 */ "Alias",
 519         /* 22 */ "method_alias",
 520         /* 23 */ "Notify",
 521         /* 24 */ "addr_handler",
 522         /* 25 */ "resource_desc",
 523         /* 26 */ "resource_fld",
 524         /* 27 */ "Scope",
 525         /* 28 */ "Extra",
 526         /* 29 */ "Data",
 527         /* 30 */ "Invalid"
 528 };
 529
 530
 531 char *
 532 acpi_ut_get_type_name (
 533         acpi_object_type                type)
 534 {
 535
 536         if (type > ACPI_TYPE_INVALID)
 537         {
 538                 return ((char *) acpi_gbl_bad_type);
 539         }
 540
 541         return ((char *) acpi_gbl_ns_type_names[type]);
 542 }
 543
 544
 545 char *
 546 acpi_ut_get_object_type_name (
 547         union acpi_operand_object       *obj_desc)
 548 {
 549
 550         if (!obj_desc)
 551         {
 552                 return ("[NULL Object Descriptor]");
 553         }
 554
 555         return (acpi_ut_get_type_name (ACPI_GET_OBJECT_TYPE (obj_desc)));
 556 }
 557
 558
 559 /*****************************************************************************
 560  *
 561  * FUNCTION:    acpi_ut_get_node_name
 562  *
 563  * PARAMETERS:  Object               - A namespace node
 564  *
 565  * RETURN:      Pointer to a string
 566  *
 567  * DESCRIPTION: Validate the node and return the node's ACPI name.
 568  *
 569  ****************************************************************************/
 570
 571 char *
 572 acpi_ut_get_node_name (
 573         void                            *object)
 574 {
 575         struct acpi_namespace_node      *node = (struct acpi_namespace_node *) object;
 576
 577
 578         /* Must return a string of exactly 4 characters == ACPI_NAME_SIZE */
 579
 580         if (!object)
 581         {
 582                 return ("NULL");
 583         }
 584
 585         /* Check for Root node */
 586
 587         if ((object == ACPI_ROOT_OBJECT) ||
 588                 (object == acpi_gbl_root_node))
 589         {
 590                 return ("\"\\\" ");
 591         }
 592
 593         /* Descriptor must be a namespace node */
 594
 595         if (node->descriptor != ACPI_DESC_TYPE_NAMED)
 596         {
 597                 return ("####");
 598         }
 599
 600         /* Name must be a valid ACPI name */
 601
 602         if (!acpi_ut_valid_acpi_name (* (u32 *) node->name.ascii))
 603         {
 604                 return ("????");
 605         }
 606
 607         /* Return the name */
 608
 609         return (node->name.ascii);
 610 }
 611
 612
 613 /*****************************************************************************
 614  *
 615  * FUNCTION:    acpi_ut_get_descriptor_name
 616  *
 617  * PARAMETERS:  Object               - An ACPI object
 618  *
 619  * RETURN:      Pointer to a string
 620  *
 621  * DESCRIPTION: Validate object and return the descriptor type
 622  *
 623  ****************************************************************************/
 624
 625 static const char                   *acpi_gbl_desc_type_names[] = /* printable names of descriptor types */
 626 {
 627         /* 00 */ "Invalid",
 628         /* 01 */ "Cached",
 629         /* 02 */ "State-Generic",
 630         /* 03 */ "State-Update",
 631         /* 04 */ "State-Package",
 632         /* 05 */ "State-Control",
 633         /* 06 */ "State-root_parse_scope",
 634         /* 07 */ "State-parse_scope",
 635         /* 08 */ "State-walk_scope",
 636         /* 09 */ "State-Result",
 637         /* 10 */ "State-Notify",
 638         /* 11 */ "State-Thread",
 639         /* 12 */ "Walk",
 640         /* 13 */ "Parser",
 641         /* 14 */ "Operand",
 642         /* 15 */ "Node"
 643 };
 644
 645
 646 char *
 647 acpi_ut_get_descriptor_name (
 648         void                            *object)
 649 {
 650
 651         if (!object)
 652         {
 653                 return ("NULL OBJECT");
 654         }
 655
 656         if (ACPI_GET_DESCRIPTOR_TYPE (object) > ACPI_DESC_TYPE_MAX)
 657         {
 658                 return ((char *) acpi_gbl_bad_type);
 659         }
 660
 661         return ((char *) acpi_gbl_desc_type_names[ACPI_GET_DESCRIPTOR_TYPE (object)]);
 662
 663 }
 664
 665
 666 #if defined(ACPI_DEBUG_OUTPUT) || defined(ACPI_DEBUGGER)
 667 /*
 668  * Strings and procedures used for debug only
 669  */
 670
 671 /*****************************************************************************
 672  *
 673  * FUNCTION:    acpi_ut_get_mutex_name
 674  *
 675  * PARAMETERS:  None.
 676  *
 677  * RETURN:      Status
 678  *
 679  * DESCRIPTION: Translate a mutex ID into a name string (Debug only)
 680  *
 681  ****************************************************************************/
 682
 683 char *
 684 acpi_ut_get_mutex_name (
 685         u32                             mutex_id)
 686 {
 687
 688         if (mutex_id > MAX_MUTEX)
 689         {
 690                 return ("Invalid Mutex ID");
 691         }
 692
 693         return (acpi_gbl_mutex_names[mutex_id]);
 694 }
 695
 696 #endif
 697
 698
 699 /*****************************************************************************
 700  *
 701  * FUNCTION:    acpi_ut_valid_object_type
 702  *
 703  * PARAMETERS:  Type            - Object type to be validated
 704  *
 705  * RETURN:      TRUE if valid object type
 706  *
 707  * DESCRIPTION: Validate an object type
 708  *
 709  ****************************************************************************/
 710
 711 u8
 712 acpi_ut_valid_object_type (
 713         acpi_object_type                type)
 714 {
 715
 716         if (type > ACPI_TYPE_LOCAL_MAX)
 717         {
 718                 /* Note: Assumes all TYPEs are contiguous (external/local) */
 719
 720                 return (FALSE);
 721         }
 722
 723         return (TRUE);
 724 }
 725
 726
 727 /****************************************************************************
 728  *
 729  * FUNCTION:    acpi_ut_allocate_owner_id
 730  *
 731  * PARAMETERS:  id_type         - Type of ID (method or table)
 732  *
 733  * DESCRIPTION: Allocate a table or method owner id
 734  *
 735  ***************************************************************************/
 736
 737 acpi_owner_id
 738 acpi_ut_allocate_owner_id (
 739         u32                             id_type)
 740 {
 741         acpi_owner_id                   owner_id = 0xFFFF;
 742
 743
 744         ACPI_FUNCTION_TRACE ("ut_allocate_owner_id");
 745
 746
 747         if (ACPI_FAILURE (acpi_ut_acquire_mutex (ACPI_MTX_CACHES)))
 748         {
 749                 return (0);
 750         }
 751
 752         switch (id_type)
 753         {
 754         case ACPI_OWNER_TYPE_TABLE:
 755
 756                 owner_id = acpi_gbl_next_table_owner_id;
 757                 acpi_gbl_next_table_owner_id++;
 758
 759                 /* Check for wraparound */
 760
 761                 if (acpi_gbl_next_table_owner_id == ACPI_FIRST_METHOD_ID)
 762                 {
 763                         acpi_gbl_next_table_owner_id = ACPI_FIRST_TABLE_ID;
 764                         ACPI_REPORT_WARNING (("Table owner ID wraparound\n"));
 765                 }
 766                 break;
 767
 768
 769         case ACPI_OWNER_TYPE_METHOD:
 770
 771                 owner_id = acpi_gbl_next_method_owner_id;
 772                 acpi_gbl_next_method_owner_id++;
 773
 774                 if (acpi_gbl_next_method_owner_id == ACPI_FIRST_TABLE_ID)
 775                 {
 776                         /* Check for wraparound */
 777
 778                         acpi_gbl_next_method_owner_id = ACPI_FIRST_METHOD_ID;
 779                 }
 780                 break;
 781
 782         default:
 783                 break;
 784         }
 785
 786         (void) acpi_ut_release_mutex (ACPI_MTX_CACHES);
 787         return_VALUE (owner_id);
 788 }
 789
 790
 791 /****************************************************************************
 792  *
 793  * FUNCTION:    acpi_ut_init_globals
 794  *
 795  * PARAMETERS:  none
 796  *
 797  * DESCRIPTION: Init library globals.  All globals that require specific
 798  *              initialization should be initialized here!
 799  *
 800  ***************************************************************************/
 801
 802 void
 803 acpi_ut_init_globals (
 804         void)
 805 {
 806         u32                             i;
 807
 808
 809         ACPI_FUNCTION_TRACE ("ut_init_globals");
 810
 811
 812         /* Memory allocation and cache lists */
 813
 814         ACPI_MEMSET (acpi_gbl_memory_lists, 0, sizeof (struct acpi_memory_list) * ACPI_NUM_MEM_LISTS);
 815
 816         acpi_gbl_memory_lists[ACPI_MEM_LIST_STATE].link_offset      = (u16) ACPI_PTR_DIFF (&(((union acpi_generic_state *) NULL)->common.next), NULL);
 817         acpi_gbl_memory_lists[ACPI_MEM_LIST_PSNODE].link_offset     = (u16) ACPI_PTR_DIFF (&(((union acpi_parse_object *) NULL)->common.next), NULL);
 818         acpi_gbl_memory_lists[ACPI_MEM_LIST_PSNODE_EXT].link_offset = (u16) ACPI_PTR_DIFF (&(((union acpi_parse_object *) NULL)->common.next), NULL);
 819         acpi_gbl_memory_lists[ACPI_MEM_LIST_OPERAND].link_offset    = (u16) ACPI_PTR_DIFF (&(((union acpi_operand_object *) NULL)->cache.next), NULL);
 820         acpi_gbl_memory_lists[ACPI_MEM_LIST_WALK].link_offset       = (u16) ACPI_PTR_DIFF (&(((struct acpi_walk_state *) NULL)->next), NULL);
 821
 822         acpi_gbl_memory_lists[ACPI_MEM_LIST_NSNODE].object_size     = sizeof (struct acpi_namespace_node);
 823         acpi_gbl_memory_lists[ACPI_MEM_LIST_STATE].object_size      = sizeof (union acpi_generic_state);
 824         acpi_gbl_memory_lists[ACPI_MEM_LIST_PSNODE].object_size     = sizeof (struct acpi_parse_obj_common);
 825         acpi_gbl_memory_lists[ACPI_MEM_LIST_PSNODE_EXT].object_size = sizeof (struct acpi_parse_obj_named);
 826         acpi_gbl_memory_lists[ACPI_MEM_LIST_OPERAND].object_size    = sizeof (union acpi_operand_object);
 827         acpi_gbl_memory_lists[ACPI_MEM_LIST_WALK].object_size       = sizeof (struct acpi_walk_state);
 828
 829         acpi_gbl_memory_lists[ACPI_MEM_LIST_STATE].max_cache_depth  = ACPI_MAX_STATE_CACHE_DEPTH;
 830         acpi_gbl_memory_lists[ACPI_MEM_LIST_PSNODE].max_cache_depth = ACPI_MAX_PARSE_CACHE_DEPTH;
 831         acpi_gbl_memory_lists[ACPI_MEM_LIST_PSNODE_EXT].max_cache_depth = ACPI_MAX_EXTPARSE_CACHE_DEPTH;
 832         acpi_gbl_memory_lists[ACPI_MEM_LIST_OPERAND].max_cache_depth = ACPI_MAX_OBJECT_CACHE_DEPTH;
 833         acpi_gbl_memory_lists[ACPI_MEM_LIST_WALK].max_cache_depth   = ACPI_MAX_WALK_CACHE_DEPTH;
 834
 835         ACPI_MEM_TRACKING (acpi_gbl_memory_lists[ACPI_MEM_LIST_GLOBAL].list_name    = "Global Memory Allocation");
 836         ACPI_MEM_TRACKING (acpi_gbl_memory_lists[ACPI_MEM_LIST_NSNODE].list_name    = "Namespace Nodes");
 837         ACPI_MEM_TRACKING (acpi_gbl_memory_lists[ACPI_MEM_LIST_STATE].list_name     = "State Object Cache");
 838         ACPI_MEM_TRACKING (acpi_gbl_memory_lists[ACPI_MEM_LIST_PSNODE].list_name    = "Parse Node Cache");
 839         ACPI_MEM_TRACKING (acpi_gbl_memory_lists[ACPI_MEM_LIST_PSNODE_EXT].list_name = "Extended Parse Node Cache");
 840         ACPI_MEM_TRACKING (acpi_gbl_memory_lists[ACPI_MEM_LIST_OPERAND].list_name   = "Operand Object Cache");
 841         ACPI_MEM_TRACKING (acpi_gbl_memory_lists[ACPI_MEM_LIST_WALK].list_name      = "Tree Walk Node Cache");
 842
 843         /* ACPI table structure */
 844
 845         for (i = 0; i < NUM_ACPI_TABLE_TYPES; i++)
 846         {
 847                 acpi_gbl_table_lists[i].next        = NULL;
 848                 acpi_gbl_table_lists[i].count       = 0;
 849         }
 850
 851         /* Mutex locked flags */
 852
 853         for (i = 0; i < NUM_MUTEX; i++)
 854         {
 855                 acpi_gbl_mutex_info[i].mutex        = NULL;
 856                 acpi_gbl_mutex_info[i].owner_id     = ACPI_MUTEX_NOT_ACQUIRED;
 857                 acpi_gbl_mutex_info[i].use_count    = 0;
 858         }
 859
 860         /* GPE support */
 861
 862         acpi_gbl_gpe_xrupt_list_head        = NULL;
 863         acpi_gbl_gpe_fadt_blocks[0]         = NULL;
 864         acpi_gbl_gpe_fadt_blocks[1]         = NULL;
 865
 866         /* Global notify handlers */
 867
 868         acpi_gbl_system_notify.handler      = NULL;
 869         acpi_gbl_device_notify.handler      = NULL;
 870         acpi_gbl_exception_handler          = NULL;
 871         acpi_gbl_init_handler               = NULL;
 872
 873         /* Global "typed" ACPI table pointers */
 874
 875         acpi_gbl_RSDP                       = NULL;
 876         acpi_gbl_XSDT                       = NULL;
 877         acpi_gbl_FACS                       = NULL;
 878         acpi_gbl_FADT                       = NULL;
 879         acpi_gbl_DSDT                       = NULL;
 880
 881         /* Global Lock support */
 882
 883         acpi_gbl_global_lock_acquired       = FALSE;
 884         acpi_gbl_global_lock_thread_count   = 0;
 885         acpi_gbl_global_lock_handle         = 0;
 886
 887         /* Miscellaneous variables */
 888
 889         acpi_gbl_table_flags                = ACPI_PHYSICAL_POINTER;
 890         acpi_gbl_rsdp_original_location     = 0;
 891         acpi_gbl_cm_single_step             = FALSE;
 892         acpi_gbl_db_terminate_threads       = FALSE;
 893         acpi_gbl_shutdown                   = FALSE;
 894         acpi_gbl_ns_lookup_count            = 0;
 895         acpi_gbl_ps_find_count              = 0;
 896         acpi_gbl_acpi_hardware_present      = TRUE;
 897         acpi_gbl_next_table_owner_id        = ACPI_FIRST_TABLE_ID;
 898         acpi_gbl_next_method_owner_id       = ACPI_FIRST_METHOD_ID;
 899         acpi_gbl_debugger_configuration     = DEBUGGER_THREADING;
 900         acpi_gbl_db_output_flags            = ACPI_DB_CONSOLE_OUTPUT;
 901
 902         /* Hardware oriented */
 903
 904         acpi_gbl_events_initialized         = FALSE;
 905         acpi_gbl_system_awake_and_running   = TRUE;
 906
 907         /* Namespace */
 908
 909         acpi_gbl_root_node                  = NULL;
 910
 911         acpi_gbl_root_node_struct.name.integer = ACPI_ROOT_NAME;
 912         acpi_gbl_root_node_struct.descriptor = ACPI_DESC_TYPE_NAMED;
 913         acpi_gbl_root_node_struct.type      = ACPI_TYPE_DEVICE;
 914         acpi_gbl_root_node_struct.child     = NULL;
 915         acpi_gbl_root_node_struct.peer      = NULL;
 916         acpi_gbl_root_node_struct.object    = NULL;
 917         acpi_gbl_root_node_struct.flags     = ANOBJ_END_OF_PEER_LIST;
 918
 919
 920 #ifdef ACPI_DEBUG_OUTPUT
 921         acpi_gbl_lowest_stack_pointer       = ACPI_SIZE_MAX;
 922 #endif
 923
 924         return_VOID;
 925 }
 926
 927