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