evxfgpe.c File Reference

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

Include dependency graph for evxfgpe.c:

Go to the source code of this file.

Macros
#define	EXPORT_ACPI_INTERFACES
#define	_COMPONENT   ACPI_EVENTS

Functions
ACPI_STATUS	AcpiUpdateAllGpes (void)
ACPI_STATUS	AcpiEnableGpe (ACPI_HANDLE GpeDevice, UINT32 GpeNumber)
ACPI_STATUS	AcpiDisableGpe (ACPI_HANDLE GpeDevice, UINT32 GpeNumber)
ACPI_STATUS	AcpiSetGpe (ACPI_HANDLE GpeDevice, UINT32 GpeNumber, UINT8 Action)
ACPI_STATUS	AcpiMaskGpe (ACPI_HANDLE GpeDevice, UINT32 GpeNumber, BOOLEAN IsMasked)
ACPI_STATUS	AcpiMarkGpeForWake (ACPI_HANDLE GpeDevice, UINT32 GpeNumber)
ACPI_STATUS	AcpiSetupGpeForWake (ACPI_HANDLE WakeDevice, ACPI_HANDLE GpeDevice, UINT32 GpeNumber)
ACPI_STATUS	AcpiSetGpeWakeMask (ACPI_HANDLE GpeDevice, UINT32 GpeNumber, UINT8 Action)
ACPI_STATUS	AcpiClearGpe (ACPI_HANDLE GpeDevice, UINT32 GpeNumber)
ACPI_STATUS	AcpiGetGpeStatus (ACPI_HANDLE GpeDevice, UINT32 GpeNumber, ACPI_EVENT_STATUS *EventStatus)
UINT32	AcpiDispatchGpe (ACPI_HANDLE GpeDevice, UINT32 GpeNumber)
ACPI_STATUS	AcpiFinishGpe (ACPI_HANDLE GpeDevice, UINT32 GpeNumber)
ACPI_STATUS	AcpiDisableAllGpes (void)
ACPI_STATUS	AcpiEnableAllRuntimeGpes (void)
ACPI_STATUS	AcpiEnableAllWakeupGpes (void)
UINT32	AcpiAnyGpeStatusSet (void)
ACPI_STATUS	AcpiInstallGpeBlock (ACPI_HANDLE GpeDevice, ACPI_GENERIC_ADDRESS *GpeBlockAddress, UINT32 RegisterCount, UINT32 InterruptNumber)
ACPI_STATUS	AcpiRemoveGpeBlock (ACPI_HANDLE GpeDevice)
ACPI_STATUS	AcpiGetGpeDevice (UINT32 Index, ACPI_HANDLE *GpeDevice)

Macro Definition Documentation

_COMPONENT

#define _COMPONENT   ACPI_EVENTS

Definition at line 51 of file evxfgpe.c.

EXPORT_ACPI_INTERFACES

#define EXPORT_ACPI_INTERFACES

Definition at line 44 of file evxfgpe.c.

Function Documentation

AcpiAnyGpeStatusSet()

UINT32 AcpiAnyGpeStatusSet

(

void

)

Definition at line 974 of file evxfgpe.c.

{
    ACPI_STATUS                Status;
    UINT8                      Ret;
 
 
    ACPI_FUNCTION_TRACE (AcpiAnyGpeStatusSet);
 
    Status = AcpiUtAcquireMutex (ACPI_MTX_EVENTS);
    if (ACPI_FAILURE (Status))
    {
        return (FALSE);
    }
 
    Ret = AcpiHwCheckAllGpes ();
    (void) AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
 
    return (Ret);
}

Referenced by AcpiAnyGpeStatusSet().

AcpiClearGpe()

ACPI_STATUS AcpiClearGpe	(	ACPI_HANDLE	GpeDevice,
		UINT32	GpeNumber
	)

Definition at line 685 of file evxfgpe.c.

{
    ACPI_STATUS             Status = AE_OK;
    ACPI_GPE_EVENT_INFO     *GpeEventInfo;
    ACPI_CPU_FLAGS          Flags;
 
 
    ACPI_FUNCTION_TRACE (AcpiClearGpe);
 
 
    Flags = AcpiOsAcquireLock (AcpiGbl_GpeLock);
 
    /* Ensure that we have a valid GPE number */
 
    GpeEventInfo = AcpiEvGetGpeEventInfo (GpeDevice, GpeNumber);
    if (!GpeEventInfo)
    {
        Status = AE_BAD_PARAMETER;
        goto UnlockAndExit;
    }
 
    Status = AcpiHwClearGpe (GpeEventInfo);
 
UnlockAndExit:
    AcpiOsReleaseLock (AcpiGbl_GpeLock, Flags);
    return_ACPI_STATUS (Status);
}

Referenced by AcpiClearGpe().

AcpiDisableAllGpes()

ACPI_STATUS AcpiDisableAllGpes

(

void

)

Definition at line 861 of file evxfgpe.c.

{
    ACPI_STATUS             Status;
 
 
    ACPI_FUNCTION_TRACE (AcpiDisableAllGpes);
 
 
    Status = AcpiUtAcquireMutex (ACPI_MTX_EVENTS);
    if (ACPI_FAILURE (Status))
    {
        return_ACPI_STATUS (Status);
    }
 
    Status = AcpiHwDisableAllGpes ();
    (void) AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
 
    return_ACPI_STATUS (Status);
}

Referenced by AcpiDisableAllGpes().

AcpiDisableGpe()

ACPI_STATUS AcpiDisableGpe	(	ACPI_HANDLE	GpeDevice,
		UINT32	GpeNumber
	)

Definition at line 203 of file evxfgpe.c.

{
    ACPI_STATUS             Status = AE_BAD_PARAMETER;
    ACPI_GPE_EVENT_INFO     *GpeEventInfo;
    ACPI_CPU_FLAGS          Flags;
 
 
    ACPI_FUNCTION_TRACE (AcpiDisableGpe);
 
 
    Flags = AcpiOsAcquireLock (AcpiGbl_GpeLock);
 
    /* Ensure that we have a valid GPE number */
 
    GpeEventInfo = AcpiEvGetGpeEventInfo (GpeDevice, GpeNumber);
    if (GpeEventInfo)
    {
        Status = AcpiEvRemoveGpeReference (GpeEventInfo);
    }
 
    AcpiOsReleaseLock (AcpiGbl_GpeLock, Flags);
    return_ACPI_STATUS (Status);
}

Referenced by AcpiDisableGpe().

AcpiDispatchGpe()

UINT32 AcpiDispatchGpe	(	ACPI_HANDLE	GpeDevice,
		UINT32	GpeNumber
	)

Definition at line 785 of file evxfgpe.c.

{
    ACPI_FUNCTION_TRACE(acpi_dispatch_gpe);
 
    return (AcpiEvDetectGpe (GpeDevice, NULL, GpeNumber));
}

AcpiEnableAllRuntimeGpes()

ACPI_STATUS AcpiEnableAllRuntimeGpes

(

void

)

Definition at line 898 of file evxfgpe.c.

{
    ACPI_STATUS             Status;
 
 
    ACPI_FUNCTION_TRACE (AcpiEnableAllRuntimeGpes);
 
 
    Status = AcpiUtAcquireMutex (ACPI_MTX_EVENTS);
    if (ACPI_FAILURE (Status))
    {
        return_ACPI_STATUS (Status);
    }
 
    Status = AcpiHwEnableAllRuntimeGpes ();
    (void) AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
 
    return_ACPI_STATUS (Status);
}

Referenced by AcpiEnableAllRuntimeGpes().

AcpiEnableAllWakeupGpes()

ACPI_STATUS AcpiEnableAllWakeupGpes

(

void

)

Definition at line 936 of file evxfgpe.c.

{
    ACPI_STATUS             Status;
 
 
    ACPI_FUNCTION_TRACE (AcpiEnableAllWakeupGpes);
 
 
    Status = AcpiUtAcquireMutex (ACPI_MTX_EVENTS);
    if (ACPI_FAILURE (Status))
    {
        return_ACPI_STATUS (Status);
    }
 
    Status = AcpiHwEnableAllWakeupGpes ();
    (void) AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
 
    return_ACPI_STATUS (Status);
}

Referenced by AcpiEnableAllWakeupGpes().

AcpiEnableGpe()

ACPI_STATUS AcpiEnableGpe	(	ACPI_HANDLE	GpeDevice,
		UINT32	GpeNumber
	)

Definition at line 137 of file evxfgpe.c.

{
    ACPI_STATUS             Status = AE_BAD_PARAMETER;
    ACPI_GPE_EVENT_INFO     *GpeEventInfo;
    ACPI_CPU_FLAGS          Flags;
 
 
    ACPI_FUNCTION_TRACE (AcpiEnableGpe);
 
 
    Flags = AcpiOsAcquireLock (AcpiGbl_GpeLock);
 
    /*
     * Ensure that we have a valid GPE number and that there is some way
     * of handling the GPE (handler or a GPE method). In other words, we
     * won't allow a valid GPE to be enabled if there is no way to handle it.
     */
    GpeEventInfo = AcpiEvGetGpeEventInfo (GpeDevice, GpeNumber);
    if (GpeEventInfo)
    {
        if (ACPI_GPE_DISPATCH_TYPE (GpeEventInfo->Flags) !=
            ACPI_GPE_DISPATCH_NONE)
        {
            Status = AcpiEvAddGpeReference (GpeEventInfo, TRUE);
            if (ACPI_SUCCESS (Status) &&
                ACPI_GPE_IS_POLLING_NEEDED (GpeEventInfo))
            {
                /* Poll edge-triggered GPEs to handle existing events */
 
                AcpiOsReleaseLock (AcpiGbl_GpeLock, Flags);
                (void) AcpiEvDetectGpe (
                    GpeDevice, GpeEventInfo, GpeNumber);
                Flags = AcpiOsAcquireLock (AcpiGbl_GpeLock);
            }
        }
        else
        {
            Status = AE_NO_HANDLER;
        }
    }
 
    AcpiOsReleaseLock (AcpiGbl_GpeLock, Flags);
    return_ACPI_STATUS (Status);
}

Referenced by AcpiEnableGpe().

AcpiFinishGpe()

ACPI_STATUS AcpiFinishGpe	(	ACPI_HANDLE	GpeDevice,
		UINT32	GpeNumber
	)

Definition at line 815 of file evxfgpe.c.

{
    ACPI_GPE_EVENT_INFO     *GpeEventInfo;
    ACPI_STATUS             Status;
    ACPI_CPU_FLAGS          Flags;
 
 
    ACPI_FUNCTION_TRACE (AcpiFinishGpe);
 
 
    Flags = AcpiOsAcquireLock (AcpiGbl_GpeLock);
 
    /* Ensure that we have a valid GPE number */
 
    GpeEventInfo = AcpiEvGetGpeEventInfo (GpeDevice, GpeNumber);
    if (!GpeEventInfo)
    {
        Status = AE_BAD_PARAMETER;
        goto UnlockAndExit;
    }
 
    Status = AcpiEvFinishGpe (GpeEventInfo);
 
UnlockAndExit:
    AcpiOsReleaseLock (AcpiGbl_GpeLock, Flags);
    return_ACPI_STATUS (Status);
}

Referenced by AcpiFinishGpe().

AcpiGetGpeDevice()

ACPI_STATUS AcpiGetGpeDevice	(	UINT32	Index,
		ACPI_HANDLE *	GpeDevice
	)

Definition at line 1207 of file evxfgpe.c.

{
    ACPI_GPE_DEVICE_INFO    Info;
    ACPI_STATUS             Status;
 
 
    ACPI_FUNCTION_TRACE (AcpiGetGpeDevice);
 
 
    if (!GpeDevice)
    {
        return_ACPI_STATUS (AE_BAD_PARAMETER);
    }
 
    if (Index >= AcpiCurrentGpeCount)
    {
        return_ACPI_STATUS (AE_NOT_EXIST);
    }
 
    /* Setup and walk the GPE list */
 
    Info.Index = Index;
    Info.Status = AE_NOT_EXIST;
    Info.GpeDevice = NULL;
    Info.NextBlockBaseIndex = 0;
 
    Status = AcpiEvWalkGpeList (AcpiEvGetGpeDevice, &Info);
    if (ACPI_FAILURE (Status))
    {
        return_ACPI_STATUS (Status);
    }
 
    *GpeDevice = ACPI_CAST_PTR (ACPI_HANDLE, Info.GpeDevice);
    return_ACPI_STATUS (Info.Status);
}

Referenced by AcpiGetGpeDevice().

AcpiGetGpeStatus()

ACPI_STATUS AcpiGetGpeStatus	(	ACPI_HANDLE	GpeDevice,
		UINT32	GpeNumber,
		ACPI_EVENT_STATUS *	EventStatus
	)

Definition at line 734 of file evxfgpe.c.

{
    ACPI_STATUS             Status = AE_OK;
    ACPI_GPE_EVENT_INFO     *GpeEventInfo;
    ACPI_CPU_FLAGS          Flags;
 
 
    ACPI_FUNCTION_TRACE (AcpiGetGpeStatus);
 
 
    Flags = AcpiOsAcquireLock (AcpiGbl_GpeLock);
 
    /* Ensure that we have a valid GPE number */
 
    GpeEventInfo = AcpiEvGetGpeEventInfo (GpeDevice, GpeNumber);
    if (!GpeEventInfo)
    {
        Status = AE_BAD_PARAMETER;
        goto UnlockAndExit;
    }
 
    /* Obtain status on the requested GPE number */
 
    Status = AcpiHwGetGpeStatus (GpeEventInfo, EventStatus);
 
UnlockAndExit:
    AcpiOsReleaseLock (AcpiGbl_GpeLock, Flags);
    return_ACPI_STATUS (Status);
}

Referenced by AcpiGetGpeStatus().

AcpiInstallGpeBlock()

ACPI_STATUS AcpiInstallGpeBlock	(	ACPI_HANDLE	GpeDevice,
		ACPI_GENERIC_ADDRESS *	GpeBlockAddress,
		UINT32	RegisterCount,
		UINT32	InterruptNumber
	)

Definition at line 1015 of file evxfgpe.c.

{
    ACPI_STATUS             Status;
    ACPI_OPERAND_OBJECT     *ObjDesc;
    ACPI_NAMESPACE_NODE     *Node;
    ACPI_GPE_BLOCK_INFO     *GpeBlock;
 
 
    ACPI_FUNCTION_TRACE (AcpiInstallGpeBlock);
 
 
    if ((!GpeDevice)       ||
        (!GpeBlockAddress) ||
        (!RegisterCount))
    {
        return_ACPI_STATUS (AE_BAD_PARAMETER);
    }
 
    Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
    if (ACPI_FAILURE (Status))
    {
        return_ACPI_STATUS (Status);
    }
 
    Node = AcpiNsValidateHandle (GpeDevice);
    if (!Node)
    {
        Status = AE_BAD_PARAMETER;
        goto UnlockAndExit;
    }
 
    /* Validate the parent device */
 
    if (Node->Type != ACPI_TYPE_DEVICE)
    {
        Status = AE_TYPE;
        goto UnlockAndExit;
    }
 
    if (Node->Object)
    {
        Status = AE_ALREADY_EXISTS;
        goto UnlockAndExit;
    }
 
    /*
     * For user-installed GPE Block Devices, the GpeBlockBaseNumber
     * is always zero
     */
    Status = AcpiEvCreateGpeBlock (Node, GpeBlockAddress->Address,
        GpeBlockAddress->SpaceId, RegisterCount,
        0, InterruptNumber, &GpeBlock);
    if (ACPI_FAILURE (Status))
    {
        goto UnlockAndExit;
    }
 
    /* Install block in the DeviceObject attached to the node */
 
    ObjDesc = AcpiNsGetAttachedObject (Node);
    if (!ObjDesc)
    {
        /*
         * No object, create a new one (Device nodes do not always have
         * an attached object)
         */
        ObjDesc = AcpiUtCreateInternalObject (ACPI_TYPE_DEVICE);
        if (!ObjDesc)
        {
            Status = AE_NO_MEMORY;
            goto UnlockAndExit;
        }
 
        Status = AcpiNsAttachObject (Node, ObjDesc, ACPI_TYPE_DEVICE);
 
        /* Remove local reference to the object */
 
        AcpiUtRemoveReference (ObjDesc);
        if (ACPI_FAILURE (Status))
        {
            goto UnlockAndExit;
        }
    }
 
    /* Now install the GPE block in the DeviceObject */
 
    ObjDesc->Device.GpeBlock = GpeBlock;
 
 
UnlockAndExit:
    (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
    return_ACPI_STATUS (Status);
}

Referenced by AcpiInstallGpeBlock().

AcpiMarkGpeForWake()

ACPI_STATUS AcpiMarkGpeForWake	(	ACPI_HANDLE	GpeDevice,
		UINT32	GpeNumber
	)

Definition at line 388 of file evxfgpe.c.

{
    ACPI_GPE_EVENT_INFO     *GpeEventInfo;
    ACPI_STATUS             Status = AE_BAD_PARAMETER;
    ACPI_CPU_FLAGS          Flags;
 
 
    ACPI_FUNCTION_TRACE (AcpiMarkGpeForWake);
 
 
    Flags = AcpiOsAcquireLock (AcpiGbl_GpeLock);
 
    /* Ensure that we have a valid GPE number */
 
    GpeEventInfo = AcpiEvGetGpeEventInfo (GpeDevice, GpeNumber);
    if (GpeEventInfo)
    {
        /* Mark the GPE as a possible wake event */
 
        GpeEventInfo->Flags |= ACPI_GPE_CAN_WAKE;
        Status = AE_OK;
    }
 
    AcpiOsReleaseLock (AcpiGbl_GpeLock, Flags);
    return_ACPI_STATUS (Status);
}

Referenced by AcpiMarkGpeForWake().

AcpiMaskGpe()

ACPI_STATUS AcpiMaskGpe	(	ACPI_HANDLE	GpeDevice,
		UINT32	GpeNumber,
		BOOLEAN	IsMasked
	)

Definition at line 332 of file evxfgpe.c.

{
    ACPI_GPE_EVENT_INFO     *GpeEventInfo;
    ACPI_STATUS             Status;
    ACPI_CPU_FLAGS          Flags;
 
 
    ACPI_FUNCTION_TRACE (AcpiMaskGpe);
 
 
    Flags = AcpiOsAcquireLock (AcpiGbl_GpeLock);
 
    /* Ensure that we have a valid GPE number */
 
    GpeEventInfo = AcpiEvGetGpeEventInfo (GpeDevice, GpeNumber);
    if (!GpeEventInfo)
    {
        Status = AE_BAD_PARAMETER;
        goto UnlockAndExit;
    }
 
    Status = AcpiEvMaskGpe (GpeEventInfo, IsMasked);
 
UnlockAndExit:
    AcpiOsReleaseLock (AcpiGbl_GpeLock, Flags);
    return_ACPI_STATUS (Status);
}

Referenced by AcpiMaskGpe().

AcpiRemoveGpeBlock()

ACPI_STATUS AcpiRemoveGpeBlock

(

ACPI_HANDLE

GpeDevice

)

Definition at line 1129 of file evxfgpe.c.

{
    ACPI_OPERAND_OBJECT     *ObjDesc;
    ACPI_STATUS             Status;
    ACPI_NAMESPACE_NODE     *Node;
 
 
    ACPI_FUNCTION_TRACE (AcpiRemoveGpeBlock);
 
 
    if (!GpeDevice)
    {
        return_ACPI_STATUS (AE_BAD_PARAMETER);
    }
 
    Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
    if (ACPI_FAILURE (Status))
    {
        return_ACPI_STATUS (Status);
    }
 
    Node = AcpiNsValidateHandle (GpeDevice);
    if (!Node)
    {
        Status = AE_BAD_PARAMETER;
        goto UnlockAndExit;
    }
 
    /* Validate the parent device */
 
    if (Node->Type != ACPI_TYPE_DEVICE)
    {
        Status = AE_TYPE;
        goto UnlockAndExit;
    }
 
    /* Get the DeviceObject attached to the node */
 
    ObjDesc = AcpiNsGetAttachedObject (Node);
    if (!ObjDesc ||
        !ObjDesc->Device.GpeBlock)
    {
        return_ACPI_STATUS (AE_NULL_OBJECT);
    }
 
    /* Delete the GPE block (but not the DeviceObject) */
 
    Status = AcpiEvDeleteGpeBlock (ObjDesc->Device.GpeBlock);
    if (ACPI_SUCCESS (Status))
    {
        ObjDesc->Device.GpeBlock = NULL;
    }
 
UnlockAndExit:
    (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
    return_ACPI_STATUS (Status);
}

Referenced by AcpiRemoveGpeBlock().

AcpiSetGpe()

ACPI_STATUS AcpiSetGpe	(	ACPI_HANDLE	GpeDevice,
		UINT32	GpeNumber,
		UINT8	Action
	)

Definition at line 262 of file evxfgpe.c.

{
    ACPI_GPE_EVENT_INFO     *GpeEventInfo;
    ACPI_STATUS             Status;
    ACPI_CPU_FLAGS          Flags;
 
 
    ACPI_FUNCTION_TRACE (AcpiSetGpe);
 
 
    Flags = AcpiOsAcquireLock (AcpiGbl_GpeLock);
 
    /* Ensure that we have a valid GPE number */
 
    GpeEventInfo = AcpiEvGetGpeEventInfo (GpeDevice, GpeNumber);
    if (!GpeEventInfo)
    {
        Status = AE_BAD_PARAMETER;
        goto UnlockAndExit;
    }
 
    /* Perform the action */
 
    switch (Action)
    {
    case ACPI_GPE_ENABLE:
 
        Status = AcpiHwLowSetGpe (GpeEventInfo, ACPI_GPE_ENABLE);
        GpeEventInfo->DisableForDispatch = FALSE;
        break;
 
    case ACPI_GPE_DISABLE:
 
        Status = AcpiHwLowSetGpe (GpeEventInfo, ACPI_GPE_DISABLE);
        GpeEventInfo->DisableForDispatch = TRUE;
        break;
 
    default:
 
        Status = AE_BAD_PARAMETER;
        break;
    }
 
UnlockAndExit:
    AcpiOsReleaseLock (AcpiGbl_GpeLock, Flags);
    return_ACPI_STATUS (Status);
}

Referenced by AcpiSetGpe().

AcpiSetGpeWakeMask()

ACPI_STATUS AcpiSetGpeWakeMask	(	ACPI_HANDLE	GpeDevice,
		UINT32	GpeNumber,
		UINT8	Action
	)

Definition at line 599 of file evxfgpe.c.

{
    ACPI_STATUS             Status = AE_OK;
    ACPI_GPE_EVENT_INFO     *GpeEventInfo;
    ACPI_GPE_REGISTER_INFO  *GpeRegisterInfo;
    ACPI_CPU_FLAGS          Flags;
    UINT32                  RegisterBit;
 
 
    ACPI_FUNCTION_TRACE (AcpiSetGpeWakeMask);
 
 
    Flags = AcpiOsAcquireLock (AcpiGbl_GpeLock);
 
    /*
     * Ensure that we have a valid GPE number and that this GPE is in
     * fact a wake GPE
     */
    GpeEventInfo = AcpiEvGetGpeEventInfo (GpeDevice, GpeNumber);
    if (!GpeEventInfo)
    {
        Status = AE_BAD_PARAMETER;
        goto UnlockAndExit;
    }
 
    if (!(GpeEventInfo->Flags & ACPI_GPE_CAN_WAKE))
    {
        Status = AE_TYPE;
        goto UnlockAndExit;
    }
 
    GpeRegisterInfo = GpeEventInfo->RegisterInfo;
    if (!GpeRegisterInfo)
    {
        Status = AE_NOT_EXIST;
        goto UnlockAndExit;
    }
 
    RegisterBit = AcpiHwGetGpeRegisterBit (GpeEventInfo);
 
    /* 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);
}

Referenced by AcpiSetGpeWakeMask().

AcpiSetupGpeForWake()

ACPI_STATUS AcpiSetupGpeForWake	(	ACPI_HANDLE	WakeDevice,
		ACPI_HANDLE	GpeDevice,
		UINT32	GpeNumber
	)

Definition at line 440 of file evxfgpe.c.

{
    ACPI_STATUS             Status;
    ACPI_GPE_EVENT_INFO     *GpeEventInfo;
    ACPI_NAMESPACE_NODE     *DeviceNode;
    ACPI_GPE_NOTIFY_INFO    *Notify;
    ACPI_GPE_NOTIFY_INFO    *NewNotify;
    ACPI_CPU_FLAGS          Flags;
 
 
    ACPI_FUNCTION_TRACE (AcpiSetupGpeForWake);
 
 
    /* Parameter Validation */
 
    if (!WakeDevice)
    {
        /*
         * By forcing WakeDevice to be valid, we automatically enable the
         * implicit notify feature on all hosts.
         */
        return_ACPI_STATUS (AE_BAD_PARAMETER);
    }
 
    /* Handle root object case */
 
    if (WakeDevice == ACPI_ROOT_OBJECT)
    {
        DeviceNode = AcpiGbl_RootNode;
    }
    else
    {
        DeviceNode = ACPI_CAST_PTR (ACPI_NAMESPACE_NODE, WakeDevice);
    }
 
    /* Validate WakeDevice is of type Device */
 
    if (DeviceNode->Type != ACPI_TYPE_DEVICE)
    {
        return_ACPI_STATUS (AE_BAD_PARAMETER);
    }
 
    /*
     * Allocate a new notify object up front, in case it is needed.
     * Memory allocation while holding a spinlock is a big no-no
     * on some hosts.
     */
    NewNotify = ACPI_ALLOCATE_ZEROED (sizeof (ACPI_GPE_NOTIFY_INFO));
    if (!NewNotify)
    {
        return_ACPI_STATUS (AE_NO_MEMORY);
    }
 
    Flags = AcpiOsAcquireLock (AcpiGbl_GpeLock);
 
    /* Ensure that we have a valid GPE number */
 
    GpeEventInfo = AcpiEvGetGpeEventInfo (GpeDevice, GpeNumber);
    if (!GpeEventInfo)
    {
        Status = AE_BAD_PARAMETER;
        goto UnlockAndExit;
    }
 
    /*
     * If there is no method or handler for this GPE, then the
     * WakeDevice will be notified whenever this GPE fires. This is
     * known as an "implicit notify". Note: The GPE is assumed to be
     * level-triggered (for windows compatibility).
     */
    if (ACPI_GPE_DISPATCH_TYPE (GpeEventInfo->Flags) ==
        ACPI_GPE_DISPATCH_NONE)
    {
        /*
         * This is the first device for implicit notify on this GPE.
         * Just set the flags here, and enter the NOTIFY block below.
         */
        GpeEventInfo->Flags =
            (ACPI_GPE_DISPATCH_NOTIFY | ACPI_GPE_LEVEL_TRIGGERED);
    }
    else if (GpeEventInfo->Flags & ACPI_GPE_AUTO_ENABLED)
    {
        /*
         * A reference to this GPE has been added during the GPE block
         * initialization, so drop it now to prevent the GPE from being
         * permanently enabled and clear its ACPI_GPE_AUTO_ENABLED flag.
         */
        (void) AcpiEvRemoveGpeReference (GpeEventInfo);
        GpeEventInfo->Flags &= ~~ACPI_GPE_AUTO_ENABLED;
    }
 
    /*
     * If we already have an implicit notify on this GPE, add
     * this device to the notify list.
     */
    if (ACPI_GPE_DISPATCH_TYPE (GpeEventInfo->Flags) ==
        ACPI_GPE_DISPATCH_NOTIFY)
    {
        /* Ensure that the device is not already in the list */
 
        Notify = GpeEventInfo->Dispatch.NotifyList;
        while (Notify)
        {
            if (Notify->DeviceNode == DeviceNode)
            {
                Status = AE_ALREADY_EXISTS;
                goto UnlockAndExit;
            }
            Notify = Notify->Next;
        }
 
        /* Add this device to the notify list for this GPE */
 
        NewNotify->DeviceNode = DeviceNode;
        NewNotify->Next = GpeEventInfo->Dispatch.NotifyList;
        GpeEventInfo->Dispatch.NotifyList = NewNotify;
        NewNotify = NULL;
    }
 
    /* Mark the GPE as a possible wake event */
 
    GpeEventInfo->Flags |= ACPI_GPE_CAN_WAKE;
    Status = AE_OK;
 
 
UnlockAndExit:
    AcpiOsReleaseLock (AcpiGbl_GpeLock, Flags);
 
    /* Delete the notify object if it was not used above */
 
    if (NewNotify)
    {
        ACPI_FREE (NewNotify);
    }
    return_ACPI_STATUS (Status);
}

Referenced by AcpiSetupGpeForWake().

AcpiUpdateAllGpes()

ACPI_STATUS AcpiUpdateAllGpes

(

void

)

Definition at line 79 of file evxfgpe.c.

{
    ACPI_STATUS             Status;
    BOOLEAN                 IsPollingNeeded = FALSE;
 
 
    ACPI_FUNCTION_TRACE (AcpiUpdateAllGpes);
 
 
    Status = AcpiUtAcquireMutex (ACPI_MTX_EVENTS);
    if (ACPI_FAILURE (Status))
    {
        return_ACPI_STATUS (Status);
    }
 
    if (AcpiGbl_AllGpesInitialized)
    {
        goto UnlockAndExit;
    }
 
    Status = AcpiEvWalkGpeList (AcpiEvInitializeGpeBlock,
        &IsPollingNeeded);
    if (ACPI_SUCCESS (Status))
    {
        AcpiGbl_AllGpesInitialized = TRUE;
    }
 
UnlockAndExit:
    (void) AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
 
    if (IsPollingNeeded && AcpiGbl_AllGpesInitialized)
    {
        /* Poll GPEs to handle already triggered events */
 
        AcpiEvGpeDetect (AcpiGbl_GpeXruptListHead);
    }
    return_ACPI_STATUS (Status);
}

Referenced by AcpiUpdateAllGpes().