1 /****************************************************************************** 2 * 3 * Module Name: utglobal - Global variables for the ACPI subsystem 4 * 5 *****************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2010, 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. 158 */ 159 const 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 */ 182 const 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 218 static 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 237 char acpi_ut_hex_to_ascii_char(u64 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 249 struct 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 317 struct 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 354 const 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 366 char *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 392 static const char *acpi_gbl_event_types[ACPI_NUM_FIXED_EVENTS] = { 393 "PM_Timer", 394 "GlobalLock", 395 "PowerButton", 396 "SleepButton", 397 "RealTimeClock", 398 }; 399 400 char *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 */ 430 static const char acpi_gbl_bad_type[] = "UNDEFINED"; 431 432 /* Printable names of the ACPI object types */ 433 434 static 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 468 char *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 478 char *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 500 char *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 547 static 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 566 char *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 597 static 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 607 const 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 642 char *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 666 static 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 681 const 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 707 u8 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 733 acpi_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_DSDT = NULL; 789 acpi_gbl_cm_single_step = FALSE; 790 acpi_gbl_db_terminate_threads = FALSE; 791 acpi_gbl_shutdown = FALSE; 792 acpi_gbl_ns_lookup_count = 0; 793 acpi_gbl_ps_find_count = 0; 794 acpi_gbl_acpi_hardware_present = TRUE; 795 acpi_gbl_last_owner_id_index = 0; 796 acpi_gbl_next_owner_id_offset = 0; 797 acpi_gbl_trace_method_name = 0; 798 acpi_gbl_trace_dbg_level = 0; 799 acpi_gbl_trace_dbg_layer = 0; 800 acpi_gbl_debugger_configuration = DEBUGGER_THREADING; 801 acpi_gbl_db_output_flags = ACPI_DB_CONSOLE_OUTPUT; 802 acpi_gbl_osi_data = 0; 803 804 /* Hardware oriented */ 805 806 acpi_gbl_events_initialized = FALSE; 807 acpi_gbl_system_awake_and_running = TRUE; 808 809 /* Namespace */ 810 811 acpi_gbl_module_code_list = NULL; 812 acpi_gbl_root_node = NULL; 813 acpi_gbl_root_node_struct.name.integer = ACPI_ROOT_NAME; 814 acpi_gbl_root_node_struct.descriptor_type = ACPI_DESC_TYPE_NAMED; 815 acpi_gbl_root_node_struct.type = ACPI_TYPE_DEVICE; 816 acpi_gbl_root_node_struct.child = NULL; 817 acpi_gbl_root_node_struct.peer = NULL; 818 acpi_gbl_root_node_struct.object = NULL; 819 acpi_gbl_root_node_struct.flags = ANOBJ_END_OF_PEER_LIST; 820 821 #ifdef ACPI_DEBUG_OUTPUT 822 acpi_gbl_lowest_stack_pointer = ACPI_CAST_PTR(acpi_size, ACPI_SIZE_MAX); 823 #endif 824 825 #ifdef ACPI_DBG_TRACK_ALLOCATIONS 826 acpi_gbl_display_final_mem_stats = FALSE; 827 #endif 828 829 return_ACPI_STATUS(AE_OK); 830 } 831 832 ACPI_EXPORT_SYMBOL(acpi_gbl_FADT) 833 ACPI_EXPORT_SYMBOL(acpi_dbg_level) 834 ACPI_EXPORT_SYMBOL(acpi_dbg_layer) 835 ACPI_EXPORT_SYMBOL(acpi_current_gpe_count) 836