status_t
install_gpe_handler(acpi_handle handle, uint32 gpeNumber, uint32 type,
acpi_gpe_handler handler, void *data)
{
return AcpiInstallGpeHandler(handle, gpeNumber, type,
(ACPI_GPE_HANDLER)handler, data) == 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
AtInstallGpeHandlerCommon(
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);
}
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 == 1)
{
/* Make Device handle invalid by unloading SSDT table*/
if (ACPI_FAILURE(Status = AtAuxiliarySsdt(AT_UNLOAD)))
{
return (Status);
}
}
else if (CheckAction == 5)
{
if (ExpectedStatus != AE_ALREADY_EXISTS)
{
TestErrors++;
printf ("Test Error: ExpectedStatus %s != AE_ALREADY_EXISTS\n",
AcpiFormatException(ExpectedStatus));
return (AE_ERROR);
}
ExpectedStatus = AE_OK;
}
GpeHandlerCounter = 0;
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;
}
GpeHandlerContext[i] = 0;
Status = AcpiInstallGpeHandler(GpeDevice, Gpe, EolType,
EventHandler, &GpeHandlerContext[i]);
if (Status != ExpectedStatus)
{
AapiErrors++;
printf ("Api Error: AcpiInstallGpeHandler(%d, 0x%x, 0x%p)"
" returned %s, expected %s\n",
Gpe, EolType, EventHandler, AcpiFormatException(Status),
AcpiFormatException(ExpectedStatus));
if (Status != AE_OK)
{
return (Status);
}
else
{
return (AE_ERROR);
}
}
}
if (CheckAction == 5)
{
for (i = 0; i < AT_NUM_GPE_EVENTS; i++)
{
Gpe = GpeNumber[i];
EolType = GpeEolType[i];
EventHandler = GpeHandlers[(i + 1) % AT_NUM_GPE_EVENTS];
Status = AcpiInstallGpeHandler(GpeDevice, Gpe, EolType,
EventHandler, &GpeHandlerContext[i]);
if (Status != AE_ALREADY_EXISTS)
{
AapiErrors++;
printf ("Error: AcpiInstallGpeHandler(%d, 0x%x, 0x%p) returned %s,"
" expected %s\n",
Gpe, EolType, EventHandler, AcpiFormatException(Status),
AcpiFormatException(AE_ALREADY_EXISTS));
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);
}
static int
acpi_ec_attach(device_t dev)
{
struct acpi_ec_softc *sc;
ACPI_STATUS Status;
int errval = 0;
ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
/*
* Fetch/initialise softc
*/
sc = device_get_softc(dev);
bzero(sc, sizeof(*sc));
sc->ec_dev = dev;
sc->ec_handle = acpi_get_handle(dev);
/*
* Attach bus resources
*/
sc->ec_data_rid = 0;
if ((sc->ec_data_res = bus_alloc_resource(sc->ec_dev, SYS_RES_IOPORT, &sc->ec_data_rid,
0, ~0, 1, RF_ACTIVE)) == NULL) {
device_printf(dev, "can't allocate data port\n");
errval = ENXIO;
goto out;
}
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;
if ((sc->ec_csr_res = bus_alloc_resource(sc->ec_dev, SYS_RES_IOPORT, &sc->ec_csr_rid,
0, ~0, 1, RF_ACTIVE)) == NULL) {
device_printf(dev, "can't allocate command/status port\n");
errval = ENXIO;
goto out;
}
sc->ec_csr_tag = rman_get_bustag(sc->ec_csr_res);
sc->ec_csr_handle = rman_get_bushandle(sc->ec_csr_res);
/*
* Install GPE handler
*
* Evaluate the _GPE method to find the GPE bit used by the EC to signal
* status (SCI).
*/
ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "attaching GPE\n"));
if (ACPI_FAILURE(Status = acpi_EvaluateInteger(sc->ec_handle, "_GPE", &sc->ec_gpebit))) {
device_printf(dev, "can't evaluate _GPE - %s\n", AcpiFormatException(Status));
errval =ENXIO;
goto out;
}
/*
* Install a handler for this EC's GPE bit. Note that EC SCIs are
* treated as both edge- and level-triggered interrupts; in other words
* we clear the status bit immediately after getting an EC-SCI, then
* again after we're done processing the event. This guarantees that
* events we cause while performing a transaction (e.g. IBE/OBF) get
* cleared before re-enabling the GPE.
*/
if (ACPI_FAILURE(Status = AcpiInstallGpeHandler(sc->ec_gpebit,
ACPI_EVENT_LEVEL_TRIGGERED |
ACPI_EVENT_EDGE_TRIGGERED,
EcGpeHandler, sc))) {
device_printf(dev, "can't install GPE handler for %s - %s\n",
acpi_name(sc->ec_handle), AcpiFormatException(Status));
errval = ENXIO;
goto out;
}
/*
* Install address space handler
*/
ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "attaching address space handler\n"));
if (ACPI_FAILURE(Status = AcpiInstallAddressSpaceHandler(sc->ec_handle,
ACPI_ADR_SPACE_EC,
EcSpaceHandler,
EcSpaceSetup,
sc))) {
device_printf(dev, "can't install address space handler for %s - %s\n",
acpi_name(sc->ec_handle), AcpiFormatException(Status));
panic("very suck");
errval = ENXIO;
goto out;
}
ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "attach complete\n"));
return_VALUE(0);
out:
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_VALUE(errval);
}
/*
* acpiec_attach:
*
* Autoconfiguration `attach' routine.
*/
void
acpiec_attach(struct device *parent, struct device *self, void *aux)
{
struct acpi_ec_softc *sc = (void *) self;
struct acpi_attach_args *aa = aux;
struct acpi_io *io0, *io1;
ACPI_STATUS rv;
FUNCTION_TRACE(__FUNCTION__);
printf(": ACPI Embedded Controller\n");
sc->sc_node = aa->aa_node;
/* Parse our resources. */
ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "parsing EC resources\n"));
rv = acpi_resource_parse(&sc->sc_dev, sc->sc_node, &sc->sc_res,
&acpi_resource_parse_ops_default);
if (rv != AE_OK) {
printf("%s: unable to parse resources: %d\n",
sc->sc_dev.dv_xname, rv);
return;
}
sc->sc_data_st = aa->aa_iot;
io0 = acpi_res_io(&sc->sc_res, 0);
if (io0 == NULL) {
printf("%s: unable to find data register resource\n",
sc->sc_dev.dv_xname);
return;
}
if (bus_space_map(sc->sc_data_st, io0->ar_base, io0->ar_length,
0, &sc->sc_data_sh) != 0) {
printf("%s: unable to map data register\n",
sc->sc_dev.dv_xname);
return;
}
sc->sc_csr_st = aa->aa_iot;
io1 = acpi_res_io(&sc->sc_res, 1);
if (io1 == NULL) {
printf("%s: unable to find csr register resource\n",
sc->sc_dev.dv_xname);
return;
}
if (bus_space_map(sc->sc_csr_st, io1->ar_base, io1->ar_length,
0, &sc->sc_csr_sh) != 0) {
printf("%s: unable to map csr register\n",
sc->sc_dev.dv_xname);
return;
}
/*
* Install GPE handler.
*
* We evaluate the _GPE method to find the GPE bit used by the
* Embedded Controller to signal status (SCI).
*/
if ((rv = acpi_eval_integer(sc->sc_node->ad_handle, "_GPE",
&sc->sc_gpebit)) != AE_OK) {
printf("%s: unable to evaluate _GPE: %d\n",
sc->sc_dev.dv_xname, rv);
return;
}
/*
* Install a handler for this EC's GPE bit. Note that EC SCIs are
* treated as both edge- and level-triggered interrupts; in other words
* we clear the status bit immediately after getting an EC-SCI, then
* again after we're done processing the event. This guarantees that
* events we cause while performing a transaction (e.g. IBE/OBF) get
* cleared before re-enabling the GPE.
*/
if ((rv = AcpiInstallGpeHandler(sc->sc_gpebit,
ACPI_EVENT_LEVEL_TRIGGERED | ACPI_EVENT_EDGE_TRIGGERED,
EcGpeHandler, sc)) != AE_OK) {
printf("%s: unable to install GPE handler: %d\n",
sc->sc_dev.dv_xname, rv);
return;
}
/* Install address space handler. */
if ((rv = AcpiInstallAddressSpaceHandler(sc->sc_node->ad_handle,
ACPI_ADR_SPACE_EC, EcSpaceHandler, EcSpaceSetup, sc)) != AE_OK) {
printf("%s: unable to install address space handler: %d\n",
sc->sc_dev.dv_xname, rv);
return;
}
return_VOID;
}
