hwgpe.c File Reference

#include "acpi.h"
#include "accommon.h"
#include "acevents.h"

Include dependency graph for hwgpe.c:

Go to the source code of this file.

Macros
#define	_COMPONENT   ACPI_HARDWARE

Functions
static ACPI_STATUS	AcpiHwEnableWakeupGpeBlock (ACPI_GPE_XRUPT_INFO *GpeXruptInfo, ACPI_GPE_BLOCK_INFO *GpeBlock, void *Context)
static ACPI_STATUS	AcpiHwGpeEnableWrite (UINT8 EnableMask, ACPI_GPE_REGISTER_INFO *GpeRegisterInfo)
UINT32	AcpiHwGetGpeRegisterBit (ACPI_GPE_EVENT_INFO *GpeEventInfo)
ACPI_STATUS	AcpiHwLowSetGpe (ACPI_GPE_EVENT_INFO *GpeEventInfo, UINT32 Action)
ACPI_STATUS	AcpiHwClearGpe (ACPI_GPE_EVENT_INFO *GpeEventInfo)
ACPI_STATUS	AcpiHwGetGpeStatus (ACPI_GPE_EVENT_INFO *GpeEventInfo, ACPI_EVENT_STATUS *EventStatus)
ACPI_STATUS	AcpiHwDisableGpeBlock (ACPI_GPE_XRUPT_INFO *GpeXruptInfo, ACPI_GPE_BLOCK_INFO *GpeBlock, void *Context)
ACPI_STATUS	AcpiHwClearGpeBlock (ACPI_GPE_XRUPT_INFO *GpeXruptInfo, ACPI_GPE_BLOCK_INFO *GpeBlock, void *Context)
ACPI_STATUS	AcpiHwEnableRuntimeGpeBlock (ACPI_GPE_XRUPT_INFO *GpeXruptInfo, ACPI_GPE_BLOCK_INFO *GpeBlock, void *Context)
static ACPI_STATUS	AcpiHwGetGpeBlockStatus (ACPI_GPE_XRUPT_INFO *GpeXruptInfo, ACPI_GPE_BLOCK_INFO *GpeBlock, void *RetPtr)
ACPI_STATUS	AcpiHwDisableAllGpes (void)
ACPI_STATUS	AcpiHwEnableAllRuntimeGpes (void)
ACPI_STATUS	AcpiHwEnableAllWakeupGpes (void)
UINT8	AcpiHwCheckAllGpes (void)

Macro Definition Documentation

_COMPONENT

#define _COMPONENT   ACPI_HARDWARE

Definition at line 48 of file hwgpe.c.

Function Documentation

AcpiHwCheckAllGpes()

UINT8 AcpiHwCheckAllGpes

(

void

)

Definition at line 677 of file hwgpe.c.

{
    UINT8                      Ret = 0;
 
 
    ACPI_FUNCTION_TRACE (AcpiHwCheckAllGpes);
 
    (void) AcpiEvWalkGpeList (AcpiHwGetGpeBlockStatus, &Ret);
    return (Ret != 0);
}

Referenced by AcpiAnyGpeStatusSet(), and AcpiHwCheckAllGpes().

AcpiHwClearGpe()

ACPI_STATUS AcpiHwClearGpe

(

ACPI_GPE_EVENT_INFO *

GpeEventInfo

)

Definition at line 190 of file hwgpe.c.

{
    ACPI_GPE_REGISTER_INFO  *GpeRegisterInfo;
    ACPI_STATUS             Status;
    UINT32                  RegisterBit;
 
 
    ACPI_FUNCTION_ENTRY ();
 
    /* Get the info block for the entire GPE register */
 
    GpeRegisterInfo = GpeEventInfo->RegisterInfo;
    if (!GpeRegisterInfo)
    {
        return (AE_NOT_EXIST);
    }
 
    /*
     * Write a one to the appropriate bit in the status register to
     * clear this GPE.
     */
    RegisterBit = AcpiHwGetGpeRegisterBit (GpeEventInfo);
 
    Status = AcpiHwWrite (RegisterBit, &GpeRegisterInfo->StatusAddress);
    return (Status);
}

Referenced by AcpiClearGpe(), AcpiEvAddGpeReference(), AcpiEvFinishGpe(), and AcpiEvGpeDispatch().

AcpiHwClearGpeBlock()

ACPI_STATUS AcpiHwClearGpeBlock	(	ACPI_GPE_XRUPT_INFO *	GpeXruptInfo,
		ACPI_GPE_BLOCK_INFO *	GpeBlock,
		void *	Context
	)

Definition at line 404 of file hwgpe.c.

{
    UINT32                  i;
    ACPI_STATUS             Status;
 
 
    /* Examine each GPE Register within the block */
 
    for (i = 0; i < GpeBlock->RegisterCount; i++)
    {
        /* Clear status on all GPEs in this register */
 
        Status = AcpiHwWrite (0xFF, &GpeBlock->RegisterInfo[i].StatusAddress);
        if (ACPI_FAILURE (Status))
        {
            return (Status);
        }
    }
 
    return (AE_OK);
}

Referenced by AcpiHwClearAcpiStatus().

AcpiHwDisableAllGpes()

ACPI_STATUS AcpiHwDisableAllGpes

(

void

)

Definition at line 595 of file hwgpe.c.

{
    ACPI_STATUS             Status;
 
 
    ACPI_FUNCTION_TRACE (HwDisableAllGpes);
 
 
    Status = AcpiEvWalkGpeList (AcpiHwDisableGpeBlock, NULL);
    return_ACPI_STATUS (Status);
}

Referenced by AcpiDisableAllGpes(), AcpiEnterSleepStateS4bios(), AcpiHwLegacySleep(), and AcpiHwLegacyWake().

AcpiHwDisableGpeBlock()

ACPI_STATUS AcpiHwDisableGpeBlock	(	ACPI_GPE_XRUPT_INFO *	GpeXruptInfo,
		ACPI_GPE_BLOCK_INFO *	GpeBlock,
		void *	Context
	)

Definition at line 364 of file hwgpe.c.

{
    UINT32                  i;
    ACPI_STATUS             Status;
 
 
    /* Examine each GPE Register within the block */
 
    for (i = 0; i < GpeBlock->RegisterCount; i++)
    {
        /* Disable all GPEs in this register */
 
        Status = AcpiHwGpeEnableWrite (0x00, &GpeBlock->RegisterInfo[i]);
        if (ACPI_FAILURE (Status))
        {
            return (Status);
        }
    }
 
    return (AE_OK);
}

Referenced by AcpiEvDeleteGpeBlock(), AcpiEvTerminate(), and AcpiHwDisableAllGpes().

AcpiHwEnableAllRuntimeGpes()

ACPI_STATUS AcpiHwEnableAllRuntimeGpes

(

void

)

Definition at line 622 of file hwgpe.c.

{
    ACPI_STATUS             Status;
 
 
    ACPI_FUNCTION_TRACE (HwEnableAllRuntimeGpes);
 
 
    Status = AcpiEvWalkGpeList (AcpiHwEnableRuntimeGpeBlock, NULL);
    return_ACPI_STATUS (Status);
}

Referenced by AcpiEnableAllRuntimeGpes(), and AcpiHwLegacyWake().

AcpiHwEnableAllWakeupGpes()

ACPI_STATUS AcpiHwEnableAllWakeupGpes

(

void

)

Definition at line 649 of file hwgpe.c.

{
    ACPI_STATUS             Status;
 
 
    ACPI_FUNCTION_TRACE (HwEnableAllWakeupGpes);
 
 
    Status = AcpiEvWalkGpeList (AcpiHwEnableWakeupGpeBlock, NULL);
    return_ACPI_STATUS (Status);
}

Referenced by AcpiEnableAllWakeupGpes(), AcpiEnterSleepStateS4bios(), and AcpiHwLegacySleep().

AcpiHwEnableRuntimeGpeBlock()

ACPI_STATUS AcpiHwEnableRuntimeGpeBlock	(	ACPI_GPE_XRUPT_INFO *	GpeXruptInfo,
		ACPI_GPE_BLOCK_INFO *	GpeBlock,
		void *	Context
	)

Definition at line 445 of file hwgpe.c.

{
    UINT32                  i;
    ACPI_STATUS             Status;
    ACPI_GPE_REGISTER_INFO  *GpeRegisterInfo;
    UINT8                   EnableMask;
 
 
    /* NOTE: assumes that all GPEs are currently disabled */
 
    /* Examine each GPE Register within the block */
 
    for (i = 0; i < GpeBlock->RegisterCount; i++)
    {
        GpeRegisterInfo = &GpeBlock->RegisterInfo[i];
        if (!GpeRegisterInfo->EnableForRun)
        {
            continue;
        }
 
        /* Enable all "runtime" GPEs in this register */
 
        EnableMask = GpeRegisterInfo->EnableForRun &
            ~GpeRegisterInfo->MaskForRun;
        Status = AcpiHwGpeEnableWrite (EnableMask, GpeRegisterInfo);
        if (ACPI_FAILURE (Status))
        {
            return (Status);
        }
    }
 
    return (AE_OK);
}

Referenced by AcpiHwEnableAllRuntimeGpes().

AcpiHwEnableWakeupGpeBlock()

static ACPI_STATUS AcpiHwEnableWakeupGpeBlock ( ACPI_GPE_XRUPT_INFO *  GpeXruptInfo, ACPI_GPE_BLOCK_INFO *  GpeBlock, void *  Context  )

static

Definition at line 498 of file hwgpe.c.

{
    UINT32                  i;
    ACPI_STATUS             Status;
    ACPI_GPE_REGISTER_INFO  *GpeRegisterInfo;
 
 
    /* Examine each GPE Register within the block */
 
    for (i = 0; i < GpeBlock->RegisterCount; i++)
    {
        GpeRegisterInfo = &GpeBlock->RegisterInfo[i];
 
        /*
         * Enable all "wake" GPEs in this register and disable the
         * remaining ones.
         */
        Status = AcpiHwGpeEnableWrite (GpeRegisterInfo->EnableForWake,
            GpeRegisterInfo);
        if (ACPI_FAILURE (Status))
        {
            return (Status);
        }
    }
 
    return (AE_OK);
}

Referenced by AcpiHwEnableAllWakeupGpes().

AcpiHwGetGpeBlockStatus()

static ACPI_STATUS AcpiHwGetGpeBlockStatus ( ACPI_GPE_XRUPT_INFO *  GpeXruptInfo, ACPI_GPE_BLOCK_INFO *  GpeBlock, void *  RetPtr  )

static

Definition at line 544 of file hwgpe.c.

{
    ACPI_GPE_REGISTER_INFO  *GpeRegisterInfo;
    UINT64                  InEnable;
    UINT64                  InStatus;
    ACPI_STATUS             Status;
    UINT8                   *Ret = RetPtr;
    UINT32                  i;
 
 
    /* Examine each GPE Register within the block */
 
    for (i = 0; i < GpeBlock->RegisterCount; i++)
    {
        GpeRegisterInfo = &GpeBlock->RegisterInfo[i];
 
        Status = AcpiHwRead (&InEnable, &GpeRegisterInfo->EnableAddress);
        if (ACPI_FAILURE (Status))
        {
            continue;
        }
 
        Status = AcpiHwRead (&InStatus, &GpeRegisterInfo->StatusAddress);
        if (ACPI_FAILURE (Status))
        {
            continue;
        }
 
        *Ret |= InEnable & InStatus;
    }
 
    return (AE_OK);
}

Referenced by AcpiHwCheckAllGpes().

AcpiHwGetGpeRegisterBit()

UINT32 AcpiHwGetGpeRegisterBit

(

ACPI_GPE_EVENT_INFO *

GpeEventInfo

)

Definition at line 81 of file hwgpe.c.

{
 
    return ((UINT32) 1 <<
        (GpeEventInfo->GpeNumber - GpeEventInfo->RegisterInfo->BaseGpeNumber));
}

Referenced by AcpiEvDetectGpe(), AcpiEvMaskGpe(), AcpiEvUpdateGpeEnableMask(), AcpiHwClearGpe(), AcpiHwGetGpeStatus(), AcpiHwLowSetGpe(), and AcpiSetGpeWakeMask().

AcpiHwGetGpeStatus()

ACPI_STATUS AcpiHwGetGpeStatus	(	ACPI_GPE_EVENT_INFO *	GpeEventInfo,
		ACPI_EVENT_STATUS *	EventStatus
	)

Definition at line 233 of file hwgpe.c.

{
    UINT64                  InByte;
    UINT32                  RegisterBit;
    ACPI_GPE_REGISTER_INFO  *GpeRegisterInfo;
    ACPI_EVENT_STATUS       LocalEventStatus = 0;
    ACPI_STATUS             Status;
 
 
    ACPI_FUNCTION_ENTRY ();
 
 
    if (!EventStatus)
    {
        return (AE_BAD_PARAMETER);
    }
 
    /* GPE currently handled? */
 
    if (ACPI_GPE_DISPATCH_TYPE (GpeEventInfo->Flags) !=
        ACPI_GPE_DISPATCH_NONE)
    {
        LocalEventStatus |= ACPI_EVENT_FLAG_HAS_HANDLER;
    }
 
    /* Get the info block for the entire GPE register */
 
    GpeRegisterInfo = GpeEventInfo->RegisterInfo;
 
    /* Get the register bitmask for this GPE */
 
    RegisterBit = AcpiHwGetGpeRegisterBit (GpeEventInfo);
 
    /* GPE currently enabled? (enabled for runtime?) */
 
    if (RegisterBit & GpeRegisterInfo->EnableForRun)
    {
        LocalEventStatus |= ACPI_EVENT_FLAG_ENABLED;
    }
 
    /* GPE currently masked? (masked for runtime?) */
 
    if (RegisterBit & GpeRegisterInfo->MaskForRun)
    {
        LocalEventStatus |= ACPI_EVENT_FLAG_MASKED;
    }
 
    /* GPE enabled for wake? */
 
    if (RegisterBit & GpeRegisterInfo->EnableForWake)
    {
        LocalEventStatus |= ACPI_EVENT_FLAG_WAKE_ENABLED;
    }
 
    /* GPE currently enabled (enable bit == 1)? */
 
    Status = AcpiHwRead (&InByte, &GpeRegisterInfo->EnableAddress);
    if (ACPI_FAILURE (Status))
    {
        return (Status);
    }
 
    if (RegisterBit & InByte)
    {
        LocalEventStatus |= ACPI_EVENT_FLAG_ENABLE_SET;
    }
 
    /* GPE currently active (status bit == 1)? */
 
    Status = AcpiHwRead (&InByte, &GpeRegisterInfo->StatusAddress);
    if (ACPI_FAILURE (Status))
    {
        return (Status);
    }
 
    if (RegisterBit & InByte)
    {
        LocalEventStatus |= ACPI_EVENT_FLAG_STATUS_SET;
    }
 
    /* Set return value */
 
    (*EventStatus) = LocalEventStatus;
    return (AE_OK);
}

Referenced by AcpiGetGpeStatus().

AcpiHwGpeEnableWrite()

static ACPI_STATUS AcpiHwGpeEnableWrite ( UINT8  EnableMask, ACPI_GPE_REGISTER_INFO *  GpeRegisterInfo  )

static

Definition at line 336 of file hwgpe.c.

{
    ACPI_STATUS             Status;
 
 
    GpeRegisterInfo->EnableMask = EnableMask;
 
    Status = AcpiHwWrite (EnableMask, &GpeRegisterInfo->EnableAddress);
    return (Status);
}

Referenced by AcpiHwDisableGpeBlock(), AcpiHwEnableRuntimeGpeBlock(), and AcpiHwEnableWakeupGpeBlock().

AcpiHwLowSetGpe()

ACPI_STATUS AcpiHwLowSetGpe	(	ACPI_GPE_EVENT_INFO *	GpeEventInfo,
		UINT32	Action
	)

Definition at line 106 of file hwgpe.c.

{
    ACPI_GPE_REGISTER_INFO  *GpeRegisterInfo;
    ACPI_STATUS             Status = AE_OK;
    UINT64                  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);
    switch (Action)
    {
    case ACPI_GPE_CONDITIONAL_ENABLE:
 
        /* Only enable if the corresponding EnableMask bit is set */
 
        if (!(RegisterBit & GpeRegisterInfo->EnableMask))
        {
            return (AE_BAD_PARAMETER);
        }
 
        ACPI_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", Action));
        return (AE_BAD_PARAMETER);
    }
 
    if (!(RegisterBit & GpeRegisterInfo->MaskForRun))
    {
        /* Write the updated enable mask */
 
        Status = AcpiHwWrite (EnableMask, &GpeRegisterInfo->EnableAddress);
    }
    return (Status);
}

Referenced by AcpiEvEnableGpe(), AcpiEvFinishGpe(), AcpiEvGpeDispatch(), AcpiEvMaskGpe(), AcpiEvMatchGpeMethod(), AcpiEvRemoveGpeReference(), and AcpiSetGpe().