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_HighestDstateNames[4] = 176 { 177 "_S1D", 178 "_S2D", 179 "_S3D", 180 "_S4D" 181 }; 182 183 184 /******************************************************************************* 185 * 186 * FUNCTION: AcpiFormatException 187 * 188 * PARAMETERS: Status - The ACPI_STATUS code to be formatted 189 * 190 * RETURN: A string containing the exception text. A valid pointer is 191 * always returned. 192 * 193 * DESCRIPTION: This function translates an ACPI exception into an ASCII string 194 * It is here instead of utxface.c so it is always present. 195 * 196 ******************************************************************************/ 197 198 const char * 199 AcpiFormatException ( 200 ACPI_STATUS Status) 201 { 202 const char *Exception = NULL; 203 204 205 ACPI_FUNCTION_ENTRY (); 206 207 208 Exception = AcpiUtValidateException (Status); 209 if (!Exception) 210 { 211 /* Exception code was not recognized */ 212 213 ACPI_ERROR ((AE_INFO, 214 "Unknown exception code: 0x%8.8X", Status)); 215 216 Exception = "UNKNOWN_STATUS_CODE"; 217 } 218 219 return (ACPI_CAST_PTR (const char, Exception)); 220 } 221 222 ACPI_EXPORT_SYMBOL (AcpiFormatException) 223 224 225 /******************************************************************************* 226 * 227 * Namespace globals 228 * 229 ******************************************************************************/ 230 231 /* 232 * Predefined ACPI Names (Built-in to the Interpreter) 233 * 234 * NOTES: 235 * 1) _SB_ is defined to be a device to allow \_SB_._INI to be run 236 * during the initialization sequence. 237 * 2) _TZ_ is defined to be a thermal zone in order to allow ASL code to 238 * perform a Notify() operation on it. 239 */ 240 const ACPI_PREDEFINED_NAMES AcpiGbl_PreDefinedNames[] = 241 { 242 {"_GPE", ACPI_TYPE_LOCAL_SCOPE, NULL}, 243 {"_PR_", ACPI_TYPE_LOCAL_SCOPE, NULL}, 244 {"_SB_", ACPI_TYPE_DEVICE, NULL}, 245 {"_SI_", ACPI_TYPE_LOCAL_SCOPE, NULL}, 246 {"_TZ_", ACPI_TYPE_THERMAL, NULL}, 247 {"_REV", ACPI_TYPE_INTEGER, (char *) ACPI_CA_SUPPORT_LEVEL}, 248 {"_OS_", ACPI_TYPE_STRING, ACPI_OS_NAME}, 249 {"_GL_", ACPI_TYPE_MUTEX, (char *) 1}, 250 251 #if !defined (ACPI_NO_METHOD_EXECUTION) || defined (ACPI_CONSTANT_EVAL_ONLY) 252 {"_OSI", ACPI_TYPE_METHOD, (char *) 1}, 253 #endif 254 255 /* Table terminator */ 256 257 {NULL, ACPI_TYPE_ANY, NULL} 258 }; 259 260 /* 261 * Properties of the ACPI Object Types, both internal and external. 262 * The table is indexed by values of ACPI_OBJECT_TYPE 263 */ 264 const UINT8 AcpiGbl_NsProperties[ACPI_NUM_NS_TYPES] = 265 { 266 ACPI_NS_NORMAL, /* 00 Any */ 267 ACPI_NS_NORMAL, /* 01 Number */ 268 ACPI_NS_NORMAL, /* 02 String */ 269 ACPI_NS_NORMAL, /* 03 Buffer */ 270 ACPI_NS_NORMAL, /* 04 Package */ 271 ACPI_NS_NORMAL, /* 05 FieldUnit */ 272 ACPI_NS_NEWSCOPE, /* 06 Device */ 273 ACPI_NS_NORMAL, /* 07 Event */ 274 ACPI_NS_NEWSCOPE, /* 08 Method */ 275 ACPI_NS_NORMAL, /* 09 Mutex */ 276 ACPI_NS_NORMAL, /* 10 Region */ 277 ACPI_NS_NEWSCOPE, /* 11 Power */ 278 ACPI_NS_NEWSCOPE, /* 12 Processor */ 279 ACPI_NS_NEWSCOPE, /* 13 Thermal */ 280 ACPI_NS_NORMAL, /* 14 BufferField */ 281 ACPI_NS_NORMAL, /* 15 DdbHandle */ 282 ACPI_NS_NORMAL, /* 16 Debug Object */ 283 ACPI_NS_NORMAL, /* 17 DefField */ 284 ACPI_NS_NORMAL, /* 18 BankField */ 285 ACPI_NS_NORMAL, /* 19 IndexField */ 286 ACPI_NS_NORMAL, /* 20 Reference */ 287 ACPI_NS_NORMAL, /* 21 Alias */ 288 ACPI_NS_NORMAL, /* 22 MethodAlias */ 289 ACPI_NS_NORMAL, /* 23 Notify */ 290 ACPI_NS_NORMAL, /* 24 Address Handler */ 291 ACPI_NS_NEWSCOPE | ACPI_NS_LOCAL, /* 25 Resource Desc */ 292 ACPI_NS_NEWSCOPE | ACPI_NS_LOCAL, /* 26 Resource Field */ 293 ACPI_NS_NEWSCOPE, /* 27 Scope */ 294 ACPI_NS_NORMAL, /* 28 Extra */ 295 ACPI_NS_NORMAL, /* 29 Data */ 296 ACPI_NS_NORMAL /* 30 Invalid */ 297 }; 298 299 300 /* Hex to ASCII conversion table */ 301 302 static const char AcpiGbl_HexToAscii[] = 303 { 304 '0','1','2','3','4','5','6','7', 305 '8','9','A','B','C','D','E','F' 306 }; 307 308 309 /******************************************************************************* 310 * 311 * FUNCTION: AcpiUtHexToAsciiChar 312 * 313 * PARAMETERS: Integer - Contains the hex digit 314 * Position - bit position of the digit within the 315 * integer (multiple of 4) 316 * 317 * RETURN: The converted Ascii character 318 * 319 * DESCRIPTION: Convert a hex digit to an Ascii character 320 * 321 ******************************************************************************/ 322 323 char 324 AcpiUtHexToAsciiChar ( 325 ACPI_INTEGER Integer, 326 UINT32 Position) 327 { 328 329 return (AcpiGbl_HexToAscii[(Integer >> Position) & 0xF]); 330 } 331 332 333 /****************************************************************************** 334 * 335 * Event and Hardware globals 336 * 337 ******************************************************************************/ 338 339 ACPI_BIT_REGISTER_INFO AcpiGbl_BitRegisterInfo[ACPI_NUM_BITREG] = 340 { 341 /* Name Parent Register Register Bit Position Register Bit Mask */ 342 343 /* ACPI_BITREG_TIMER_STATUS */ {ACPI_REGISTER_PM1_STATUS, ACPI_BITPOSITION_TIMER_STATUS, ACPI_BITMASK_TIMER_STATUS}, 344 /* ACPI_BITREG_BUS_MASTER_STATUS */ {ACPI_REGISTER_PM1_STATUS, ACPI_BITPOSITION_BUS_MASTER_STATUS, ACPI_BITMASK_BUS_MASTER_STATUS}, 345 /* ACPI_BITREG_GLOBAL_LOCK_STATUS */ {ACPI_REGISTER_PM1_STATUS, ACPI_BITPOSITION_GLOBAL_LOCK_STATUS, ACPI_BITMASK_GLOBAL_LOCK_STATUS}, 346 /* ACPI_BITREG_POWER_BUTTON_STATUS */ {ACPI_REGISTER_PM1_STATUS, ACPI_BITPOSITION_POWER_BUTTON_STATUS, ACPI_BITMASK_POWER_BUTTON_STATUS}, 347 /* ACPI_BITREG_SLEEP_BUTTON_STATUS */ {ACPI_REGISTER_PM1_STATUS, ACPI_BITPOSITION_SLEEP_BUTTON_STATUS, ACPI_BITMASK_SLEEP_BUTTON_STATUS}, 348 /* ACPI_BITREG_RT_CLOCK_STATUS */ {ACPI_REGISTER_PM1_STATUS, ACPI_BITPOSITION_RT_CLOCK_STATUS, ACPI_BITMASK_RT_CLOCK_STATUS}, 349 /* ACPI_BITREG_WAKE_STATUS */ {ACPI_REGISTER_PM1_STATUS, ACPI_BITPOSITION_WAKE_STATUS, ACPI_BITMASK_WAKE_STATUS}, 350 /* ACPI_BITREG_PCIEXP_WAKE_STATUS */ {ACPI_REGISTER_PM1_STATUS, ACPI_BITPOSITION_PCIEXP_WAKE_STATUS, ACPI_BITMASK_PCIEXP_WAKE_STATUS}, 351 352 /* ACPI_BITREG_TIMER_ENABLE */ {ACPI_REGISTER_PM1_ENABLE, ACPI_BITPOSITION_TIMER_ENABLE, ACPI_BITMASK_TIMER_ENABLE}, 353 /* ACPI_BITREG_GLOBAL_LOCK_ENABLE */ {ACPI_REGISTER_PM1_ENABLE, ACPI_BITPOSITION_GLOBAL_LOCK_ENABLE, ACPI_BITMASK_GLOBAL_LOCK_ENABLE}, 354 /* ACPI_BITREG_POWER_BUTTON_ENABLE */ {ACPI_REGISTER_PM1_ENABLE, ACPI_BITPOSITION_POWER_BUTTON_ENABLE, ACPI_BITMASK_POWER_BUTTON_ENABLE}, 355 /* ACPI_BITREG_SLEEP_BUTTON_ENABLE */ {ACPI_REGISTER_PM1_ENABLE, ACPI_BITPOSITION_SLEEP_BUTTON_ENABLE, ACPI_BITMASK_SLEEP_BUTTON_ENABLE}, 356 /* ACPI_BITREG_RT_CLOCK_ENABLE */ {ACPI_REGISTER_PM1_ENABLE, ACPI_BITPOSITION_RT_CLOCK_ENABLE, ACPI_BITMASK_RT_CLOCK_ENABLE}, 357 /* ACPI_BITREG_PCIEXP_WAKE_DISABLE */ {ACPI_REGISTER_PM1_ENABLE, ACPI_BITPOSITION_PCIEXP_WAKE_DISABLE, ACPI_BITMASK_PCIEXP_WAKE_DISABLE}, 358 359 /* ACPI_BITREG_SCI_ENABLE */ {ACPI_REGISTER_PM1_CONTROL, ACPI_BITPOSITION_SCI_ENABLE, ACPI_BITMASK_SCI_ENABLE}, 360 /* ACPI_BITREG_BUS_MASTER_RLD */ {ACPI_REGISTER_PM1_CONTROL, ACPI_BITPOSITION_BUS_MASTER_RLD, ACPI_BITMASK_BUS_MASTER_RLD}, 361 /* ACPI_BITREG_GLOBAL_LOCK_RELEASE */ {ACPI_REGISTER_PM1_CONTROL, ACPI_BITPOSITION_GLOBAL_LOCK_RELEASE, ACPI_BITMASK_GLOBAL_LOCK_RELEASE}, 362 /* ACPI_BITREG_SLEEP_TYPE */ {ACPI_REGISTER_PM1_CONTROL, ACPI_BITPOSITION_SLEEP_TYPE, ACPI_BITMASK_SLEEP_TYPE}, 363 /* ACPI_BITREG_SLEEP_ENABLE */ {ACPI_REGISTER_PM1_CONTROL, ACPI_BITPOSITION_SLEEP_ENABLE, ACPI_BITMASK_SLEEP_ENABLE}, 364 365 /* ACPI_BITREG_ARB_DIS */ {ACPI_REGISTER_PM2_CONTROL, ACPI_BITPOSITION_ARB_DISABLE, ACPI_BITMASK_ARB_DISABLE} 366 }; 367 368 369 ACPI_FIXED_EVENT_INFO AcpiGbl_FixedEventInfo[ACPI_NUM_FIXED_EVENTS] = 370 { 371 /* ACPI_EVENT_PMTIMER */ {ACPI_BITREG_TIMER_STATUS, ACPI_BITREG_TIMER_ENABLE, ACPI_BITMASK_TIMER_STATUS, ACPI_BITMASK_TIMER_ENABLE}, 372 /* ACPI_EVENT_GLOBAL */ {ACPI_BITREG_GLOBAL_LOCK_STATUS, ACPI_BITREG_GLOBAL_LOCK_ENABLE, ACPI_BITMASK_GLOBAL_LOCK_STATUS, ACPI_BITMASK_GLOBAL_LOCK_ENABLE}, 373 /* ACPI_EVENT_POWER_BUTTON */ {ACPI_BITREG_POWER_BUTTON_STATUS, ACPI_BITREG_POWER_BUTTON_ENABLE, ACPI_BITMASK_POWER_BUTTON_STATUS, ACPI_BITMASK_POWER_BUTTON_ENABLE}, 374 /* ACPI_EVENT_SLEEP_BUTTON */ {ACPI_BITREG_SLEEP_BUTTON_STATUS, ACPI_BITREG_SLEEP_BUTTON_ENABLE, ACPI_BITMASK_SLEEP_BUTTON_STATUS, ACPI_BITMASK_SLEEP_BUTTON_ENABLE}, 375 /* ACPI_EVENT_RTC */ {ACPI_BITREG_RT_CLOCK_STATUS, ACPI_BITREG_RT_CLOCK_ENABLE, ACPI_BITMASK_RT_CLOCK_STATUS, ACPI_BITMASK_RT_CLOCK_ENABLE}, 376 }; 377 378 /******************************************************************************* 379 * 380 * FUNCTION: AcpiUtGetRegionName 381 * 382 * PARAMETERS: None. 383 * 384 * RETURN: Status 385 * 386 * DESCRIPTION: Translate a Space ID into a name string (Debug only) 387 * 388 ******************************************************************************/ 389 390 /* Region type decoding */ 391 392 const char *AcpiGbl_RegionTypes[ACPI_NUM_PREDEFINED_REGIONS] = 393 { 394 "SystemMemory", 395 "SystemIO", 396 "PCI_Config", 397 "EmbeddedControl", 398 "SMBus", 399 "SystemCMOS", 400 "PCIBARTarget", 401 "DataTable" 402 }; 403 404 405 char * 406 AcpiUtGetRegionName ( 407 UINT8 SpaceId) 408 { 409 410 if (SpaceId >= ACPI_USER_REGION_BEGIN) 411 { 412 return ("UserDefinedRegion"); 413 } 414 else if (SpaceId >= ACPI_NUM_PREDEFINED_REGIONS) 415 { 416 return ("InvalidSpaceId"); 417 } 418 419 return (ACPI_CAST_PTR (char, AcpiGbl_RegionTypes[SpaceId])); 420 } 421 422 423 /******************************************************************************* 424 * 425 * FUNCTION: AcpiUtGetEventName 426 * 427 * PARAMETERS: None. 428 * 429 * RETURN: Status 430 * 431 * DESCRIPTION: Translate a Event ID into a name string (Debug only) 432 * 433 ******************************************************************************/ 434 435 /* Event type decoding */ 436 437 static const char *AcpiGbl_EventTypes[ACPI_NUM_FIXED_EVENTS] = 438 { 439 "PM_Timer", 440 "GlobalLock", 441 "PowerButton", 442 "SleepButton", 443 "RealTimeClock", 444 }; 445 446 447 char * 448 AcpiUtGetEventName ( 449 UINT32 EventId) 450 { 451 452 if (EventId > ACPI_EVENT_MAX) 453 { 454 return ("InvalidEventID"); 455 } 456 457 return (ACPI_CAST_PTR (char, AcpiGbl_EventTypes[EventId])); 458 } 459 460 461 /******************************************************************************* 462 * 463 * FUNCTION: AcpiUtGetTypeName 464 * 465 * PARAMETERS: None. 466 * 467 * RETURN: Status 468 * 469 * DESCRIPTION: Translate a Type ID into a name string (Debug only) 470 * 471 ******************************************************************************/ 472 473 /* 474 * Elements of AcpiGbl_NsTypeNames below must match 475 * one-to-one with values of ACPI_OBJECT_TYPE 476 * 477 * The type ACPI_TYPE_ANY (Untyped) is used as a "don't care" when searching; 478 * when stored in a table it really means that we have thus far seen no 479 * evidence to indicate what type is actually going to be stored for this entry. 480 */ 481 static const char AcpiGbl_BadType[] = "UNDEFINED"; 482 483 /* Printable names of the ACPI object types */ 484 485 static const char *AcpiGbl_NsTypeNames[] = 486 { 487 /* 00 */ "Untyped", 488 /* 01 */ "Integer", 489 /* 02 */ "String", 490 /* 03 */ "Buffer", 491 /* 04 */ "Package", 492 /* 05 */ "FieldUnit", 493 /* 06 */ "Device", 494 /* 07 */ "Event", 495 /* 08 */ "Method", 496 /* 09 */ "Mutex", 497 /* 10 */ "Region", 498 /* 11 */ "Power", 499 /* 12 */ "Processor", 500 /* 13 */ "Thermal", 501 /* 14 */ "BufferField", 502 /* 15 */ "DdbHandle", 503 /* 16 */ "DebugObject", 504 /* 17 */ "RegionField", 505 /* 18 */ "BankField", 506 /* 19 */ "IndexField", 507 /* 20 */ "Reference", 508 /* 21 */ "Alias", 509 /* 22 */ "MethodAlias", 510 /* 23 */ "Notify", 511 /* 24 */ "AddrHandler", 512 /* 25 */ "ResourceDesc", 513 /* 26 */ "ResourceFld", 514 /* 27 */ "Scope", 515 /* 28 */ "Extra", 516 /* 29 */ "Data", 517 /* 30 */ "Invalid" 518 }; 519 520 521 char * 522 AcpiUtGetTypeName ( 523 ACPI_OBJECT_TYPE Type) 524 { 525 526 if (Type > ACPI_TYPE_INVALID) 527 { 528 return (ACPI_CAST_PTR (char, AcpiGbl_BadType)); 529 } 530 531 return (ACPI_CAST_PTR (char, AcpiGbl_NsTypeNames[Type])); 532 } 533 534 535 char * 536 AcpiUtGetObjectTypeName ( 537 ACPI_OPERAND_OBJECT *ObjDesc) 538 { 539 540 if (!ObjDesc) 541 { 542 return ("[NULL Object Descriptor]"); 543 } 544 545 return (AcpiUtGetTypeName (ObjDesc->Common.Type)); 546 } 547 548 549 /******************************************************************************* 550 * 551 * FUNCTION: AcpiUtGetNodeName 552 * 553 * PARAMETERS: Object - A namespace node 554 * 555 * RETURN: Pointer to a string 556 * 557 * DESCRIPTION: Validate the node and return the node's ACPI name. 558 * 559 ******************************************************************************/ 560 561 char * 562 AcpiUtGetNodeName ( 563 void *Object) 564 { 565 ACPI_NAMESPACE_NODE *Node = (ACPI_NAMESPACE_NODE *) Object; 566 567 568 /* Must return a string of exactly 4 characters == ACPI_NAME_SIZE */ 569 570 if (!Object) 571 { 572 return ("NULL"); 573 } 574 575 /* Check for Root node */ 576 577 if ((Object == ACPI_ROOT_OBJECT) || 578 (Object == AcpiGbl_RootNode)) 579 { 580 return ("\"\\\" "); 581 } 582 583 /* Descriptor must be a namespace node */ 584 585 if (ACPI_GET_DESCRIPTOR_TYPE (Node) != ACPI_DESC_TYPE_NAMED) 586 { 587 return ("####"); 588 } 589 590 /* 591 * Ensure name is valid. The name was validated/repaired when the node 592 * was created, but make sure it has not been corrupted. 593 */ 594 AcpiUtRepairName (Node->Name.Ascii); 595 596 /* Return the name */ 597 598 return (Node->Name.Ascii); 599 } 600 601 602 /******************************************************************************* 603 * 604 * FUNCTION: AcpiUtGetDescriptorName 605 * 606 * PARAMETERS: Object - An ACPI object 607 * 608 * RETURN: Pointer to a string 609 * 610 * DESCRIPTION: Validate object and return the descriptor type 611 * 612 ******************************************************************************/ 613 614 /* Printable names of object descriptor types */ 615 616 static const char *AcpiGbl_DescTypeNames[] = 617 { 618 /* 00 */ "Invalid", 619 /* 01 */ "Cached", 620 /* 02 */ "State-Generic", 621 /* 03 */ "State-Update", 622 /* 04 */ "State-Package", 623 /* 05 */ "State-Control", 624 /* 06 */ "State-RootParseScope", 625 /* 07 */ "State-ParseScope", 626 /* 08 */ "State-WalkScope", 627 /* 09 */ "State-Result", 628 /* 10 */ "State-Notify", 629 /* 11 */ "State-Thread", 630 /* 12 */ "Walk", 631 /* 13 */ "Parser", 632 /* 14 */ "Operand", 633 /* 15 */ "Node" 634 }; 635 636 637 char * 638 AcpiUtGetDescriptorName ( 639 void *Object) 640 { 641 642 if (!Object) 643 { 644 return ("NULL OBJECT"); 645 } 646 647 if (ACPI_GET_DESCRIPTOR_TYPE (Object) > ACPI_DESC_TYPE_MAX) 648 { 649 return (ACPI_CAST_PTR (char, AcpiGbl_BadType)); 650 } 651 652 return (ACPI_CAST_PTR (char, 653 AcpiGbl_DescTypeNames[ACPI_GET_DESCRIPTOR_TYPE (Object)])); 654 655 } 656 657 658 /******************************************************************************* 659 * 660 * FUNCTION: AcpiUtGetReferenceName 661 * 662 * PARAMETERS: Object - An ACPI reference object 663 * 664 * RETURN: Pointer to a string 665 * 666 * DESCRIPTION: Decode a reference object sub-type to a string. 667 * 668 ******************************************************************************/ 669 670 /* Printable names of reference object sub-types */ 671 672 static const char *AcpiGbl_RefClassNames[] = 673 { 674 /* 00 */ "Local", 675 /* 01 */ "Argument", 676 /* 02 */ "RefOf", 677 /* 03 */ "Index", 678 /* 04 */ "DdbHandle", 679 /* 05 */ "Named Object", 680 /* 06 */ "Debug" 681 }; 682 683 const char * 684 AcpiUtGetReferenceName ( 685 ACPI_OPERAND_OBJECT *Object) 686 { 687 688 if (!Object) 689 { 690 return ("NULL Object"); 691 } 692 693 if (ACPI_GET_DESCRIPTOR_TYPE (Object) != ACPI_DESC_TYPE_OPERAND) 694 { 695 return ("Not an Operand object"); 696 } 697 698 if (Object->Common.Type != ACPI_TYPE_LOCAL_REFERENCE) 699 { 700 return ("Not a Reference object"); 701 } 702 703 if (Object->Reference.Class > ACPI_REFCLASS_MAX) 704 { 705 return ("Unknown Reference class"); 706 } 707 708 return (AcpiGbl_RefClassNames[Object->Reference.Class]); 709 } 710 711 712 #if defined(ACPI_DEBUG_OUTPUT) || defined(ACPI_DEBUGGER) 713 /* 714 * Strings and procedures used for debug only 715 */ 716 717 /******************************************************************************* 718 * 719 * FUNCTION: AcpiUtGetMutexName 720 * 721 * PARAMETERS: MutexId - The predefined ID for this mutex. 722 * 723 * RETURN: String containing the name of the mutex. Always returns a valid 724 * pointer. 725 * 726 * DESCRIPTION: Translate a mutex ID into a name string (Debug only) 727 * 728 ******************************************************************************/ 729 730 char * 731 AcpiUtGetMutexName ( 732 UINT32 MutexId) 733 { 734 735 if (MutexId > ACPI_MAX_MUTEX) 736 { 737 return ("Invalid Mutex ID"); 738 } 739 740 return (AcpiGbl_MutexNames[MutexId]); 741 } 742 743 744 /******************************************************************************* 745 * 746 * FUNCTION: AcpiUtGetNotifyName 747 * 748 * PARAMETERS: NotifyValue - Value from the Notify() request 749 * 750 * RETURN: String corresponding to the Notify Value. 751 * 752 * DESCRIPTION: Translate a Notify Value to a notify namestring. 753 * 754 ******************************************************************************/ 755 756 /* Names for Notify() values, used for debug output */ 757 758 static const char *AcpiGbl_NotifyValueNames[] = 759 { 760 "Bus Check", 761 "Device Check", 762 "Device Wake", 763 "Eject Request", 764 "Device Check Light", 765 "Frequency Mismatch", 766 "Bus Mode Mismatch", 767 "Power Fault", 768 "Capabilities Check", 769 "Device PLD Check", 770 "Reserved", 771 "System Locality Update" 772 }; 773 774 const char * 775 AcpiUtGetNotifyName ( 776 UINT32 NotifyValue) 777 { 778 779 if (NotifyValue <= ACPI_NOTIFY_MAX) 780 { 781 return (AcpiGbl_NotifyValueNames[NotifyValue]); 782 } 783 else if (NotifyValue <= ACPI_MAX_SYS_NOTIFY) 784 { 785 return ("Reserved"); 786 } 787 else /* Greater or equal to 0x80 */ 788 { 789 return ("**Device Specific**"); 790 } 791 } 792 #endif 793 794 795 /******************************************************************************* 796 * 797 * FUNCTION: AcpiUtValidObjectType 798 * 799 * PARAMETERS: Type - Object type to be validated 800 * 801 * RETURN: TRUE if valid object type, FALSE otherwise 802 * 803 * DESCRIPTION: Validate an object type 804 * 805 ******************************************************************************/ 806 807 BOOLEAN 808 AcpiUtValidObjectType ( 809 ACPI_OBJECT_TYPE Type) 810 { 811 812 if (Type > ACPI_TYPE_LOCAL_MAX) 813 { 814 /* Note: Assumes all TYPEs are contiguous (external/local) */ 815 816 return (FALSE); 817 } 818 819 return (TRUE); 820 } 821 822 823 /******************************************************************************* 824 * 825 * FUNCTION: AcpiUtInitGlobals 826 * 827 * PARAMETERS: None 828 * 829 * RETURN: Status 830 * 831 * DESCRIPTION: Init library globals. All globals that require specific 832 * initialization should be initialized here! 833 * 834 ******************************************************************************/ 835 836 ACPI_STATUS 837 AcpiUtInitGlobals ( 838 void) 839 { 840 ACPI_STATUS Status; 841 UINT32 i; 842 843 844 ACPI_FUNCTION_TRACE (UtInitGlobals); 845 846 847 /* Create all memory caches */ 848 849 Status = AcpiUtCreateCaches (); 850 if (ACPI_FAILURE (Status)) 851 { 852 return_ACPI_STATUS (Status); 853 } 854 855 /* Mutex locked flags */ 856 857 for (i = 0; i < ACPI_NUM_MUTEX; i++) 858 { 859 AcpiGbl_MutexInfo[i].Mutex = NULL; 860 AcpiGbl_MutexInfo[i].ThreadId = ACPI_MUTEX_NOT_ACQUIRED; 861 AcpiGbl_MutexInfo[i].UseCount = 0; 862 } 863 864 for (i = 0; i < ACPI_NUM_OWNERID_MASKS; i++) 865 { 866 AcpiGbl_OwnerIdMask[i] = 0; 867 } 868 869 /* Last OwnerID is never valid */ 870 871 AcpiGbl_OwnerIdMask[ACPI_NUM_OWNERID_MASKS - 1] = 0x80000000; 872 873 /* Event counters */ 874 875 AcpiMethodCount = 0; 876 AcpiSciCount = 0; 877 AcpiGpeCount = 0; 878 879 for (i = 0; i < ACPI_NUM_FIXED_EVENTS; i++) 880 { 881 AcpiFixedEventCount[i] = 0; 882 } 883 884 /* GPE support */ 885 886 AcpiGbl_GpeXruptListHead = NULL; 887 AcpiGbl_GpeFadtBlocks[0] = NULL; 888 AcpiGbl_GpeFadtBlocks[1] = NULL; 889 AcpiCurrentGpeCount = 0; 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 AcpiGbl_GlobalLockPresent = FALSE; 906 907 /* Miscellaneous variables */ 908 909 AcpiGbl_CmSingleStep = FALSE; 910 AcpiGbl_DbTerminateThreads = FALSE; 911 AcpiGbl_Shutdown = FALSE; 912 AcpiGbl_NsLookupCount = 0; 913 AcpiGbl_PsFindCount = 0; 914 AcpiGbl_AcpiHardwarePresent = TRUE; 915 AcpiGbl_LastOwnerIdIndex = 0; 916 AcpiGbl_NextOwnerIdOffset = 0; 917 AcpiGbl_TraceMethodName = 0; 918 AcpiGbl_TraceDbgLevel = 0; 919 AcpiGbl_TraceDbgLayer = 0; 920 AcpiGbl_DebuggerConfiguration = DEBUGGER_THREADING; 921 AcpiGbl_DbOutputFlags = ACPI_DB_CONSOLE_OUTPUT; 922 AcpiGbl_OsiData = 0; 923 924 /* Hardware oriented */ 925 926 AcpiGbl_EventsInitialized = FALSE; 927 AcpiGbl_SystemAwakeAndRunning = TRUE; 928 929 /* Namespace */ 930 931 AcpiGbl_RootNode = NULL; 932 AcpiGbl_RootNodeStruct.Name.Integer = ACPI_ROOT_NAME; 933 AcpiGbl_RootNodeStruct.DescriptorType = ACPI_DESC_TYPE_NAMED; 934 AcpiGbl_RootNodeStruct.Type = ACPI_TYPE_DEVICE; 935 AcpiGbl_RootNodeStruct.Child = NULL; 936 AcpiGbl_RootNodeStruct.Peer = NULL; 937 AcpiGbl_RootNodeStruct.Object = NULL; 938 AcpiGbl_RootNodeStruct.Flags = ANOBJ_END_OF_PEER_LIST; 939 940 941 #ifdef ACPI_DEBUG_OUTPUT 942 AcpiGbl_LowestStackPointer = ACPI_CAST_PTR (ACPI_SIZE, ACPI_SIZE_MAX); 943 #endif 944 945 #ifdef ACPI_DBG_TRACK_ALLOCATIONS 946 AcpiGbl_DisplayFinalMemStats = FALSE; 947 #endif 948 949 return_ACPI_STATUS (AE_OK); 950 } 951 952 /* Public globals */ 953 954 ACPI_EXPORT_SYMBOL (AcpiGbl_FADT) 955 ACPI_EXPORT_SYMBOL (AcpiDbgLevel) 956 ACPI_EXPORT_SYMBOL (AcpiDbgLayer) 957 ACPI_EXPORT_SYMBOL (AcpiGpeCount) 958 ACPI_EXPORT_SYMBOL (AcpiCurrentGpeCount) 959 960 961