1 /****************************************************************************** 2 * 3 * Module Name: utglobal - Global variables for the ACPI subsystem 4 * 5 *****************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2008, Intel Corp. 9 * All rights reserved. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions, and the following disclaimer, 16 * without modification. 17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer 18 * substantially similar to the "NO WARRANTY" disclaimer below 19 * ("Disclaimer") and any redistribution must be conditioned upon 20 * including a substantially similar Disclaimer requirement for further 21 * binary redistribution. 22 * 3. Neither the names of the above-listed copyright holders nor the names 23 * of any contributors may be used to endorse or promote products derived 24 * from this software without specific prior written permission. 25 * 26 * Alternatively, this software may be distributed under the terms of the 27 * GNU General Public License ("GPL") version 2 as published by the Free 28 * Software Foundation. 29 * 30 * NO WARRANTY 31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR 34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 41 * POSSIBILITY OF SUCH DAMAGES. 42 */ 43 44 #define DEFINE_ACPI_GLOBALS 45 46 #include <acpi/acpi.h> 47 #include "accommon.h" 48 #include "acnamesp.h" 49 50 #define _COMPONENT ACPI_UTILITIES 51 ACPI_MODULE_NAME("utglobal") 52 53 /******************************************************************************* 54 * 55 * Static global variable initialization. 56 * 57 ******************************************************************************/ 58 /* 59 * We want the debug switches statically initialized so they 60 * are already set when the debugger is entered. 61 */ 62 /* Debug switch - level and trace mask */ 63 u32 acpi_dbg_level = ACPI_DEBUG_DEFAULT; 64 65 /* Debug switch - layer (component) mask */ 66 67 u32 acpi_dbg_layer = 0; 68 u32 acpi_gbl_nesting_level = 0; 69 70 /* Debugger globals */ 71 72 u8 acpi_gbl_db_terminate_threads = FALSE; 73 u8 acpi_gbl_abort_method = FALSE; 74 u8 acpi_gbl_method_executing = FALSE; 75 76 /* System flags */ 77 78 u32 acpi_gbl_startup_flags = 0; 79 80 /* System starts uninitialized */ 81 82 u8 acpi_gbl_shutdown = TRUE; 83 84 const char *acpi_gbl_sleep_state_names[ACPI_S_STATE_COUNT] = { 85 "\\_S0_", 86 "\\_S1_", 87 "\\_S2_", 88 "\\_S3_", 89 "\\_S4_", 90 "\\_S5_" 91 }; 92 93 const char *acpi_gbl_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 "SystemCMOS", 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 acpi_current_gpe_count = 0; 760 761 /* Global handlers */ 762 763 acpi_gbl_system_notify.handler = NULL; 764 acpi_gbl_device_notify.handler = NULL; 765 acpi_gbl_exception_handler = NULL; 766 acpi_gbl_init_handler = NULL; 767 acpi_gbl_table_handler = NULL; 768 769 /* Global Lock support */ 770 771 acpi_gbl_global_lock_semaphore = NULL; 772 acpi_gbl_global_lock_mutex = NULL; 773 acpi_gbl_global_lock_acquired = FALSE; 774 acpi_gbl_global_lock_handle = 0; 775 acpi_gbl_global_lock_present = FALSE; 776 777 /* Miscellaneous variables */ 778 779 acpi_gbl_cm_single_step = FALSE; 780 acpi_gbl_db_terminate_threads = FALSE; 781 acpi_gbl_shutdown = FALSE; 782 acpi_gbl_ns_lookup_count = 0; 783 acpi_gbl_ps_find_count = 0; 784 acpi_gbl_acpi_hardware_present = TRUE; 785 acpi_gbl_last_owner_id_index = 0; 786 acpi_gbl_next_owner_id_offset = 0; 787 acpi_gbl_trace_method_name = 0; 788 acpi_gbl_trace_dbg_level = 0; 789 acpi_gbl_trace_dbg_layer = 0; 790 acpi_gbl_debugger_configuration = DEBUGGER_THREADING; 791 acpi_gbl_db_output_flags = ACPI_DB_CONSOLE_OUTPUT; 792 793 /* Hardware oriented */ 794 795 acpi_gbl_events_initialized = FALSE; 796 acpi_gbl_system_awake_and_running = TRUE; 797 798 /* Namespace */ 799 800 acpi_gbl_root_node = NULL; 801 acpi_gbl_root_node_struct.name.integer = ACPI_ROOT_NAME; 802 acpi_gbl_root_node_struct.descriptor_type = ACPI_DESC_TYPE_NAMED; 803 acpi_gbl_root_node_struct.type = ACPI_TYPE_DEVICE; 804 acpi_gbl_root_node_struct.child = NULL; 805 acpi_gbl_root_node_struct.peer = NULL; 806 acpi_gbl_root_node_struct.object = NULL; 807 acpi_gbl_root_node_struct.flags = ANOBJ_END_OF_PEER_LIST; 808 809 #ifdef ACPI_DEBUG_OUTPUT 810 acpi_gbl_lowest_stack_pointer = ACPI_CAST_PTR(acpi_size, ACPI_SIZE_MAX); 811 #endif 812 813 #ifdef ACPI_DBG_TRACK_ALLOCATIONS 814 acpi_gbl_display_final_mem_stats = FALSE; 815 #endif 816 817 return_ACPI_STATUS(AE_OK); 818 } 819 820 ACPI_EXPORT_SYMBOL(acpi_gbl_FADT) 821 ACPI_EXPORT_SYMBOL(acpi_dbg_level) 822 ACPI_EXPORT_SYMBOL(acpi_dbg_layer) 823 ACPI_EXPORT_SYMBOL(acpi_current_gpe_count) 824