sys/contrib/dev/acpica/source/tools/acpiexec/aeexec.c

   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     AE_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         AE_CHECK_OK (AcpiInstallGpeBlock, Status);
 185
 186         Status = AcpiInstallGpeHandler (Handle, 8,
 187             ACPI_GPE_LEVEL_TRIGGERED, AeGpeHandler, NULL);
 188         AE_CHECK_OK (AcpiInstallGpeHandler, Status);
 189
 190         Status = AcpiEnableGpe (Handle, 8);
 191         AE_CHECK_OK (AcpiEnableGpe, Status);
 192
 193         Status = AcpiGetGpeDevice (0x30, &GpeDevice);
 194         AE_CHECK_OK (AcpiGetGpeDevice, Status);
 195
 196         Status = AcpiGetGpeDevice (0x42, &GpeDevice);
 197         AE_CHECK_OK (AcpiGetGpeDevice, Status);
 198
 199         Status = AcpiGetGpeDevice (AcpiCurrentGpeCount-1, &GpeDevice);
 200         AE_CHECK_OK (AcpiGetGpeDevice, Status);
 201
 202         Status = AcpiGetGpeDevice (AcpiCurrentGpeCount, &GpeDevice);
 203         AE_CHECK_STATUS (AcpiGetGpeDevice, Status, AE_NOT_EXIST);
 204
 205         Status = AcpiRemoveGpeHandler (Handle, 8, AeGpeHandler);
 206         AE_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         AE_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         0,0,0,0,
 238         4,0,0,0,
 239         1,2,3,4};
 240
 241
 242     BufArg.Type = ACPI_TYPE_BUFFER;
 243     BufArg.Buffer.Length = 12;
 244     BufArg.Buffer.Pointer = Buffer;
 245
 246     Params.Count = 1;
 247     Params.Pointer = &BufArg;
 248
 249     (void) AcpiEvaluateObject (NULL, "\\BUF", &Params, NULL);
 250 }
 251
 252
 253 static ACPI_OBJECT                 PkgArg;
 254 static ACPI_OBJECT                 PkgElements[5];
 255 static ACPI_OBJECT                 Pkg2Elements[5];
 256 static ACPI_OBJECT_LIST            Params;
 257
 258
 259 /*
 260  * Test using a Package object as an method argument
 261  */
 262 static void
 263 AeTestPackageArgument (
 264     void)
 265 {
 266
 267     /* Main package */
 268
 269     PkgArg.Type = ACPI_TYPE_PACKAGE;
 270     PkgArg.Package.Count = 4;
 271     PkgArg.Package.Elements = PkgElements;
 272
 273     /* Main package elements */
 274
 275     PkgElements[0].Type = ACPI_TYPE_INTEGER;
 276     PkgElements[0].Integer.Value = 0x22228888;
 277
 278     PkgElements[1].Type = ACPI_TYPE_STRING;
 279     PkgElements[1].String.Length = sizeof ("Top-level package");
 280     PkgElements[1].String.Pointer = "Top-level package";
 281
 282     PkgElements[2].Type = ACPI_TYPE_BUFFER;
 283     PkgElements[2].Buffer.Length = sizeof ("XXXX");
 284     PkgElements[2].Buffer.Pointer = (UINT8 *) "XXXX";
 285
 286     PkgElements[3].Type = ACPI_TYPE_PACKAGE;
 287     PkgElements[3].Package.Count = 2;
 288     PkgElements[3].Package.Elements = Pkg2Elements;
 289
 290     /* Subpackage elements */
 291
 292     Pkg2Elements[0].Type = ACPI_TYPE_INTEGER;
 293     Pkg2Elements[0].Integer.Value = 0xAAAABBBB;
 294
 295     Pkg2Elements[1].Type = ACPI_TYPE_STRING;
 296     Pkg2Elements[1].String.Length = sizeof ("Nested Package");
 297     Pkg2Elements[1].String.Pointer = "Nested Package";
 298
 299     /* Parameter object */
 300
 301     Params.Count = 1;
 302     Params.Pointer = &PkgArg;
 303
 304     (void) AcpiEvaluateObject (NULL, "\\_PKG", &Params, NULL);
 305 }
 306
 307
 308 static ACPI_STATUS
 309 AeGetDevices (
 310     ACPI_HANDLE                     ObjHandle,
 311     UINT32                          NestingLevel,
 312     void                            *Context,
 313     void                            **ReturnValue)
 314 {
 315
 316     return (AE_OK);
 317 }
 318
 319
 320 /******************************************************************************
 321  *
 322  * FUNCTION:    ExecuteOSI
 323  *
 324  * PARAMETERS:  OsiString           - String passed to _OSI method
 325  *              ExpectedResult      - 0 (FALSE) or 0xFFFFFFFF (TRUE)
 326  *
 327  * RETURN:      Status
 328  *
 329  * DESCRIPTION: Execute the internally implemented (in ACPICA) _OSI method.
 330  *
 331  *****************************************************************************/
 332
 333 static ACPI_STATUS
 334 ExecuteOSI (
 335     char                    *OsiString,
 336     UINT32                  ExpectedResult)
 337 {
 338     ACPI_STATUS             Status;
 339     ACPI_OBJECT_LIST        ArgList;
 340     ACPI_OBJECT             Arg[1];
 341     ACPI_BUFFER             ReturnValue;
 342     ACPI_OBJECT             *Obj;
 343
 344
 345     /* Setup input argument */
 346
 347     ArgList.Count = 1;
 348     ArgList.Pointer = Arg;
 349
 350     Arg[0].Type = ACPI_TYPE_STRING;
 351     Arg[0].String.Pointer = OsiString;
 352     Arg[0].String.Length = strlen (Arg[0].String.Pointer);
 353
 354     /* Ask ACPICA to allocate space for the return object */
 355
 356     ReturnValue.Length = ACPI_ALLOCATE_BUFFER;
 357
 358     Status = AcpiEvaluateObject (NULL, "\\_OSI", &ArgList, &ReturnValue);
 359
 360     if (ACPI_FAILURE (Status))
 361     {
 362         AcpiOsPrintf ("Could not execute _OSI method, %s\n",
 363             AcpiFormatException (Status));
 364         return (Status);
 365     }
 366
 367     Status = AE_ERROR;
 368
 369     if (ReturnValue.Length < sizeof (ACPI_OBJECT))
 370     {
 371         AcpiOsPrintf ("Return value from _OSI method too small, %.8X\n",
 372             ReturnValue.Length);
 373         goto ErrorExit;
 374     }
 375
 376     Obj = ReturnValue.Pointer;
 377     if (Obj->Type != ACPI_TYPE_INTEGER)
 378     {
 379         AcpiOsPrintf ("Invalid return type from _OSI method, %.2X\n", Obj->Type);
 380         goto ErrorExit;
 381     }
 382
 383     if (Obj->Integer.Value != ExpectedResult)
 384     {
 385         AcpiOsPrintf ("Invalid return value from _OSI, expected %.8X found %.8X\n",
 386             ExpectedResult, (UINT32) Obj->Integer.Value);
 387         goto ErrorExit;
 388     }
 389
 390     Status = AE_OK;
 391
 392     /* Reset the OSI data */
 393
 394     AcpiGbl_OsiData = 0;
 395
 396 ErrorExit:
 397
 398     /* Free a buffer created via ACPI_ALLOCATE_BUFFER */
 399
 400     AcpiOsFree (ReturnValue.Pointer);
 401
 402     return (Status);
 403 }
 404
 405
 406 /******************************************************************************
 407  *
 408  * FUNCTION:    AeGenericRegisters
 409  *
 410  * DESCRIPTION: Call the AcpiRead/Write interfaces.
 411  *
 412  *****************************************************************************/
 413
 414 static ACPI_GENERIC_ADDRESS       GenericRegister;
 415
 416 static void
 417 AeGenericRegisters (
 418     void)
 419 {
 420     ACPI_STATUS             Status;
 421     UINT64                  Value;
 422
 423
 424     GenericRegister.Address = 0x1234;
 425     GenericRegister.BitWidth = 64;
 426     GenericRegister.BitOffset = 0;
 427     GenericRegister.SpaceId = ACPI_ADR_SPACE_SYSTEM_IO;
 428
 429     Status = AcpiRead (&Value, &GenericRegister);
 430     AE_CHECK_OK (AcpiRead, Status);
 431
 432     Status = AcpiWrite (Value, &GenericRegister);
 433     AE_CHECK_OK (AcpiWrite, Status);
 434
 435     GenericRegister.Address = 0x12345678;
 436     GenericRegister.BitOffset = 0;
 437     GenericRegister.SpaceId = ACPI_ADR_SPACE_SYSTEM_MEMORY;
 438
 439     Status = AcpiRead (&Value, &GenericRegister);
 440     AE_CHECK_OK (AcpiRead, Status);
 441
 442     Status = AcpiWrite (Value, &GenericRegister);
 443     AE_CHECK_OK (AcpiWrite, Status);
 444 }
 445
 446
 447 /******************************************************************************
 448  *
 449  * FUNCTION:    AeMutexInterfaces
 450  *
 451  * DESCRIPTION: Exercise the AML mutex access interfaces
 452  *
 453  *****************************************************************************/
 454
 455 static void
 456 AeMutexInterfaces (
 457     void)
 458 {
 459     ACPI_STATUS             Status;
 460     ACPI_HANDLE             MutexHandle;
 461
 462
 463     /* Get a handle to an AML mutex */
 464
 465     Status = AcpiGetHandle (NULL, "\\MTX1", &MutexHandle);
 466     if (Status == AE_NOT_FOUND)
 467     {
 468         return;
 469     }
 470
 471     AE_CHECK_OK (AcpiGetHandle, Status);
 472     if (ACPI_FAILURE (Status))
 473     {
 474         return;
 475     }
 476
 477     /* Acquire the  mutex */
 478
 479     Status = AcpiAcquireMutex (NULL, "\\MTX1", 0xFFFF);
 480     AE_CHECK_OK (AcpiAcquireMutex, Status);
 481     if (ACPI_FAILURE (Status))
 482     {
 483         return;
 484     }
 485
 486     /* Release mutex with different parameters */
 487
 488     Status = AcpiReleaseMutex (MutexHandle, NULL);
 489     AE_CHECK_OK (AcpiReleaseMutex, Status);
 490 }
 491
 492
 493 /******************************************************************************
 494  *
 495  * FUNCTION:    AeHardwareInterfaces
 496  *
 497  * DESCRIPTION: Call various hardware support interfaces
 498  *
 499  *****************************************************************************/
 500
 501 static void
 502 AeHardwareInterfaces (
 503     void)
 504 {
 505 #if (!ACPI_REDUCED_HARDWARE)
 506
 507     ACPI_STATUS             Status;
 508     UINT32                  Value;
 509
 510
 511     /* If Hardware Reduced flag is set, we are all done */
 512
 513     if (AcpiGbl_ReducedHardware)
 514     {
 515         return;
 516     }
 517
 518     Status = AcpiWriteBitRegister (ACPI_BITREG_WAKE_STATUS, 1);
 519     AE_CHECK_OK (AcpiWriteBitRegister, Status);
 520
 521     Status = AcpiWriteBitRegister (ACPI_BITREG_GLOBAL_LOCK_ENABLE, 1);
 522     AE_CHECK_OK (AcpiWriteBitRegister, Status);
 523
 524     Status = AcpiWriteBitRegister (ACPI_BITREG_SLEEP_ENABLE, 1);
 525     AE_CHECK_OK (AcpiWriteBitRegister, Status);
 526
 527     Status = AcpiWriteBitRegister (ACPI_BITREG_ARB_DISABLE, 1);
 528     AE_CHECK_OK (AcpiWriteBitRegister, Status);
 529
 530
 531     Status = AcpiReadBitRegister (ACPI_BITREG_WAKE_STATUS, &Value);
 532     AE_CHECK_OK (AcpiReadBitRegister, Status);
 533
 534     Status = AcpiReadBitRegister (ACPI_BITREG_GLOBAL_LOCK_ENABLE, &Value);
 535     AE_CHECK_OK (AcpiReadBitRegister, Status);
 536
 537     Status = AcpiReadBitRegister (ACPI_BITREG_SLEEP_ENABLE, &Value);
 538     AE_CHECK_OK (AcpiReadBitRegister, Status);
 539
 540     Status = AcpiReadBitRegister (ACPI_BITREG_ARB_DISABLE, &Value);
 541     AE_CHECK_OK (AcpiReadBitRegister, Status);
 542
 543 #endif /* !ACPI_REDUCED_HARDWARE */
 544 }
 545
 546
 547 /******************************************************************************
 548  *
 549  * FUNCTION:    AeMiscellaneousTests
 550  *
 551  * DESCRIPTION: Various ACPICA validation tests.
 552  *
 553  *****************************************************************************/
 554
 555 void
 556 AeMiscellaneousTests (
 557     void)
 558 {
 559     ACPI_BUFFER             ReturnBuf;
 560     char                    Buffer[32];
 561     ACPI_STATUS             Status;
 562     ACPI_STATISTICS         Stats;
 563     ACPI_HANDLE             Handle;
 564
 565 #if (!ACPI_REDUCED_HARDWARE)
 566     ACPI_VENDOR_UUID        Uuid = {0, {ACPI_INIT_UUID (0,0,0,0,0,0,0,0,0,0,0)}};
 567     UINT32                  LockHandle1;
 568     UINT32                  LockHandle2;
 569 #endif /* !ACPI_REDUCED_HARDWARE */
 570
 571
 572     Status = AcpiGetHandle (NULL, "\\", &Handle);
 573     AE_CHECK_OK (AcpiGetHandle, Status);
 574
 575     if (AcpiGbl_DoInterfaceTests)
 576     {
 577         /*
 578          * Tests for AcpiLoadTable and AcpiUnloadParentTable
 579          */
 580
 581         /* Attempt unload of DSDT, should fail */
 582
 583         Status = AcpiGetHandle (NULL, "\\_SB_", &Handle);
 584         AE_CHECK_OK (AcpiGetHandle, Status);
 585
 586         Status = AcpiUnloadParentTable (Handle);
 587         AE_CHECK_STATUS (AcpiUnloadParentTable, Status, AE_TYPE);
 588
 589         /* Load and unload SSDT4 */
 590
 591         Status = AcpiLoadTable ((ACPI_TABLE_HEADER *) Ssdt4Code);
 592         AE_CHECK_OK (AcpiLoadTable, Status);
 593
 594         Status = AcpiGetHandle (NULL, "\\_T96", &Handle);
 595         AE_CHECK_OK (AcpiGetHandle, Status);
 596
 597         Status = AcpiUnloadParentTable (Handle);
 598         AE_CHECK_OK (AcpiUnloadParentTable, Status);
 599
 600         /* Re-load SSDT4 */
 601
 602         Status = AcpiLoadTable ((ACPI_TABLE_HEADER *) Ssdt4Code);
 603         AE_CHECK_OK (AcpiLoadTable, Status);
 604
 605         /* Unload and re-load SSDT2 (SSDT2 is in the XSDT) */
 606
 607         Status = AcpiGetHandle (NULL, "\\_T99", &Handle);
 608         AE_CHECK_OK (AcpiGetHandle, Status);
 609
 610         Status = AcpiUnloadParentTable (Handle);
 611         AE_CHECK_OK (AcpiUnloadParentTable, Status);
 612
 613         Status = AcpiLoadTable ((ACPI_TABLE_HEADER *) Ssdt2Code);
 614         AE_CHECK_OK (AcpiLoadTable, Status);
 615
 616         /* Load OEM9 table (causes table override) */
 617
 618         Status = AcpiLoadTable ((ACPI_TABLE_HEADER *) Ssdt3Code);
 619         AE_CHECK_OK (AcpiLoadTable, Status);
 620     }
 621
 622     AeHardwareInterfaces ();
 623     AeGenericRegisters ();
 624     AeSetupConfiguration (Ssdt3Code);
 625
 626     AeTestBufferArgument();
 627     AeTestPackageArgument ();
 628     AeMutexInterfaces ();
 629
 630     /* Test _OSI install/remove */
 631
 632     Status = AcpiInstallInterface ("");
 633     AE_CHECK_STATUS (AcpiInstallInterface, Status, AE_BAD_PARAMETER);
 634
 635     Status = AcpiInstallInterface ("TestString");
 636     AE_CHECK_OK (AcpiInstallInterface, Status);
 637
 638     Status = AcpiInstallInterface ("TestString");
 639     AE_CHECK_STATUS (AcpiInstallInterface, Status, AE_ALREADY_EXISTS);
 640
 641     Status = AcpiRemoveInterface ("Windows 2006");
 642     AE_CHECK_OK (AcpiRemoveInterface, Status);
 643
 644     Status = AcpiRemoveInterface ("TestString");
 645     AE_CHECK_OK (AcpiRemoveInterface, Status);
 646
 647     Status = AcpiRemoveInterface ("XXXXXX");
 648     AE_CHECK_STATUS (AcpiRemoveInterface, Status, AE_NOT_EXIST);
 649
 650     Status = AcpiInstallInterface ("AnotherTestString");
 651     AE_CHECK_OK (AcpiInstallInterface, Status);
 652
 653     /* Test _OSI execution */
 654
 655     Status = ExecuteOSI ("Extended Address Space Descriptor", 0xFFFFFFFF);
 656     AE_CHECK_OK (ExecuteOSI, Status);
 657
 658     Status = ExecuteOSI ("Windows 2001", 0xFFFFFFFF);
 659     AE_CHECK_OK (ExecuteOSI, Status);
 660
 661     Status = ExecuteOSI ("MichiganTerminalSystem", 0);
 662     AE_CHECK_OK (ExecuteOSI, Status);
 663
 664
 665     ReturnBuf.Length = 32;
 666     ReturnBuf.Pointer = Buffer;
 667
 668     Status = AcpiGetName (ACPI_ROOT_OBJECT, ACPI_FULL_PATHNAME, &ReturnBuf);
 669     AE_CHECK_OK (AcpiGetName, Status);
 670
 671     /* Get Devices */
 672
 673     Status = AcpiGetDevices (NULL, AeGetDevices, NULL, NULL);
 674     AE_CHECK_OK (AcpiGetDevices, Status);
 675
 676     Status = AcpiGetStatistics (&Stats);
 677     AE_CHECK_OK (AcpiGetStatistics, Status);
 678
 679
 680 #if (!ACPI_REDUCED_HARDWARE)
 681
 682     Status = AcpiInstallGlobalEventHandler (AeGlobalEventHandler, NULL);
 683     AE_CHECK_OK (AcpiInstallGlobalEventHandler, Status);
 684
 685     /* If Hardware Reduced flag is set, we are all done */
 686
 687     if (AcpiGbl_ReducedHardware)
 688     {
 689         return;
 690     }
 691
 692     Status = AcpiEnableEvent (ACPI_EVENT_GLOBAL, 0);
 693     AE_CHECK_OK (AcpiEnableEvent, Status);
 694
 695     /*
 696      * GPEs: Handlers, enable/disable, etc.
 697      */
 698     Status = AcpiInstallGpeHandler (NULL, 0, ACPI_GPE_LEVEL_TRIGGERED, AeGpeHandler, NULL);
 699     AE_CHECK_OK (AcpiInstallGpeHandler, Status);
 700
 701     Status = AcpiEnableGpe (NULL, 0);
 702     AE_CHECK_OK (AcpiEnableGpe, Status);
 703
 704     Status = AcpiRemoveGpeHandler (NULL, 0, AeGpeHandler);
 705     AE_CHECK_OK (AcpiRemoveGpeHandler, Status);
 706
 707     Status = AcpiInstallGpeHandler (NULL, 0, ACPI_GPE_LEVEL_TRIGGERED, AeGpeHandler, NULL);
 708     AE_CHECK_OK (AcpiInstallGpeHandler, Status);
 709
 710     Status = AcpiEnableGpe (NULL, 0);
 711     AE_CHECK_OK (AcpiEnableGpe, Status);
 712
 713     Status = AcpiSetGpe (NULL, 0, ACPI_GPE_DISABLE);
 714     AE_CHECK_OK (AcpiSetGpe, Status);
 715
 716     Status = AcpiSetGpe (NULL, 0, ACPI_GPE_ENABLE);
 717     AE_CHECK_OK (AcpiSetGpe, Status);
 718
 719
 720     Status = AcpiInstallGpeHandler (NULL, 1, ACPI_GPE_EDGE_TRIGGERED, AeGpeHandler, NULL);
 721     AE_CHECK_OK (AcpiInstallGpeHandler, Status);
 722
 723     Status = AcpiEnableGpe (NULL, 1);
 724     AE_CHECK_OK (AcpiEnableGpe, Status);
 725
 726
 727     Status = AcpiInstallGpeHandler (NULL, 2, ACPI_GPE_LEVEL_TRIGGERED, AeGpeHandler, NULL);
 728     AE_CHECK_OK (AcpiInstallGpeHandler, Status);
 729
 730     Status = AcpiEnableGpe (NULL, 2);
 731     AE_CHECK_OK (AcpiEnableGpe, Status);
 732
 733
 734     Status = AcpiInstallGpeHandler (NULL, 3, ACPI_GPE_EDGE_TRIGGERED, AeGpeHandler, NULL);
 735     AE_CHECK_OK (AcpiInstallGpeHandler, Status);
 736
 737     Status = AcpiInstallGpeHandler (NULL, 4, ACPI_GPE_LEVEL_TRIGGERED, AeGpeHandler, NULL);
 738     AE_CHECK_OK (AcpiInstallGpeHandler, Status);
 739
 740     Status = AcpiInstallGpeHandler (NULL, 5, ACPI_GPE_EDGE_TRIGGERED, AeGpeHandler, NULL);
 741     AE_CHECK_OK (AcpiInstallGpeHandler, Status);
 742
 743     Status = AcpiGetHandle (NULL, "\\_SB", &Handle);
 744     AE_CHECK_OK (AcpiGetHandle, Status);
 745
 746     Status = AcpiSetupGpeForWake (Handle, NULL, 5);
 747     AE_CHECK_OK (AcpiSetupGpeForWake, Status);
 748
 749     Status = AcpiSetGpeWakeMask (NULL, 5, ACPI_GPE_ENABLE);
 750     AE_CHECK_OK (AcpiSetGpeWakeMask, Status);
 751
 752     Status = AcpiSetupGpeForWake (Handle, NULL, 6);
 753     AE_CHECK_OK (AcpiSetupGpeForWake, Status);
 754
 755     Status = AcpiSetupGpeForWake (ACPI_ROOT_OBJECT, NULL, 6);
 756     AE_CHECK_OK (AcpiSetupGpeForWake, Status);
 757
 758     Status = AcpiSetupGpeForWake (Handle, NULL, 9);
 759     AE_CHECK_OK (AcpiSetupGpeForWake, Status);
 760
 761     Status = AcpiInstallGpeHandler (NULL, 0x19, ACPI_GPE_LEVEL_TRIGGERED, AeGpeHandler, NULL);
 762     AE_CHECK_OK (AcpiInstallGpeHandler, Status);
 763
 764     Status = AcpiEnableGpe (NULL, 0x19);
 765     AE_CHECK_OK (AcpiEnableGpe, Status);
 766
 767
 768     /* GPE block 1 */
 769
 770     Status = AcpiInstallGpeHandler (NULL, 101, ACPI_GPE_LEVEL_TRIGGERED, AeGpeHandler, NULL);
 771     AE_CHECK_OK (AcpiInstallGpeHandler, Status);
 772
 773     Status = AcpiEnableGpe (NULL, 101);
 774     AE_CHECK_OK (AcpiEnableGpe, Status);
 775
 776     Status = AcpiDisableGpe (NULL, 101);
 777     AE_CHECK_OK (AcpiDisableGpe, Status);
 778
 779     AfInstallGpeBlock ();
 780
 781     /* Here is where the GPEs are actually "enabled" */
 782
 783     Status = AcpiUpdateAllGpes ();
 784     AE_CHECK_OK (AcpiUpdateAllGpes, Status);
 785
 786     Status = AcpiGetHandle (NULL, "RSRC", &Handle);
 787     if (ACPI_SUCCESS (Status))
 788     {
 789         ReturnBuf.Length = ACPI_ALLOCATE_BUFFER;
 790
 791         Status = AcpiGetVendorResource (Handle, "_CRS", &Uuid, &ReturnBuf);
 792         if (ACPI_SUCCESS (Status))
 793         {
 794             AcpiOsFree (ReturnBuf.Pointer);
 795         }
 796     }
 797
 798     /* Test global lock */
 799
 800     Status = AcpiAcquireGlobalLock (0xFFFF, &LockHandle1);
 801     AE_CHECK_OK (AcpiAcquireGlobalLock, Status);
 802
 803     Status = AcpiAcquireGlobalLock (0x5, &LockHandle2);
 804     AE_CHECK_OK (AcpiAcquireGlobalLock, Status);
 805
 806     Status = AcpiReleaseGlobalLock (LockHandle1);
 807     AE_CHECK_OK (AcpiReleaseGlobalLock, Status);
 808
 809     Status = AcpiReleaseGlobalLock (LockHandle2);
 810     AE_CHECK_OK (AcpiReleaseGlobalLock, Status);
 811
 812 #endif /* !ACPI_REDUCED_HARDWARE */
 813 }