acpi_status acpi_ev_update_gpe_enable_masks(struct acpi_gpe_event_info *gpe_event_info) { struct acpi_gpe_register_info *gpe_register_info; u32 register_bit; ACPI_FUNCTION_TRACE(ev_update_gpe_enable_masks); gpe_register_info = gpe_event_info->register_info; if (!gpe_register_info) { return_ACPI_STATUS(AE_NOT_EXIST); } register_bit = acpi_hw_gpe_register_bit(gpe_event_info, gpe_register_info); ACPI_CLEAR_BIT(gpe_register_info->enable_for_wake, register_bit); ACPI_CLEAR_BIT(gpe_register_info->enable_for_run, register_bit); if (gpe_event_info->runtime_count) ACPI_SET_BIT(gpe_register_info->enable_for_run, register_bit); if (gpe_event_info->wakeup_count) ACPI_SET_BIT(gpe_register_info->enable_for_wake, register_bit); return_ACPI_STATUS(AE_OK); }
acpi_status acpi_ev_update_gpe_enable_masks(struct acpi_gpe_event_info *gpe_event_info, u8 type) { struct acpi_gpe_register_info *gpe_register_info; u8 register_bit; ACPI_FUNCTION_TRACE(ev_update_gpe_enable_masks); gpe_register_info = gpe_event_info->register_info; if (!gpe_register_info) { return_ACPI_STATUS(AE_NOT_EXIST); } register_bit = (u8) (1 << (gpe_event_info->gpe_number - gpe_register_info->base_gpe_number)); /* 1) Disable case. Simply clear all enable bits */ if (type == ACPI_GPE_DISABLE) { ACPI_CLEAR_BIT(gpe_register_info->enable_for_wake, register_bit); ACPI_CLEAR_BIT(gpe_register_info->enable_for_run, register_bit); return_ACPI_STATUS(AE_OK); } /* 2) Enable case. Set/Clear the appropriate enable bits */ switch (gpe_event_info->flags & ACPI_GPE_TYPE_MASK) { case ACPI_GPE_TYPE_WAKE: ACPI_SET_BIT(gpe_register_info->enable_for_wake, register_bit); ACPI_CLEAR_BIT(gpe_register_info->enable_for_run, register_bit); break; case ACPI_GPE_TYPE_RUNTIME: ACPI_CLEAR_BIT(gpe_register_info->enable_for_wake, register_bit); ACPI_SET_BIT(gpe_register_info->enable_for_run, register_bit); break; case ACPI_GPE_TYPE_WAKE_RUN: ACPI_SET_BIT(gpe_register_info->enable_for_wake, register_bit); ACPI_SET_BIT(gpe_register_info->enable_for_run, register_bit); break; default: return_ACPI_STATUS(AE_BAD_PARAMETER); } return_ACPI_STATUS(AE_OK); }
acpi_status acpi_ev_disable_gpe(struct acpi_gpe_event_info *gpe_event_info) { acpi_status status; ACPI_FUNCTION_TRACE(ev_disable_gpe); /* Make sure HW enable masks are updated */ status = acpi_ev_update_gpe_enable_masks(gpe_event_info, ACPI_GPE_DISABLE); if (ACPI_FAILURE(status)) { return_ACPI_STATUS(status); } /* Clear the appropriate enabled flags for this GPE */ switch (gpe_event_info->flags & ACPI_GPE_TYPE_MASK) { case ACPI_GPE_TYPE_WAKE: ACPI_CLEAR_BIT(gpe_event_info->flags, ACPI_GPE_WAKE_ENABLED); break; case ACPI_GPE_TYPE_WAKE_RUN: ACPI_CLEAR_BIT(gpe_event_info->flags, ACPI_GPE_WAKE_ENABLED); /* fallthrough */ case ACPI_GPE_TYPE_RUNTIME: /* Disable the requested runtime GPE */ ACPI_CLEAR_BIT(gpe_event_info->flags, ACPI_GPE_RUN_ENABLED); break; default: break; } /* * Even if we don't know the GPE type, make sure that we always * disable it. low_disable_gpe will just clear the enable bit for this * GPE and write it. It will not write out the current GPE enable mask, * since this may inadvertently enable GPEs too early, if a rogue GPE has * come in during ACPICA initialization - possibly as a result of AML or * other code that has enabled the GPE. */ status = acpi_hw_low_disable_gpe(gpe_event_info); return_ACPI_STATUS(status); }
acpi_status acpi_ev_update_gpe_enable_mask(struct acpi_gpe_event_info *gpe_event_info) { struct acpi_gpe_register_info *gpe_register_info; u32 register_bit; ACPI_FUNCTION_TRACE(ev_update_gpe_enable_mask); gpe_register_info = gpe_event_info->register_info; if (!gpe_register_info) { return_ACPI_STATUS(AE_NOT_EXIST); } register_bit = acpi_hw_get_gpe_register_bit(gpe_event_info); /* Clear the run bit up front */ ACPI_CLEAR_BIT(gpe_register_info->enable_for_run, register_bit); /* Set the mask bit only if there are references to this GPE */ if (gpe_event_info->runtime_count) { ACPI_SET_BIT(gpe_register_info->enable_for_run, (u8)register_bit); } gpe_register_info->enable_mask = gpe_register_info->enable_for_run; return_ACPI_STATUS(AE_OK); }
ACPI_STATUS AcpiEvUpdateGpeEnableMask ( ACPI_GPE_EVENT_INFO *GpeEventInfo) { ACPI_GPE_REGISTER_INFO *GpeRegisterInfo; UINT32 RegisterBit; ACPI_FUNCTION_TRACE (EvUpdateGpeEnableMask); GpeRegisterInfo = GpeEventInfo->RegisterInfo; if (!GpeRegisterInfo) { return_ACPI_STATUS (AE_NOT_EXIST); } RegisterBit = AcpiHwGetGpeRegisterBit (GpeEventInfo); /* Clear the run bit up front */ ACPI_CLEAR_BIT (GpeRegisterInfo->EnableForRun, RegisterBit); /* Set the mask bit only if there are references to this GPE */ if (GpeEventInfo->RuntimeCount) { ACPI_SET_BIT (GpeRegisterInfo->EnableForRun, (UINT8) RegisterBit); } GpeRegisterInfo->EnableMask = GpeRegisterInfo->EnableForRun; return_ACPI_STATUS (AE_OK); }
acpi_status acpi_hw_low_disable_gpe(struct acpi_gpe_event_info *gpe_event_info) { struct acpi_gpe_register_info *gpe_register_info; acpi_status status; u32 enable_mask; /* Get the info block for the entire GPE register */ gpe_register_info = gpe_event_info->register_info; if (!gpe_register_info) { return (AE_NOT_EXIST); } /* Get current value of the enable register that contains this GPE */ status = acpi_hw_read(&enable_mask, &gpe_register_info->enable_address); if (ACPI_FAILURE(status)) { return (status); } /* Clear just the bit that corresponds to this GPE */ ACPI_CLEAR_BIT(enable_mask, ((u32)1 << (gpe_event_info->gpe_number - gpe_register_info->base_gpe_number))); /* Write the updated enable mask */ status = acpi_hw_write(enable_mask, &gpe_register_info->enable_address); return (status); }
acpi_status acpi_ev_disable_gpe ( struct acpi_gpe_event_info *gpe_event_info) { acpi_status status; ACPI_FUNCTION_TRACE ("ev_disable_gpe"); if (!(gpe_event_info->flags & ACPI_GPE_ENABLE_MASK)) { return_ACPI_STATUS (AE_OK); } /* Make sure HW enable masks are updated */ status = acpi_ev_update_gpe_enable_masks (gpe_event_info, ACPI_GPE_DISABLE); if (ACPI_FAILURE (status)) { return_ACPI_STATUS (status); } /* Mark wake-disabled or HW disable, or both */ switch (gpe_event_info->flags & ACPI_GPE_TYPE_MASK) { case ACPI_GPE_TYPE_WAKE: ACPI_CLEAR_BIT (gpe_event_info->flags, ACPI_GPE_WAKE_ENABLED); break; case ACPI_GPE_TYPE_WAKE_RUN: ACPI_CLEAR_BIT (gpe_event_info->flags, ACPI_GPE_WAKE_ENABLED); /*lint -fallthrough */ case ACPI_GPE_TYPE_RUNTIME: /* Disable the requested runtime GPE */ ACPI_CLEAR_BIT (gpe_event_info->flags, ACPI_GPE_RUN_ENABLED); status = acpi_hw_write_gpe_enable_reg (gpe_event_info); break; default: return_ACPI_STATUS (AE_BAD_PARAMETER); } return_ACPI_STATUS (AE_OK); }
acpi_status acpi_hw_low_set_gpe(struct acpi_gpe_event_info *gpe_event_info, u32 action) { struct acpi_gpe_register_info *gpe_register_info; acpi_status status; u32 enable_mask; u32 register_bit; ACPI_FUNCTION_ENTRY(); /* Get the info block for the entire GPE register */ gpe_register_info = gpe_event_info->register_info; if (!gpe_register_info) { return (AE_NOT_EXIST); } /* Get current value of the enable register that contains this GPE */ status = acpi_hw_read(&enable_mask, &gpe_register_info->enable_address); if (ACPI_FAILURE(status)) { return (status); } /* Set or clear just the bit that corresponds to this GPE */ register_bit = acpi_hw_get_gpe_register_bit(gpe_event_info); switch (action) { case ACPI_GPE_CONDITIONAL_ENABLE: /* Only enable if the enable_for_run bit is set */ if (!(register_bit & gpe_register_info->enable_for_run)) { return (AE_BAD_PARAMETER); } /*lint -fallthrough */ case ACPI_GPE_ENABLE: ACPI_SET_BIT(enable_mask, register_bit); break; case ACPI_GPE_DISABLE: ACPI_CLEAR_BIT(enable_mask, register_bit); break; default: ACPI_ERROR((AE_INFO, "Invalid GPE Action, %u", action)); return (AE_BAD_PARAMETER); } /* Write the updated enable mask */ status = acpi_hw_write(enable_mask, &gpe_register_info->enable_address); return (status); }
acpi_status acpi_set_gpe_wake_mask(acpi_handle gpe_device, u32 gpe_number, u8 action) { acpi_status status = AE_OK; struct acpi_gpe_event_info *gpe_event_info; struct acpi_gpe_register_info *gpe_register_info; acpi_cpu_flags flags; u32 register_bit; ACPI_FUNCTION_TRACE(acpi_set_gpe_wake_mask); flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock); /* * Ensure that we have a valid GPE number and that this GPE is in * fact a wake GPE */ gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number); if (!gpe_event_info) { status = AE_BAD_PARAMETER; goto unlock_and_exit; } if (!(gpe_event_info->flags & ACPI_GPE_CAN_WAKE)) { status = AE_TYPE; goto unlock_and_exit; } gpe_register_info = gpe_event_info->register_info; if (!gpe_register_info) { status = AE_NOT_EXIST; goto unlock_and_exit; } register_bit = acpi_hw_get_gpe_register_bit(gpe_event_info, gpe_register_info); /* Perform the action */ switch (action) { case ACPI_GPE_ENABLE: ACPI_SET_BIT(gpe_register_info->enable_for_wake, (u8)register_bit); break; case ACPI_GPE_DISABLE: ACPI_CLEAR_BIT(gpe_register_info->enable_for_wake, (u8)register_bit); break; default: ACPI_ERROR((AE_INFO, "%u, Invalid action", action)); status = AE_BAD_PARAMETER; break; } unlock_and_exit: acpi_os_release_lock(acpi_gbl_gpe_lock, flags); return_ACPI_STATUS(status); }
ACPI_STATUS AcpiGpeWakeup ( ACPI_HANDLE GpeDevice, UINT32 GpeNumber, UINT8 Action) { ACPI_STATUS Status = AE_OK; ACPI_GPE_EVENT_INFO *GpeEventInfo; ACPI_GPE_REGISTER_INFO *GpeRegisterInfo; ACPI_CPU_FLAGS Flags; UINT32 RegisterBit; ACPI_FUNCTION_TRACE (AcpiGpeWakeup); Flags = AcpiOsAcquireLock (AcpiGbl_GpeLock); /* Ensure that we have a valid GPE number */ GpeEventInfo = AcpiEvGetGpeEventInfo (GpeDevice, GpeNumber); if (!GpeEventInfo) { Status = AE_BAD_PARAMETER; goto UnlockAndExit; } GpeRegisterInfo = GpeEventInfo->RegisterInfo; if (!GpeRegisterInfo) { Status = AE_NOT_EXIST; goto UnlockAndExit; } RegisterBit = AcpiHwGetGpeRegisterBit (GpeEventInfo, GpeRegisterInfo); /* Perform the action */ switch (Action) { case ACPI_GPE_ENABLE: ACPI_SET_BIT (GpeRegisterInfo->EnableForWake, (UINT8) RegisterBit); break; case ACPI_GPE_DISABLE: ACPI_CLEAR_BIT (GpeRegisterInfo->EnableForWake, (UINT8) RegisterBit); break; default: ACPI_ERROR ((AE_INFO, "%u, Invalid action", Action)); Status = AE_BAD_PARAMETER; break; } UnlockAndExit: AcpiOsReleaseLock (AcpiGbl_GpeLock, Flags); return_ACPI_STATUS (Status); }
acpi_status acpi_ev_disable_gpe(struct acpi_gpe_event_info *gpe_event_info) { acpi_status status; ACPI_FUNCTION_TRACE(ev_disable_gpe); status = acpi_ev_update_gpe_enable_masks(gpe_event_info, ACPI_GPE_DISABLE); if (ACPI_FAILURE(status)) { return_ACPI_STATUS(status); } switch (gpe_event_info->flags & ACPI_GPE_TYPE_MASK) { case ACPI_GPE_TYPE_WAKE: ACPI_CLEAR_BIT(gpe_event_info->flags, ACPI_GPE_WAKE_ENABLED); break; case ACPI_GPE_TYPE_WAKE_RUN: ACPI_CLEAR_BIT(gpe_event_info->flags, ACPI_GPE_WAKE_ENABLED); case ACPI_GPE_TYPE_RUNTIME: ACPI_CLEAR_BIT(gpe_event_info->flags, ACPI_GPE_RUN_ENABLED); break; default: break; } status = acpi_hw_low_disable_gpe(gpe_event_info); return_ACPI_STATUS(status); }
ACPI_STATUS AcpiEvMaskGpe ( ACPI_GPE_EVENT_INFO *GpeEventInfo, BOOLEAN IsMasked) { ACPI_GPE_REGISTER_INFO *GpeRegisterInfo; UINT32 RegisterBit; ACPI_FUNCTION_TRACE (EvMaskGpe); GpeRegisterInfo = GpeEventInfo->RegisterInfo; if (!GpeRegisterInfo) { return_ACPI_STATUS (AE_NOT_EXIST); } RegisterBit = AcpiHwGetGpeRegisterBit (GpeEventInfo); /* Perform the action */ if (IsMasked) { if (RegisterBit & GpeRegisterInfo->MaskForRun) { return_ACPI_STATUS (AE_BAD_PARAMETER); } (void) AcpiHwLowSetGpe (GpeEventInfo, ACPI_GPE_DISABLE); ACPI_SET_BIT (GpeRegisterInfo->MaskForRun, (UINT8) RegisterBit); } else { if (!(RegisterBit & GpeRegisterInfo->MaskForRun)) { return_ACPI_STATUS (AE_BAD_PARAMETER); } ACPI_CLEAR_BIT (GpeRegisterInfo->MaskForRun, (UINT8) RegisterBit); if (GpeEventInfo->RuntimeCount && !GpeEventInfo->DisableForDispatch) { (void) AcpiHwLowSetGpe (GpeEventInfo, ACPI_GPE_ENABLE); } } return_ACPI_STATUS (AE_OK); }
ACPI_STATUS AcpiHwLowDisableGpe ( ACPI_GPE_EVENT_INFO *GpeEventInfo) { ACPI_GPE_REGISTER_INFO *GpeRegisterInfo; ACPI_STATUS Status; UINT32 EnableMask; /* Get the info block for the entire GPE register */ GpeRegisterInfo = GpeEventInfo->RegisterInfo; if (!GpeRegisterInfo) { return (AE_NOT_EXIST); } /* Get current value of the enable register that contains this GPE */ Status = AcpiRead (&EnableMask, &GpeRegisterInfo->EnableAddress); if (ACPI_FAILURE (Status)) { return (Status); } /* Clear just the bit that corresponds to this GPE */ ACPI_CLEAR_BIT (EnableMask, ((UINT32) 1 << (GpeEventInfo->GpeNumber - GpeRegisterInfo->BaseGpeNumber))); /* Write the updated enable mask */ Status = AcpiWrite (EnableMask, &GpeRegisterInfo->EnableAddress); return (Status); }
ACPI_STATUS AcpiHwLowSetGpe ( ACPI_GPE_EVENT_INFO *GpeEventInfo, UINT32 Action) { ACPI_GPE_REGISTER_INFO *GpeRegisterInfo; ACPI_STATUS Status; UINT32 EnableMask; UINT32 RegisterBit; ACPI_FUNCTION_ENTRY (); /* Get the info block for the entire GPE register */ GpeRegisterInfo = GpeEventInfo->RegisterInfo; if (!GpeRegisterInfo) { return (AE_NOT_EXIST); } /* Get current value of the enable register that contains this GPE */ Status = AcpiHwRead (&EnableMask, &GpeRegisterInfo->EnableAddress); if (ACPI_FAILURE (Status)) { return (Status); } /* Set or clear just the bit that corresponds to this GPE */ RegisterBit = AcpiHwGetGpeRegisterBit (GpeEventInfo, GpeRegisterInfo); switch (Action) { case ACPI_GPE_CONDITIONAL_ENABLE: /* Only enable if the EnableForRun bit is set */ if (!(RegisterBit & GpeRegisterInfo->EnableForRun)) { return (AE_BAD_PARAMETER); } /*lint -fallthrough */ case ACPI_GPE_ENABLE: ACPI_SET_BIT (EnableMask, RegisterBit); break; case ACPI_GPE_DISABLE: ACPI_CLEAR_BIT (EnableMask, RegisterBit); break; default: ACPI_ERROR ((AE_INFO, "Invalid GPE Action, %u\n", Action)); return (AE_BAD_PARAMETER); } /* Write the updated enable mask */ Status = AcpiHwWrite (EnableMask, &GpeRegisterInfo->EnableAddress); return (Status); }