drivers/acpi/acpica/utglobal.c

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