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 #include <acpi/acpi.h>
  48 #include <acpi/acnamesp.h>
  49
  50 #define _COMPONENT          ACPI_UTILITIES
  51          ACPI_MODULE_NAME    ("utglobal")
  52
  53
  54 /*******************************************************************************
  55  *
  56  * FUNCTION:    acpi_format_exception
  57  *
  58  * PARAMETERS:  Status       - The acpi_status code to be formatted
  59  *
  60  * RETURN:      A string containing the exception text. A valid pointer is
  61  *              always returned.
  62  *
  63  * DESCRIPTION: This function translates an ACPI exception into an ASCII string.
  64  *
  65  ******************************************************************************/
  66
  67 const char *
  68 acpi_format_exception (
  69         acpi_status                     status)
  70 {
  71         acpi_status                     sub_status;
  72         const char                      *exception = NULL;
  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                 }
  86                 break;
  87
  88         case AE_CODE_PROGRAMMER:
  89
  90                 if (sub_status <= AE_CODE_PGM_MAX) {
  91                         exception = acpi_gbl_exception_names_pgm [sub_status -1];
  92                 }
  93                 break;
  94
  95         case AE_CODE_ACPI_TABLES:
  96
  97                 if (sub_status <= AE_CODE_TBL_MAX) {
  98                         exception = acpi_gbl_exception_names_tbl [sub_status -1];
  99                 }
 100                 break;
 101
 102         case AE_CODE_AML:
 103
 104                 if (sub_status <= AE_CODE_AML_MAX) {
 105                         exception = acpi_gbl_exception_names_aml [sub_status -1];
 106                 }
 107                 break;
 108
 109         case AE_CODE_CONTROL:
 110
 111                 if (sub_status <= AE_CODE_CTRL_MAX) {
 112                         exception = acpi_gbl_exception_names_ctrl [sub_status -1];
 113                 }
 114                 break;
 115
 116         default:
 117                 break;
 118         }
 119
 120         if (!exception) {
 121                 /* Exception code was not recognized */
 122
 123                 ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
 124                         "Unknown exception code: 0x%8.8X\n", status));
 125
 126                 return ((const char *) "UNKNOWN_STATUS_CODE");
 127         }
 128
 129         return ((const char *) exception);
 130 }
 131
 132
 133 /*******************************************************************************
 134  *
 135  * Static global variable initialization.
 136  *
 137  ******************************************************************************/
 138
 139 /*
 140  * We want the debug switches statically initialized so they
 141  * are already set when the debugger is entered.
 142  */
 143
 144 /* Debug switch - level and trace mask */
 145 u32                                 acpi_dbg_level = ACPI_DEBUG_DEFAULT;
 146 EXPORT_SYMBOL(acpi_dbg_level);
 147
 148 /* Debug switch - layer (component) mask */
 149
 150 u32                                 acpi_dbg_layer = ACPI_COMPONENT_DEFAULT | ACPI_ALL_DRIVERS;
 151 EXPORT_SYMBOL(acpi_dbg_layer);
 152 u32                                 acpi_gbl_nesting_level = 0;
 153
 154
 155 /* Debugger globals */
 156
 157 u8                                  acpi_gbl_db_terminate_threads = FALSE;
 158 u8                                  acpi_gbl_abort_method = FALSE;
 159 u8                                  acpi_gbl_method_executing = FALSE;
 160
 161 /* System flags */
 162
 163 u32                                 acpi_gbl_startup_flags = 0;
 164
 165 /* System starts uninitialized */
 166
 167 u8                                  acpi_gbl_shutdown = TRUE;
 168
 169 const u8                            acpi_gbl_decode_to8bit [8] = {1,2,4,8,16,32,64,128};
 170
 171 const char                          *acpi_gbl_sleep_state_names[ACPI_S_STATE_COUNT] =
 172 {
 173         "\\_S0_",
 174         "\\_S1_",
 175         "\\_S2_",
 176         "\\_S3_",
 177         "\\_S4_",
 178         "\\_S5_"
 179 };
 180
 181 const char                          *acpi_gbl_highest_dstate_names[4] =
 182 {
 183         "_S1D",
 184         "_S2D",
 185         "_S3D",
 186         "_S4D"
 187 };
 188
 189 /*
 190  * Strings supported by the _OSI predefined (internal) method.
 191  * When adding strings, be sure to update ACPI_NUM_OSI_STRINGS.
 192  */
 193 const char                          *acpi_gbl_valid_osi_strings[ACPI_NUM_OSI_STRINGS] =
 194 {
 195         /* Operating System Vendor 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         /* Feature Group Strings */
 208
 209         "Extended Address Space Descriptor"
 210 };
 211
 212
 213 /*******************************************************************************
 214  *
 215  * Namespace globals
 216  *
 217  ******************************************************************************/
 218
 219 /*
 220  * Predefined ACPI Names (Built-in to the Interpreter)
 221  *
 222  * NOTES:
 223  * 1) _SB_ is defined to be a device to allow \_SB_._INI to be run
 224  *    during the initialization sequence.
 225  * 2) _TZ_ is defined to be a thermal zone in order to allow ASL code to
 226  *    perform a Notify() operation on it.
 227  */
 228 const struct acpi_predefined_names      acpi_gbl_pre_defined_names[] =
 229 { {"_GPE",    ACPI_TYPE_LOCAL_SCOPE,      NULL},
 230         {"_PR_",    ACPI_TYPE_LOCAL_SCOPE,      NULL},
 231         {"_SB_",    ACPI_TYPE_DEVICE,           NULL},
 232         {"_SI_",    ACPI_TYPE_LOCAL_SCOPE,      NULL},
 233         {"_TZ_",    ACPI_TYPE_THERMAL,          NULL},
 234         {"_REV",    ACPI_TYPE_INTEGER,          (char *) ACPI_CA_SUPPORT_LEVEL},
 235         {"_OS_",    ACPI_TYPE_STRING,           ACPI_OS_NAME},
 236         {"_GL_",    ACPI_TYPE_MUTEX,            (char *) 1},
 237
 238 #if !defined (ACPI_NO_METHOD_EXECUTION) || defined (ACPI_CONSTANT_EVAL_ONLY)
 239         {"_OSI",    ACPI_TYPE_METHOD,           (char *) 1},
 240 #endif
 241
 242         /* Table terminator */
 243
 244         {NULL,      ACPI_TYPE_ANY,              NULL}
 245 };
 246
 247 /*
 248  * Properties of the ACPI Object Types, both internal and external.
 249  * The table is indexed by values of acpi_object_type
 250  */
 251 const u8                                acpi_gbl_ns_properties[] =
 252 {
 253         ACPI_NS_NORMAL,                     /* 00 Any              */
 254         ACPI_NS_NORMAL,                     /* 01 Number           */
 255         ACPI_NS_NORMAL,                     /* 02 String           */
 256         ACPI_NS_NORMAL,                     /* 03 Buffer           */
 257         ACPI_NS_NORMAL,                     /* 04 Package          */
 258         ACPI_NS_NORMAL,                     /* 05 field_unit       */
 259         ACPI_NS_NEWSCOPE,                   /* 06 Device           */
 260         ACPI_NS_NORMAL,                     /* 07 Event            */
 261         ACPI_NS_NEWSCOPE,                   /* 08 Method           */
 262         ACPI_NS_NORMAL,                     /* 09 Mutex            */
 263         ACPI_NS_NORMAL,                     /* 10 Region           */
 264         ACPI_NS_NEWSCOPE,                   /* 11 Power            */
 265         ACPI_NS_NEWSCOPE,                   /* 12 Processor        */
 266         ACPI_NS_NEWSCOPE,                   /* 13 Thermal          */
 267         ACPI_NS_NORMAL,                     /* 14 buffer_field     */
 268         ACPI_NS_NORMAL,                     /* 15 ddb_handle       */
 269         ACPI_NS_NORMAL,                     /* 16 Debug Object     */
 270         ACPI_NS_NORMAL,                     /* 17 def_field        */
 271         ACPI_NS_NORMAL,                     /* 18 bank_field       */
 272         ACPI_NS_NORMAL,                     /* 19 index_field      */
 273         ACPI_NS_NORMAL,                     /* 20 Reference        */
 274         ACPI_NS_NORMAL,                     /* 21 Alias            */
 275         ACPI_NS_NORMAL,                     /* 22 method_alias     */
 276         ACPI_NS_NORMAL,                     /* 23 Notify           */
 277         ACPI_NS_NORMAL,                     /* 24 Address Handler  */
 278         ACPI_NS_NEWSCOPE | ACPI_NS_LOCAL,   /* 25 Resource Desc    */
 279         ACPI_NS_NEWSCOPE | ACPI_NS_LOCAL,   /* 26 Resource Field   */
 280         ACPI_NS_NEWSCOPE,                   /* 27 Scope            */
 281         ACPI_NS_NORMAL,                     /* 28 Extra            */
 282         ACPI_NS_NORMAL,                     /* 29 Data             */
 283         ACPI_NS_NORMAL                      /* 30 Invalid          */
 284 };
 285
 286
 287 /* Hex to ASCII conversion table */
 288
 289 static const char                   acpi_gbl_hex_to_ascii[] =
 290 {
 291         '0','1','2','3','4','5','6','7',
 292         '8','9','A','B','C','D','E','F'
 293 };
 294
 295
 296 /*******************************************************************************
 297  *
 298  * FUNCTION:    acpi_ut_hex_to_ascii_char
 299  *
 300  * PARAMETERS:  Integer             - Contains the hex digit
 301  *              Position            - bit position of the digit within the
 302  *                                    integer (multiple of 4)
 303  *
 304  * RETURN:      The converted Ascii character
 305  *
 306  * DESCRIPTION: Convert a hex digit to an Ascii character
 307  *
 308  ******************************************************************************/
 309
 310 char
 311 acpi_ut_hex_to_ascii_char (
 312         acpi_integer                    integer,
 313         u32                             position)
 314 {
 315
 316         return (acpi_gbl_hex_to_ascii[(integer >> position) & 0xF]);
 317 }
 318
 319
 320 /*******************************************************************************
 321  *
 322  * Table name globals
 323  *
 324  * NOTE: This table includes ONLY the ACPI tables that the subsystem consumes.
 325  * it is NOT an exhaustive list of all possible ACPI tables.  All ACPI tables
 326  * that are not used by the subsystem are simply ignored.
 327  *
 328  * Do NOT add any table to this list that is not consumed directly by this
 329  * subsystem (No MADT, ECDT, SBST, etc.)
 330  *
 331  ******************************************************************************/
 332
 333 struct acpi_table_list              acpi_gbl_table_lists[NUM_ACPI_TABLE_TYPES];
 334
 335 struct acpi_table_support           acpi_gbl_table_data[NUM_ACPI_TABLE_TYPES] =
 336 {
 337         /***********    Name,   Signature, Global typed pointer     Signature size,      Type                  How many allowed?,    Contains valid AML? */
 338
 339         /* RSDP 0 */ {RSDP_NAME, RSDP_SIG, NULL,                    sizeof (RSDP_SIG)-1, ACPI_TABLE_ROOT     | ACPI_TABLE_SINGLE},
 340         /* DSDT 1 */ {DSDT_SIG,  DSDT_SIG, (void *) &acpi_gbl_DSDT, sizeof (DSDT_SIG)-1, ACPI_TABLE_SECONDARY| ACPI_TABLE_SINGLE   | ACPI_TABLE_EXECUTABLE},
 341         /* FADT 2 */ {FADT_SIG,  FADT_SIG, (void *) &acpi_gbl_FADT, sizeof (FADT_SIG)-1, ACPI_TABLE_PRIMARY  | ACPI_TABLE_SINGLE},
 342         /* FACS 3 */ {FACS_SIG,  FACS_SIG, (void *) &acpi_gbl_FACS, sizeof (FACS_SIG)-1, ACPI_TABLE_SECONDARY| ACPI_TABLE_SINGLE},
 343         /* PSDT 4 */ {PSDT_SIG,  PSDT_SIG, NULL,                    sizeof (PSDT_SIG)-1, ACPI_TABLE_PRIMARY  | ACPI_TABLE_MULTIPLE | ACPI_TABLE_EXECUTABLE},
 344         /* SSDT 5 */ {SSDT_SIG,  SSDT_SIG, NULL,                    sizeof (SSDT_SIG)-1, ACPI_TABLE_PRIMARY  | ACPI_TABLE_MULTIPLE | ACPI_TABLE_EXECUTABLE},
 345         /* XSDT 6 */ {XSDT_SIG,  XSDT_SIG, NULL,                    sizeof (RSDT_SIG)-1, ACPI_TABLE_ROOT     | ACPI_TABLE_SINGLE},
 346 };
 347
 348
 349 /******************************************************************************
 350  *
 351  * Event and Hardware globals
 352  *
 353  ******************************************************************************/
 354
 355 struct acpi_bit_register_info       acpi_gbl_bit_register_info[ACPI_NUM_BITREG] =
 356 {
 357         /* Name                                     Parent Register             Register Bit Position                   Register Bit Mask       */
 358
 359         /* ACPI_BITREG_TIMER_STATUS         */   {ACPI_REGISTER_PM1_STATUS,   ACPI_BITPOSITION_TIMER_STATUS,          ACPI_BITMASK_TIMER_STATUS},
 360         /* ACPI_BITREG_BUS_MASTER_STATUS    */   {ACPI_REGISTER_PM1_STATUS,   ACPI_BITPOSITION_BUS_MASTER_STATUS,     ACPI_BITMASK_BUS_MASTER_STATUS},
 361         /* ACPI_BITREG_GLOBAL_LOCK_STATUS   */   {ACPI_REGISTER_PM1_STATUS,   ACPI_BITPOSITION_GLOBAL_LOCK_STATUS,    ACPI_BITMASK_GLOBAL_LOCK_STATUS},
 362         /* ACPI_BITREG_POWER_BUTTON_STATUS  */   {ACPI_REGISTER_PM1_STATUS,   ACPI_BITPOSITION_POWER_BUTTON_STATUS,   ACPI_BITMASK_POWER_BUTTON_STATUS},
 363         /* ACPI_BITREG_SLEEP_BUTTON_STATUS  */   {ACPI_REGISTER_PM1_STATUS,   ACPI_BITPOSITION_SLEEP_BUTTON_STATUS,   ACPI_BITMASK_SLEEP_BUTTON_STATUS},
 364         /* ACPI_BITREG_RT_CLOCK_STATUS      */   {ACPI_REGISTER_PM1_STATUS,   ACPI_BITPOSITION_RT_CLOCK_STATUS,       ACPI_BITMASK_RT_CLOCK_STATUS},
 365         /* ACPI_BITREG_WAKE_STATUS          */   {ACPI_REGISTER_PM1_STATUS,   ACPI_BITPOSITION_WAKE_STATUS,           ACPI_BITMASK_WAKE_STATUS},
 366         /* ACPI_BITREG_PCIEXP_WAKE_STATUS   */   {ACPI_REGISTER_PM1_STATUS,   ACPI_BITPOSITION_PCIEXP_WAKE_STATUS,    ACPI_BITMASK_PCIEXP_WAKE_STATUS},
 367
 368         /* ACPI_BITREG_TIMER_ENABLE         */   {ACPI_REGISTER_PM1_ENABLE,   ACPI_BITPOSITION_TIMER_ENABLE,          ACPI_BITMASK_TIMER_ENABLE},
 369         /* ACPI_BITREG_GLOBAL_LOCK_ENABLE   */   {ACPI_REGISTER_PM1_ENABLE,   ACPI_BITPOSITION_GLOBAL_LOCK_ENABLE,    ACPI_BITMASK_GLOBAL_LOCK_ENABLE},
 370         /* ACPI_BITREG_POWER_BUTTON_ENABLE  */   {ACPI_REGISTER_PM1_ENABLE,   ACPI_BITPOSITION_POWER_BUTTON_ENABLE,   ACPI_BITMASK_POWER_BUTTON_ENABLE},
 371         /* ACPI_BITREG_SLEEP_BUTTON_ENABLE  */   {ACPI_REGISTER_PM1_ENABLE,   ACPI_BITPOSITION_SLEEP_BUTTON_ENABLE,   ACPI_BITMASK_SLEEP_BUTTON_ENABLE},
 372         /* ACPI_BITREG_RT_CLOCK_ENABLE      */   {ACPI_REGISTER_PM1_ENABLE,   ACPI_BITPOSITION_RT_CLOCK_ENABLE,       ACPI_BITMASK_RT_CLOCK_ENABLE},
 373         /* ACPI_BITREG_WAKE_ENABLE          */   {ACPI_REGISTER_PM1_ENABLE,   0,                                      0},
 374         /* ACPI_BITREG_PCIEXP_WAKE_DISABLE  */   {ACPI_REGISTER_PM1_ENABLE,   ACPI_BITPOSITION_PCIEXP_WAKE_DISABLE,   ACPI_BITMASK_PCIEXP_WAKE_DISABLE},
 375
 376         /* ACPI_BITREG_SCI_ENABLE           */   {ACPI_REGISTER_PM1_CONTROL,  ACPI_BITPOSITION_SCI_ENABLE,            ACPI_BITMASK_SCI_ENABLE},
 377         /* ACPI_BITREG_BUS_MASTER_RLD       */   {ACPI_REGISTER_PM1_CONTROL,  ACPI_BITPOSITION_BUS_MASTER_RLD,        ACPI_BITMASK_BUS_MASTER_RLD},
 378         /* ACPI_BITREG_GLOBAL_LOCK_RELEASE  */   {ACPI_REGISTER_PM1_CONTROL,  ACPI_BITPOSITION_GLOBAL_LOCK_RELEASE,   ACPI_BITMASK_GLOBAL_LOCK_RELEASE},
 379         /* ACPI_BITREG_SLEEP_TYPE_A         */   {ACPI_REGISTER_PM1_CONTROL,  ACPI_BITPOSITION_SLEEP_TYPE_X,          ACPI_BITMASK_SLEEP_TYPE_X},
 380         /* ACPI_BITREG_SLEEP_TYPE_B         */   {ACPI_REGISTER_PM1_CONTROL,  ACPI_BITPOSITION_SLEEP_TYPE_X,          ACPI_BITMASK_SLEEP_TYPE_X},
 381         /* ACPI_BITREG_SLEEP_ENABLE         */   {ACPI_REGISTER_PM1_CONTROL,  ACPI_BITPOSITION_SLEEP_ENABLE,          ACPI_BITMASK_SLEEP_ENABLE},
 382
 383         /* ACPI_BITREG_ARB_DIS              */   {ACPI_REGISTER_PM2_CONTROL,  ACPI_BITPOSITION_ARB_DISABLE,           ACPI_BITMASK_ARB_DISABLE}
 384 };
 385
 386
 387 struct acpi_fixed_event_info        acpi_gbl_fixed_event_info[ACPI_NUM_FIXED_EVENTS] =
 388 {
 389         /* ACPI_EVENT_PMTIMER       */  {ACPI_BITREG_TIMER_STATUS,          ACPI_BITREG_TIMER_ENABLE,        ACPI_BITMASK_TIMER_STATUS,          ACPI_BITMASK_TIMER_ENABLE},
 390         /* ACPI_EVENT_GLOBAL        */  {ACPI_BITREG_GLOBAL_LOCK_STATUS,    ACPI_BITREG_GLOBAL_LOCK_ENABLE,  ACPI_BITMASK_GLOBAL_LOCK_STATUS,    ACPI_BITMASK_GLOBAL_LOCK_ENABLE},
 391         /* ACPI_EVENT_POWER_BUTTON  */  {ACPI_BITREG_POWER_BUTTON_STATUS,   ACPI_BITREG_POWER_BUTTON_ENABLE, ACPI_BITMASK_POWER_BUTTON_STATUS,   ACPI_BITMASK_POWER_BUTTON_ENABLE},
 392         /* ACPI_EVENT_SLEEP_BUTTON  */  {ACPI_BITREG_SLEEP_BUTTON_STATUS,   ACPI_BITREG_SLEEP_BUTTON_ENABLE, ACPI_BITMASK_SLEEP_BUTTON_STATUS,   ACPI_BITMASK_SLEEP_BUTTON_ENABLE},
 393         /* ACPI_EVENT_RTC           */  {ACPI_BITREG_RT_CLOCK_STATUS,       ACPI_BITREG_RT_CLOCK_ENABLE,     ACPI_BITMASK_RT_CLOCK_STATUS,       ACPI_BITMASK_RT_CLOCK_ENABLE},
 394 };
 395
 396 /*******************************************************************************
 397  *
 398  * FUNCTION:    acpi_ut_get_region_name
 399  *
 400  * PARAMETERS:  None.
 401  *
 402  * RETURN:      Status
 403  *
 404  * DESCRIPTION: Translate a Space ID into a name string (Debug only)
 405  *
 406  ******************************************************************************/
 407
 408 /* Region type decoding */
 409
 410 const char                *acpi_gbl_region_types[ACPI_NUM_PREDEFINED_REGIONS] =
 411 {
 412 /*! [Begin] no source code translation (keep these ASL Keywords as-is) */
 413         "SystemMemory",
 414         "SystemIO",
 415         "PCI_Config",
 416         "EmbeddedControl",
 417         "SMBus",
 418         "CMOS",
 419         "PCIBARTarget",
 420         "DataTable"
 421 /*! [End] no source code translation !*/
 422 };
 423
 424
 425 char *
 426 acpi_ut_get_region_name (
 427         u8                              space_id)
 428 {
 429
 430         if (space_id >= ACPI_USER_REGION_BEGIN)
 431         {
 432                 return ("user_defined_region");
 433         }
 434         else if (space_id >= ACPI_NUM_PREDEFINED_REGIONS)
 435         {
 436                 return ("invalid_space_id");
 437         }
 438
 439         return ((char *) acpi_gbl_region_types[space_id]);
 440 }
 441
 442
 443 /*******************************************************************************
 444  *
 445  * FUNCTION:    acpi_ut_get_event_name
 446  *
 447  * PARAMETERS:  None.
 448  *
 449  * RETURN:      Status
 450  *
 451  * DESCRIPTION: Translate a Event ID into a name string (Debug only)
 452  *
 453  ******************************************************************************/
 454
 455 /* Event type decoding */
 456
 457 static const char                *acpi_gbl_event_types[ACPI_NUM_FIXED_EVENTS] =
 458 {
 459         "PM_Timer",
 460         "global_lock",
 461         "power_button",
 462         "sleep_button",
 463         "real_time_clock",
 464 };
 465
 466
 467 char *
 468 acpi_ut_get_event_name (
 469         u32                             event_id)
 470 {
 471
 472         if (event_id > ACPI_EVENT_MAX)
 473         {
 474                 return ("invalid_event_iD");
 475         }
 476
 477         return ((char *) acpi_gbl_event_types[event_id]);
 478 }
 479
 480
 481 /*******************************************************************************
 482  *
 483  * FUNCTION:    acpi_ut_get_type_name
 484  *
 485  * PARAMETERS:  None.
 486  *
 487  * RETURN:      Status
 488  *
 489  * DESCRIPTION: Translate a Type ID into a name string (Debug only)
 490  *
 491  ******************************************************************************/
 492
 493 /*
 494  * Elements of acpi_gbl_ns_type_names below must match
 495  * one-to-one with values of acpi_object_type
 496  *
 497  * The type ACPI_TYPE_ANY (Untyped) is used as a "don't care" when searching;
 498  * when stored in a table it really means that we have thus far seen no
 499  * evidence to indicate what type is actually going to be stored for this entry.
 500  */
 501 static const char                   acpi_gbl_bad_type[] = "UNDEFINED";
 502
 503 /* Printable names of the ACPI object types */
 504
 505 static const char                   *acpi_gbl_ns_type_names[] =
 506 {
 507         /* 00 */ "Untyped",
 508         /* 01 */ "Integer",
 509         /* 02 */ "String",
 510         /* 03 */ "Buffer",
 511         /* 04 */ "Package",
 512         /* 05 */ "field_unit",
 513         /* 06 */ "Device",
 514         /* 07 */ "Event",
 515         /* 08 */ "Method",
 516         /* 09 */ "Mutex",
 517         /* 10 */ "Region",
 518         /* 11 */ "Power",
 519         /* 12 */ "Processor",
 520         /* 13 */ "Thermal",
 521         /* 14 */ "buffer_field",
 522         /* 15 */ "ddb_handle",
 523         /* 16 */ "debug_object",
 524         /* 17 */ "region_field",
 525         /* 18 */ "bank_field",
 526         /* 19 */ "index_field",
 527         /* 20 */ "Reference",
 528         /* 21 */ "Alias",
 529         /* 22 */ "method_alias",
 530         /* 23 */ "Notify",
 531         /* 24 */ "addr_handler",
 532         /* 25 */ "resource_desc",
 533         /* 26 */ "resource_fld",
 534         /* 27 */ "Scope",
 535         /* 28 */ "Extra",
 536         /* 29 */ "Data",
 537         /* 30 */ "Invalid"
 538 };
 539
 540
 541 char *
 542 acpi_ut_get_type_name (
 543         acpi_object_type                type)
 544 {
 545
 546         if (type > ACPI_TYPE_INVALID)
 547         {
 548                 return ((char *) acpi_gbl_bad_type);
 549         }
 550
 551         return ((char *) acpi_gbl_ns_type_names[type]);
 552 }
 553
 554
 555 char *
 556 acpi_ut_get_object_type_name (
 557         union acpi_operand_object       *obj_desc)
 558 {
 559
 560         if (!obj_desc)
 561         {
 562                 return ("[NULL Object Descriptor]");
 563         }
 564
 565         return (acpi_ut_get_type_name (ACPI_GET_OBJECT_TYPE (obj_desc)));
 566 }
 567
 568
 569 /*******************************************************************************
 570  *
 571  * FUNCTION:    acpi_ut_get_node_name
 572  *
 573  * PARAMETERS:  Object               - A namespace node
 574  *
 575  * RETURN:      Pointer to a string
 576  *
 577  * DESCRIPTION: Validate the node and return the node's ACPI name.
 578  *
 579  ******************************************************************************/
 580
 581 char *
 582 acpi_ut_get_node_name (
 583         void                            *object)
 584 {
 585         struct acpi_namespace_node      *node = (struct acpi_namespace_node *) object;
 586
 587
 588         /* Must return a string of exactly 4 characters == ACPI_NAME_SIZE */
 589
 590         if (!object)
 591         {
 592                 return ("NULL");
 593         }
 594
 595         /* Check for Root node */
 596
 597         if ((object == ACPI_ROOT_OBJECT) ||
 598                 (object == acpi_gbl_root_node))
 599         {
 600                 return ("\"\\\" ");
 601         }
 602
 603         /* Descriptor must be a namespace node */
 604
 605         if (node->descriptor != ACPI_DESC_TYPE_NAMED)
 606         {
 607                 return ("####");
 608         }
 609
 610         /* Name must be a valid ACPI name */
 611
 612         if (!acpi_ut_valid_acpi_name (* (u32 *) node->name.ascii))
 613         {
 614                 return ("????");
 615         }
 616
 617         /* Return the name */
 618
 619         return (node->name.ascii);
 620 }
 621
 622
 623 /*******************************************************************************
 624  *
 625  * FUNCTION:    acpi_ut_get_descriptor_name
 626  *
 627  * PARAMETERS:  Object               - An ACPI object
 628  *
 629  * RETURN:      Pointer to a string
 630  *
 631  * DESCRIPTION: Validate object and return the descriptor type
 632  *
 633  ******************************************************************************/
 634
 635 /* Printable names of object descriptor types */
 636
 637 static const char                   *acpi_gbl_desc_type_names[] =
 638 {
 639         /* 00 */ "Invalid",
 640         /* 01 */ "Cached",
 641         /* 02 */ "State-Generic",
 642         /* 03 */ "State-Update",
 643         /* 04 */ "State-Package",
 644         /* 05 */ "State-Control",
 645         /* 06 */ "State-root_parse_scope",
 646         /* 07 */ "State-parse_scope",
 647         /* 08 */ "State-walk_scope",
 648         /* 09 */ "State-Result",
 649         /* 10 */ "State-Notify",
 650         /* 11 */ "State-Thread",
 651         /* 12 */ "Walk",
 652         /* 13 */ "Parser",
 653         /* 14 */ "Operand",
 654         /* 15 */ "Node"
 655 };
 656
 657
 658 char *
 659 acpi_ut_get_descriptor_name (
 660         void                            *object)
 661 {
 662
 663         if (!object)
 664         {
 665                 return ("NULL OBJECT");
 666         }
 667
 668         if (ACPI_GET_DESCRIPTOR_TYPE (object) > ACPI_DESC_TYPE_MAX)
 669         {
 670                 return ((char *) acpi_gbl_bad_type);
 671         }
 672
 673         return ((char *) acpi_gbl_desc_type_names[ACPI_GET_DESCRIPTOR_TYPE (object)]);
 674
 675 }
 676
 677
 678 #if defined(ACPI_DEBUG_OUTPUT) || defined(ACPI_DEBUGGER)
 679 /*
 680  * Strings and procedures used for debug only
 681  */
 682
 683 /*******************************************************************************
 684  *
 685  * FUNCTION:    acpi_ut_get_mutex_name
 686  *
 687  * PARAMETERS:  mutex_id        - The predefined ID for this mutex.
 688  *
 689  * RETURN:      String containing the name of the mutex. Always returns a valid
 690  *              pointer.
 691  *
 692  * DESCRIPTION: Translate a mutex ID into a name string (Debug only)
 693  *
 694  ******************************************************************************/
 695
 696 char *
 697 acpi_ut_get_mutex_name (
 698         u32                             mutex_id)
 699 {
 700
 701         if (mutex_id > MAX_MUTEX)
 702         {
 703                 return ("Invalid Mutex ID");
 704         }
 705
 706         return (acpi_gbl_mutex_names[mutex_id]);
 707 }
 708 #endif
 709
 710
 711 /*******************************************************************************
 712  *
 713  * FUNCTION:    acpi_ut_valid_object_type
 714  *
 715  * PARAMETERS:  Type            - Object type to be validated
 716  *
 717  * RETURN:      TRUE if valid object type, FALSE otherwise
 718  *
 719  * DESCRIPTION: Validate an object type
 720  *
 721  ******************************************************************************/
 722
 723 u8
 724 acpi_ut_valid_object_type (
 725         acpi_object_type                type)
 726 {
 727
 728         if (type > ACPI_TYPE_LOCAL_MAX)
 729         {
 730                 /* Note: Assumes all TYPEs are contiguous (external/local) */
 731
 732                 return (FALSE);
 733         }
 734
 735         return (TRUE);
 736 }
 737
 738
 739 /*******************************************************************************
 740  *
 741  * FUNCTION:    acpi_ut_init_globals
 742  *
 743  * PARAMETERS:  None
 744  *
 745  * RETURN:      None
 746  *
 747  * DESCRIPTION: Init library globals.  All globals that require specific
 748  *              initialization should be initialized here!
 749  *
 750  ******************************************************************************/
 751
 752 void
 753 acpi_ut_init_globals (
 754         void)
 755 {
 756         acpi_status                     status;
 757         u32                             i;
 758
 759
 760         ACPI_FUNCTION_TRACE ("ut_init_globals");
 761
 762
 763         /* Create all memory caches */
 764
 765         status = acpi_ut_create_caches ();
 766         if (ACPI_FAILURE (status))
 767         {
 768                 return;
 769         }
 770
 771         /* ACPI table structure */
 772
 773         for (i = 0; i < NUM_ACPI_TABLE_TYPES; i++)
 774         {
 775                 acpi_gbl_table_lists[i].next        = NULL;
 776                 acpi_gbl_table_lists[i].count       = 0;
 777         }
 778
 779         /* Mutex locked flags */
 780
 781         for (i = 0; i < NUM_MUTEX; i++)
 782         {
 783                 acpi_gbl_mutex_info[i].mutex        = NULL;
 784                 acpi_gbl_mutex_info[i].thread_id    = ACPI_MUTEX_NOT_ACQUIRED;
 785                 acpi_gbl_mutex_info[i].use_count    = 0;
 786         }
 787
 788         /* GPE support */
 789
 790         acpi_gbl_gpe_xrupt_list_head        = NULL;
 791         acpi_gbl_gpe_fadt_blocks[0]         = NULL;
 792         acpi_gbl_gpe_fadt_blocks[1]         = NULL;
 793
 794         /* Global notify handlers */
 795
 796         acpi_gbl_system_notify.handler      = NULL;
 797         acpi_gbl_device_notify.handler      = NULL;
 798         acpi_gbl_exception_handler          = NULL;
 799         acpi_gbl_init_handler               = NULL;
 800
 801         /* Global "typed" ACPI table pointers */
 802
 803         acpi_gbl_RSDP                       = NULL;
 804         acpi_gbl_XSDT                       = NULL;
 805         acpi_gbl_FACS                       = NULL;
 806         acpi_gbl_FADT                       = NULL;
 807         acpi_gbl_DSDT                       = NULL;
 808
 809         /* Global Lock support */
 810
 811         acpi_gbl_global_lock_acquired       = FALSE;
 812         acpi_gbl_global_lock_thread_count   = 0;
 813         acpi_gbl_global_lock_handle         = 0;
 814
 815         /* Miscellaneous variables */
 816
 817         acpi_gbl_table_flags                = ACPI_PHYSICAL_POINTER;
 818         acpi_gbl_rsdp_original_location     = 0;
 819         acpi_gbl_cm_single_step             = FALSE;
 820         acpi_gbl_db_terminate_threads       = FALSE;
 821         acpi_gbl_shutdown                   = FALSE;
 822         acpi_gbl_ns_lookup_count            = 0;
 823         acpi_gbl_ps_find_count              = 0;
 824         acpi_gbl_acpi_hardware_present      = TRUE;
 825         acpi_gbl_owner_id_mask              = 0;
 826         acpi_gbl_debugger_configuration     = DEBUGGER_THREADING;
 827         acpi_gbl_db_output_flags            = ACPI_DB_CONSOLE_OUTPUT;
 828
 829         /* Hardware oriented */
 830
 831         acpi_gbl_events_initialized         = FALSE;
 832         acpi_gbl_system_awake_and_running   = TRUE;
 833
 834         /* Namespace */
 835
 836         acpi_gbl_root_node                  = NULL;
 837
 838         acpi_gbl_root_node_struct.name.integer = ACPI_ROOT_NAME;
 839         acpi_gbl_root_node_struct.descriptor = ACPI_DESC_TYPE_NAMED;
 840         acpi_gbl_root_node_struct.type      = ACPI_TYPE_DEVICE;
 841         acpi_gbl_root_node_struct.child     = NULL;
 842         acpi_gbl_root_node_struct.peer      = NULL;
 843         acpi_gbl_root_node_struct.object    = NULL;
 844         acpi_gbl_root_node_struct.flags     = ANOBJ_END_OF_PEER_LIST;
 845
 846
 847 #ifdef ACPI_DEBUG_OUTPUT
 848         acpi_gbl_lowest_stack_pointer       = ACPI_SIZE_MAX;
 849 #endif
 850
 851         return_VOID;
 852 }
 853
 854