static int acpi_lid_attach(device_t dev) { struct acpi_prw_data prw; struct acpi_lid_softc *sc; ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__); sc = device_get_softc(dev); sc->lid_dev = dev; sc->lid_handle = acpi_get_handle(dev); /* * If a system does not get lid events, it may make sense to change * the type to ACPI_ALL_NOTIFY. Some systems generate both a wake and * runtime notify in that case though. */ AcpiInstallNotifyHandler(sc->lid_handle, ACPI_DEVICE_NOTIFY, acpi_lid_notify_handler, sc); /* Enable the GPE for wake/runtime. */ acpi_wake_set_enable(dev, 1); if (acpi_parse_prw(sc->lid_handle, &prw) == 0) AcpiEnableGpe(prw.gpe_handle, prw.gpe_bit); return (0); }
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); } }
static int acpi_button_attach(device_t dev) { struct acpi_prw_data prw; struct acpi_button_softc *sc; ACPI_STATUS status; int event; ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__); sc = device_get_softc(dev); sc->button_dev = dev; sc->button_handle = acpi_get_handle(dev); event = (sc->button_type == ACPI_SLEEP_BUTTON) ? ACPI_EVENT_SLEEP_BUTTON : ACPI_EVENT_POWER_BUTTON; /* * Install the new handler. We could remove any fixed handlers added * from the FADT once we have a duplicate from the AML but some systems * only return events on one or the other so we have to keep both. */ if (sc->fixed) { AcpiClearEvent(event); status = AcpiInstallFixedEventHandler(event, acpi_button_fixed_handler, sc); } else { /* * If a system does not get lid events, it may make sense to change * the type to ACPI_ALL_NOTIFY. Some systems generate both a wake * and runtime notify in that case though. */ status = AcpiInstallNotifyHandler(sc->button_handle, ACPI_DEVICE_NOTIFY, acpi_button_notify_handler, sc); } if (ACPI_FAILURE(status)) { device_printf(sc->button_dev, "couldn't install notify handler - %s\n", AcpiFormatException(status)); return_VALUE (ENXIO); } /* Enable the GPE for wake/runtime */ acpi_wake_set_enable(dev, 1); if (acpi_parse_prw(sc->button_handle, &prw) == 0) AcpiEnableGpe(prw.gpe_handle, prw.gpe_bit); return_VALUE (0); }
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 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)); }
ACPI_STATUS AcpiEvMatchGpeMethod ( ACPI_HANDLE ObjHandle, UINT32 Level, void *Context, void **ReturnValue) { ACPI_NAMESPACE_NODE *MethodNode = ACPI_CAST_PTR (ACPI_NAMESPACE_NODE, ObjHandle); ACPI_GPE_WALK_INFO *WalkInfo = ACPI_CAST_PTR (ACPI_GPE_WALK_INFO, Context); ACPI_GPE_EVENT_INFO *GpeEventInfo; ACPI_NAMESPACE_NODE *GpeDevice; ACPI_STATUS Status; UINT32 GpeNumber; char Name[ACPI_NAME_SIZE + 1]; UINT8 Type; ACPI_FUNCTION_TRACE (EvMatchGpeMethod); /* Check if requested OwnerId matches this OwnerId */ if ((WalkInfo->ExecuteByOwnerId) && (MethodNode->OwnerId != WalkInfo->OwnerId)) { return_ACPI_STATUS (AE_OK); } /* * Match and decode the _Lxx and _Exx GPE method names * * 1) Extract the method name and null terminate it */ ACPI_MOVE_32_TO_32 (Name, &MethodNode->Name.Integer); Name[ACPI_NAME_SIZE] = 0; /* 2) Name must begin with an underscore */ if (Name[0] != '_') { return_ACPI_STATUS (AE_OK); /* Ignore this method */ } /* * 3) Edge/Level determination is based on the 2nd character * of the method name * * NOTE: Default GPE type is RUNTIME only. Later, if a _PRW object is * found that points to this GPE, the ACPI_GPE_CAN_WAKE flag is set. */ switch (Name[1]) { case 'L': Type = ACPI_GPE_LEVEL_TRIGGERED; break; case 'E': Type = ACPI_GPE_EDGE_TRIGGERED; break; default: /* Unknown method type, just ignore it */ ACPI_DEBUG_PRINT ((ACPI_DB_LOAD, "Ignoring unknown GPE method type: %s " "(name not of form _Lxx or _Exx)", Name)); return_ACPI_STATUS (AE_OK); } /* 4) The last two characters of the name are the hex GPE Number */ GpeNumber = ACPI_STRTOUL (&Name[2], NULL, 16); if (GpeNumber == ACPI_UINT32_MAX) { /* Conversion failed; invalid method, just ignore it */ ACPI_DEBUG_PRINT ((ACPI_DB_LOAD, "Could not extract GPE number from name: %s " "(name is not of form _Lxx or _Exx)", Name)); return_ACPI_STATUS (AE_OK); } /* Ensure that we have a valid GPE number for this GPE block */ GpeEventInfo = AcpiEvLowGetGpeInfo (GpeNumber, WalkInfo->GpeBlock); if (!GpeEventInfo) { /* * This GpeNumber is not valid for this GPE block, just ignore it. * However, it may be valid for a different GPE block, since GPE0 * and GPE1 methods both appear under \_GPE. */ return_ACPI_STATUS (AE_OK); } if ((GpeEventInfo->Flags & ACPI_GPE_DISPATCH_MASK) == ACPI_GPE_DISPATCH_HANDLER) { /* If there is already a handler, ignore this GPE method */ return_ACPI_STATUS (AE_OK); } if ((GpeEventInfo->Flags & ACPI_GPE_DISPATCH_MASK) == ACPI_GPE_DISPATCH_METHOD) { /* * If there is already a method, ignore this method. But check * for a type mismatch (if both the _Lxx AND _Exx exist) */ if (Type != (GpeEventInfo->Flags & ACPI_GPE_XRUPT_TYPE_MASK)) { ACPI_ERROR ((AE_INFO, "For GPE 0x%.2X, found both _L%2.2X and _E%2.2X methods", GpeNumber, GpeNumber, GpeNumber)); } return_ACPI_STATUS (AE_OK); } /* * Add the GPE information from above to the GpeEventInfo block for * use during dispatch of this GPE. */ GpeEventInfo->Flags |= (UINT8) (Type | ACPI_GPE_DISPATCH_METHOD); GpeEventInfo->Dispatch.MethodNode = MethodNode; /* * Enable this GPE if requested. This only happens when during the * execution of a Load or LoadTable operator. We have found a new * GPE method and want to immediately enable the GPE if it is a * runtime GPE. */ if (WalkInfo->EnableThisGpe) { /* Ignore GPEs that can wake the system */ if (!(GpeEventInfo->Flags & ACPI_GPE_CAN_WAKE) || !AcpiGbl_LeaveWakeGpesDisabled) { WalkInfo->Count++; GpeDevice = WalkInfo->GpeDevice; if (GpeDevice == AcpiGbl_FadtGpeDevice) { GpeDevice = NULL; } Status = AcpiEnableGpe (GpeDevice, GpeNumber); if (ACPI_FAILURE (Status)) { ACPI_EXCEPTION ((AE_INFO, Status, "Could not enable GPE 0x%02X", GpeNumber)); } } } ACPI_DEBUG_PRINT ((ACPI_DB_LOAD, "Registered GPE method %s as GPE number 0x%.2X\n", Name, GpeNumber)); return_ACPI_STATUS (AE_OK); }
status_t enable_gpe(acpi_handle handle, uint32 gpeNumber) { return AcpiEnableGpe(handle, gpeNumber) == AE_OK ? B_OK : B_ERROR; }
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); }