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