FxWakeInterruptMachine Class Reference

#include <fxwakeinterruptstatemachine.hpp>

Inheritance diagram for FxWakeInterruptMachine:

Collaboration diagram for FxWakeInterruptMachine:

Public Member Functions
	FxWakeInterruptMachine (__in FxInterrupt *Interrupt)
VOID	ProcessEvent (__in FxWakeInterruptEvents Event)
Public Member Functions inherited from FxThreadedEventQueue
	FxThreadedEventQueue (__in UCHAR QueueDepth)
	~FxThreadedEventQueue (VOID)
_Must_inspect_result_ NTSTATUS	Init (__inout FxPkgPnp *Pnp, __in PFN_PNP_EVENT_WORKER WorkerRoutine, __in PVOID WorkerContext=NULL)
VOID	QueueToThread (VOID)
Public Member Functions inherited from FxEventQueue
	FxEventQueue (__in UCHAR QueueDepth)
_Must_inspect_result_ NTSTATUS	Initialize (__in PFX_DRIVER_GLOBALS DriverGlobals)
	_Acquires_lock_ (this->m_QueueLock) __drv_maxIRQL(DISPATCH_LEVEL) __drv_setsIRQL(DISPATCH_LEVEL) VOID Lock(__out __drv_deref(__drv_savesIRQL) PKIRQL Irql)
	_Releases_lock_ (this->m_QueueLock) __drv_requiresIRQL(DISPATCH_LEVEL) VOID Unlock(__in __drv_restoresIRQL KIRQL Irql)
BOOLEAN	IsFull (VOID)
BOOLEAN	IsEmpty (VOID)
VOID	IncrementHead (VOID)
UCHAR	GetHead (VOID)
UCHAR	InsertAtHead (VOID)
UCHAR	InsertAtTail (VOID)
UCHAR	IncrementHistoryIndex (VOID)
BOOLEAN	IsClosedLocked (VOID)
VOID	GetFinishedState (__inout FxPostProcessInfo *Info)
BOOLEAN	SetFinished (__in FxCREvent *Event)
VOID	SetDelayedDeletion (VOID)
Public Member Functions inherited from FxStump
PVOID	operator new (__in size_t Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals)
PVOID	operator new (__in size_t Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in POOL_TYPE PoolType)
VOID	operator delete (__in PVOID pointer)
PVOID	operator new[] (__in size_t Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals)
VOID	operator delete[] (__in PVOID pointer)

Static Public Member Functions
static VOID	_ProcessEventInner (__inout FxPkgPnp *PkgPnp, __inout FxPostProcessInfo *Info, __in PVOID WorkerContext)

Protected Attributes
FxInterrupt *	m_Interrupt
BOOLEAN	m_ActiveForWake
BOOLEAN	m_Claimed
MxEvent	m_IsrEvent
BYTE	m_CurrentState
FxWakeInterruptEvents	m_Queue [FxWakeInterruptEventQueueDepth]
FxWakeInterruptMachineStateHistory	m_States
Protected Attributes inherited from FxThreadedEventQueue
MxWorkItem	m_WorkItem
WORK_QUEUE_ITEM	m_EventWorkQueueItem
Protected Attributes inherited from FxEventQueue
UCHAR	m_QueueHead
UCHAR	m_QueueTail
UCHAR	m_QueueDepth
UCHAR	m_HistoryIndex
FxPkgPnp *	m_PkgPnp
PVOID	m_EventWorkerContext
MxLock	m_QueueLock
PFN_PNP_EVENT_WORKER	m_EventWorker
FxCREvent *	m_WorkItemFinished
union {
UCHAR   m_QueueFlags
struct {
UCHAR   WorkItemQueued: 1
UCHAR   Closed: 1
UCHAR   DelayDeletion: 1
}   m_QueueFlagsByName
};
UCHAR	m_WorkItemRunningCount

Static Protected Attributes
static const FxWakeInterruptStateTable	m_StateTable []
static const FxWakeInterruptTargetState	m_FailedStates []
static const FxWakeInterruptTargetState	m_D0States []
static const FxWakeInterruptTargetState	m_DxStates []
static const FxWakeInterruptTargetState	m_DxNotArmedForWakeStates []
static const FxWakeInterruptTargetState	m_WakingStates []
static const FxWakeInterruptTargetState	m_InvokingEvtIsrPostWakeStates []
static const FxWakeInterruptTargetState	m_CompletingD0States []
static const FxWakeInterruptTargetState	m_InvokingIsrInD0 []
Static Protected Attributes inherited from FxThreadedEventQueue
static WORKER_THREAD_ROUTINE	_WorkerThreadRoutine
static MX_WORKITEM_ROUTINE	_WorkItemCallback

Private Member Functions
VOID	ProcessEventInner (__inout FxPostProcessInfo *Info)

Static Private Member Functions
static FxWakeInterruptStates	Waking (__in FxWakeInterruptMachine *This)
static FxWakeInterruptStates	Dx (__in FxWakeInterruptMachine *This)
static FxWakeInterruptStates	DxNotArmedForWake (__in FxWakeInterruptMachine *This)
static FxWakeInterruptStates	Failed (__in FxWakeInterruptMachine *This)
static FxWakeInterruptStates	InvokingEvtIsrPostWake (__in FxWakeInterruptMachine *This)
static FxWakeInterruptStates	InvokingEvtIsrInDxNotArmedForWake (__in FxWakeInterruptMachine *This)
static FxWakeInterruptStates	InvokingEvtIsrInD0 (__in FxWakeInterruptMachine *This)
static FxWakeInterruptStates	CompletingD0 (__in FxWakeInterruptMachine *This)

Private Attributes
friend	FxInterrupt

Additional Inherited Members
Public Attributes inherited from FxEventQueue
FxWaitLockInternal	m_StateMachineLock
Protected Member Functions inherited from FxThreadedEventQueue
VOID	QueueWorkItem (VOID)
Protected Member Functions inherited from FxEventQueue
VOID	Configure (__in FxPkgPnp *Pnp, __in PFN_PNP_EVENT_WORKER WorkerRoutine, __in PVOID Context)
BOOLEAN	QueueToThreadWorker (VOID)
VOID	EventQueueWorker (VOID)
BOOLEAN	IsIdleLocked (VOID)
Protected Member Functions inherited from FxStump
	FxStump (VOID)

Detailed Description

Definition at line 89 of file fxwakeinterruptstatemachine.hpp.

Constructor & Destructor Documentation

FxWakeInterruptMachine()

FxWakeInterruptMachine::FxWakeInterruptMachine

(

__in FxInterrupt *

Interrupt

)

Definition at line 118 of file wakeinterruptstatemachine.cpp.

      : FxThreadedEventQueue(FxWakeInterruptEventQueueDepth)
{
    //
    // Make sure we can fit the state into a byte
    //
    C_ASSERT(WakeInterruptMax <= 0xFF);
 
    m_CurrentState = WakeInterruptD0;
 
    RtlZeroMemory(&m_Queue, sizeof(m_Queue));
    RtlZeroMemory(&m_States, sizeof(m_States));
 
    //
    // Store the initial state in the state history array
    //
    m_States.History[IncrementHistoryIndex()] = m_CurrentState;
    m_Interrupt = Interrupt;
}

Member Function Documentation

_ProcessEventInner()

VOID FxWakeInterruptMachine::_ProcessEventInner ( __inout FxPkgPnp *  PkgPnp, __inout FxPostProcessInfo *  Info, __in PVOID  WorkerContext  )

static

Definition at line 245 of file wakeinterruptstatemachine.cpp.

{
 
    UNREFERENCED_PARAMETER(PkgPnp);
 
    FxWakeInterruptMachine * pThis = (FxWakeInterruptMachine *) WorkerContext;
 
    //
    // Take the state machine lock.
    //
    pThis->m_StateMachineLock.AcquireLock(
                pThis->m_PkgPnp->GetDriverGlobals()
                );
 
    //
    // Call the function that will actually run the state machine.
    //
    pThis->ProcessEventInner(Info);
 
    //
    // We are being called from the work item and m_WorkItemRunning is > 0, so
    // we cannot be deleted yet.
    //
    ASSERT(Info->SomethingToDo() == FALSE);
 
    //
    // Now release the state machine lock
    //
    pThis->m_StateMachineLock.ReleaseLock(
                pThis->m_PkgPnp->GetDriverGlobals()
                );
 
    return;
}

Referenced by FxInterrupt::CreateWakeInterruptMachine().

CompletingD0()

FxWakeInterruptStates FxWakeInterruptMachine::CompletingD0 ( __in FxWakeInterruptMachine *  This )

staticprivate

Definition at line 486 of file wakeinterruptstatemachine.cpp.

{
    This->m_PkgPnp->AckPendingWakeInterruptOperation(FALSE);
 
    return WakeInterruptD0;
}

Dx()

FxWakeInterruptStates FxWakeInterruptMachine::Dx ( __in FxWakeInterruptMachine *  This )

staticprivate

Definition at line 418 of file wakeinterruptstatemachine.cpp.

{
    //
    // Flush queued callbacks so that we know that nobody is still trying to
    // synchronize against this interrupt. For KMDF this will flush DPCs and
    // for UMDF this will send a message to reflector to flush queued DPCs.
    //
    This->m_Interrupt->FlushQueuedDpcs();
 
#if FX_IS_KERNEL_MODE
    //
    // Rundown the workitem if present (passive-level interrupt support or KMDF).
    // Not needed for UMDF since reflector doesn't use workitem for isr.
    //
    This->m_Interrupt->FlushQueuedWorkitem();
 
#endif
 
    This->m_PkgPnp->AckPendingWakeInterruptOperation(FALSE);
 
    return WakeInterruptMax;
}

DxNotArmedForWake()

FxWakeInterruptStates FxWakeInterruptMachine::DxNotArmedForWake ( __in FxWakeInterruptMachine *  This )

staticprivate

Definition at line 444 of file wakeinterruptstatemachine.cpp.

{
    //
    // Ask power state machine to process the acknowledgement event
    // on a different thread as we could be running the state machine's
    // engine in the context of a wake ISR, and the power
    // state machine will attempt to disconnect this interrupt when
    // it processes the acknowledgement event.
    //
    This->m_PkgPnp->AckPendingWakeInterruptOperation(TRUE);
 
    return WakeInterruptMax;
}

Failed()

FxWakeInterruptStates FxWakeInterruptMachine::Failed ( __in FxWakeInterruptMachine *  This )

staticprivate

Definition at line 508 of file wakeinterruptstatemachine.cpp.

{
    //
    // Device failed to power up and we are not invoking the
    // client driver's callback. So we cannot claim the
    // interrupt
    //
    This->m_Claimed = FALSE;
 
    This->m_IsrEvent.Set();
 
    return WakeInterruptMax;
}

InvokingEvtIsrInD0()

FxWakeInterruptStates FxWakeInterruptMachine::InvokingEvtIsrInD0 ( __in FxWakeInterruptMachine *  This )

staticprivate

Definition at line 496 of file wakeinterruptstatemachine.cpp.

{
    This->m_Interrupt->InvokeWakeInterruptEvtIsr();
 
    This->m_IsrEvent.Set();
 
    return WakeInterruptD0;
}

InvokingEvtIsrInDxNotArmedForWake()

FxWakeInterruptStates FxWakeInterruptMachine::InvokingEvtIsrInDxNotArmedForWake ( __in FxWakeInterruptMachine *  This )

staticprivate

Definition at line 462 of file wakeinterruptstatemachine.cpp.

{
    This->m_Interrupt->InvokeWakeInterruptEvtIsr();
 
    This->m_IsrEvent.Set();
 
    return WakeInterruptDxNotArmedForWake;
}

InvokingEvtIsrPostWake()

FxWakeInterruptStates FxWakeInterruptMachine::InvokingEvtIsrPostWake ( __in FxWakeInterruptMachine *  This )

staticprivate

Definition at line 474 of file wakeinterruptstatemachine.cpp.

{
    This->m_Interrupt->InvokeWakeInterruptEvtIsr();
 
    This->m_IsrEvent.Set();
 
    return WakeInterruptCompletingD0;
}

ProcessEvent()

VOID FxWakeInterruptMachine::ProcessEvent

(

__in FxWakeInterruptEvents

Event

)

Definition at line 140 of file wakeinterruptstatemachine.cpp.

{
    NTSTATUS status;
    KIRQL irql;
    LONGLONG timeout = 0;
 
    //
    // Acquire state machine *queue* lock, raising to DISPATCH_LEVEL
    //
    Lock(&irql);
 
    if (IsFull()) {
        //
        // The queue is full. This should never happen.
        //
        Unlock(irql);
 
        ASSERTMSG("The wake interrupt state machine queue is full\n",
                  FALSE);
        return;
    }
 
    if (IsClosedLocked()) {
        //
        // The queue is closed. This should never happen.
        //
        DoTraceLevelMessage(
          m_PkgPnp->GetDriverGlobals(), TRACE_LEVEL_INFORMATION, TRACINGPNP,
          "WDFDEVICE 0x%p !devobj 0x%p current wake interrupt state"
          " %!FxWakeInterruptStates! dropping event "
          "%!FxWakeInterruptEvents! because of a closed queue",
          m_PkgPnp->GetDevice()->GetHandle(),
          m_PkgPnp->GetDevice()->GetDeviceObject(),
          m_CurrentState,
          Event);
 
        Unlock(irql);
 
        ASSERTMSG(
            "The wake interrupt state machine queue is closed\n",
            FALSE
            );
        return;
    }
 
    //
    // Enqueue the event
    //
    m_Queue[InsertAtTail()] = Event;
 
    //
    // Drop the state machine *queue* lock
    //
    Unlock(irql);
 
    //
    // Now, if we are running at PASSIVE_LEVEL, attempt to run the state machine
    // on this thread. If we can't do that, then queue a work item.
    //
    if (irql == PASSIVE_LEVEL) {
        //
        // Try to acquire the state machine lock
        //
        status = m_StateMachineLock.AcquireLock(
                    m_PkgPnp->GetDriverGlobals(),
                    &timeout
                    );
        if (FxWaitLockInternal::IsLockAcquired(status)) {
            FxPostProcessInfo info;
 
            //
            // We now hold the state machine lock.  So call the function that
            // dispatches the next state.
            //
            ProcessEventInner(&info);
 
            //
            // The pnp state machine should be the only one deleting the object
            //
            ASSERT(info.m_DeleteObject == FALSE);
 
            //
            // Release the state machine lock
            //
            m_StateMachineLock.ReleaseLock(
                m_PkgPnp->GetDriverGlobals()
                );
 
            info.Evaluate(m_PkgPnp);
 
            return;
        }
    }
 
    //
    // For one reason or another, we couldn't run the state machine on this
    // thread.  So queue a work item to do it.
    //
    QueueToThread();
    return;
}

Referenced by FxInterrupt::ProcessWakeInterruptEvent(), and FxInterrupt::WakeInterruptIsr().

ProcessEventInner()

VOID FxWakeInterruptMachine::ProcessEventInner ( __inout FxPostProcessInfo *  Info )

private

Definition at line 285 of file wakeinterruptstatemachine.cpp.

{
    KIRQL irql;
    FxWakeInterruptEvents event;
    const FxWakeInterruptStateTable* entry;
    FxWakeInterruptStates newState;
 
    //
    // Process as many events as we can
    //
    for ( ; ; ) {
        //
        // Acquire state machine *queue* lock
        //
        Lock(&irql);
 
        if (IsEmpty()) {
            //
            // The queue is empty.
            //
            GetFinishedState(Info);
            Unlock(irql);
            return;
        }
 
        //
        // Get the event from the queue
        //
        event = m_Queue[GetHead()];
        IncrementHead();
 
        //
        // Drop the state machine *queue* lock
        //
        Unlock(irql);
 
        //
        // Get the state table entry for the current state
        //
        // NOTE: Prefast complains about buffer overflow if (m_CurrentState ==
        // WakeInterruptMax), but that should never happen because WakeInterruptMax is not a real
        // state. We just use it to represent the maximum value in the enum that
        // defines the states.
        //
        __analysis_assume(m_CurrentState < WakeInterruptMax);
        entry = &m_StateTable[m_CurrentState - WakeInterruptFailed];
 
        //
        // Based on the event received, figure out the next state
        //
        newState = WakeInterruptMax;
        for (ULONG i = 0; i < entry->TargetStatesCount; i++) {
            if (entry->TargetStates[i].WakeInterruptEvent == event) {
                DO_EVENT_TRAP(&entry->TargetStates[i]);
                newState = entry->TargetStates[i].WakeInterruptState;
                break;
            }
        }
 
        if (newState == WakeInterruptMax) {
            //
            // Unexpected event for this state
            //
            DoTraceLevelMessage(
                m_PkgPnp->GetDriverGlobals(),
                TRACE_LEVEL_INFORMATION,
                TRACINGPNP,
                "WDFDEVICE 0x%p !devobj 0x%p wake interrupt state "
                "%!FxWakeInterruptStates! dropping event "
                "%!FxWakeInterruptEvents!",
                m_PkgPnp->GetDevice()->GetHandle(),
                m_PkgPnp->GetDevice()->GetDeviceObject(),
                m_CurrentState,
                event
                );
 
            COVERAGE_TRAP();
        }
 
        while (newState != WakeInterruptMax) {
            DoTraceLevelMessage(
                m_PkgPnp->GetDriverGlobals(),
                TRACE_LEVEL_INFORMATION,
                TRACINGPNPPOWERSTATES,
                "WDFDEVICE 0x%p !devobj 0x%p entering wake interrupt "
                "state %!FxWakeInterruptStates! from "
                "%!FxWakeInterruptStates!",
                m_PkgPnp->GetDevice()->GetHandle(),
                m_PkgPnp->GetDevice()->GetDeviceObject(),
                newState,
                m_CurrentState
                );
 
            //
            // Update the state history array
            //
            m_States.History[IncrementHistoryIndex()] = (UCHAR) newState;
 
            //
            // Move to the new state
            //
            m_CurrentState = (BYTE) newState;
            entry = &m_StateTable[m_CurrentState-WakeInterruptFailed];
 
            //
            // Invoke the state entry function (if present) for the new state
            //
            if (entry->StateFunc != NULL) {
                newState = entry->StateFunc(this);
            }
            else {
                newState = WakeInterruptMax;
            }
        }
    }
 
    return;
}

Referenced by _ProcessEventInner(), and ProcessEvent().

Waking()

FxWakeInterruptStates FxWakeInterruptMachine::Waking ( __in FxWakeInterruptMachine *  This )

staticprivate

Definition at line 408 of file wakeinterruptstatemachine.cpp.

{
    This->m_PkgPnp->PowerPolicyProcessEvent(PwrPolWakeInterruptFired);
 
    return WakeInterruptMax;
}

Member Data Documentation

FxInterrupt

friend FxWakeInterruptMachine::FxInterrupt

private

Definition at line 91 of file fxwakeinterruptstatemachine.hpp.

m_ActiveForWake

BOOLEAN FxWakeInterruptMachine::m_ActiveForWake

protected

Definition at line 172 of file fxwakeinterruptstatemachine.hpp.

Referenced by FxInterrupt::IsActiveForWake(), and FxInterrupt::SetActiveForWake().

m_Claimed

BOOLEAN FxWakeInterruptMachine::m_Claimed

protected

Definition at line 173 of file fxwakeinterruptstatemachine.hpp.

Referenced by FxInterrupt::InvokeWakeInterruptEvtIsr(), and FxInterrupt::WakeInterruptIsr().

m_CompletingD0States

const FxWakeInterruptTargetState FxWakeInterruptMachine::m_CompletingD0States[]

staticprotected

Definition at line 192 of file fxwakeinterruptstatemachine.hpp.

m_CurrentState

BYTE FxWakeInterruptMachine::m_CurrentState

protected

Definition at line 177 of file fxwakeinterruptstatemachine.hpp.

Referenced by FxWakeInterruptMachine(), ProcessEvent(), and ProcessEventInner().

m_D0States

const FxWakeInterruptTargetState FxWakeInterruptMachine::m_D0States

staticprotected

Initial value:

=
{
    {WakeInterruptEventIsr, WakeInterruptInvokingEvtIsrInD0 DEBUGGED_EVENT},
    {WakeInterruptEventLeavingD0, WakeInterruptDx DEBUGGED_EVENT},
    {WakeInterruptEventLeavingD0NotArmedForWake, WakeInterruptDxNotArmedForWake DEBUGGED_EVENT}
}

Definition at line 187 of file fxwakeinterruptstatemachine.hpp.

m_DxNotArmedForWakeStates

const FxWakeInterruptTargetState FxWakeInterruptMachine::m_DxNotArmedForWakeStates

staticprotected

Initial value:

=
{
    { WakeInterruptEventEnteringD0, WakeInterruptCompletingD0 DEBUGGED_EVENT },
    { WakeInterruptEventIsr, WakeInterruptInvokingEvtIsrInDxNotArmedForWake DEBUGGED_EVENT },
    { WakeInterruptEventD0EntryFailed, WakeInterruptFailed DEBUGGED_EVENT }
}

Definition at line 189 of file fxwakeinterruptstatemachine.hpp.

m_DxStates

const FxWakeInterruptTargetState FxWakeInterruptMachine::m_DxStates

staticprotected

Initial value:

=
{
    {WakeInterruptEventEnteringD0, WakeInterruptCompletingD0 DEBUGGED_EVENT},
    {WakeInterruptEventIsr, WakeInterruptWaking DEBUGGED_EVENT},
    {WakeInterruptEventD0EntryFailed, WakeInterruptFailed DEBUGGED_EVENT}
}

Definition at line 188 of file fxwakeinterruptstatemachine.hpp.

m_FailedStates

const FxWakeInterruptTargetState FxWakeInterruptMachine::m_FailedStates

staticprotected

Initial value:

=
{
    {WakeInterruptEventIsr, WakeInterruptFailed DEBUGGED_EVENT}
}

Definition at line 186 of file fxwakeinterruptstatemachine.hpp.

m_Interrupt

FxInterrupt* FxWakeInterruptMachine::m_Interrupt

protected

Definition at line 167 of file fxwakeinterruptstatemachine.hpp.

Referenced by FxWakeInterruptMachine().

m_InvokingEvtIsrPostWakeStates

const FxWakeInterruptTargetState FxWakeInterruptMachine::m_InvokingEvtIsrPostWakeStates[]

staticprotected

Definition at line 191 of file fxwakeinterruptstatemachine.hpp.

m_InvokingIsrInD0

const FxWakeInterruptTargetState FxWakeInterruptMachine::m_InvokingIsrInD0[]

staticprotected

Definition at line 193 of file fxwakeinterruptstatemachine.hpp.

m_IsrEvent

MxEvent FxWakeInterruptMachine::m_IsrEvent

protected

Definition at line 174 of file fxwakeinterruptstatemachine.hpp.

Referenced by FxInterrupt::CreateWakeInterruptMachine(), and FxInterrupt::WakeInterruptIsr().

m_Queue

FxWakeInterruptEvents FxWakeInterruptMachine::m_Queue[FxWakeInterruptEventQueueDepth]

protected

Definition at line 181 of file fxwakeinterruptstatemachine.hpp.

Referenced by FxWakeInterruptMachine(), ProcessEvent(), and ProcessEventInner().

m_States

FxWakeInterruptMachineStateHistory FxWakeInterruptMachine::m_States

protected

Definition at line 182 of file fxwakeinterruptstatemachine.hpp.

Referenced by FxWakeInterruptMachine(), and ProcessEventInner().

m_StateTable

const FxWakeInterruptStateTable FxWakeInterruptMachine::m_StateTable

staticprotected

Definition at line 184 of file fxwakeinterruptstatemachine.hpp.

Referenced by ProcessEventInner().

m_WakingStates

const FxWakeInterruptTargetState FxWakeInterruptMachine::m_WakingStates

staticprotected

Initial value:

=
{
    {WakeInterruptEventEnteringD0, WakeInterruptInvokingEvtIsrPostWake DEBUGGED_EVENT},
    {WakeInterruptEventD0EntryFailed, WakeInterruptFailed DEBUGGED_EVENT}
}

Definition at line 190 of file fxwakeinterruptstatemachine.hpp.

---

The documentation for this class was generated from the following files:

• sdk/lib/drivers/wdf/shared/inc/private/common/fxwakeinterruptstatemachine.hpp
• sdk/lib/drivers/wdf/shared/irphandlers/pnp/wakeinterruptstatemachine.cpp