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