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