LXR linux/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
  51ACPI_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 */
  63u32 acpi_dbg_level = ACPI_DEBUG_DEFAULT;
  64
  65/* Debug switch - layer (component) mask */
  66
  67u32 acpi_dbg_layer = 0;
  68u32 acpi_gbl_nesting_level = 0;
  69
  70/* Debugger globals */
  71
  72u8 acpi_gbl_db_terminate_threads = FALSE;
  73u8 acpi_gbl_abort_method = FALSE;
  74u8 acpi_gbl_method_executing = FALSE;
  75
  76/* System flags */
  77
  78u32 acpi_gbl_startup_flags = 0;
  79
  80/* System starts uninitialized */
  81
  82u8 acpi_gbl_shutdown = TRUE;
  83
  84const char *acpi_gbl_sleep_state_names[ACPI_S_STATE_COUNT] = {
  85        "\\_S0_",
  86        "\\_S1_",
  87        "\\_S2_",
  88        "\\_S3_",
  89        "\\_S4_",
  90        "\\_S5_"
  91};
  92
  93const char *acpi_gbl_lowest_dstate_names[ACPI_NUM_sx_w_METHODS] = {
  94        "_S0W",
  95        "_S1W",
  96        "_S2W",
  97        "_S3W",
  98        "_S4W"
  99};
 100
 101const 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
 122const 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
 143ACPI_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 */
 159const 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 */
 182const 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
 218static 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
 237char 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
 249struct 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
 317struct 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
 354const 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
 366char *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
 392static const char *acpi_gbl_event_types[ACPI_NUM_FIXED_EVENTS] = {
 393        "PM_Timer",
 394        "GlobalLock",
 395        "PowerButton",
 396        "SleepButton",
 397        "RealTimeClock",
 398};
 399
 400char *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 */
 430static const char acpi_gbl_bad_type[] = "UNDEFINED";
 431
 432/* Printable names of the ACPI object types */
 433
 434static 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
 468char *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
 478char *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
 500char *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
 547static 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
 566char *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
 597static 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
 607const 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
 642char *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
 666static 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
 681const 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
 707u8 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
 733acpi_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
 831ACPI_EXPORT_SYMBOL(acpi_gbl_FADT)
 832ACPI_EXPORT_SYMBOL(acpi_dbg_level)
 833ACPI_EXPORT_SYMBOL(acpi_dbg_layer)
 834ACPI_EXPORT_SYMBOL(acpi_current_gpe_count)
 835