ACPI_STATUS
AtGpeCommon(
ACPI_STRING Pathname,
UINT32 GpeNumber[],
UINT8 GpeType[],
UINT32 GpeCount,
UINT32 ApiCall,
UINT32 CheckAction,
ACPI_STATUS ExpectedStatus)
{
ACPI_STATUS Status;
ACPI_HANDLE GpeDevice = NULL;
UINT32 Gpe;
UINT32 i;
char *ApiCallName;
ACPI_EVENT_STATUS GpeStatus, *GpeStatusPointer = &GpeStatus;
if (ACPI_FAILURE(Status = AtAMLcodeFileNameSet("gpev0000.aml")))
{
return (Status);
}
Status = AtSubsystemInit(
AAPITS_INI_DEF,
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";
}
if (Pathname)
{
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 0
/* OBSOLETE interface, AcpiSetGpeType */
if (CheckAction != 2 && ApiCall != 0)
{
for (i = 0; i < GpeCount; i++)
{
Gpe = GpeNumber[i];
Type = GpeType[i];
Status = AcpiSetGpeType(GpeDevice, Gpe, Type);
if (ACPI_FAILURE(Status))
{
AapiErrors++;
printf ("API Error: AcpiSetGpeType(0x%x, 0x%x) returned %s\n",
Gpe, (UINT32)Type, AcpiFormatException(Status));
return (Status);
}
}
}
#endif
if (CheckAction == 1)
{
/* Make Device handle invalid by unloading SSDT table*/
if (ACPI_FAILURE(Status = AtAuxiliarySsdt(AT_UNLOAD)))
{
return (Status);
}
}
for (i = 0; i < GpeCount; i++)
{
Gpe = GpeNumber[i];
if (CheckAction == 3)
{
Gpe += 256;
}
else if (CheckAction == 5)
{
GpeStatusPointer = NULL;
}
switch (ApiCall)
{
case 0:
ApiCallName = "AcpiSetGpeType";
#if 0
/* OBSOLETE INTERFACE */
Status = AcpiSetGpeType(GpeDevice, Gpe, Type);
#endif
Status = AE_OK;
break;
case 1:
ApiCallName = "AcpiEnableGpe";
Status = AcpiEnableGpe(GpeDevice, Gpe);
break;
case 2:
ApiCallName = "AcpiClearGpe";
Status = AcpiClearGpe(GpeDevice, Gpe);
break;
case 3:
ApiCallName = "AcpiGetGpeStatus";
Status = AcpiGetGpeStatus(GpeDevice, Gpe, GpeStatusPointer);
break;
case 4:
ApiCallName = "AcpiDisableGpe";
Status = AcpiDisableGpe(GpeDevice, Gpe);
break;
default:
TestErrors++;
printf ("Test Error: the ApiCall number (%d) should be in range 0-4\n",
ApiCall);
return (AE_ERROR);
}
if (Status != ExpectedStatus)
{
AapiErrors++;
printf ("Api Error: %s(%d) returned %s, expected %s\n",
ApiCallName, Gpe, AcpiFormatException(Status),
AcpiFormatException(ExpectedStatus));
if (Status != AE_OK)
{
return (Status);
}
else
{
return (AE_ERROR);
}
}
}
return (AtTerminateCtrlCheck(AE_OK, ALL_STAT));
}
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);
/* 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);
free(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 = AcpiSetGpeType(sc->ec_gpehandle, sc->ec_gpebit,
ACPI_GPE_TYPE_RUNTIME);
if (ACPI_FAILURE(Status)) {
device_printf(dev, "AcpiSetGpeType failed: %s\n",
AcpiFormatException(Status));
goto error;
}
Status = AcpiEnableGpe(sc->ec_gpehandle, sc->ec_gpebit, ACPI_NOT_ISR);
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);
}
