status_t
remove_gpe_handler(acpi_handle handle, uint32 gpeNumber,
acpi_gpe_handler address)
{
return AcpiRemoveGpeHandler(handle, gpeNumber, (ACPI_GPE_HANDLER)address)
== AE_OK ? B_OK : B_ERROR;
}
static void
AfInstallGpeBlock (
void)
{
ACPI_STATUS Status;
ACPI_HANDLE Handle;
ACPI_HANDLE Handle2 = NULL;
ACPI_HANDLE Handle3 = NULL;
ACPI_GENERIC_ADDRESS BlockAddress;
ACPI_HANDLE GpeDevice;
Status = AcpiGetHandle (NULL, "\\_GPE", &Handle);
if (ACPI_FAILURE (Status))
{
return;
}
ACPI_MEMSET (&BlockAddress, 0, sizeof (ACPI_GENERIC_ADDRESS));
BlockAddress.SpaceId = ACPI_ADR_SPACE_SYSTEM_MEMORY;
BlockAddress.Address = 0x76540000;
Status = AcpiGetHandle (NULL, "\\GPE2", &Handle2);
if (ACPI_SUCCESS (Status))
{
Status = AcpiInstallGpeBlock (Handle2, &BlockAddress, 7, 8);
AE_CHECK_OK (AcpiInstallGpeBlock, Status);
Status = AcpiInstallGpeHandler (Handle2, 8,
ACPI_GPE_LEVEL_TRIGGERED, AeGpeHandler, NULL);
AE_CHECK_OK (AcpiInstallGpeHandler, Status);
Status = AcpiEnableGpe (Handle2, 8);
AE_CHECK_OK (AcpiEnableGpe, Status);
Status = AcpiGetGpeDevice (0x30, &GpeDevice);
AE_CHECK_OK (AcpiGetGpeDevice, Status);
Status = AcpiGetGpeDevice (0x42, &GpeDevice);
AE_CHECK_OK (AcpiGetGpeDevice, Status);
Status = AcpiGetGpeDevice (AcpiCurrentGpeCount-1, &GpeDevice);
AE_CHECK_OK (AcpiGetGpeDevice, Status);
Status = AcpiGetGpeDevice (AcpiCurrentGpeCount, &GpeDevice);
AE_CHECK_STATUS (AcpiGetGpeDevice, Status, AE_NOT_EXIST);
Status = AcpiRemoveGpeHandler (Handle2, 8, AeGpeHandler);
AE_CHECK_OK (AcpiRemoveGpeHandler, Status);
}
Status = AcpiGetHandle (NULL, "\\GPE3", &Handle3);
if (ACPI_SUCCESS (Status))
{
Status = AcpiInstallGpeBlock (Handle3, &BlockAddress, 8, 11);
AE_CHECK_OK (AcpiInstallGpeBlock, Status);
}
}
void
AeMiscellaneousTests (
void)
{
ACPI_BUFFER ReturnBuf;
char Buffer[32];
ACPI_STATUS Status;
ACPI_STATISTICS Stats;
ACPI_HANDLE Handle;
#if (!ACPI_REDUCED_HARDWARE)
UINT32 LockHandle1;
UINT32 LockHandle2;
ACPI_VENDOR_UUID Uuid =
{0, {ACPI_INIT_UUID (0,0,0,0,0,0,0,0,0,0,0)}};
#endif /* !ACPI_REDUCED_HARDWARE */
Status = AcpiGetHandle (NULL, "\\", &Handle);
ACPI_CHECK_OK (AcpiGetHandle, Status);
if (AcpiGbl_DoInterfaceTests)
{
/*
* Tests for AcpiLoadTable and AcpiUnloadParentTable
*/
/* Attempt unload of DSDT, should fail */
Status = AcpiGetHandle (NULL, "\\_SB_", &Handle);
ACPI_CHECK_OK (AcpiGetHandle, Status);
Status = AcpiUnloadParentTable (Handle);
ACPI_CHECK_STATUS (AcpiUnloadParentTable, Status, AE_TYPE);
/* Load and unload SSDT4 */
Status = AcpiLoadTable ((ACPI_TABLE_HEADER *) Ssdt4Code);
ACPI_CHECK_OK (AcpiLoadTable, Status);
Status = AcpiGetHandle (NULL, "\\_T96", &Handle);
ACPI_CHECK_OK (AcpiGetHandle, Status);
Status = AcpiUnloadParentTable (Handle);
ACPI_CHECK_OK (AcpiUnloadParentTable, Status);
/* Re-load SSDT4 */
Status = AcpiLoadTable ((ACPI_TABLE_HEADER *) Ssdt4Code);
ACPI_CHECK_OK (AcpiLoadTable, Status);
/* Unload and re-load SSDT2 (SSDT2 is in the XSDT) */
Status = AcpiGetHandle (NULL, "\\_T99", &Handle);
ACPI_CHECK_OK (AcpiGetHandle, Status);
Status = AcpiUnloadParentTable (Handle);
ACPI_CHECK_OK (AcpiUnloadParentTable, Status);
Status = AcpiLoadTable ((ACPI_TABLE_HEADER *) Ssdt2Code);
ACPI_CHECK_OK (AcpiLoadTable, Status);
/* Load OEM9 table (causes table override) */
Status = AcpiLoadTable ((ACPI_TABLE_HEADER *) Ssdt3Code);
ACPI_CHECK_OK (AcpiLoadTable, Status);
}
AeHardwareInterfaces ();
AeGenericRegisters ();
AeSetupConfiguration (Ssdt3Code);
AeTestBufferArgument();
AeTestPackageArgument ();
AeMutexInterfaces ();
AeTestSleepData ();
/* Test _OSI install/remove */
Status = AcpiInstallInterface ("");
ACPI_CHECK_STATUS (AcpiInstallInterface, Status, AE_BAD_PARAMETER);
Status = AcpiInstallInterface ("TestString");
ACPI_CHECK_OK (AcpiInstallInterface, Status);
Status = AcpiInstallInterface ("TestString");
ACPI_CHECK_STATUS (AcpiInstallInterface, Status, AE_ALREADY_EXISTS);
Status = AcpiRemoveInterface ("Windows 2006");
ACPI_CHECK_OK (AcpiRemoveInterface, Status);
Status = AcpiRemoveInterface ("TestString");
ACPI_CHECK_OK (AcpiRemoveInterface, Status);
Status = AcpiRemoveInterface ("XXXXXX");
ACPI_CHECK_STATUS (AcpiRemoveInterface, Status, AE_NOT_EXIST);
Status = AcpiInstallInterface ("AnotherTestString");
ACPI_CHECK_OK (AcpiInstallInterface, Status);
/* Test _OSI execution */
Status = ExecuteOSI ("Extended Address Space Descriptor", ACPI_UINT64_MAX);
ACPI_CHECK_OK (ExecuteOSI, Status);
Status = ExecuteOSI ("Windows 2001", ACPI_UINT64_MAX);
ACPI_CHECK_OK (ExecuteOSI, Status);
Status = ExecuteOSI ("MichiganTerminalSystem", 0);
ACPI_CHECK_OK (ExecuteOSI, Status);
ReturnBuf.Length = 32;
ReturnBuf.Pointer = Buffer;
Status = AcpiGetName (ACPI_ROOT_OBJECT,
ACPI_FULL_PATHNAME_NO_TRAILING, &ReturnBuf);
ACPI_CHECK_OK (AcpiGetName, Status);
/* Get Devices */
Status = AcpiGetDevices (NULL, AeGetDevices, NULL, NULL);
ACPI_CHECK_OK (AcpiGetDevices, Status);
Status = AcpiGetStatistics (&Stats);
ACPI_CHECK_OK (AcpiGetStatistics, Status);
#if (!ACPI_REDUCED_HARDWARE)
Status = AcpiInstallGlobalEventHandler (AeGlobalEventHandler, NULL);
ACPI_CHECK_OK (AcpiInstallGlobalEventHandler, Status);
/* If Hardware Reduced flag is set, we are all done */
if (AcpiGbl_ReducedHardware)
{
return;
}
Status = AcpiEnableEvent (ACPI_EVENT_GLOBAL, 0);
ACPI_CHECK_OK (AcpiEnableEvent, Status);
/*
* GPEs: Handlers, enable/disable, etc.
*/
Status = AcpiInstallGpeHandler (NULL, 0,
ACPI_GPE_LEVEL_TRIGGERED, AeGpeHandler, NULL);
ACPI_CHECK_OK (AcpiInstallGpeHandler, Status);
Status = AcpiEnableGpe (NULL, 0);
ACPI_CHECK_OK (AcpiEnableGpe, Status);
Status = AcpiRemoveGpeHandler (NULL, 0, AeGpeHandler);
ACPI_CHECK_OK (AcpiRemoveGpeHandler, Status);
Status = AcpiInstallGpeHandler (NULL, 0,
ACPI_GPE_LEVEL_TRIGGERED, AeGpeHandler, NULL);
ACPI_CHECK_OK (AcpiInstallGpeHandler, Status);
Status = AcpiEnableGpe (NULL, 0);
ACPI_CHECK_OK (AcpiEnableGpe, Status);
Status = AcpiSetGpe (NULL, 0, ACPI_GPE_DISABLE);
ACPI_CHECK_OK (AcpiSetGpe, Status);
Status = AcpiSetGpe (NULL, 0, ACPI_GPE_ENABLE);
ACPI_CHECK_OK (AcpiSetGpe, Status);
Status = AcpiInstallGpeHandler (NULL, 1,
ACPI_GPE_EDGE_TRIGGERED, AeGpeHandler, NULL);
ACPI_CHECK_OK (AcpiInstallGpeHandler, Status);
Status = AcpiEnableGpe (NULL, 1);
ACPI_CHECK_OK (AcpiEnableGpe, Status);
Status = AcpiInstallGpeHandler (NULL, 2,
ACPI_GPE_LEVEL_TRIGGERED, AeGpeHandler, NULL);
ACPI_CHECK_OK (AcpiInstallGpeHandler, Status);
Status = AcpiEnableGpe (NULL, 2);
ACPI_CHECK_OK (AcpiEnableGpe, Status);
Status = AcpiInstallGpeHandler (NULL, 3,
ACPI_GPE_EDGE_TRIGGERED, AeGpeHandler, NULL);
ACPI_CHECK_OK (AcpiInstallGpeHandler, Status);
Status = AcpiInstallGpeHandler (NULL, 4,
ACPI_GPE_LEVEL_TRIGGERED, AeGpeHandler, NULL);
ACPI_CHECK_OK (AcpiInstallGpeHandler, Status);
Status = AcpiInstallGpeHandler (NULL, 5,
ACPI_GPE_EDGE_TRIGGERED, AeGpeHandler, NULL);
ACPI_CHECK_OK (AcpiInstallGpeHandler, Status);
Status = AcpiGetHandle (NULL, "\\_SB", &Handle);
ACPI_CHECK_OK (AcpiGetHandle, Status);
Status = AcpiSetupGpeForWake (Handle, NULL, 5);
ACPI_CHECK_OK (AcpiSetupGpeForWake, Status);
Status = AcpiSetGpeWakeMask (NULL, 5, ACPI_GPE_ENABLE);
ACPI_CHECK_OK (AcpiSetGpeWakeMask, Status);
Status = AcpiSetupGpeForWake (Handle, NULL, 6);
ACPI_CHECK_OK (AcpiSetupGpeForWake, Status);
Status = AcpiSetupGpeForWake (ACPI_ROOT_OBJECT, NULL, 6);
ACPI_CHECK_OK (AcpiSetupGpeForWake, Status);
Status = AcpiSetupGpeForWake (Handle, NULL, 9);
ACPI_CHECK_OK (AcpiSetupGpeForWake, Status);
Status = AcpiInstallGpeHandler (NULL, 0x19,
ACPI_GPE_LEVEL_TRIGGERED, AeGpeHandler, NULL);
ACPI_CHECK_OK (AcpiInstallGpeHandler, Status);
Status = AcpiEnableGpe (NULL, 0x19);
ACPI_CHECK_OK (AcpiEnableGpe, Status);
/* GPE block 1 */
Status = AcpiInstallGpeHandler (NULL, 101,
ACPI_GPE_LEVEL_TRIGGERED, AeGpeHandler, NULL);
ACPI_CHECK_OK (AcpiInstallGpeHandler, Status);
Status = AcpiEnableGpe (NULL, 101);
ACPI_CHECK_OK (AcpiEnableGpe, Status);
Status = AcpiDisableGpe (NULL, 101);
ACPI_CHECK_OK (AcpiDisableGpe, Status);
AfInstallGpeBlock ();
/* Here is where the GPEs are actually "enabled" */
Status = AcpiUpdateAllGpes ();
ACPI_CHECK_OK (AcpiUpdateAllGpes, Status);
Status = AcpiGetHandle (NULL, "RSRC", &Handle);
if (ACPI_SUCCESS (Status))
{
ReturnBuf.Length = ACPI_ALLOCATE_BUFFER;
Status = AcpiGetVendorResource (Handle, "_CRS", &Uuid, &ReturnBuf);
if (ACPI_SUCCESS (Status))
{
AcpiOsFree (ReturnBuf.Pointer);
}
}
/* Test global lock */
Status = AcpiAcquireGlobalLock (0xFFFF, &LockHandle1);
ACPI_CHECK_OK (AcpiAcquireGlobalLock, Status);
Status = AcpiAcquireGlobalLock (0x5, &LockHandle2);
ACPI_CHECK_OK (AcpiAcquireGlobalLock, Status);
Status = AcpiReleaseGlobalLock (LockHandle1);
ACPI_CHECK_OK (AcpiReleaseGlobalLock, Status);
Status = AcpiReleaseGlobalLock (LockHandle2);
ACPI_CHECK_OK (AcpiReleaseGlobalLock, Status);
#endif /* !ACPI_REDUCED_HARDWARE */
}
static void
AfInstallGpeBlock (
void)
{
ACPI_STATUS Status;
ACPI_HANDLE Handle;
ACPI_GENERIC_ADDRESS BlockAddress;
ACPI_HANDLE GpeDevice;
ACPI_OBJECT_TYPE Type;
/* _GPE should always exist */
Status = AcpiGetHandle (NULL, "\\_GPE", &Handle);
ACPI_CHECK_OK (AcpiGetHandle, Status);
if (ACPI_FAILURE (Status))
{
return;
}
memset (&BlockAddress, 0, sizeof (ACPI_GENERIC_ADDRESS));
BlockAddress.SpaceId = ACPI_ADR_SPACE_SYSTEM_MEMORY;
BlockAddress.Address = 0x76540000;
/* Attempt to install a GPE block on GPE2 (if present) */
Status = AcpiGetHandle (NULL, "\\GPE2", &Handle);
if (ACPI_SUCCESS (Status))
{
Status = AcpiGetType (Handle, &Type);
if (ACPI_FAILURE (Status) ||
(Type != ACPI_TYPE_DEVICE))
{
return;
}
Status = AcpiInstallGpeBlock (Handle, &BlockAddress, 7, 8);
ACPI_CHECK_OK (AcpiInstallGpeBlock, Status);
Status = AcpiInstallGpeHandler (Handle, 8,
ACPI_GPE_LEVEL_TRIGGERED, AeGpeHandler, NULL);
ACPI_CHECK_OK (AcpiInstallGpeHandler, Status);
Status = AcpiEnableGpe (Handle, 8);
ACPI_CHECK_OK (AcpiEnableGpe, Status);
Status = AcpiGetGpeDevice (0x30, &GpeDevice);
ACPI_CHECK_OK (AcpiGetGpeDevice, Status);
Status = AcpiGetGpeDevice (0x42, &GpeDevice);
ACPI_CHECK_OK (AcpiGetGpeDevice, Status);
Status = AcpiGetGpeDevice (AcpiCurrentGpeCount-1, &GpeDevice);
ACPI_CHECK_OK (AcpiGetGpeDevice, Status);
Status = AcpiGetGpeDevice (AcpiCurrentGpeCount, &GpeDevice);
ACPI_CHECK_STATUS (AcpiGetGpeDevice, Status, AE_NOT_EXIST);
Status = AcpiRemoveGpeHandler (Handle, 8, AeGpeHandler);
ACPI_CHECK_OK (AcpiRemoveGpeHandler, Status);
}
/* Attempt to install a GPE block on GPE3 (if present) */
Status = AcpiGetHandle (NULL, "\\GPE3", &Handle);
if (ACPI_SUCCESS (Status))
{
Status = AcpiGetType (Handle, &Type);
if (ACPI_FAILURE (Status) ||
(Type != ACPI_TYPE_DEVICE))
{
return;
}
Status = AcpiInstallGpeBlock (Handle, &BlockAddress, 8, 11);
ACPI_CHECK_OK (AcpiInstallGpeBlock, Status);
}
}
static int
acpi_ec_attach(device_t dev)
{
struct acpi_ec_softc *sc;
struct acpi_ec_params *params;
ACPI_STATUS Status;
ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
/* Fetch/initialize softc (assumes softc is pre-zeroed). */
sc = device_get_softc(dev);
params = acpi_get_private(dev);
sc->ec_dev = dev;
sc->ec_handle = acpi_get_handle(dev);
ACPI_SERIAL_INIT(ec);
/* Retrieve previously probed values via device ivars. */
sc->ec_glk = params->glk;
sc->ec_gpebit = params->gpe_bit;
sc->ec_gpehandle = params->gpe_handle;
sc->ec_uid = params->uid;
sc->ec_suspending = FALSE;
acpi_set_private(dev, NULL);
kfree(params, M_TEMP);
/* Attach bus resources for data and command/status ports. */
sc->ec_data_rid = 0;
sc->ec_data_res = bus_alloc_resource_any(sc->ec_dev, SYS_RES_IOPORT,
&sc->ec_data_rid, RF_ACTIVE);
if (sc->ec_data_res == NULL) {
device_printf(dev, "can't allocate data port\n");
goto error;
}
sc->ec_data_tag = rman_get_bustag(sc->ec_data_res);
sc->ec_data_handle = rman_get_bushandle(sc->ec_data_res);
sc->ec_csr_rid = 1;
sc->ec_csr_res = bus_alloc_resource_any(sc->ec_dev, SYS_RES_IOPORT,
&sc->ec_csr_rid, RF_ACTIVE);
if (sc->ec_csr_res == NULL) {
device_printf(dev, "can't allocate command/status port\n");
goto error;
}
sc->ec_csr_tag = rman_get_bustag(sc->ec_csr_res);
sc->ec_csr_handle = rman_get_bushandle(sc->ec_csr_res);
/*
* Install a handler for this EC's GPE bit. We want edge-triggered
* behavior.
*/
ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "attaching GPE handler\n"));
Status = AcpiInstallGpeHandler(sc->ec_gpehandle, sc->ec_gpebit,
ACPI_GPE_EDGE_TRIGGERED, &EcGpeHandler, sc);
if (ACPI_FAILURE(Status)) {
device_printf(dev, "can't install GPE handler for %s - %s\n",
acpi_name(sc->ec_handle), AcpiFormatException(Status));
goto error;
}
/*
* Install address space handler
*/
ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "attaching address space handler\n"));
Status = AcpiInstallAddressSpaceHandler(sc->ec_handle, ACPI_ADR_SPACE_EC,
&EcSpaceHandler, &EcSpaceSetup, sc);
if (ACPI_FAILURE(Status)) {
device_printf(dev, "can't install address space handler for %s - %s\n",
acpi_name(sc->ec_handle), AcpiFormatException(Status));
goto error;
}
/* Enable runtime GPEs for the handler */
Status = AcpiEnableGpe(sc->ec_gpehandle, sc->ec_gpebit);
if (ACPI_FAILURE(Status)) {
device_printf(dev, "AcpiEnableGpe failed: %s\n",
AcpiFormatException(Status));
goto error;
}
ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "acpi_ec_attach complete\n"));
return (0);
error:
AcpiRemoveGpeHandler(sc->ec_gpehandle, sc->ec_gpebit, &EcGpeHandler);
AcpiRemoveAddressSpaceHandler(sc->ec_handle, ACPI_ADR_SPACE_EC,
EcSpaceHandler);
if (sc->ec_csr_res)
bus_release_resource(sc->ec_dev, SYS_RES_IOPORT, sc->ec_csr_rid,
sc->ec_csr_res);
if (sc->ec_data_res)
bus_release_resource(sc->ec_dev, SYS_RES_IOPORT, sc->ec_data_rid,
sc->ec_data_res);
return (ENXIO);
}
ACPI_STATUS
AtRemoveGpeHandlerCommon(
UINT32 CheckAction,
ACPI_STATUS ExpectedStatus)
{
ACPI_STATUS Status;
ACPI_STRING Pathname = "\\DGPE";
ACPI_HANDLE GpeDevice = NULL;
UINT32 Gpe;
UINT8 EolType;
ACPI_GPE_HANDLER EventHandler;
UINT32 i;
UINT32 InitStages = AAPITS_INI_DEF & ~AAPITS_INSTALL_HS;
if (ACPI_FAILURE(Status = AtAMLcodeFileNameSet("gpev0000.aml")))
{
return (Status);
}
if (CheckAction == 1)
{
InitStages |= AAPITS_INSTALL_HS;
}
Status = AtSubsystemInit(
InitStages,
AAPITS_EN_FLAGS, AAPITS_OI_FLAGS, AtAMLcodeFileName);
if (ACPI_FAILURE(Status))
{
return (Status);
}
if (CheckAction == 1)
{
if (ACPI_FAILURE(Status = AtAuxiliarySsdt(AT_LOAD)))
{
return (Status);
}
Pathname = "\\AUX2.DEV0";
}
Status = AcpiGetHandle (NULL, Pathname, &GpeDevice);
if (ACPI_FAILURE(Status))
{
AapiErrors++;
printf ("Api Error: AcpiGetHandle(%s) returned %s\n",
Pathname, AcpiFormatException(Status));
return (Status);
}
GpeHandlerCounter = 0;
if (CheckAction != 2)
{
Status = AcpiInstallGpeBlock (GpeDevice, &GpeBlockAddress,
RegisterCount, InterruptNumber);
if (ACPI_FAILURE(Status))
{
AapiErrors++;
printf ("Api Error: AcpiInstallGpeBlock(%s) returned %s\n",
Pathname, AcpiFormatException(Status));
return (Status);
}
if (CheckAction != 6)
{
for (i = 0; i < AT_NUM_GPE_EVENTS; i++)
{
Gpe = GpeNumber[i];
EolType = GpeEolType[i];
EventHandler = GpeHandlers[i];
GpeHandlerContext[i] = 0;
Status = AcpiInstallGpeHandler(GpeDevice, Gpe, EolType,
EventHandler, &GpeHandlerContext[i]);
if (ACPI_FAILURE(Status))
{
AapiErrors++;
printf ("Error: AcpiInstallGpeHandler(%d, 0x%x, 0x%p) returned %s\n",
Gpe, EolType, EventHandler, AcpiFormatException(Status));
return (Status);
}
}
}
}
if (CheckAction == 1)
{
/* Make Device handle invalid by unloading SSDT table*/
if (ACPI_FAILURE(Status = AtAuxiliarySsdt(AT_UNLOAD)))
{
return (Status);
}
}
for (i = 0; i < AT_NUM_GPE_EVENTS; i++)
{
Gpe = GpeNumber[i];
EolType = GpeEolType[i];
EventHandler = GpeHandlers[i];
if (CheckAction == 3)
{
Gpe += 256;
}
else if (CheckAction == 4)
{
EventHandler = NULL;
}
else if (CheckAction == 5)
{
EventHandler = GpeHandlers[(i + 2) % AT_NUM_GPE_EVENTS];
}
Status = AcpiRemoveGpeHandler(GpeDevice, Gpe, EventHandler);
if (Status != ExpectedStatus)
{
AapiErrors++;
printf ("Api Error: AcpiRemoveGpeHandler(%d, 0x%p)"
" returned %s, expected %s\n",
Gpe, EventHandler, AcpiFormatException(Status),
AcpiFormatException(ExpectedStatus));
if (Status != AE_OK)
{
return (Status);
}
else
{
return (AE_ERROR);
}
}
}
if (GpeHandlerCounter != 0)
{
AapiErrors++;
printf ("Api Error: Gpe Handler invoked %d times\n",
GpeHandlerCounter);
return (AE_ERROR);
}
return (AtTerminateCtrlCheck(AE_OK, ALL_STAT));
}
void
AeMiscellaneousTests (
void)
{
ACPI_HANDLE Handle;
ACPI_BUFFER ReturnBuf;
char Buffer[32];
ACPI_VENDOR_UUID Uuid = {0, {ACPI_INIT_UUID (0,0,0,0,0,0,0,0,0,0,0)}};
ACPI_STATUS Status;
UINT32 LockHandle1;
UINT32 LockHandle2;
ACPI_STATISTICS Stats;
AeHardwareInterfaces ();
AeGenericRegisters ();
AeSetupConfiguration (Ssdt3Code);
AeTestBufferArgument();
AeTestPackageArgument ();
Status = AcpiInstallInterface ("");
AE_CHECK_STATUS (AcpiInstallInterface, Status, AE_BAD_PARAMETER);
Status = AcpiInstallInterface ("TestString");
AE_CHECK_OK (AcpiInstallInterface, Status);
Status = AcpiInstallInterface ("TestString");
AE_CHECK_STATUS (AcpiInstallInterface, Status, AE_ALREADY_EXISTS);
Status = AcpiRemoveInterface ("Windows 2006");
AE_CHECK_OK (AcpiRemoveInterface, Status);
Status = AcpiRemoveInterface ("TestString");
AE_CHECK_OK (AcpiRemoveInterface, Status);
Status = AcpiRemoveInterface ("XXXXXX");
AE_CHECK_STATUS (AcpiRemoveInterface, Status, AE_NOT_EXIST);
Status = AcpiInstallInterface ("AnotherTestString");
AE_CHECK_OK (AcpiInstallInterface, Status);
Status = ExecuteOSI ("Windows 2001", 0xFFFFFFFF);
AE_CHECK_OK (ExecuteOSI, Status);
Status = ExecuteOSI ("MichiganTerminalSystem", 0);
AE_CHECK_OK (ExecuteOSI, Status);
ReturnBuf.Length = 32;
ReturnBuf.Pointer = Buffer;
Status = AcpiGetName (AcpiGbl_RootNode, ACPI_FULL_PATHNAME, &ReturnBuf);
AE_CHECK_OK (AcpiGetName, Status);
Status = AcpiEnableEvent (ACPI_EVENT_GLOBAL, 0);
AE_CHECK_OK (AcpiEnableEvent, Status);
/*
* GPEs: Handlers, enable/disable, etc.
*/
Status = AcpiInstallGpeHandler (NULL, 0, ACPI_GPE_LEVEL_TRIGGERED, AeGpeHandler, NULL);
AE_CHECK_OK (AcpiInstallGpeHandler, Status);
Status = AcpiEnableGpe (NULL, 0);
AE_CHECK_OK (AcpiEnableGpe, Status);
Status = AcpiRemoveGpeHandler (NULL, 0, AeGpeHandler);
AE_CHECK_OK (AcpiRemoveGpeHandler, Status);
Status = AcpiInstallGpeHandler (NULL, 0, ACPI_GPE_LEVEL_TRIGGERED, AeGpeHandler, NULL);
AE_CHECK_OK (AcpiInstallGpeHandler, Status);
Status = AcpiEnableGpe (NULL, 0);
AE_CHECK_OK (AcpiEnableGpe, Status);
Status = AcpiSetGpe (NULL, 0, ACPI_GPE_DISABLE);
AE_CHECK_OK (AcpiSetGpe, Status);
Status = AcpiSetGpe (NULL, 0, ACPI_GPE_ENABLE);
AE_CHECK_OK (AcpiSetGpe, Status);
Status = AcpiInstallGpeHandler (NULL, 1, ACPI_GPE_EDGE_TRIGGERED, AeGpeHandler, NULL);
AE_CHECK_OK (AcpiInstallGpeHandler, Status);
Status = AcpiEnableGpe (NULL, 1);
AE_CHECK_OK (AcpiEnableGpe, Status);
Status = AcpiInstallGpeHandler (NULL, 2, ACPI_GPE_LEVEL_TRIGGERED, AeGpeHandler, NULL);
AE_CHECK_OK (AcpiInstallGpeHandler, Status);
Status = AcpiEnableGpe (NULL, 2);
AE_CHECK_OK (AcpiEnableGpe, Status);
Status = AcpiInstallGpeHandler (NULL, 3, ACPI_GPE_EDGE_TRIGGERED, AeGpeHandler, NULL);
AE_CHECK_OK (AcpiInstallGpeHandler, Status);
Status = AcpiInstallGpeHandler (NULL, 4, ACPI_GPE_LEVEL_TRIGGERED, AeGpeHandler, NULL);
AE_CHECK_OK (AcpiInstallGpeHandler, Status);
Status = AcpiInstallGpeHandler (NULL, 5, ACPI_GPE_EDGE_TRIGGERED, AeGpeHandler, NULL);
AE_CHECK_OK (AcpiInstallGpeHandler, Status);
Status = AcpiInstallGpeHandler (NULL, 0x19, ACPI_GPE_LEVEL_TRIGGERED, AeGpeHandler, NULL);
AE_CHECK_OK (AcpiInstallGpeHandler, Status);
Status = AcpiEnableGpe (NULL, 0x19);
AE_CHECK_OK (AcpiEnableGpe, Status);
Status = AcpiInstallGpeHandler (NULL, 0x62, ACPI_GPE_LEVEL_TRIGGERED, AeGpeHandler, NULL);
AE_CHECK_OK (AcpiInstallGpeHandler, Status);
Status = AcpiEnableGpe (NULL, 0x62);
AE_CHECK_OK (AcpiEnableGpe, Status);
Status = AcpiDisableGpe (NULL, 0x62);
AE_CHECK_OK (AcpiDisableGpe, Status);
AfInstallGpeBlock ();
Status = AcpiGetHandle (NULL, "RSRC", &Handle);
if (ACPI_SUCCESS (Status))
{
ReturnBuf.Length = ACPI_ALLOCATE_BUFFER;
Status = AcpiGetVendorResource (Handle, "_CRS", &Uuid, &ReturnBuf);
if (ACPI_SUCCESS (Status))
{
AcpiOsFree (ReturnBuf.Pointer);
}
}
/* Test global lock */
Status = AcpiAcquireGlobalLock (0xFFFF, &LockHandle1);
AE_CHECK_OK (AcpiAcquireGlobalLock, Status);
Status = AcpiAcquireGlobalLock (0x5, &LockHandle2);
AE_CHECK_OK (AcpiAcquireGlobalLock, Status);
Status = AcpiReleaseGlobalLock (LockHandle1);
AE_CHECK_OK (AcpiReleaseGlobalLock, Status);
Status = AcpiReleaseGlobalLock (LockHandle2);
AE_CHECK_OK (AcpiReleaseGlobalLock, Status);
/* Get Devices */
Status = AcpiGetDevices (NULL, AeGetDevices, NULL, NULL);
AE_CHECK_OK (AcpiGetDevices, Status);
Status = AcpiGetStatistics (&Stats);
AE_CHECK_OK (AcpiGetStatistics, Status);
}
