drivers/acpi/utilities/utglobal.c

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