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