1 /****************************************************************************** 2 * 3 * Module Name: aeexec - Support routines for AcpiExec utility 4 * 5 *****************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2015, 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 #include "aecommon.h" 45 46 #define _COMPONENT ACPI_TOOLS 47 ACPI_MODULE_NAME ("aeexec") 48 49 /* Local prototypes */ 50 51 static ACPI_STATUS 52 AeSetupConfiguration ( 53 void *RegionAddr); 54 55 static void 56 AeTestBufferArgument ( 57 void); 58 59 static void 60 AeTestPackageArgument ( 61 void); 62 63 static ACPI_STATUS 64 AeGetDevices ( 65 ACPI_HANDLE ObjHandle, 66 UINT32 NestingLevel, 67 void *Context, 68 void **ReturnValue); 69 70 static ACPI_STATUS 71 ExecuteOSI ( 72 char *OsiString, 73 UINT32 ExpectedResult); 74 75 static void 76 AeMutexInterfaces ( 77 void); 78 79 static void 80 AeHardwareInterfaces ( 81 void); 82 83 static void 84 AeGenericRegisters ( 85 void); 86 87 #if (!ACPI_REDUCED_HARDWARE) 88 static void 89 AfInstallGpeBlock ( 90 void); 91 #endif /* !ACPI_REDUCED_HARDWARE */ 92 93 extern unsigned char Ssdt2Code[]; 94 extern unsigned char Ssdt3Code[]; 95 extern unsigned char Ssdt4Code[]; 96 97 98 /****************************************************************************** 99 * 100 * FUNCTION: AeSetupConfiguration 101 * 102 * PARAMETERS: RegionAddr - Address for an ACPI table to be loaded 103 * dynamically. Test purposes only. 104 * 105 * RETURN: Status 106 * 107 * DESCRIPTION: Call AML _CFG configuration control method 108 * 109 *****************************************************************************/ 110 111 static ACPI_STATUS 112 AeSetupConfiguration ( 113 void *RegionAddr) 114 { 115 ACPI_OBJECT_LIST ArgList; 116 ACPI_OBJECT Arg[3]; 117 118 119 /* 120 * Invoke _CFG method if present 121 */ 122 ArgList.Count = 1; 123 ArgList.Pointer = Arg; 124 125 Arg[0].Type = ACPI_TYPE_INTEGER; 126 Arg[0].Integer.Value = ACPI_TO_INTEGER (RegionAddr); 127 128 (void) AcpiEvaluateObject (NULL, "\\_CFG", &ArgList, NULL); 129 return (AE_OK); 130 } 131 132 133 #if (!ACPI_REDUCED_HARDWARE) 134 /****************************************************************************** 135 * 136 * FUNCTION: AfInstallGpeBlock 137 * 138 * PARAMETERS: None 139 * 140 * RETURN: None 141 * 142 * DESCRIPTION: Test GPE block device initialization. Requires test ASL with 143 * A \GPE2 device. 144 * 145 *****************************************************************************/ 146 147 static void 148 AfInstallGpeBlock ( 149 void) 150 { 151 ACPI_STATUS Status; 152 ACPI_HANDLE Handle; 153 ACPI_GENERIC_ADDRESS BlockAddress; 154 ACPI_HANDLE GpeDevice; 155 ACPI_OBJECT_TYPE Type; 156 157 158 /* _GPE should always exist */ 159 160 Status = AcpiGetHandle (NULL, "\\_GPE", &Handle); 161 ACPI_CHECK_OK (AcpiGetHandle, Status); 162 if (ACPI_FAILURE (Status)) 163 { 164 return; 165 } 166 167 memset (&BlockAddress, 0, sizeof (ACPI_GENERIC_ADDRESS)); 168 BlockAddress.SpaceId = ACPI_ADR_SPACE_SYSTEM_MEMORY; 169 BlockAddress.Address = 0x76540000; 170 171 /* Attempt to install a GPE block on GPE2 (if present) */ 172 173 Status = AcpiGetHandle (NULL, "\\GPE2", &Handle); 174 if (ACPI_SUCCESS (Status)) 175 { 176 Status = AcpiGetType (Handle, &Type); 177 if (ACPI_FAILURE (Status) || 178 (Type != ACPI_TYPE_DEVICE)) 179 { 180 return; 181 } 182 183 Status = AcpiInstallGpeBlock (Handle, &BlockAddress, 7, 8); 184 ACPI_CHECK_OK (AcpiInstallGpeBlock, Status); 185 186 Status = AcpiInstallGpeHandler (Handle, 8, 187 ACPI_GPE_LEVEL_TRIGGERED, AeGpeHandler, NULL); 188 ACPI_CHECK_OK (AcpiInstallGpeHandler, Status); 189 190 Status = AcpiEnableGpe (Handle, 8); 191 ACPI_CHECK_OK (AcpiEnableGpe, Status); 192 193 Status = AcpiGetGpeDevice (0x30, &GpeDevice); 194 ACPI_CHECK_OK (AcpiGetGpeDevice, Status); 195 196 Status = AcpiGetGpeDevice (0x42, &GpeDevice); 197 ACPI_CHECK_OK (AcpiGetGpeDevice, Status); 198 199 Status = AcpiGetGpeDevice (AcpiCurrentGpeCount-1, &GpeDevice); 200 ACPI_CHECK_OK (AcpiGetGpeDevice, Status); 201 202 Status = AcpiGetGpeDevice (AcpiCurrentGpeCount, &GpeDevice); 203 ACPI_CHECK_STATUS (AcpiGetGpeDevice, Status, AE_NOT_EXIST); 204 205 Status = AcpiRemoveGpeHandler (Handle, 8, AeGpeHandler); 206 ACPI_CHECK_OK (AcpiRemoveGpeHandler, Status); 207 } 208 209 /* Attempt to install a GPE block on GPE3 (if present) */ 210 211 Status = AcpiGetHandle (NULL, "\\GPE3", &Handle); 212 if (ACPI_SUCCESS (Status)) 213 { 214 Status = AcpiGetType (Handle, &Type); 215 if (ACPI_FAILURE (Status) || 216 (Type != ACPI_TYPE_DEVICE)) 217 { 218 return; 219 } 220 221 Status = AcpiInstallGpeBlock (Handle, &BlockAddress, 8, 11); 222 ACPI_CHECK_OK (AcpiInstallGpeBlock, Status); 223 } 224 } 225 #endif /* !ACPI_REDUCED_HARDWARE */ 226 227 228 /* Test using a Buffer object as a method argument */ 229 230 static void 231 AeTestBufferArgument ( 232 void) 233 { 234 ACPI_OBJECT_LIST Params; 235 ACPI_OBJECT BufArg; 236 UINT8 Buffer[] = 237 { 238 0,0,0,0, 239 4,0,0,0, 240 1,2,3,4 241 }; 242 243 244 BufArg.Type = ACPI_TYPE_BUFFER; 245 BufArg.Buffer.Length = 12; 246 BufArg.Buffer.Pointer = Buffer; 247 248 Params.Count = 1; 249 Params.Pointer = &BufArg; 250 251 (void) AcpiEvaluateObject (NULL, "\\BUF", &Params, NULL); 252 } 253 254 255 static ACPI_OBJECT PkgArg; 256 static ACPI_OBJECT PkgElements[5]; 257 static ACPI_OBJECT Pkg2Elements[5]; 258 static ACPI_OBJECT_LIST Params; 259 260 261 /* 262 * Test using a Package object as an method argument 263 */ 264 static void 265 AeTestPackageArgument ( 266 void) 267 { 268 269 /* Main package */ 270 271 PkgArg.Type = ACPI_TYPE_PACKAGE; 272 PkgArg.Package.Count = 4; 273 PkgArg.Package.Elements = PkgElements; 274 275 /* Main package elements */ 276 277 PkgElements[0].Type = ACPI_TYPE_INTEGER; 278 PkgElements[0].Integer.Value = 0x22228888; 279 280 PkgElements[1].Type = ACPI_TYPE_STRING; 281 PkgElements[1].String.Length = sizeof ("Top-level package"); 282 PkgElements[1].String.Pointer = "Top-level package"; 283 284 PkgElements[2].Type = ACPI_TYPE_BUFFER; 285 PkgElements[2].Buffer.Length = sizeof ("XXXX"); 286 PkgElements[2].Buffer.Pointer = (UINT8 *) "XXXX"; 287 288 PkgElements[3].Type = ACPI_TYPE_PACKAGE; 289 PkgElements[3].Package.Count = 2; 290 PkgElements[3].Package.Elements = Pkg2Elements; 291 292 /* Subpackage elements */ 293 294 Pkg2Elements[0].Type = ACPI_TYPE_INTEGER; 295 Pkg2Elements[0].Integer.Value = 0xAAAABBBB; 296 297 Pkg2Elements[1].Type = ACPI_TYPE_STRING; 298 Pkg2Elements[1].String.Length = sizeof ("Nested Package"); 299 Pkg2Elements[1].String.Pointer = "Nested Package"; 300 301 /* Parameter object */ 302 303 Params.Count = 1; 304 Params.Pointer = &PkgArg; 305 306 (void) AcpiEvaluateObject (NULL, "\\_PKG", &Params, NULL); 307 } 308 309 310 static ACPI_STATUS 311 AeGetDevices ( 312 ACPI_HANDLE ObjHandle, 313 UINT32 NestingLevel, 314 void *Context, 315 void **ReturnValue) 316 { 317 318 return (AE_OK); 319 } 320 321 322 /****************************************************************************** 323 * 324 * FUNCTION: ExecuteOSI 325 * 326 * PARAMETERS: OsiString - String passed to _OSI method 327 * ExpectedResult - 0 (FALSE) or 0xFFFFFFFF (TRUE) 328 * 329 * RETURN: Status 330 * 331 * DESCRIPTION: Execute the internally implemented (in ACPICA) _OSI method. 332 * 333 *****************************************************************************/ 334 335 static ACPI_STATUS 336 ExecuteOSI ( 337 char *OsiString, 338 UINT32 ExpectedResult) 339 { 340 ACPI_STATUS Status; 341 ACPI_OBJECT_LIST ArgList; 342 ACPI_OBJECT Arg[1]; 343 ACPI_BUFFER ReturnValue; 344 ACPI_OBJECT *Obj; 345 346 347 /* Setup input argument */ 348 349 ArgList.Count = 1; 350 ArgList.Pointer = Arg; 351 352 Arg[0].Type = ACPI_TYPE_STRING; 353 Arg[0].String.Pointer = OsiString; 354 Arg[0].String.Length = strlen (Arg[0].String.Pointer); 355 356 /* Ask ACPICA to allocate space for the return object */ 357 358 ReturnValue.Length = ACPI_ALLOCATE_BUFFER; 359 360 Status = AcpiEvaluateObject (NULL, "\\_OSI", &ArgList, &ReturnValue); 361 362 if (ACPI_FAILURE (Status)) 363 { 364 AcpiOsPrintf ( 365 "Could not execute _OSI method, %s\n", 366 AcpiFormatException (Status)); 367 return (Status); 368 } 369 370 Status = AE_ERROR; 371 372 if (ReturnValue.Length < sizeof (ACPI_OBJECT)) 373 { 374 AcpiOsPrintf ( 375 "Return value from _OSI method too small, %.8X\n", 376 ReturnValue.Length); 377 goto ErrorExit; 378 } 379 380 Obj = ReturnValue.Pointer; 381 if (Obj->Type != ACPI_TYPE_INTEGER) 382 { 383 AcpiOsPrintf ( 384 "Invalid return type from _OSI method, %.2X\n", Obj->Type); 385 goto ErrorExit; 386 } 387 388 if (Obj->Integer.Value != ExpectedResult) 389 { 390 AcpiOsPrintf ( 391 "Invalid return value from _OSI, expected %.8X found %.8X\n", 392 ExpectedResult, (UINT32) Obj->Integer.Value); 393 goto ErrorExit; 394 } 395 396 Status = AE_OK; 397 398 /* Reset the OSI data */ 399 400 AcpiGbl_OsiData = 0; 401 402 ErrorExit: 403 404 /* Free a buffer created via ACPI_ALLOCATE_BUFFER */ 405 406 AcpiOsFree (ReturnValue.Pointer); 407 return (Status); 408 } 409 410 411 /****************************************************************************** 412 * 413 * FUNCTION: AeGenericRegisters 414 * 415 * DESCRIPTION: Call the AcpiRead/Write interfaces. 416 * 417 *****************************************************************************/ 418 419 static ACPI_GENERIC_ADDRESS GenericRegister; 420 421 static void 422 AeGenericRegisters ( 423 void) 424 { 425 ACPI_STATUS Status; 426 UINT64 Value; 427 428 429 GenericRegister.Address = 0x1234; 430 GenericRegister.BitWidth = 64; 431 GenericRegister.BitOffset = 0; 432 GenericRegister.SpaceId = ACPI_ADR_SPACE_SYSTEM_IO; 433 434 Status = AcpiRead (&Value, &GenericRegister); 435 ACPI_CHECK_OK (AcpiRead, Status); 436 437 Status = AcpiWrite (Value, &GenericRegister); 438 ACPI_CHECK_OK (AcpiWrite, Status); 439 440 GenericRegister.Address = 0x12345678; 441 GenericRegister.BitOffset = 0; 442 GenericRegister.SpaceId = ACPI_ADR_SPACE_SYSTEM_MEMORY; 443 444 Status = AcpiRead (&Value, &GenericRegister); 445 ACPI_CHECK_OK (AcpiRead, Status); 446 447 Status = AcpiWrite (Value, &GenericRegister); 448 ACPI_CHECK_OK (AcpiWrite, Status); 449 } 450 451 452 /****************************************************************************** 453 * 454 * FUNCTION: AeMutexInterfaces 455 * 456 * DESCRIPTION: Exercise the AML mutex access interfaces 457 * 458 *****************************************************************************/ 459 460 static void 461 AeMutexInterfaces ( 462 void) 463 { 464 ACPI_STATUS Status; 465 ACPI_HANDLE MutexHandle; 466 467 468 /* Get a handle to an AML mutex */ 469 470 Status = AcpiGetHandle (NULL, "\\MTX1", &MutexHandle); 471 if (Status == AE_NOT_FOUND) 472 { 473 return; 474 } 475 476 ACPI_CHECK_OK (AcpiGetHandle, Status); 477 if (ACPI_FAILURE (Status)) 478 { 479 return; 480 } 481 482 /* Acquire the mutex */ 483 484 Status = AcpiAcquireMutex (NULL, "\\MTX1", 0xFFFF); 485 ACPI_CHECK_OK (AcpiAcquireMutex, Status); 486 if (ACPI_FAILURE (Status)) 487 { 488 return; 489 } 490 491 /* Release mutex with different parameters */ 492 493 Status = AcpiReleaseMutex (MutexHandle, NULL); 494 ACPI_CHECK_OK (AcpiReleaseMutex, Status); 495 } 496 497 498 /****************************************************************************** 499 * 500 * FUNCTION: AeHardwareInterfaces 501 * 502 * DESCRIPTION: Call various hardware support interfaces 503 * 504 *****************************************************************************/ 505 506 static void 507 AeHardwareInterfaces ( 508 void) 509 { 510 #if (!ACPI_REDUCED_HARDWARE) 511 512 ACPI_STATUS Status; 513 UINT32 Value; 514 515 516 /* If Hardware Reduced flag is set, we are all done */ 517 518 if (AcpiGbl_ReducedHardware) 519 { 520 return; 521 } 522 523 Status = AcpiWriteBitRegister (ACPI_BITREG_WAKE_STATUS, 1); 524 ACPI_CHECK_OK (AcpiWriteBitRegister, Status); 525 526 Status = AcpiWriteBitRegister (ACPI_BITREG_GLOBAL_LOCK_ENABLE, 1); 527 ACPI_CHECK_OK (AcpiWriteBitRegister, Status); 528 529 Status = AcpiWriteBitRegister (ACPI_BITREG_SLEEP_ENABLE, 1); 530 ACPI_CHECK_OK (AcpiWriteBitRegister, Status); 531 532 Status = AcpiWriteBitRegister (ACPI_BITREG_ARB_DISABLE, 1); 533 ACPI_CHECK_OK (AcpiWriteBitRegister, Status); 534 535 536 Status = AcpiReadBitRegister (ACPI_BITREG_WAKE_STATUS, &Value); 537 ACPI_CHECK_OK (AcpiReadBitRegister, Status); 538 539 Status = AcpiReadBitRegister (ACPI_BITREG_GLOBAL_LOCK_ENABLE, &Value); 540 ACPI_CHECK_OK (AcpiReadBitRegister, Status); 541 542 Status = AcpiReadBitRegister (ACPI_BITREG_SLEEP_ENABLE, &Value); 543 ACPI_CHECK_OK (AcpiReadBitRegister, Status); 544 545 Status = AcpiReadBitRegister (ACPI_BITREG_ARB_DISABLE, &Value); 546 ACPI_CHECK_OK (AcpiReadBitRegister, Status); 547 548 #endif /* !ACPI_REDUCED_HARDWARE */ 549 } 550 551 552 /****************************************************************************** 553 * 554 * FUNCTION: AeMiscellaneousTests 555 * 556 * DESCRIPTION: Various ACPICA validation tests. 557 * 558 *****************************************************************************/ 559 560 void 561 AeMiscellaneousTests ( 562 void) 563 { 564 ACPI_BUFFER ReturnBuf; 565 char Buffer[32]; 566 ACPI_STATUS Status; 567 ACPI_STATISTICS Stats; 568 ACPI_HANDLE Handle; 569 570 #if (!ACPI_REDUCED_HARDWARE) 571 UINT32 LockHandle1; 572 UINT32 LockHandle2; 573 ACPI_VENDOR_UUID Uuid = 574 {0, {ACPI_INIT_UUID (0,0,0,0,0,0,0,0,0,0,0)}}; 575 #endif /* !ACPI_REDUCED_HARDWARE */ 576 577 578 Status = AcpiGetHandle (NULL, "\\", &Handle); 579 ACPI_CHECK_OK (AcpiGetHandle, Status); 580 581 if (AcpiGbl_DoInterfaceTests) 582 { 583 /* 584 * Tests for AcpiLoadTable and AcpiUnloadParentTable 585 */ 586 587 /* Attempt unload of DSDT, should fail */ 588 589 Status = AcpiGetHandle (NULL, "\\_SB_", &Handle); 590 ACPI_CHECK_OK (AcpiGetHandle, Status); 591 592 Status = AcpiUnloadParentTable (Handle); 593 ACPI_CHECK_STATUS (AcpiUnloadParentTable, Status, AE_TYPE); 594 595 /* Load and unload SSDT4 */ 596 597 Status = AcpiLoadTable ((ACPI_TABLE_HEADER *) Ssdt4Code); 598 ACPI_CHECK_OK (AcpiLoadTable, Status); 599 600 Status = AcpiGetHandle (NULL, "\\_T96", &Handle); 601 ACPI_CHECK_OK (AcpiGetHandle, Status); 602 603 Status = AcpiUnloadParentTable (Handle); 604 ACPI_CHECK_OK (AcpiUnloadParentTable, Status); 605 606 /* Re-load SSDT4 */ 607 608 Status = AcpiLoadTable ((ACPI_TABLE_HEADER *) Ssdt4Code); 609 ACPI_CHECK_OK (AcpiLoadTable, Status); 610 611 /* Unload and re-load SSDT2 (SSDT2 is in the XSDT) */ 612 613 Status = AcpiGetHandle (NULL, "\\_T99", &Handle); 614 ACPI_CHECK_OK (AcpiGetHandle, Status); 615 616 Status = AcpiUnloadParentTable (Handle); 617 ACPI_CHECK_OK (AcpiUnloadParentTable, Status); 618 619 Status = AcpiLoadTable ((ACPI_TABLE_HEADER *) Ssdt2Code); 620 ACPI_CHECK_OK (AcpiLoadTable, Status); 621 622 /* Load OEM9 table (causes table override) */ 623 624 Status = AcpiLoadTable ((ACPI_TABLE_HEADER *) Ssdt3Code); 625 ACPI_CHECK_OK (AcpiLoadTable, Status); 626 } 627 628 AeHardwareInterfaces (); 629 AeGenericRegisters (); 630 AeSetupConfiguration (Ssdt3Code); 631 632 AeTestBufferArgument(); 633 AeTestPackageArgument (); 634 AeMutexInterfaces (); 635 636 /* Test _OSI install/remove */ 637 638 Status = AcpiInstallInterface (""); 639 ACPI_CHECK_STATUS (AcpiInstallInterface, Status, AE_BAD_PARAMETER); 640 641 Status = AcpiInstallInterface ("TestString"); 642 ACPI_CHECK_OK (AcpiInstallInterface, Status); 643 644 Status = AcpiInstallInterface ("TestString"); 645 ACPI_CHECK_STATUS (AcpiInstallInterface, Status, AE_ALREADY_EXISTS); 646 647 Status = AcpiRemoveInterface ("Windows 2006"); 648 ACPI_CHECK_OK (AcpiRemoveInterface, Status); 649 650 Status = AcpiRemoveInterface ("TestString"); 651 ACPI_CHECK_OK (AcpiRemoveInterface, Status); 652 653 Status = AcpiRemoveInterface ("XXXXXX"); 654 ACPI_CHECK_STATUS (AcpiRemoveInterface, Status, AE_NOT_EXIST); 655 656 Status = AcpiInstallInterface ("AnotherTestString"); 657 ACPI_CHECK_OK (AcpiInstallInterface, Status); 658 659 /* Test _OSI execution */ 660 661 Status = ExecuteOSI ("Extended Address Space Descriptor", 0xFFFFFFFF); 662 ACPI_CHECK_OK (ExecuteOSI, Status); 663 664 Status = ExecuteOSI ("Windows 2001", 0xFFFFFFFF); 665 ACPI_CHECK_OK (ExecuteOSI, Status); 666 667 Status = ExecuteOSI ("MichiganTerminalSystem", 0); 668 ACPI_CHECK_OK (ExecuteOSI, Status); 669 670 671 ReturnBuf.Length = 32; 672 ReturnBuf.Pointer = Buffer; 673 674 Status = AcpiGetName (ACPI_ROOT_OBJECT, 675 ACPI_FULL_PATHNAME_NO_TRAILING, &ReturnBuf); 676 ACPI_CHECK_OK (AcpiGetName, Status); 677 678 /* Get Devices */ 679 680 Status = AcpiGetDevices (NULL, AeGetDevices, NULL, NULL); 681 ACPI_CHECK_OK (AcpiGetDevices, Status); 682 683 Status = AcpiGetStatistics (&Stats); 684 ACPI_CHECK_OK (AcpiGetStatistics, Status); 685 686 687 #if (!ACPI_REDUCED_HARDWARE) 688 689 Status = AcpiInstallGlobalEventHandler (AeGlobalEventHandler, NULL); 690 ACPI_CHECK_OK (AcpiInstallGlobalEventHandler, Status); 691 692 /* If Hardware Reduced flag is set, we are all done */ 693 694 if (AcpiGbl_ReducedHardware) 695 { 696 return; 697 } 698 699 Status = AcpiEnableEvent (ACPI_EVENT_GLOBAL, 0); 700 ACPI_CHECK_OK (AcpiEnableEvent, Status); 701 702 /* 703 * GPEs: Handlers, enable/disable, etc. 704 */ 705 Status = AcpiInstallGpeHandler (NULL, 0, 706 ACPI_GPE_LEVEL_TRIGGERED, AeGpeHandler, NULL); 707 ACPI_CHECK_OK (AcpiInstallGpeHandler, Status); 708 709 Status = AcpiEnableGpe (NULL, 0); 710 ACPI_CHECK_OK (AcpiEnableGpe, Status); 711 712 Status = AcpiRemoveGpeHandler (NULL, 0, AeGpeHandler); 713 ACPI_CHECK_OK (AcpiRemoveGpeHandler, Status); 714 715 Status = AcpiInstallGpeHandler (NULL, 0, 716 ACPI_GPE_LEVEL_TRIGGERED, AeGpeHandler, NULL); 717 ACPI_CHECK_OK (AcpiInstallGpeHandler, Status); 718 719 Status = AcpiEnableGpe (NULL, 0); 720 ACPI_CHECK_OK (AcpiEnableGpe, Status); 721 722 Status = AcpiSetGpe (NULL, 0, ACPI_GPE_DISABLE); 723 ACPI_CHECK_OK (AcpiSetGpe, Status); 724 725 Status = AcpiSetGpe (NULL, 0, ACPI_GPE_ENABLE); 726 ACPI_CHECK_OK (AcpiSetGpe, Status); 727 728 729 Status = AcpiInstallGpeHandler (NULL, 1, 730 ACPI_GPE_EDGE_TRIGGERED, AeGpeHandler, NULL); 731 ACPI_CHECK_OK (AcpiInstallGpeHandler, Status); 732 733 Status = AcpiEnableGpe (NULL, 1); 734 ACPI_CHECK_OK (AcpiEnableGpe, Status); 735 736 737 Status = AcpiInstallGpeHandler (NULL, 2, 738 ACPI_GPE_LEVEL_TRIGGERED, AeGpeHandler, NULL); 739 ACPI_CHECK_OK (AcpiInstallGpeHandler, Status); 740 741 Status = AcpiEnableGpe (NULL, 2); 742 ACPI_CHECK_OK (AcpiEnableGpe, Status); 743 744 745 Status = AcpiInstallGpeHandler (NULL, 3, 746 ACPI_GPE_EDGE_TRIGGERED, AeGpeHandler, NULL); 747 ACPI_CHECK_OK (AcpiInstallGpeHandler, Status); 748 749 Status = AcpiInstallGpeHandler (NULL, 4, 750 ACPI_GPE_LEVEL_TRIGGERED, AeGpeHandler, NULL); 751 ACPI_CHECK_OK (AcpiInstallGpeHandler, Status); 752 753 Status = AcpiInstallGpeHandler (NULL, 5, 754 ACPI_GPE_EDGE_TRIGGERED, AeGpeHandler, NULL); 755 ACPI_CHECK_OK (AcpiInstallGpeHandler, Status); 756 757 Status = AcpiGetHandle (NULL, "\\_SB", &Handle); 758 ACPI_CHECK_OK (AcpiGetHandle, Status); 759 760 Status = AcpiSetupGpeForWake (Handle, NULL, 5); 761 ACPI_CHECK_OK (AcpiSetupGpeForWake, Status); 762 763 Status = AcpiSetGpeWakeMask (NULL, 5, ACPI_GPE_ENABLE); 764 ACPI_CHECK_OK (AcpiSetGpeWakeMask, Status); 765 766 Status = AcpiSetupGpeForWake (Handle, NULL, 6); 767 ACPI_CHECK_OK (AcpiSetupGpeForWake, Status); 768 769 Status = AcpiSetupGpeForWake (ACPI_ROOT_OBJECT, NULL, 6); 770 ACPI_CHECK_OK (AcpiSetupGpeForWake, Status); 771 772 Status = AcpiSetupGpeForWake (Handle, NULL, 9); 773 ACPI_CHECK_OK (AcpiSetupGpeForWake, Status); 774 775 Status = AcpiInstallGpeHandler (NULL, 0x19, 776 ACPI_GPE_LEVEL_TRIGGERED, AeGpeHandler, NULL); 777 ACPI_CHECK_OK (AcpiInstallGpeHandler, Status); 778 779 Status = AcpiEnableGpe (NULL, 0x19); 780 ACPI_CHECK_OK (AcpiEnableGpe, Status); 781 782 783 /* GPE block 1 */ 784 785 Status = AcpiInstallGpeHandler (NULL, 101, 786 ACPI_GPE_LEVEL_TRIGGERED, AeGpeHandler, NULL); 787 ACPI_CHECK_OK (AcpiInstallGpeHandler, Status); 788 789 Status = AcpiEnableGpe (NULL, 101); 790 ACPI_CHECK_OK (AcpiEnableGpe, Status); 791 792 Status = AcpiDisableGpe (NULL, 101); 793 ACPI_CHECK_OK (AcpiDisableGpe, Status); 794 795 AfInstallGpeBlock (); 796 797 /* Here is where the GPEs are actually "enabled" */ 798 799 Status = AcpiUpdateAllGpes (); 800 ACPI_CHECK_OK (AcpiUpdateAllGpes, Status); 801 802 Status = AcpiGetHandle (NULL, "RSRC", &Handle); 803 if (ACPI_SUCCESS (Status)) 804 { 805 ReturnBuf.Length = ACPI_ALLOCATE_BUFFER; 806 807 Status = AcpiGetVendorResource (Handle, "_CRS", &Uuid, &ReturnBuf); 808 if (ACPI_SUCCESS (Status)) 809 { 810 AcpiOsFree (ReturnBuf.Pointer); 811 } 812 } 813 814 /* Test global lock */ 815 816 Status = AcpiAcquireGlobalLock (0xFFFF, &LockHandle1); 817 ACPI_CHECK_OK (AcpiAcquireGlobalLock, Status); 818 819 Status = AcpiAcquireGlobalLock (0x5, &LockHandle2); 820 ACPI_CHECK_OK (AcpiAcquireGlobalLock, Status); 821 822 Status = AcpiReleaseGlobalLock (LockHandle1); 823 ACPI_CHECK_OK (AcpiReleaseGlobalLock, Status); 824 825 Status = AcpiReleaseGlobalLock (LockHandle2); 826 ACPI_CHECK_OK (AcpiReleaseGlobalLock, Status); 827 828 #endif /* !ACPI_REDUCED_HARDWARE */ 829 } 830