evmisc.c File Reference

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

Include dependency graph for evmisc.c:

Go to the source code of this file.

Macros
#define	_COMPONENT   ACPI_EVENTS

Functions
static void ACPI_SYSTEM_XFACE	AcpiEvNotifyDispatch (void *Context)
BOOLEAN	AcpiEvIsNotifyObject (ACPI_NAMESPACE_NODE *Node)
ACPI_STATUS	AcpiEvQueueNotifyRequest (ACPI_NAMESPACE_NODE *Node, UINT32 NotifyValue)
void	AcpiEvTerminate (void)

Macro Definition Documentation

_COMPONENT

#define _COMPONENT   ACPI_EVENTS

Definition at line 49 of file evmisc.c.

Function Documentation

AcpiEvIsNotifyObject()

BOOLEAN AcpiEvIsNotifyObject

(

ACPI_NAMESPACE_NODE *

Node

)

Definition at line 75 of file evmisc.c.

{
 
    switch (Node->Type)
    {
    case ACPI_TYPE_DEVICE:
    case ACPI_TYPE_PROCESSOR:
    case ACPI_TYPE_THERMAL:
        /*
         * These are the ONLY objects that can receive ACPI notifications
         */
        return (TRUE);
 
    default:
 
        return (FALSE);
    }
}

Referenced by AcpiEvQueueNotifyRequest(), AcpiExOpcode_2A_0T_0R(), AcpiInstallNotifyHandler(), and AcpiRemoveNotifyHandler().

AcpiEvNotifyDispatch()

static void ACPI_SYSTEM_XFACE AcpiEvNotifyDispatch ( void *  Context )

static

Definition at line 212 of file evmisc.c.

{
    ACPI_GENERIC_STATE      *Info = (ACPI_GENERIC_STATE *) Context;
    ACPI_OPERAND_OBJECT     *HandlerObj;
 
 
    ACPI_FUNCTION_ENTRY ();
 
 
    /* Invoke a global notify handler if installed */
 
    if (Info->Notify.Global->Handler)
    {
        Info->Notify.Global->Handler (Info->Notify.Node,
            Info->Notify.Value,
            Info->Notify.Global->Context);
    }
 
    /* Now invoke the local notify handler(s) if any are installed */
 
    HandlerObj = Info->Notify.HandlerListHead;
    while (HandlerObj)
    {
        HandlerObj->Notify.Handler (Info->Notify.Node,
            Info->Notify.Value,
            HandlerObj->Notify.Context);
 
        HandlerObj = HandlerObj->Notify.Next[Info->Notify.HandlerListId];
    }
 
    /* All done with the info object */
 
    AcpiUtDeleteGenericState (Info);
}

Referenced by AcpiEvQueueNotifyRequest().

AcpiEvQueueNotifyRequest()

ACPI_STATUS AcpiEvQueueNotifyRequest	(	ACPI_NAMESPACE_NODE *	Node,
		UINT32	NotifyValue
	)

Definition at line 111 of file evmisc.c.

{
    ACPI_OPERAND_OBJECT     *ObjDesc;
    ACPI_OPERAND_OBJECT     *HandlerListHead = NULL;
    ACPI_GENERIC_STATE      *Info;
    UINT8                   HandlerListId = 0;
    ACPI_STATUS             Status = AE_OK;
 
 
    ACPI_FUNCTION_NAME (EvQueueNotifyRequest);
 
 
    /* Are Notifies allowed on this object? */
 
    if (!AcpiEvIsNotifyObject (Node))
    {
        return (AE_TYPE);
    }
 
    /* Get the correct notify list type (System or Device) */
 
    if (NotifyValue <= ACPI_MAX_SYS_NOTIFY)
    {
        HandlerListId = ACPI_SYSTEM_HANDLER_LIST;
    }
    else
    {
        HandlerListId = ACPI_DEVICE_HANDLER_LIST;
    }
 
    /* Get the notify object attached to the namespace Node */
 
    ObjDesc = AcpiNsGetAttachedObject (Node);
    if (ObjDesc)
    {
        /* We have an attached object, Get the correct handler list */
 
        HandlerListHead = ObjDesc->CommonNotify.NotifyList[HandlerListId];
    }
 
    /*
     * If there is no notify handler (Global or Local)
     * for this object, just ignore the notify
     */
    if (!AcpiGbl_GlobalNotify[HandlerListId].Handler && !HandlerListHead)
    {
        ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
            "No notify handler for Notify, ignoring (%4.4s, %X) node %p\n",
            AcpiUtGetNodeName (Node), NotifyValue, Node));
 
        return (AE_OK);
    }
 
    /* Setup notify info and schedule the notify dispatcher */
 
    Info = AcpiUtCreateGenericState ();
    if (!Info)
    {
        return (AE_NO_MEMORY);
    }
 
    Info->Common.DescriptorType = ACPI_DESC_TYPE_STATE_NOTIFY;
 
    Info->Notify.Node = Node;
    Info->Notify.Value = (UINT16) NotifyValue;
    Info->Notify.HandlerListId = HandlerListId;
    Info->Notify.HandlerListHead = HandlerListHead;
    Info->Notify.Global = &AcpiGbl_GlobalNotify[HandlerListId];
 
    ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
        "Dispatching Notify on [%4.4s] (%s) Value 0x%2.2X (%s) Node %p\n",
        AcpiUtGetNodeName (Node), AcpiUtGetTypeName (Node->Type),
        NotifyValue, AcpiUtGetNotifyName (NotifyValue, ACPI_TYPE_ANY), Node));
 
    Status = AcpiOsExecute (OSL_NOTIFY_HANDLER,
        AcpiEvNotifyDispatch, Info);
    if (ACPI_FAILURE (Status))
    {
        AcpiUtDeleteGenericState (Info);
    }
 
    return (Status);
}

Referenced by AcpiEvAsynchExecuteGpeMethod(), and AcpiExOpcode_2A_0T_0R().

AcpiEvTerminate()

void AcpiEvTerminate

(

void

)

Definition at line 263 of file evmisc.c.

{
    UINT32                  i;
    ACPI_STATUS             Status;
 
 
    ACPI_FUNCTION_TRACE (EvTerminate);
 
 
    if (AcpiGbl_EventsInitialized)
    {
        /*
         * Disable all event-related functionality. In all cases, on error,
         * print a message but obviously we don't abort.
         */
 
        /* Disable all fixed events */
 
        for (i = 0; i < ACPI_NUM_FIXED_EVENTS; i++)
        {
            Status = AcpiDisableEvent (i, 0);
            if (ACPI_FAILURE (Status))
            {
                ACPI_ERROR ((AE_INFO,
                    "Could not disable fixed event %u", (UINT32) i));
            }
        }
 
        /* Disable all GPEs in all GPE blocks */
 
        Status = AcpiEvWalkGpeList (AcpiHwDisableGpeBlock, NULL);
        if (ACPI_FAILURE (Status))
        {
            ACPI_EXCEPTION ((AE_INFO, Status,
                "Could not disable GPEs in GPE block"));
        }
 
        Status = AcpiEvRemoveGlobalLockHandler ();
        if (ACPI_FAILURE (Status))
        {
            ACPI_EXCEPTION ((AE_INFO, Status,
                "Could not remove Global Lock handler"));
        }
 
        AcpiGbl_EventsInitialized = FALSE;
    }
 
    /* Remove SCI handlers */
 
    Status = AcpiEvRemoveAllSciHandlers ();
    if (ACPI_FAILURE (Status))
    {
        ACPI_ERROR ((AE_INFO,
            "Could not remove SCI handler"));
    }
 
    /* Deallocate all handler objects installed within GPE info structs */
 
    Status = AcpiEvWalkGpeList (AcpiEvDeleteGpeHandlers, NULL);
    if (ACPI_FAILURE (Status))
    {
        ACPI_EXCEPTION ((AE_INFO, Status,
            "Could not delete GPE handlers"));
    }
 
 
    /* Return to original mode if necessary */
 
    if (AcpiGbl_OriginalMode == ACPI_SYS_MODE_LEGACY)
    {
        Status = AcpiDisable ();
        if (ACPI_FAILURE (Status))
        {
            ACPI_WARNING ((AE_INFO, "AcpiDisable failed"));
        }
    }
    return_VOID;
}

Referenced by AcpiUtSubsystemShutdown().