1 /****************************************************************************** 2 * 3 * Module Name: utglobal - Global variables for the ACPI subsystem 4 * $Revision: 1.256 $ 5 * 6 *****************************************************************************/ 7 8 /****************************************************************************** 9 * 10 * 1. Copyright Notice 11 * 12 * Some or all of this work - Copyright (c) 1999 - 2008, Intel Corp. 13 * All rights reserved. 14 * 15 * 2. License 16 * 17 * 2.1. This is your license from Intel Corp. under its intellectual property 18 * rights. You may have additional license terms from the party that provided 19 * you this software, covering your right to use that party's intellectual 20 * property rights. 21 * 22 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a 23 * copy of the source code appearing in this file ("Covered Code") an 24 * irrevocable, perpetual, worldwide license under Intel's copyrights in the 25 * base code distributed originally by Intel ("Original Intel Code") to copy, 26 * make derivatives, distribute, use and display any portion of the Covered 27 * Code in any form, with the right to sublicense such rights; and 28 * 29 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent 30 * license (with the right to sublicense), under only those claims of Intel 31 * patents that are infringed by the Original Intel Code, to make, use, sell, 32 * offer to sell, and import the Covered Code and derivative works thereof 33 * solely to the minimum extent necessary to exercise the above copyright 34 * license, and in no event shall the patent license extend to any additions 35 * to or modifications of the Original Intel Code. No other license or right 36 * is granted directly or by implication, estoppel or otherwise; 37 * 38 * The above copyright and patent license is granted only if the following 39 * conditions are met: 40 * 41 * 3. Conditions 42 * 43 * 3.1. Redistribution of Source with Rights to Further Distribute Source. 44 * Redistribution of source code of any substantial portion of the Covered 45 * Code or modification with rights to further distribute source must include 46 * the above Copyright Notice, the above License, this list of Conditions, 47 * and the following Disclaimer and Export Compliance provision. In addition, 48 * Licensee must cause all Covered Code to which Licensee contributes to 49 * contain a file documenting the changes Licensee made to create that Covered 50 * Code and the date of any change. Licensee must include in that file the 51 * documentation of any changes made by any predecessor Licensee. Licensee 52 * must include a prominent statement that the modification is derived, 53 * directly or indirectly, from Original Intel Code. 54 * 55 * 3.2. Redistribution of Source with no Rights to Further Distribute Source. 56 * Redistribution of source code of any substantial portion of the Covered 57 * Code or modification without rights to further distribute source must 58 * include the following Disclaimer and Export Compliance provision in the 59 * documentation and/or other materials provided with distribution. In 60 * addition, Licensee may not authorize further sublicense of source of any 61 * portion of the Covered Code, and must include terms to the effect that the 62 * license from Licensee to its licensee is limited to the intellectual 63 * property embodied in the software Licensee provides to its licensee, and 64 * not to intellectual property embodied in modifications its licensee may 65 * make. 66 * 67 * 3.3. Redistribution of Executable. Redistribution in executable form of any 68 * substantial portion of the Covered Code or modification must reproduce the 69 * above Copyright Notice, and the following Disclaimer and Export Compliance 70 * provision in the documentation and/or other materials provided with the 71 * distribution. 72 * 73 * 3.4. Intel retains all right, title, and interest in and to the Original 74 * Intel Code. 75 * 76 * 3.5. Neither the name Intel nor any other trademark owned or controlled by 77 * Intel shall be used in advertising or otherwise to promote the sale, use or 78 * other dealings in products derived from or relating to the Covered Code 79 * without prior written authorization from Intel. 80 * 81 * 4. Disclaimer and Export Compliance 82 * 83 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED 84 * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE 85 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, 86 * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY 87 * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY 88 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A 89 * PARTICULAR PURPOSE. 90 * 91 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES 92 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR 93 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, 94 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY 95 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL 96 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS 97 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY 98 * LIMITED REMEDY. 99 * 100 * 4.3. Licensee shall not export, either directly or indirectly, any of this 101 * software or system incorporating such software without first obtaining any 102 * required license or other approval from the U. S. Department of Commerce or 103 * any other agency or department of the United States Government. In the 104 * event Licensee exports any such software from the United States or 105 * re-exports any such software from a foreign destination, Licensee shall 106 * ensure that the distribution and export/re-export of the software is in 107 * compliance with all laws, regulations, orders, or other restrictions of the 108 * U.S. Export Administration Regulations. Licensee agrees that neither it nor 109 * any of its subsidiaries will export/re-export any technical data, process, 110 * software, or service, directly or indirectly, to any country for which the 111 * United States government or any agency thereof requires an export license, 112 * other governmental approval, or letter of assurance, without first obtaining 113 * such license, approval or letter. 114 * 115 *****************************************************************************/ 116 117 #define __UTGLOBAL_C__ 118 #define DEFINE_ACPI_GLOBALS 119 120 #include "acpi.h" 121 #include "acnamesp.h" 122 123 ACPI_EXPORT_SYMBOL (AcpiGbl_FADT) 124 125 #define _COMPONENT ACPI_UTILITIES 126 ACPI_MODULE_NAME ("utglobal") 127 128 129 /******************************************************************************* 130 * 131 * Static global variable initialization. 132 * 133 ******************************************************************************/ 134 135 /* 136 * We want the debug switches statically initialized so they 137 * are already set when the debugger is entered. 138 */ 139 140 /* Debug switch - level and trace mask */ 141 142 #ifdef ACPI_DEBUG_OUTPUT 143 UINT32 AcpiDbgLevel = ACPI_DEBUG_DEFAULT; 144 #else 145 UINT32 AcpiDbgLevel = ACPI_NORMAL_DEFAULT; 146 #endif 147 148 /* Debug switch - layer (component) mask */ 149 150 UINT32 AcpiDbgLayer = ACPI_COMPONENT_DEFAULT; 151 UINT32 AcpiGbl_NestingLevel = 0; 152 153 /* Debugger globals */ 154 155 BOOLEAN AcpiGbl_DbTerminateThreads = FALSE; 156 BOOLEAN AcpiGbl_AbortMethod = FALSE; 157 BOOLEAN AcpiGbl_MethodExecuting = FALSE; 158 159 /* System flags */ 160 161 UINT32 AcpiGbl_StartupFlags = 0; 162 163 /* System starts uninitialized */ 164 165 BOOLEAN AcpiGbl_Shutdown = TRUE; 166 167 const char *AcpiGbl_SleepStateNames[ACPI_S_STATE_COUNT] = 168 { 169 "\\_S0_", 170 "\\_S1_", 171 "\\_S2_", 172 "\\_S3_", 173 "\\_S4_", 174 "\\_S5_" 175 }; 176 177 const char *AcpiGbl_HighestDstateNames[4] = 178 { 179 "_S1D", 180 "_S2D", 181 "_S3D", 182 "_S4D" 183 }; 184 185 186 /******************************************************************************* 187 * 188 * FUNCTION: AcpiFormatException 189 * 190 * PARAMETERS: Status - The ACPI_STATUS code to be formatted 191 * 192 * RETURN: A string containing the exception text. A valid pointer is 193 * always returned. 194 * 195 * DESCRIPTION: This function translates an ACPI exception into an ASCII string 196 * It is here instead of utxface.c so it is always present. 197 * 198 ******************************************************************************/ 199 200 const char * 201 AcpiFormatException ( 202 ACPI_STATUS Status) 203 { 204 const char *Exception = NULL; 205 206 207 ACPI_FUNCTION_ENTRY (); 208 209 210 Exception = AcpiUtValidateException (Status); 211 if (!Exception) 212 { 213 /* Exception code was not recognized */ 214 215 ACPI_ERROR ((AE_INFO, 216 "Unknown exception code: 0x%8.8X", Status)); 217 218 Exception = "UNKNOWN_STATUS_CODE"; 219 } 220 221 return (ACPI_CAST_PTR (const char, Exception)); 222 } 223 224 ACPI_EXPORT_SYMBOL (AcpiFormatException) 225 226 227 /******************************************************************************* 228 * 229 * Namespace globals 230 * 231 ******************************************************************************/ 232 233 /* 234 * Predefined ACPI Names (Built-in to the Interpreter) 235 * 236 * NOTES: 237 * 1) _SB_ is defined to be a device to allow \_SB_._INI to be run 238 * during the initialization sequence. 239 * 2) _TZ_ is defined to be a thermal zone in order to allow ASL code to 240 * perform a Notify() operation on it. 241 */ 242 const ACPI_PREDEFINED_NAMES AcpiGbl_PreDefinedNames[] = 243 { 244 {"_GPE", ACPI_TYPE_LOCAL_SCOPE, NULL}, 245 {"_PR_", ACPI_TYPE_LOCAL_SCOPE, NULL}, 246 {"_SB_", ACPI_TYPE_DEVICE, NULL}, 247 {"_SI_", ACPI_TYPE_LOCAL_SCOPE, NULL}, 248 {"_TZ_", ACPI_TYPE_THERMAL, NULL}, 249 {"_REV", ACPI_TYPE_INTEGER, (char *) ACPI_CA_SUPPORT_LEVEL}, 250 {"_OS_", ACPI_TYPE_STRING, ACPI_OS_NAME}, 251 {"_GL_", ACPI_TYPE_MUTEX, (char *) 1}, 252 253 #if !defined (ACPI_NO_METHOD_EXECUTION) || defined (ACPI_CONSTANT_EVAL_ONLY) 254 {"_OSI", ACPI_TYPE_METHOD, (char *) 1}, 255 #endif 256 257 /* Table terminator */ 258 259 {NULL, ACPI_TYPE_ANY, NULL} 260 }; 261 262 /* 263 * Properties of the ACPI Object Types, both internal and external. 264 * The table is indexed by values of ACPI_OBJECT_TYPE 265 */ 266 const UINT8 AcpiGbl_NsProperties[ACPI_NUM_NS_TYPES] = 267 { 268 ACPI_NS_NORMAL, /* 00 Any */ 269 ACPI_NS_NORMAL, /* 01 Number */ 270 ACPI_NS_NORMAL, /* 02 String */ 271 ACPI_NS_NORMAL, /* 03 Buffer */ 272 ACPI_NS_NORMAL, /* 04 Package */ 273 ACPI_NS_NORMAL, /* 05 FieldUnit */ 274 ACPI_NS_NEWSCOPE, /* 06 Device */ 275 ACPI_NS_NORMAL, /* 07 Event */ 276 ACPI_NS_NEWSCOPE, /* 08 Method */ 277 ACPI_NS_NORMAL, /* 09 Mutex */ 278 ACPI_NS_NORMAL, /* 10 Region */ 279 ACPI_NS_NEWSCOPE, /* 11 Power */ 280 ACPI_NS_NEWSCOPE, /* 12 Processor */ 281 ACPI_NS_NEWSCOPE, /* 13 Thermal */ 282 ACPI_NS_NORMAL, /* 14 BufferField */ 283 ACPI_NS_NORMAL, /* 15 DdbHandle */ 284 ACPI_NS_NORMAL, /* 16 Debug Object */ 285 ACPI_NS_NORMAL, /* 17 DefField */ 286 ACPI_NS_NORMAL, /* 18 BankField */ 287 ACPI_NS_NORMAL, /* 19 IndexField */ 288 ACPI_NS_NORMAL, /* 20 Reference */ 289 ACPI_NS_NORMAL, /* 21 Alias */ 290 ACPI_NS_NORMAL, /* 22 MethodAlias */ 291 ACPI_NS_NORMAL, /* 23 Notify */ 292 ACPI_NS_NORMAL, /* 24 Address Handler */ 293 ACPI_NS_NEWSCOPE | ACPI_NS_LOCAL, /* 25 Resource Desc */ 294 ACPI_NS_NEWSCOPE | ACPI_NS_LOCAL, /* 26 Resource Field */ 295 ACPI_NS_NEWSCOPE, /* 27 Scope */ 296 ACPI_NS_NORMAL, /* 28 Extra */ 297 ACPI_NS_NORMAL, /* 29 Data */ 298 ACPI_NS_NORMAL /* 30 Invalid */ 299 }; 300 301 302 /* Hex to ASCII conversion table */ 303 304 static const char AcpiGbl_HexToAscii[] = 305 { 306 '0','1','2','3','4','5','6','7', 307 '8','9','A','B','C','D','E','F' 308 }; 309 310 311 /******************************************************************************* 312 * 313 * FUNCTION: AcpiUtHexToAsciiChar 314 * 315 * PARAMETERS: Integer - Contains the hex digit 316 * Position - bit position of the digit within the 317 * integer (multiple of 4) 318 * 319 * RETURN: The converted Ascii character 320 * 321 * DESCRIPTION: Convert a hex digit to an Ascii character 322 * 323 ******************************************************************************/ 324 325 char 326 AcpiUtHexToAsciiChar ( 327 ACPI_INTEGER Integer, 328 UINT32 Position) 329 { 330 331 return (AcpiGbl_HexToAscii[(Integer >> Position) & 0xF]); 332 } 333 334 335 /****************************************************************************** 336 * 337 * Event and Hardware globals 338 * 339 ******************************************************************************/ 340 341 ACPI_BIT_REGISTER_INFO AcpiGbl_BitRegisterInfo[ACPI_NUM_BITREG] = 342 { 343 /* Name Parent Register Register Bit Position Register Bit Mask */ 344 345 /* ACPI_BITREG_TIMER_STATUS */ {ACPI_REGISTER_PM1_STATUS, ACPI_BITPOSITION_TIMER_STATUS, ACPI_BITMASK_TIMER_STATUS}, 346 /* ACPI_BITREG_BUS_MASTER_STATUS */ {ACPI_REGISTER_PM1_STATUS, ACPI_BITPOSITION_BUS_MASTER_STATUS, ACPI_BITMASK_BUS_MASTER_STATUS}, 347 /* ACPI_BITREG_GLOBAL_LOCK_STATUS */ {ACPI_REGISTER_PM1_STATUS, ACPI_BITPOSITION_GLOBAL_LOCK_STATUS, ACPI_BITMASK_GLOBAL_LOCK_STATUS}, 348 /* ACPI_BITREG_POWER_BUTTON_STATUS */ {ACPI_REGISTER_PM1_STATUS, ACPI_BITPOSITION_POWER_BUTTON_STATUS, ACPI_BITMASK_POWER_BUTTON_STATUS}, 349 /* ACPI_BITREG_SLEEP_BUTTON_STATUS */ {ACPI_REGISTER_PM1_STATUS, ACPI_BITPOSITION_SLEEP_BUTTON_STATUS, ACPI_BITMASK_SLEEP_BUTTON_STATUS}, 350 /* ACPI_BITREG_RT_CLOCK_STATUS */ {ACPI_REGISTER_PM1_STATUS, ACPI_BITPOSITION_RT_CLOCK_STATUS, ACPI_BITMASK_RT_CLOCK_STATUS}, 351 /* ACPI_BITREG_WAKE_STATUS */ {ACPI_REGISTER_PM1_STATUS, ACPI_BITPOSITION_WAKE_STATUS, ACPI_BITMASK_WAKE_STATUS}, 352 /* ACPI_BITREG_PCIEXP_WAKE_STATUS */ {ACPI_REGISTER_PM1_STATUS, ACPI_BITPOSITION_PCIEXP_WAKE_STATUS, ACPI_BITMASK_PCIEXP_WAKE_STATUS}, 353 354 /* ACPI_BITREG_TIMER_ENABLE */ {ACPI_REGISTER_PM1_ENABLE, ACPI_BITPOSITION_TIMER_ENABLE, ACPI_BITMASK_TIMER_ENABLE}, 355 /* ACPI_BITREG_GLOBAL_LOCK_ENABLE */ {ACPI_REGISTER_PM1_ENABLE, ACPI_BITPOSITION_GLOBAL_LOCK_ENABLE, ACPI_BITMASK_GLOBAL_LOCK_ENABLE}, 356 /* ACPI_BITREG_POWER_BUTTON_ENABLE */ {ACPI_REGISTER_PM1_ENABLE, ACPI_BITPOSITION_POWER_BUTTON_ENABLE, ACPI_BITMASK_POWER_BUTTON_ENABLE}, 357 /* ACPI_BITREG_SLEEP_BUTTON_ENABLE */ {ACPI_REGISTER_PM1_ENABLE, ACPI_BITPOSITION_SLEEP_BUTTON_ENABLE, ACPI_BITMASK_SLEEP_BUTTON_ENABLE}, 358 /* ACPI_BITREG_RT_CLOCK_ENABLE */ {ACPI_REGISTER_PM1_ENABLE, ACPI_BITPOSITION_RT_CLOCK_ENABLE, ACPI_BITMASK_RT_CLOCK_ENABLE}, 359 /* ACPI_BITREG_WAKE_ENABLE */ {ACPI_REGISTER_PM1_ENABLE, 0, 0}, 360 /* ACPI_BITREG_PCIEXP_WAKE_DISABLE */ {ACPI_REGISTER_PM1_ENABLE, ACPI_BITPOSITION_PCIEXP_WAKE_DISABLE, ACPI_BITMASK_PCIEXP_WAKE_DISABLE}, 361 362 /* ACPI_BITREG_SCI_ENABLE */ {ACPI_REGISTER_PM1_CONTROL, ACPI_BITPOSITION_SCI_ENABLE, ACPI_BITMASK_SCI_ENABLE}, 363 /* ACPI_BITREG_BUS_MASTER_RLD */ {ACPI_REGISTER_PM1_CONTROL, ACPI_BITPOSITION_BUS_MASTER_RLD, ACPI_BITMASK_BUS_MASTER_RLD}, 364 /* ACPI_BITREG_GLOBAL_LOCK_RELEASE */ {ACPI_REGISTER_PM1_CONTROL, ACPI_BITPOSITION_GLOBAL_LOCK_RELEASE, ACPI_BITMASK_GLOBAL_LOCK_RELEASE}, 365 /* ACPI_BITREG_SLEEP_TYPE_A */ {ACPI_REGISTER_PM1_CONTROL, ACPI_BITPOSITION_SLEEP_TYPE_X, ACPI_BITMASK_SLEEP_TYPE_X}, 366 /* ACPI_BITREG_SLEEP_TYPE_B */ {ACPI_REGISTER_PM1_CONTROL, ACPI_BITPOSITION_SLEEP_TYPE_X, ACPI_BITMASK_SLEEP_TYPE_X}, 367 /* ACPI_BITREG_SLEEP_ENABLE */ {ACPI_REGISTER_PM1_CONTROL, ACPI_BITPOSITION_SLEEP_ENABLE, ACPI_BITMASK_SLEEP_ENABLE}, 368 369 /* ACPI_BITREG_ARB_DIS */ {ACPI_REGISTER_PM2_CONTROL, ACPI_BITPOSITION_ARB_DISABLE, ACPI_BITMASK_ARB_DISABLE} 370 }; 371 372 373 ACPI_FIXED_EVENT_INFO AcpiGbl_FixedEventInfo[ACPI_NUM_FIXED_EVENTS] = 374 { 375 /* ACPI_EVENT_PMTIMER */ {ACPI_BITREG_TIMER_STATUS, ACPI_BITREG_TIMER_ENABLE, ACPI_BITMASK_TIMER_STATUS, ACPI_BITMASK_TIMER_ENABLE}, 376 /* ACPI_EVENT_GLOBAL */ {ACPI_BITREG_GLOBAL_LOCK_STATUS, ACPI_BITREG_GLOBAL_LOCK_ENABLE, ACPI_BITMASK_GLOBAL_LOCK_STATUS, ACPI_BITMASK_GLOBAL_LOCK_ENABLE}, 377 /* ACPI_EVENT_POWER_BUTTON */ {ACPI_BITREG_POWER_BUTTON_STATUS, ACPI_BITREG_POWER_BUTTON_ENABLE, ACPI_BITMASK_POWER_BUTTON_STATUS, ACPI_BITMASK_POWER_BUTTON_ENABLE}, 378 /* ACPI_EVENT_SLEEP_BUTTON */ {ACPI_BITREG_SLEEP_BUTTON_STATUS, ACPI_BITREG_SLEEP_BUTTON_ENABLE, ACPI_BITMASK_SLEEP_BUTTON_STATUS, ACPI_BITMASK_SLEEP_BUTTON_ENABLE}, 379 /* ACPI_EVENT_RTC */ {ACPI_BITREG_RT_CLOCK_STATUS, ACPI_BITREG_RT_CLOCK_ENABLE, ACPI_BITMASK_RT_CLOCK_STATUS, ACPI_BITMASK_RT_CLOCK_ENABLE}, 380 }; 381 382 /******************************************************************************* 383 * 384 * FUNCTION: AcpiUtGetRegionName 385 * 386 * PARAMETERS: None. 387 * 388 * RETURN: Status 389 * 390 * DESCRIPTION: Translate a Space ID into a name string (Debug only) 391 * 392 ******************************************************************************/ 393 394 /* Region type decoding */ 395 396 const char *AcpiGbl_RegionTypes[ACPI_NUM_PREDEFINED_REGIONS] = 397 { 398 "SystemMemory", 399 "SystemIO", 400 "PCI_Config", 401 "EmbeddedControl", 402 "SMBus", 403 "CMOS", 404 "PCIBARTarget", 405 "DataTable" 406 }; 407 408 409 char * 410 AcpiUtGetRegionName ( 411 UINT8 SpaceId) 412 { 413 414 if (SpaceId >= ACPI_USER_REGION_BEGIN) 415 { 416 return ("UserDefinedRegion"); 417 } 418 else if (SpaceId >= ACPI_NUM_PREDEFINED_REGIONS) 419 { 420 return ("InvalidSpaceId"); 421 } 422 423 return (ACPI_CAST_PTR (char, AcpiGbl_RegionTypes[SpaceId])); 424 } 425 426 427 /******************************************************************************* 428 * 429 * FUNCTION: AcpiUtGetEventName 430 * 431 * PARAMETERS: None. 432 * 433 * RETURN: Status 434 * 435 * DESCRIPTION: Translate a Event ID into a name string (Debug only) 436 * 437 ******************************************************************************/ 438 439 /* Event type decoding */ 440 441 static const char *AcpiGbl_EventTypes[ACPI_NUM_FIXED_EVENTS] = 442 { 443 "PM_Timer", 444 "GlobalLock", 445 "PowerButton", 446 "SleepButton", 447 "RealTimeClock", 448 }; 449 450 451 char * 452 AcpiUtGetEventName ( 453 UINT32 EventId) 454 { 455 456 if (EventId > ACPI_EVENT_MAX) 457 { 458 return ("InvalidEventID"); 459 } 460 461 return (ACPI_CAST_PTR (char, AcpiGbl_EventTypes[EventId])); 462 } 463 464 465 /******************************************************************************* 466 * 467 * FUNCTION: AcpiUtGetTypeName 468 * 469 * PARAMETERS: None. 470 * 471 * RETURN: Status 472 * 473 * DESCRIPTION: Translate a Type ID into a name string (Debug only) 474 * 475 ******************************************************************************/ 476 477 /* 478 * Elements of AcpiGbl_NsTypeNames below must match 479 * one-to-one with values of ACPI_OBJECT_TYPE 480 * 481 * The type ACPI_TYPE_ANY (Untyped) is used as a "don't care" when searching; 482 * when stored in a table it really means that we have thus far seen no 483 * evidence to indicate what type is actually going to be stored for this entry. 484 */ 485 static const char AcpiGbl_BadType[] = "UNDEFINED"; 486 487 /* Printable names of the ACPI object types */ 488 489 static const char *AcpiGbl_NsTypeNames[] = 490 { 491 /* 00 */ "Untyped", 492 /* 01 */ "Integer", 493 /* 02 */ "String", 494 /* 03 */ "Buffer", 495 /* 04 */ "Package", 496 /* 05 */ "FieldUnit", 497 /* 06 */ "Device", 498 /* 07 */ "Event", 499 /* 08 */ "Method", 500 /* 09 */ "Mutex", 501 /* 10 */ "Region", 502 /* 11 */ "Power", 503 /* 12 */ "Processor", 504 /* 13 */ "Thermal", 505 /* 14 */ "BufferField", 506 /* 15 */ "DdbHandle", 507 /* 16 */ "DebugObject", 508 /* 17 */ "RegionField", 509 /* 18 */ "BankField", 510 /* 19 */ "IndexField", 511 /* 20 */ "Reference", 512 /* 21 */ "Alias", 513 /* 22 */ "MethodAlias", 514 /* 23 */ "Notify", 515 /* 24 */ "AddrHandler", 516 /* 25 */ "ResourceDesc", 517 /* 26 */ "ResourceFld", 518 /* 27 */ "Scope", 519 /* 28 */ "Extra", 520 /* 29 */ "Data", 521 /* 30 */ "Invalid" 522 }; 523 524 525 char * 526 AcpiUtGetTypeName ( 527 ACPI_OBJECT_TYPE Type) 528 { 529 530 if (Type > ACPI_TYPE_INVALID) 531 { 532 return (ACPI_CAST_PTR (char, AcpiGbl_BadType)); 533 } 534 535 return (ACPI_CAST_PTR (char, AcpiGbl_NsTypeNames[Type])); 536 } 537 538 539 char * 540 AcpiUtGetObjectTypeName ( 541 ACPI_OPERAND_OBJECT *ObjDesc) 542 { 543 544 if (!ObjDesc) 545 { 546 return ("[NULL Object Descriptor]"); 547 } 548 549 return (AcpiUtGetTypeName (ACPI_GET_OBJECT_TYPE (ObjDesc))); 550 } 551 552 553 /******************************************************************************* 554 * 555 * FUNCTION: AcpiUtGetNodeName 556 * 557 * PARAMETERS: Object - A namespace node 558 * 559 * RETURN: Pointer to a string 560 * 561 * DESCRIPTION: Validate the node and return the node's ACPI name. 562 * 563 ******************************************************************************/ 564 565 char * 566 AcpiUtGetNodeName ( 567 void *Object) 568 { 569 ACPI_NAMESPACE_NODE *Node = (ACPI_NAMESPACE_NODE *) Object; 570 571 572 /* Must return a string of exactly 4 characters == ACPI_NAME_SIZE */ 573 574 if (!Object) 575 { 576 return ("NULL"); 577 } 578 579 /* Check for Root node */ 580 581 if ((Object == ACPI_ROOT_OBJECT) || 582 (Object == AcpiGbl_RootNode)) 583 { 584 return ("\"\\\" "); 585 } 586 587 /* Descriptor must be a namespace node */ 588 589 if (ACPI_GET_DESCRIPTOR_TYPE (Node) != ACPI_DESC_TYPE_NAMED) 590 { 591 return ("####"); 592 } 593 594 /* 595 * Ensure name is valid. The name was validated/repaired when the node 596 * was created, but make sure it has not been corrupted. 597 */ 598 AcpiUtRepairName (Node->Name.Ascii); 599 600 /* Return the name */ 601 602 return (Node->Name.Ascii); 603 } 604 605 606 /******************************************************************************* 607 * 608 * FUNCTION: AcpiUtGetDescriptorName 609 * 610 * PARAMETERS: Object - An ACPI object 611 * 612 * RETURN: Pointer to a string 613 * 614 * DESCRIPTION: Validate object and return the descriptor type 615 * 616 ******************************************************************************/ 617 618 /* Printable names of object descriptor types */ 619 620 static const char *AcpiGbl_DescTypeNames[] = 621 { 622 /* 00 */ "Invalid", 623 /* 01 */ "Cached", 624 /* 02 */ "State-Generic", 625 /* 03 */ "State-Update", 626 /* 04 */ "State-Package", 627 /* 05 */ "State-Control", 628 /* 06 */ "State-RootParseScope", 629 /* 07 */ "State-ParseScope", 630 /* 08 */ "State-WalkScope", 631 /* 09 */ "State-Result", 632 /* 10 */ "State-Notify", 633 /* 11 */ "State-Thread", 634 /* 12 */ "Walk", 635 /* 13 */ "Parser", 636 /* 14 */ "Operand", 637 /* 15 */ "Node" 638 }; 639 640 641 char * 642 AcpiUtGetDescriptorName ( 643 void *Object) 644 { 645 646 if (!Object) 647 { 648 return ("NULL OBJECT"); 649 } 650 651 if (ACPI_GET_DESCRIPTOR_TYPE (Object) > ACPI_DESC_TYPE_MAX) 652 { 653 return (ACPI_CAST_PTR (char, AcpiGbl_BadType)); 654 } 655 656 return (ACPI_CAST_PTR (char, 657 AcpiGbl_DescTypeNames[ACPI_GET_DESCRIPTOR_TYPE (Object)])); 658 659 } 660 661 662 /******************************************************************************* 663 * 664 * FUNCTION: AcpiUtGetReferenceName 665 * 666 * PARAMETERS: Object - An ACPI reference object 667 * 668 * RETURN: Pointer to a string 669 * 670 * DESCRIPTION: Decode a reference object sub-type to a string. 671 * 672 ******************************************************************************/ 673 674 /* Printable names of reference object sub-types */ 675 676 static const char *AcpiGbl_RefClassNames[] = 677 { 678 /* 00 */ "Local", 679 /* 01 */ "Argument", 680 /* 02 */ "RefOf", 681 /* 03 */ "Index", 682 /* 04 */ "DdbHandle", 683 /* 05 */ "Named Object", 684 /* 06 */ "Debug" 685 }; 686 687 const char * 688 AcpiUtGetReferenceName ( 689 ACPI_OPERAND_OBJECT *Object) 690 { 691 692 if (!Object) 693 { 694 return ("NULL Object"); 695 } 696 697 if (ACPI_GET_DESCRIPTOR_TYPE (Object) != ACPI_DESC_TYPE_OPERAND) 698 { 699 return ("Not an Operand object"); 700 } 701 702 if (Object->Common.Type != ACPI_TYPE_LOCAL_REFERENCE) 703 { 704 return ("Not a Reference object"); 705 } 706 707 if (Object->Reference.Class > ACPI_REFCLASS_MAX) 708 { 709 return ("Unknown Reference class"); 710 } 711 712 return (AcpiGbl_RefClassNames[Object->Reference.Class]); 713 } 714 715 716 #if defined(ACPI_DEBUG_OUTPUT) || defined(ACPI_DEBUGGER) 717 /* 718 * Strings and procedures used for debug only 719 */ 720 721 /******************************************************************************* 722 * 723 * FUNCTION: AcpiUtGetMutexName 724 * 725 * PARAMETERS: MutexId - The predefined ID for this mutex. 726 * 727 * RETURN: String containing the name of the mutex. Always returns a valid 728 * pointer. 729 * 730 * DESCRIPTION: Translate a mutex ID into a name string (Debug only) 731 * 732 ******************************************************************************/ 733 734 char * 735 AcpiUtGetMutexName ( 736 UINT32 MutexId) 737 { 738 739 if (MutexId > ACPI_MAX_MUTEX) 740 { 741 return ("Invalid Mutex ID"); 742 } 743 744 return (AcpiGbl_MutexNames[MutexId]); 745 } 746 747 748 /******************************************************************************* 749 * 750 * FUNCTION: AcpiUtGetNotifyName 751 * 752 * PARAMETERS: NotifyValue - Value from the Notify() request 753 * 754 * RETURN: String corresponding to the Notify Value. 755 * 756 * DESCRIPTION: Translate a Notify Value to a notify namestring. 757 * 758 ******************************************************************************/ 759 760 /* Names for Notify() values, used for debug output */ 761 762 static const char *AcpiGbl_NotifyValueNames[] = 763 { 764 "Bus Check", 765 "Device Check", 766 "Device Wake", 767 "Eject Request", 768 "Device Check Light", 769 "Frequency Mismatch", 770 "Bus Mode Mismatch", 771 "Power Fault", 772 "Capabilities Check", 773 "Device PLD Check", 774 "Reserved", 775 "System Locality Update" 776 }; 777 778 const char * 779 AcpiUtGetNotifyName ( 780 UINT32 NotifyValue) 781 { 782 783 if (NotifyValue <= ACPI_NOTIFY_MAX) 784 { 785 return (AcpiGbl_NotifyValueNames[NotifyValue]); 786 } 787 else if (NotifyValue <= ACPI_MAX_SYS_NOTIFY) 788 { 789 return ("Reserved"); 790 } 791 else /* Greater or equal to 0x80 */ 792 { 793 return ("**Device Specific**"); 794 } 795 } 796 #endif 797 798 799 /******************************************************************************* 800 * 801 * FUNCTION: AcpiUtValidObjectType 802 * 803 * PARAMETERS: Type - Object type to be validated 804 * 805 * RETURN: TRUE if valid object type, FALSE otherwise 806 * 807 * DESCRIPTION: Validate an object type 808 * 809 ******************************************************************************/ 810 811 BOOLEAN 812 AcpiUtValidObjectType ( 813 ACPI_OBJECT_TYPE Type) 814 { 815 816 if (Type > ACPI_TYPE_LOCAL_MAX) 817 { 818 /* Note: Assumes all TYPEs are contiguous (external/local) */ 819 820 return (FALSE); 821 } 822 823 return (TRUE); 824 } 825 826 827 /******************************************************************************* 828 * 829 * FUNCTION: AcpiUtInitGlobals 830 * 831 * PARAMETERS: None 832 * 833 * RETURN: Status 834 * 835 * DESCRIPTION: Init library globals. All globals that require specific 836 * initialization should be initialized here! 837 * 838 ******************************************************************************/ 839 840 ACPI_STATUS 841 AcpiUtInitGlobals ( 842 void) 843 { 844 ACPI_STATUS Status; 845 UINT32 i; 846 847 848 ACPI_FUNCTION_TRACE (UtInitGlobals); 849 850 851 /* Create all memory caches */ 852 853 Status = AcpiUtCreateCaches (); 854 if (ACPI_FAILURE (Status)) 855 { 856 return_ACPI_STATUS (Status); 857 } 858 859 /* Mutex locked flags */ 860 861 for (i = 0; i < ACPI_NUM_MUTEX; i++) 862 { 863 AcpiGbl_MutexInfo[i].Mutex = NULL; 864 AcpiGbl_MutexInfo[i].ThreadId = ACPI_MUTEX_NOT_ACQUIRED; 865 AcpiGbl_MutexInfo[i].UseCount = 0; 866 } 867 868 for (i = 0; i < ACPI_NUM_OWNERID_MASKS; i++) 869 { 870 AcpiGbl_OwnerIdMask[i] = 0; 871 } 872 AcpiGbl_OwnerIdMask[ACPI_NUM_OWNERID_MASKS - 1] = 0x80000000; /* Last ID is never valid */ 873 874 /* Event counters */ 875 876 AcpiMethodCount = 0; 877 AcpiSciCount = 0; 878 AcpiGpeCount = 0; 879 880 for (i = 0; i < ACPI_NUM_FIXED_EVENTS; i++) 881 { 882 AcpiFixedEventCount[i] = 0; 883 } 884 885 /* GPE support */ 886 887 AcpiGbl_GpeXruptListHead = NULL; 888 AcpiGbl_GpeFadtBlocks[0] = NULL; 889 AcpiGbl_GpeFadtBlocks[1] = NULL; 890 891 /* Global handlers */ 892 893 AcpiGbl_SystemNotify.Handler = NULL; 894 AcpiGbl_DeviceNotify.Handler = NULL; 895 AcpiGbl_ExceptionHandler = NULL; 896 AcpiGbl_InitHandler = NULL; 897 AcpiGbl_TableHandler = NULL; 898 899 /* Global Lock support */ 900 901 AcpiGbl_GlobalLockSemaphore = NULL; 902 AcpiGbl_GlobalLockMutex = NULL; 903 AcpiGbl_GlobalLockAcquired = FALSE; 904 AcpiGbl_GlobalLockHandle = 0; 905 906 /* Miscellaneous variables */ 907 908 AcpiGbl_CmSingleStep = FALSE; 909 AcpiGbl_DbTerminateThreads = FALSE; 910 AcpiGbl_Shutdown = FALSE; 911 AcpiGbl_NsLookupCount = 0; 912 AcpiGbl_PsFindCount = 0; 913 AcpiGbl_AcpiHardwarePresent = TRUE; 914 AcpiGbl_LastOwnerIdIndex = 0; 915 AcpiGbl_NextOwnerIdOffset = 0; 916 AcpiGbl_TraceMethodName = 0; 917 AcpiGbl_TraceDbgLevel = 0; 918 AcpiGbl_TraceDbgLayer = 0; 919 AcpiGbl_DebuggerConfiguration = DEBUGGER_THREADING; 920 AcpiGbl_DbOutputFlags = ACPI_DB_CONSOLE_OUTPUT; 921 922 /* Hardware oriented */ 923 924 AcpiGbl_EventsInitialized = FALSE; 925 AcpiGbl_SystemAwakeAndRunning = TRUE; 926 927 /* Namespace */ 928 929 AcpiGbl_RootNode = NULL; 930 AcpiGbl_RootNodeStruct.Name.Integer = ACPI_ROOT_NAME; 931 AcpiGbl_RootNodeStruct.DescriptorType = ACPI_DESC_TYPE_NAMED; 932 AcpiGbl_RootNodeStruct.Type = ACPI_TYPE_DEVICE; 933 AcpiGbl_RootNodeStruct.Child = NULL; 934 AcpiGbl_RootNodeStruct.Peer = NULL; 935 AcpiGbl_RootNodeStruct.Object = NULL; 936 AcpiGbl_RootNodeStruct.Flags = ANOBJ_END_OF_PEER_LIST; 937 938 939 #ifdef ACPI_DEBUG_OUTPUT 940 AcpiGbl_LowestStackPointer = ACPI_CAST_PTR (ACPI_SIZE, ACPI_SIZE_MAX); 941 #endif 942 943 #ifdef ACPI_DBG_TRACK_ALLOCATIONS 944 AcpiGbl_DisplayFinalMemStats = FALSE; 945 #endif 946 947 return_ACPI_STATUS (AE_OK); 948 } 949 950 /* Public globals */ 951 952 ACPI_EXPORT_SYMBOL (AcpiDbgLevel) 953 ACPI_EXPORT_SYMBOL (AcpiDbgLayer) 954 ACPI_EXPORT_SYMBOL (AcpiGpeCount) 955 956 957