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