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.
 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(u64 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         "IPMI",
 363         "DataTable"
 364 };
 365
 366 char *acpi_ut_get_region_name(u8 space_id)
 367 {
 368
 369         if (space_id >= ACPI_USER_REGION_BEGIN) {
 370                 return ("UserDefinedRegion");
 371         } else if (space_id >= ACPI_NUM_PREDEFINED_REGIONS) {
 372                 return ("InvalidSpaceId");
 373         }
 374
 375         return (ACPI_CAST_PTR(char, acpi_gbl_region_types[space_id]));
 376 }
 377
 378 /*******************************************************************************
 379  *
 380  * FUNCTION:    acpi_ut_get_event_name
 381  *
 382  * PARAMETERS:  None.
 383  *
 384  * RETURN:      Status
 385  *
 386  * DESCRIPTION: Translate a Event ID into a name string (Debug only)
 387  *
 388  ******************************************************************************/
 389
 390 /* Event type decoding */
 391
 392 static const char *acpi_gbl_event_types[ACPI_NUM_FIXED_EVENTS] = {
 393         "PM_Timer",
 394         "GlobalLock",
 395         "PowerButton",
 396         "SleepButton",
 397         "RealTimeClock",
 398 };
 399
 400 char *acpi_ut_get_event_name(u32 event_id)
 401 {
 402
 403         if (event_id > ACPI_EVENT_MAX) {
 404                 return ("InvalidEventID");
 405         }
 406
 407         return (ACPI_CAST_PTR(char, acpi_gbl_event_types[event_id]));
 408 }
 409
 410 /*******************************************************************************
 411  *
 412  * FUNCTION:    acpi_ut_get_type_name
 413  *
 414  * PARAMETERS:  None.
 415  *
 416  * RETURN:      Status
 417  *
 418  * DESCRIPTION: Translate a Type ID into a name string (Debug only)
 419  *
 420  ******************************************************************************/
 421
 422 /*
 423  * Elements of acpi_gbl_ns_type_names below must match
 424  * one-to-one with values of acpi_object_type
 425  *
 426  * The type ACPI_TYPE_ANY (Untyped) is used as a "don't care" when searching;
 427  * when stored in a table it really means that we have thus far seen no
 428  * evidence to indicate what type is actually going to be stored for this entry.
 429  */
 430 static const char acpi_gbl_bad_type[] = "UNDEFINED";
 431
 432 /* Printable names of the ACPI object types */
 433
 434 static const char *acpi_gbl_ns_type_names[] = {
 435         /* 00 */ "Untyped",
 436         /* 01 */ "Integer",
 437         /* 02 */ "String",
 438         /* 03 */ "Buffer",
 439         /* 04 */ "Package",
 440         /* 05 */ "FieldUnit",
 441         /* 06 */ "Device",
 442         /* 07 */ "Event",
 443         /* 08 */ "Method",
 444         /* 09 */ "Mutex",
 445         /* 10 */ "Region",
 446         /* 11 */ "Power",
 447         /* 12 */ "Processor",
 448         /* 13 */ "Thermal",
 449         /* 14 */ "BufferField",
 450         /* 15 */ "DdbHandle",
 451         /* 16 */ "DebugObject",
 452         /* 17 */ "RegionField",
 453         /* 18 */ "BankField",
 454         /* 19 */ "IndexField",
 455         /* 20 */ "Reference",
 456         /* 21 */ "Alias",
 457         /* 22 */ "MethodAlias",
 458         /* 23 */ "Notify",
 459         /* 24 */ "AddrHandler",
 460         /* 25 */ "ResourceDesc",
 461         /* 26 */ "ResourceFld",
 462         /* 27 */ "Scope",
 463         /* 28 */ "Extra",
 464         /* 29 */ "Data",
 465         /* 30 */ "Invalid"
 466 };
 467
 468 char *acpi_ut_get_type_name(acpi_object_type type)
 469 {
 470
 471         if (type > ACPI_TYPE_INVALID) {
 472                 return (ACPI_CAST_PTR(char, acpi_gbl_bad_type));
 473         }
 474
 475         return (ACPI_CAST_PTR(char, acpi_gbl_ns_type_names[type]));
 476 }
 477
 478 char *acpi_ut_get_object_type_name(union acpi_operand_object *obj_desc)
 479 {
 480
 481         if (!obj_desc) {
 482                 return ("[NULL Object Descriptor]");
 483         }
 484
 485         return (acpi_ut_get_type_name(obj_desc->common.type));
 486 }
 487
 488 /*******************************************************************************
 489  *
 490  * FUNCTION:    acpi_ut_get_node_name
 491  *
 492  * PARAMETERS:  Object               - A namespace node
 493  *
 494  * RETURN:      Pointer to a string
 495  *
 496  * DESCRIPTION: Validate the node and return the node's ACPI name.
 497  *
 498  ******************************************************************************/
 499
 500 char *acpi_ut_get_node_name(void *object)
 501 {
 502         struct acpi_namespace_node *node = (struct acpi_namespace_node *)object;
 503
 504         /* Must return a string of exactly 4 characters == ACPI_NAME_SIZE */
 505
 506         if (!object) {
 507                 return ("NULL");
 508         }
 509
 510         /* Check for Root node */
 511
 512         if ((object == ACPI_ROOT_OBJECT) || (object == acpi_gbl_root_node)) {
 513                 return ("\"\\\" ");
 514         }
 515
 516         /* Descriptor must be a namespace node */
 517
 518         if (ACPI_GET_DESCRIPTOR_TYPE(node) != ACPI_DESC_TYPE_NAMED) {
 519                 return ("####");
 520         }
 521
 522         /* Name must be a valid ACPI name */
 523
 524         if (!acpi_ut_valid_acpi_name(node->name.integer)) {
 525                 node->name.integer = acpi_ut_repair_name(node->name.ascii);
 526         }
 527
 528         /* Return the name */
 529
 530         return (node->name.ascii);
 531 }
 532
 533 /*******************************************************************************
 534  *
 535  * FUNCTION:    acpi_ut_get_descriptor_name
 536  *
 537  * PARAMETERS:  Object               - An ACPI object
 538  *
 539  * RETURN:      Pointer to a string
 540  *
 541  * DESCRIPTION: Validate object and return the descriptor type
 542  *
 543  ******************************************************************************/
 544
 545 /* Printable names of object descriptor types */
 546
 547 static const char *acpi_gbl_desc_type_names[] = {
 548         /* 00 */ "Invalid",
 549         /* 01 */ "Cached",
 550         /* 02 */ "State-Generic",
 551         /* 03 */ "State-Update",
 552         /* 04 */ "State-Package",
 553         /* 05 */ "State-Control",
 554         /* 06 */ "State-RootParseScope",
 555         /* 07 */ "State-ParseScope",
 556         /* 08 */ "State-WalkScope",
 557         /* 09 */ "State-Result",
 558         /* 10 */ "State-Notify",
 559         /* 11 */ "State-Thread",
 560         /* 12 */ "Walk",
 561         /* 13 */ "Parser",
 562         /* 14 */ "Operand",
 563         /* 15 */ "Node"
 564 };
 565
 566 char *acpi_ut_get_descriptor_name(void *object)
 567 {
 568
 569         if (!object) {
 570                 return ("NULL OBJECT");
 571         }
 572
 573         if (ACPI_GET_DESCRIPTOR_TYPE(object) > ACPI_DESC_TYPE_MAX) {
 574                 return (ACPI_CAST_PTR(char, acpi_gbl_bad_type));
 575         }
 576
 577         return (ACPI_CAST_PTR(char,
 578                               acpi_gbl_desc_type_names[ACPI_GET_DESCRIPTOR_TYPE
 579                                                        (object)]));
 580
 581 }
 582
 583 /*******************************************************************************
 584  *
 585  * FUNCTION:    acpi_ut_get_reference_name
 586  *
 587  * PARAMETERS:  Object               - An ACPI reference object
 588  *
 589  * RETURN:      Pointer to a string
 590  *
 591  * DESCRIPTION: Decode a reference object sub-type to a string.
 592  *
 593  ******************************************************************************/
 594
 595 /* Printable names of reference object sub-types */
 596
 597 static const char *acpi_gbl_ref_class_names[] = {
 598         /* 00 */ "Local",
 599         /* 01 */ "Argument",
 600         /* 02 */ "RefOf",
 601         /* 03 */ "Index",
 602         /* 04 */ "DdbHandle",
 603         /* 05 */ "Named Object",
 604         /* 06 */ "Debug"
 605 };
 606
 607 const char *acpi_ut_get_reference_name(union acpi_operand_object *object)
 608 {
 609         if (!object)
 610                 return "NULL Object";
 611
 612         if (ACPI_GET_DESCRIPTOR_TYPE(object) != ACPI_DESC_TYPE_OPERAND)
 613                 return "Not an Operand object";
 614
 615         if (object->common.type != ACPI_TYPE_LOCAL_REFERENCE)
 616                 return "Not a Reference object";
 617
 618         if (object->reference.class > ACPI_REFCLASS_MAX)
 619                 return "Unknown Reference class";
 620
 621         return acpi_gbl_ref_class_names[object->reference.class];
 622 }
 623
 624 #if defined(ACPI_DEBUG_OUTPUT) || defined(ACPI_DEBUGGER)
 625 /*
 626  * Strings and procedures used for debug only
 627  */
 628
 629 /*******************************************************************************
 630  *
 631  * FUNCTION:    acpi_ut_get_mutex_name
 632  *
 633  * PARAMETERS:  mutex_id        - The predefined ID for this mutex.
 634  *
 635  * RETURN:      String containing the name of the mutex. Always returns a valid
 636  *              pointer.
 637  *
 638  * DESCRIPTION: Translate a mutex ID into a name string (Debug only)
 639  *
 640  ******************************************************************************/
 641
 642 char *acpi_ut_get_mutex_name(u32 mutex_id)
 643 {
 644
 645         if (mutex_id > ACPI_MAX_MUTEX) {
 646                 return ("Invalid Mutex ID");
 647         }
 648
 649         return (acpi_gbl_mutex_names[mutex_id]);
 650 }
 651
 652 /*******************************************************************************
 653  *
 654  * FUNCTION:    acpi_ut_get_notify_name
 655  *
 656  * PARAMETERS:  notify_value    - Value from the Notify() request
 657  *
 658  * RETURN:      String corresponding to the Notify Value.
 659  *
 660  * DESCRIPTION: Translate a Notify Value to a notify namestring.
 661  *
 662  ******************************************************************************/
 663
 664 /* Names for Notify() values, used for debug output */
 665
 666 static const char *acpi_gbl_notify_value_names[] = {
 667         "Bus Check",
 668         "Device Check",
 669         "Device Wake",
 670         "Eject Request",
 671         "Device Check Light",
 672         "Frequency Mismatch",
 673         "Bus Mode Mismatch",
 674         "Power Fault",
 675         "Capabilities Check",
 676         "Device PLD Check",
 677         "Reserved",
 678         "System Locality Update"
 679 };
 680
 681 const char *acpi_ut_get_notify_name(u32 notify_value)
 682 {
 683
 684         if (notify_value <= ACPI_NOTIFY_MAX) {
 685                 return (acpi_gbl_notify_value_names[notify_value]);
 686         } else if (notify_value <= ACPI_MAX_SYS_NOTIFY) {
 687                 return ("Reserved");
 688         } else {                /* Greater or equal to 0x80 */
 689
 690                 return ("**Device Specific**");
 691         }
 692 }
 693 #endif
 694
 695 /*******************************************************************************
 696  *
 697  * FUNCTION:    acpi_ut_valid_object_type
 698  *
 699  * PARAMETERS:  Type            - Object type to be validated
 700  *
 701  * RETURN:      TRUE if valid object type, FALSE otherwise
 702  *
 703  * DESCRIPTION: Validate an object type
 704  *
 705  ******************************************************************************/
 706
 707 u8 acpi_ut_valid_object_type(acpi_object_type type)
 708 {
 709
 710         if (type > ACPI_TYPE_LOCAL_MAX) {
 711
 712                 /* Note: Assumes all TYPEs are contiguous (external/local) */
 713
 714                 return (FALSE);
 715         }
 716
 717         return (TRUE);
 718 }
 719
 720 /*******************************************************************************
 721  *
 722  * FUNCTION:    acpi_ut_init_globals
 723  *
 724  * PARAMETERS:  None
 725  *
 726  * RETURN:      Status
 727  *
 728  * DESCRIPTION: Init library globals.  All globals that require specific
 729  *              initialization should be initialized here!
 730  *
 731  ******************************************************************************/
 732
 733 acpi_status acpi_ut_init_globals(void)
 734 {
 735         acpi_status status;
 736         u32 i;
 737
 738         ACPI_FUNCTION_TRACE(ut_init_globals);
 739
 740         /* Create all memory caches */
 741
 742         status = acpi_ut_create_caches();
 743         if (ACPI_FAILURE(status)) {
 744                 return_ACPI_STATUS(status);
 745         }
 746
 747         /* Mutex locked flags */
 748
 749         for (i = 0; i < ACPI_NUM_MUTEX; i++) {
 750                 acpi_gbl_mutex_info[i].mutex = NULL;
 751                 acpi_gbl_mutex_info[i].thread_id = ACPI_MUTEX_NOT_ACQUIRED;
 752                 acpi_gbl_mutex_info[i].use_count = 0;
 753         }
 754
 755         for (i = 0; i < ACPI_NUM_OWNERID_MASKS; i++) {
 756                 acpi_gbl_owner_id_mask[i] = 0;
 757         }
 758
 759         /* Last owner_iD is never valid */
 760
 761         acpi_gbl_owner_id_mask[ACPI_NUM_OWNERID_MASKS - 1] = 0x80000000;
 762
 763         /* GPE support */
 764
 765         acpi_gbl_gpe_xrupt_list_head = NULL;
 766         acpi_gbl_gpe_fadt_blocks[0] = NULL;
 767         acpi_gbl_gpe_fadt_blocks[1] = NULL;
 768         acpi_current_gpe_count = 0;
 769
 770         /* Global handlers */
 771
 772         acpi_gbl_system_notify.handler = NULL;
 773         acpi_gbl_device_notify.handler = NULL;
 774         acpi_gbl_exception_handler = NULL;
 775         acpi_gbl_init_handler = NULL;
 776         acpi_gbl_table_handler = NULL;
 777
 778         /* Global Lock support */
 779
 780         acpi_gbl_global_lock_semaphore = NULL;
 781         acpi_gbl_global_lock_mutex = NULL;
 782         acpi_gbl_global_lock_acquired = FALSE;
 783         acpi_gbl_global_lock_handle = 0;
 784         acpi_gbl_global_lock_present = FALSE;
 785
 786         /* Miscellaneous variables */
 787
 788         acpi_gbl_cm_single_step = FALSE;
 789         acpi_gbl_db_terminate_threads = FALSE;
 790         acpi_gbl_shutdown = FALSE;
 791         acpi_gbl_ns_lookup_count = 0;
 792         acpi_gbl_ps_find_count = 0;
 793         acpi_gbl_acpi_hardware_present = TRUE;
 794         acpi_gbl_last_owner_id_index = 0;
 795         acpi_gbl_next_owner_id_offset = 0;
 796         acpi_gbl_trace_method_name = 0;
 797         acpi_gbl_trace_dbg_level = 0;
 798         acpi_gbl_trace_dbg_layer = 0;
 799         acpi_gbl_debugger_configuration = DEBUGGER_THREADING;
 800         acpi_gbl_db_output_flags = ACPI_DB_CONSOLE_OUTPUT;
 801         acpi_gbl_osi_data = 0;
 802
 803         /* Hardware oriented */
 804
 805         acpi_gbl_events_initialized = FALSE;
 806         acpi_gbl_system_awake_and_running = TRUE;
 807
 808         /* Namespace */
 809
 810         acpi_gbl_module_code_list = NULL;
 811         acpi_gbl_root_node = NULL;
 812         acpi_gbl_root_node_struct.name.integer = ACPI_ROOT_NAME;
 813         acpi_gbl_root_node_struct.descriptor_type = ACPI_DESC_TYPE_NAMED;
 814         acpi_gbl_root_node_struct.type = ACPI_TYPE_DEVICE;
 815         acpi_gbl_root_node_struct.child = NULL;
 816         acpi_gbl_root_node_struct.peer = NULL;
 817         acpi_gbl_root_node_struct.object = NULL;
 818         acpi_gbl_root_node_struct.flags = ANOBJ_END_OF_PEER_LIST;
 819
 820 #ifdef ACPI_DEBUG_OUTPUT
 821         acpi_gbl_lowest_stack_pointer = ACPI_CAST_PTR(acpi_size, ACPI_SIZE_MAX);
 822 #endif
 823
 824 #ifdef ACPI_DBG_TRACK_ALLOCATIONS
 825         acpi_gbl_display_final_mem_stats = FALSE;
 826 #endif
 827
 828         return_ACPI_STATUS(AE_OK);
 829 }
 830
 831 ACPI_EXPORT_SYMBOL(acpi_gbl_FADT)
 832 ACPI_EXPORT_SYMBOL(acpi_dbg_level)
 833 ACPI_EXPORT_SYMBOL(acpi_dbg_layer)
 834 ACPI_EXPORT_SYMBOL(acpi_current_gpe_count)