#include <fxpoweridlestatemachine.hpp>

Inheritance diagram for FxPowerIdleMachine:

Collaboration diagram for FxPowerIdleMachine:

[legend]

Public Member Functions
	FxPowerIdleMachine (VOID)

	~FxPowerIdleMachine (VOID)

_Must_inspect_result_ NTSTATUS	Init (VOID)

VOID	EnableTimer (VOID)

BOOLEAN	DisableTimer (VOID)

VOID	Start (VOID)

VOID	Stop (VOID)

VOID	Reset (VOID)

_Must_inspect_result_ NTSTATUS	IoIncrement (VOID)

_Must_inspect_result_ NTSTATUS	IoIncrementWithFlags (__in FxPowerReferenceFlags Flags, __out_opt PULONG Count=NULL)

VOID	IoDecrement (__in_opt PVOID Tag=NULL, __in_opt LONG Line=0, __in_opt PSTR File=NULL)

BOOLEAN	QueryReturnToIdle (VOID)

VOID	WaitForD0 (VOID)

_Must_inspect_result_ NTSTATUS	PowerReference (__in BOOLEAN WaitForD0, __in_opt PVOID Tag=NULL, __in_opt LONG Line=0, __in_opt PSTR File=NULL)

_Must_inspect_result_ NTSTATUS	PowerReferenceWithFlags (__in FxPowerReferenceFlags Flags)

VOID	ProcessPowerEvent (__in FxPowerIdleEvents Event)

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)

Public Attributes
LARGE_INTEGER	m_PowerTimeout

UCHAR	m_Flags

UCHAR	TimerEnabled: 1

UCHAR	InDx: 1

UCHAR	TimerCanceled: 1

UCHAR	TimerStarted: 1

UCHAR	TimerPowerFailed: 1

UCHAR	IsStarted: 1

UCHAR	IoPresentSent: 1

UCHAR	SendPnpPowerUpEvent: 1

struct {
UCHAR TimerEnabled: 1

UCHAR InDx: 1

UCHAR TimerCanceled: 1

UCHAR TimerStarted: 1

UCHAR TimerPowerFailed: 1

UCHAR IsStarted: 1

UCHAR IoPresentSent: 1

UCHAR SendPnpPowerUpEvent: 1

}	m_FlagsByName

Protected Member Functions
VOID	ProcessEventLocked (__in FxPowerIdleEvents Event)

BOOLEAN	IsTransitioning (VOID)

BOOLEAN	CancelIdleTimer (VOID)

BOOLEAN	InD0Locked (VOID)

VOID	SendD0Notification (VOID)

_Must_inspect_result_ NTSTATUS	PowerReferenceWorker (__in BOOLEAN WaitForD0, __in FxPowerReferenceFlags Flags, __in_opt PVOID Tag=NULL, __in_opt LONG Line=0, __in_opt PSTR File=NULL)

Protected Member Functions inherited from FxStump
	FxStump (VOID)

Static Protected Member Functions
static FxPowerIdleStates	Stopped (__inout FxPowerIdleMachine *This)

static FxPowerIdleStates	Started (__inout FxPowerIdleMachine *This)

static FxPowerIdleStates	StartedPowerUp (__inout FxPowerIdleMachine *This)

static FxPowerIdleStates	StartedPowerFailed (__inout FxPowerIdleMachine *This)

static FxPowerIdleStates	Disabled (__inout FxPowerIdleMachine *This)

static FxPowerIdleStates	CheckIoCount (__inout FxPowerIdleMachine *This)

static FxPowerIdleStates	DecrementIo (__inout FxPowerIdleMachine *This)

static FxPowerIdleStates	StartTimer (__inout FxPowerIdleMachine *This)

static FxPowerIdleStates	TimingOut (__inout FxPowerIdleMachine *This)

static FxPowerIdleStates	TimedOutIoIncrement (__inout FxPowerIdleMachine *This)

static FxPowerIdleStates	TimedOutPowerDown (__inout FxPowerIdleMachine *This)

static FxPowerIdleStates	TimedOutPowerDownFailed (__inout FxPowerIdleMachine *This)

static FxPowerIdleStates	GoingToDx (__inout FxPowerIdleMachine *This)

static FxPowerIdleStates	InDx (__inout FxPowerIdleMachine *This)

static FxPowerIdleStates	InDxIoIncrement (__inout FxPowerIdleMachine *This)

static FxPowerIdleStates	InDxPowerUpFailure (__inout FxPowerIdleMachine *This)

static FxPowerIdleStates	InDxStopped (__inout FxPowerIdleMachine *This)

static FxPowerIdleStates	InDxDisabled (__inout FxPowerIdleMachine *This)

static FxPowerIdleStates	InDxEnabled (__inout FxPowerIdleMachine *This)

static FxPowerIdleStates	PowerUp (__inout FxPowerIdleMachine *This)

static FxPowerIdleStates	PowerUpComplete (__inout FxPowerIdleMachine *This)

static FxPowerIdleStates	TimedOutDisabled (__inout FxPowerIdleMachine *This)

static FxPowerIdleStates	TimedOutEnabled (__inout FxPowerIdleMachine *This)

static FxPowerIdleStates	CancelTimer (__inout FxPowerIdleMachine *This)

static FxPowerIdleStates	TimerExpired (__inout FxPowerIdleMachine *This)

static FxPowerIdleStates	Disabling (__inout FxPowerIdleMachine *This)

static FxPowerIdleStates	DisablingTimerExpired (__inout FxPowerIdleMachine *This)

static FxPowerIdleStates	PowerFailed (__inout FxPowerIdleMachine *This)

Protected Attributes
MxLock	m_Lock

ULONG	m_IoCount

FxTagTracker *	m_TagTracker

MxTimer	m_PowerTimeoutTimer

FxCREvent	m_D0NotificationEvent

union {
UCHAR m_Flags

struct {
UCHAR TimerEnabled: 1

UCHAR InDx: 1

UCHAR TimerCanceled: 1

UCHAR TimerStarted: 1

UCHAR TimerPowerFailed: 1

UCHAR IsStarted: 1

UCHAR IoPresentSent: 1

UCHAR SendPnpPowerUpEvent: 1

} m_FlagsByName

};

UCHAR	m_EventHistoryIndex

UCHAR	m_StateHistoryIndex

FxPowerIdleStates	m_CurrentIdleState

FxPowerIdleEvents	m_EventHistory [FxPowerIdleEventQueueDepth]

FxPowerIdleStates	m_StateHistory [FxPowerIdleEventQueueDepth]

Static Protected Attributes
static MdDeferredRoutineType	_PowerTimeoutDpcRoutine

static const FxPowerIdleTargetState	m_StoppedStates []

static const FxPowerIdleTargetState	m_StartedStates []

static const FxPowerIdleTargetState	m_DisabledStates []

static const FxPowerIdleTargetState	m_BusyStates []

static const FxPowerIdleTargetState	m_TimerRunningStates []

static const FxPowerIdleTargetState	m_TimedOutStates []

static const FxPowerIdleTargetState	m_InDxStates []

static const FxPowerIdleTargetState	m_WaitForTimeoutStates []

static const FxPowerIdleTargetState	m_DisablingWaitForTimeoutStates []

static const FxPowerIdleTargetState	m_PowerFailedWaitForTimeoutStates []

static const FxIdleStateTable	m_StateTable []

static const ULONG	m_IdleTimerTolerableDelayMS = 100

Private Member Functions
VOID	CheckAssumptions (VOID)

Detailed Description

Definition at line 116 of file fxpoweridlestatemachine.hpp.

Constructor & Destructor Documentation

◆ FxPowerIdleMachine()

FxPowerIdleMachine::FxPowerIdleMachine ( VOID )

Definition at line 332 of file poweridlestatemachine.cpp.

{
    //
    // m_Lock and m_PowerTimeoutTimer are now being initialized in Init method
    // since they may fail for UM.
    //
 
    m_PowerTimeout.QuadPart = 0;
    m_CurrentIdleState = FxIdleStopped;
 
    m_EventHistoryIndex = 0;
    m_StateHistoryIndex = 0;
 
    RtlZeroMemory(&m_EventHistory[0], sizeof(m_EventHistory));
    RtlZeroMemory(&m_StateHistory[0], sizeof(m_StateHistory));
 
    m_TagTracker = NULL;
}

◆ ~FxPowerIdleMachine()

FxPowerIdleMachine::~FxPowerIdleMachine ( VOID )

Definition at line 365 of file poweridlestatemachine.cpp.

{
    if (m_TagTracker != NULL) {
        delete m_TagTracker;
        m_TagTracker = NULL;
    }
}

Member Function Documentation

◆ CancelIdleTimer()

BOOLEAN FxPowerIdleMachine::CancelIdleTimer ( VOID )

inlineprotected

Definition at line 234 of file fxpoweridlestatemachine.hpp.

    {
        //
        // If we are canceling the timer, be well sure it is started
        //
        ASSERT(m_Flags & FxPowerIdleTimerStarted);
 
        if (m_PowerTimeoutTimer.Stop()) {
            m_Flags &= ~FxPowerIdleTimerStarted;
            return TRUE;
        }
        else {
            return FALSE;
        }
    }

◆ CancelTimer()

FxPowerIdleStates FxPowerIdleMachine::CancelTimer ( __inout FxPowerIdleMachine * This )

staticprotected

Definition at line 1112 of file poweridlestatemachine.cpp.

{
    if (This->CancelIdleTimer()) {
        return FxIdleCheckIoCount;
    }
    else {
        return FxIdleWaitForTimeout;
    }
}

◆ CheckAssumptions()

VOID FxPowerIdleMachine::CheckAssumptions ( VOID )

private

Definition at line 405 of file poweridlestatemachine.cpp.

{
    WDFCASSERT((sizeof(m_StateTable)/sizeof(m_StateTable[0]))
               ==
               (FxIdleMax - FxIdleStopped));
}

◆ CheckIoCount()

FxPowerIdleStates FxPowerIdleMachine::CheckIoCount ( __inout FxPowerIdleMachine * This )

staticprotected

Definition at line 560 of file poweridlestatemachine.cpp.

{
    This->m_Flags |= FxPowerIdleTimerEnabled;
 
    if (This->m_IoCount == 0) {
        return FxIdleStartTimer;
    }
    else {
        return FxIdleBusy;
    }
}

◆ DecrementIo()

FxPowerIdleStates FxPowerIdleMachine::DecrementIo ( __inout FxPowerIdleMachine * This )

staticprotected

Definition at line 589 of file poweridlestatemachine.cpp.

{
    if (This->m_IoCount == 0) {
        return FxIdleStartTimer;
    }
    else {
        return FxIdleBusy;
    }
}

◆ Disabled()

FxPowerIdleStates FxPowerIdleMachine::Disabled ( __inout FxPowerIdleMachine * This )

staticprotected

Definition at line 537 of file poweridlestatemachine.cpp.

{
    This->m_Flags &= ~FxPowerIdleTimerEnabled;
 
    return FxIdleMax;
}

◆ DisableTimer()

BOOLEAN FxPowerIdleMachine::DisableTimer ( VOID )

Definition at line 1381 of file poweridlestatemachine.cpp.

{
    KIRQL irql;
    BOOLEAN disabledImmediately;
 
    m_Lock.Acquire(&irql);
 
    ProcessEventLocked(PowerIdleEventDisabled);
 
    //
    // If FxPowerIdleTimerStarted is still set after disabling the state machine,
    // then we could not cancel the timer and we must wait for the timer expired
    // event to be posted to this state machine.  This state machine will then
    // post a PwrPolIoPresent event to power policy.
    //
    if (m_Flags & FxPowerIdleTimerStarted) {
        disabledImmediately = FALSE;
    }
    else {
        disabledImmediately = TRUE;
    }
 
    m_Lock.Release(irql);
 
    return disabledImmediately;
}

◆ Disabling()

FxPowerIdleStates FxPowerIdleMachine::Disabling ( __inout FxPowerIdleMachine * This )

staticprotected

Definition at line 1161 of file poweridlestatemachine.cpp.

{
    if (This->CancelIdleTimer()) {
        return FxIdleDisabled;
    }
    else {
        return FxIdleDisablingWaitForTimeout;
    }
}

◆ DisablingTimerExpired()

FxPowerIdleStates FxPowerIdleMachine::DisablingTimerExpired ( __inout FxPowerIdleMachine * This )

staticprotected

Definition at line 1187 of file poweridlestatemachine.cpp.

{
    This->m_Flags &= ~FxPowerIdleTimerStarted;
 
#if (FX_CORE_MODE==FX_CORE_KERNEL_MODE)
    GetPnpPkg(This)->PowerPolicyProcessEvent(PwrPolPowerTimeoutExpired);
#else
    GetPnpPkg(This)->PowerPolicyProcessEvent(
        PwrPolPowerTimeoutExpired,
        TRUE // ProcessEventOnDifferentThread
        );
#endif
 
    return FxIdleDisabled;
}

◆ EnableTimer()

VOID FxPowerIdleMachine::EnableTimer ( VOID )

Definition at line 1356 of file poweridlestatemachine.cpp.

{
    KIRQL irql;
 
    m_Lock.Acquire(&irql);
    ProcessEventLocked(PowerIdleEventEnabled);
    m_Lock.Release(irql);
}

◆ GoingToDx()

FxPowerIdleStates FxPowerIdleMachine::GoingToDx ( __inout FxPowerIdleMachine * This )

staticprotected

Definition at line 785 of file poweridlestatemachine.cpp.

{
    This->m_D0NotificationEvent.Clear();
    return FxIdleInDx;
}

◆ InD0Locked()

BOOLEAN FxPowerIdleMachine::InD0Locked ( VOID )

inlineprotected

Definition at line 253 of file fxpoweridlestatemachine.hpp.

    {
        return m_D0NotificationEvent.ReadState() ? TRUE : FALSE;
    }

Referenced by IoIncrementWithFlags().

◆ InDx()

static FxPowerIdleStates FxPowerIdleMachine::InDx ( __inout FxPowerIdleMachine * This )

staticprotected

◆ InDxDisabled()

FxPowerIdleStates FxPowerIdleMachine::InDxDisabled ( __inout FxPowerIdleMachine * This )

staticprotected

Definition at line 944 of file poweridlestatemachine.cpp.

{
    //
    // Idle timer is being disabled while in Dx.  Remain in Dx.
    //
    This->m_Flags &= ~FxPowerIdleTimerEnabled;
 
    return FxIdleInDx;
}

◆ InDxEnabled()

FxPowerIdleStates FxPowerIdleMachine::InDxEnabled ( __inout FxPowerIdleMachine * This )

staticprotected

Definition at line 970 of file poweridlestatemachine.cpp.

{
    //
    // Idle timer is being enabled while in Dx.  Remain in Dx.
    //
    This->m_Flags |= FxPowerIdleTimerEnabled;
 
    return FxIdleInDx;
}

◆ InDxIoIncrement()

FxPowerIdleStates FxPowerIdleMachine::InDxIoIncrement ( __inout FxPowerIdleMachine * This )

staticprotected

Definition at line 832 of file poweridlestatemachine.cpp.

{
    FxPkgPnp* pPkgPnp;
 
    pPkgPnp = GetPnpPkg(This);
 
    if (This->m_Flags & FxPowerIdleIoPresentSent) {
        DoTraceLevelMessage(
            pPkgPnp->GetDriverGlobals(), TRACE_LEVEL_INFORMATION, TRACINGPNP,
            "WDFDEVICE %p idle (in Dx) not sending io present event (already sent)",
            pPkgPnp->GetDevice()->GetHandle());
    }
    else {
#if (FX_CORE_MODE==FX_CORE_KERNEL_MODE)
        pPkgPnp->PowerPolicyProcessEvent(PwrPolIoPresent);
#else
        pPkgPnp->PowerPolicyProcessEvent(
            PwrPolIoPresent,
            TRUE // ProcessEventOnDifferentThread
            );
#endif
        This->m_Flags |= FxPowerIdleIoPresentSent;
    }
 
    return FxIdleInDx;
}

◆ InDxPowerUpFailure()

FxPowerIdleStates FxPowerIdleMachine::InDxPowerUpFailure ( __inout FxPowerIdleMachine * This )

staticprotected

Definition at line 875 of file poweridlestatemachine.cpp.

{
    //
    // FxPowerIdleInDx - We are no longer in Dx
    // FxPowerIdleIoPresentSent = We can send the io present event again
    //
    This->m_Flags &= ~(FxPowerIdleInDx | FxPowerIdleIoPresentSent);
 
    return FxIdlePowerFailed;
}

◆ InDxStopped()

FxPowerIdleStates FxPowerIdleMachine::InDxStopped ( __inout FxPowerIdleMachine * This )

staticprotected

Definition at line 902 of file poweridlestatemachine.cpp.

{
    //
    // When the machine is in the stopped state, the notification event is in
    // the signaled state.
    //
    This->SendD0Notification();
 
    //
    // We are not longer idle since we are not in the Dx state anymore
    //
    This->m_Flags &= ~FxPowerIdleInDx;
 
    //
    // We are no longer enabled since we are stopped from the Dx state
    //
    This->m_Flags &= ~FxPowerIdleTimerEnabled;
 
    //
    // We can send the io present event again
    //
    This->m_Flags &= ~FxPowerIdleIoPresentSent;
 
    return FxIdleStopped;
}

◆ Init()

_Must_inspect_result_ NTSTATUS FxPowerIdleMachine::Init ( VOID )

Definition at line 377 of file poweridlestatemachine.cpp.

{
    NTSTATUS status;
 
    //
    // For KM, event initialize always succeeds. For UM, it might fail.
    //
    status = m_D0NotificationEvent.Initialize(NotificationEvent, TRUE);
    if (!NT_SUCCESS(status)) {
        return status;
    }
 
    //
    // For KM, timer initialize always succeeds. For UM, it might fail.
    //
    status = m_PowerTimeoutTimer.Initialize(this, _PowerTimeoutDpcRoutine, 0);
    if (!NT_SUCCESS(status)) {
        return status;
    }
 
    Reset();
 
    return STATUS_SUCCESS;
}

Referenced by FxPowerPolicyOwnerSettings::Init().

◆ IoDecrement()

VOID FxPowerIdleMachine::IoDecrement	(	__in_opt PVOID	Tag = `NULL`,
		__in_opt LONG	Line = `0`,
		__in_opt PSTR	File = `NULL`
	)

Definition at line 1735 of file poweridlestatemachine.cpp.

{
    KIRQL irql;
    FxPkgPnp* pPkgPnp;
    PFX_DRIVER_GLOBALS pFxDriverGlobals;
    ULONG count;
 
    pPkgPnp = GetPnpPkg(this);
    pFxDriverGlobals = pPkgPnp->GetDriverGlobals();
 
    m_Lock.Acquire(&irql);
 
    if (m_IoCount == 0) {
        //
        // We can get here for the following reasons:
        // 1. Driver called WdfDevicveStopIdle/WdfDeviceResumeIdle in a mismatched
        //    manner. This is a driver bug.
        // 2. Framework did power deref without a corresponding power ref.
        //    This would be a framework bug.
        //
        // We will break into debugger if verifier is turned on. This will allow
        // developers to catch this problem during develeopment.
        // We limit this break to version 1.11+ because otherwise older drivers
        // may hit this, and if they cannot be fixed for some reason, then
        // verifier would need to be turned off to avoid the break which is not
        // desirable.
        //
        DoTraceLevelMessage(
            pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGPNP,
            "WDFDEVICE 0x%p !devobj 0x%p The device is being power-dereferenced"
            " without a matching power-reference. This could occur if driver"
            " incorrectly calls WdfDeviceResumeIdle without a matching call to"
            " WdfDeviceStopIdle.",
            pPkgPnp->GetDevice()->GetHandle(),
            pPkgPnp->GetDevice()->GetDeviceObject());
 
        if (pFxDriverGlobals->IsVerificationEnabled(1, 11, OkForDownLevel)) {
           FxVerifierDbgBreakPoint(pFxDriverGlobals);
        }
    }
 
    ASSERT(m_IoCount > 0);
    count = --m_IoCount;
    ProcessEventLocked(PowerIdleEventIoDecrement);
    m_Lock.Release(irql);
 
    if (m_TagTracker != NULL) {
        m_TagTracker->UpdateTagHistory(Tag, Line, File, TagRelease, count);
    }
}

Referenced by FxPkgPnp::PowerDereference().

◆ IoIncrement()

_Must_inspect_result_ NTSTATUS FxPowerIdleMachine::IoIncrement ( VOID )

Definition at line 1639 of file poweridlestatemachine.cpp.

{
    return IoIncrementWithFlags(FxPowerReferenceDefault);
}

◆ IoIncrementWithFlags()

_Must_inspect_result_ NTSTATUS FxPowerIdleMachine::IoIncrementWithFlags	(	__in FxPowerReferenceFlags	Flags,
		__out_opt PULONG	Count = `NULL`
	)

Definition at line 1664 of file poweridlestatemachine.cpp.

{
    NTSTATUS status;
    KIRQL irql;
 
    m_Lock.Acquire(&irql);
 
    if (m_Flags & FxPowerIdlePowerFailed) {
        //
        // fail without incrementing the count because we are in an
        // invalid power state
        //
        status = STATUS_POWER_STATE_INVALID;
        COVERAGE_TRAP();
    }
    else if ((m_Flags & FxPowerIdleIsStarted) == 0x0) {
        //
        // The state machine is not yet in a started state
        //
        status = STATUS_POWER_STATE_INVALID;
    }
    else {
        m_IoCount++;
        if (Count != NULL) {
            *Count = m_IoCount;
        }
 
        ProcessEventLocked(PowerIdleEventIoIncrement);
 
        if (InD0Locked()) {
            status = STATUS_SUCCESS;
        }
        else {
            status = STATUS_PENDING;
            if (Flags & FxPowerReferenceSendPnpPowerUpEvent) {
                m_Flags |= FxPowerIdleSendPnpPowerUpEvent;
            }
        }
    }
    m_Lock.Release(irql);
 
    return status;
}

Referenced by IoIncrement(), and PowerReferenceWorker().

◆ IsTransitioning()

BOOLEAN FxPowerIdleMachine::IsTransitioning ( VOID )

inlineprotected

Definition at line 226 of file fxpoweridlestatemachine.hpp.

    {
        return m_D0NotificationEvent.ReadState() ? FALSE : TRUE;
    }

◆ PowerFailed()

FxPowerIdleStates FxPowerIdleMachine::PowerFailed ( __inout FxPowerIdleMachine * This )

staticprotected

Definition at line 1219 of file poweridlestatemachine.cpp.

{
    //
    // By this time, the timer should be stopped
    //
    ASSERT((This->m_Flags & FxPowerIdleTimerStarted) == 0);
 
    This->m_Flags |= FxPowerIdlePowerFailed;
 
    //
    // We are no longer enabled to time out since we are in a failed state
    //
    This->m_Flags &= ~FxPowerIdleTimerEnabled;
 
    //
    // Wake up any waiters and indicate failure to them.
    //
    This->SendD0Notification();
 
    return FxIdleDisabled;
}

◆ PowerReference()

_Must_inspect_result_ NTSTATUS FxPowerIdleMachine::PowerReference	(	__in BOOLEAN	WaitForD0,
		__in_opt PVOID	Tag = `NULL`,
		__in_opt LONG	Line = `0`,
		__in_opt PSTR	File = `NULL`
	)

inline

Definition at line 193 of file fxpoweridlestatemachine.hpp.

    {
        return PowerReferenceWorker(WaitForD0, FxPowerReferenceDefault, Tag, Line, File);
    }

Referenced by FxPkgPnp::PowerReference().

◆ PowerReferenceWithFlags()

_Must_inspect_result_ NTSTATUS FxPowerIdleMachine::PowerReferenceWithFlags ( __in FxPowerReferenceFlags Flags )

inline

Definition at line 205 of file fxpoweridlestatemachine.hpp.

    {
        return PowerReferenceWorker(FALSE, // WaitForD0
                                    Flags);
    }

◆ PowerReferenceWorker()

_Must_inspect_result_ NTSTATUS FxPowerIdleMachine::PowerReferenceWorker	(	__in BOOLEAN	WaitForD0,
		__in FxPowerReferenceFlags	Flags,
		__in_opt PVOID	Tag = `NULL`,
		__in_opt LONG	Line = `0`,
		__in_opt PSTR	File = `NULL`
	)

protected

Definition at line 1480 of file poweridlestatemachine.cpp.

{
    NTSTATUS status;
    KIRQL irql;
    ULONG count = 0;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
    //
    // Poke the state machine
    //
    status = IoIncrementWithFlags(Flags, &count);
 
    //
    // STATUS_PENDING indicates a Dx to D0 transition is occurring right now
    //
    if (status == STATUS_PENDING) {
        if (WaitForD0) {
            FxPkgPnp* pPkgPnp;
 
            ASSERT(Mx::MxGetCurrentIrql() <= APC_LEVEL);
 
            //
            // With the current usage, if WaitForD0 is TRUE, then the only
            // acceptable flag is FxPowerReferenceDefault.
            //
            // If the usage changes in the future such that it is acceptable to
            // have WaitForD0 set to TRUE and some flag(s) set, then the ASSERT
            // below should be updated accordingly (or removed altogether).
            //
            ASSERT(FxPowerReferenceDefault == Flags);
 
            pPkgPnp = GetPnpPkg(this);
 
            DoTraceLevelMessage(
                pPkgPnp->GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGPNP,
                "WDFDEVICE %p in thread %p waiting synchronously for Dx to D0 "
                "transition",
                pPkgPnp->GetDevice()->GetHandle(),
                Mx::MxGetCurrentThread());
 
            //
            // Returns success always
            //
            (void) FxPowerIdleMachine::WaitForD0();
 
            m_Lock.Acquire(&irql);
 
            //
            // If WaitForD0 is TRUE, then the FxPowerIdleSendPnpPowerUpEvent
            // flag can't be set. That flag is only used when the PnP state
            // machine waits asynchronously for the device to power up during
            // query-remove.
            //
            ASSERT(0 == (m_Flags & FxPowerIdleSendPnpPowerUpEvent));
 
            if ((m_Flags & FxPowerIdlePowerFailed) != 0x0 ||
                (m_Flags & FxPowerIdleIsStarted) == 0x0) {
 
                //
                // Event was set because a power up or down failure occurred
                //
                status = STATUS_POWER_STATE_INVALID;
 
                if (m_Flags & FxPowerIdlePowerFailed) {
                    DoTraceLevelMessage(
                        pPkgPnp->GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGPNP,
                        "WDFDEVICE %p waiting for D0 in thread %p failed because of "
                        "power failure, %!STATUS!",
                        pPkgPnp->GetDevice()->GetHandle(),
                        Mx::MxGetCurrentThread(),
                        status);
                }
                else {
                    COVERAGE_TRAP();
                    DoTraceLevelMessage(
                        pPkgPnp->GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGPNP,
                        "WDFDEVICE %p waiting for D0 in thread %p failed because of "
                        "invalid state , %!STATUS!",
                        pPkgPnp->GetDevice()->GetHandle(),
                        Mx::MxGetCurrentThread(), status);
                }
 
                //
                // Decrement the io count that was taken above
                //
                ASSERT(m_IoCount > 0);
                m_IoCount--;
                ProcessEventLocked(PowerIdleEventIoDecrement);
            }
            else {
                //
                // Successfully returned to D0
                //
                status = STATUS_SUCCESS;
            }
            m_Lock.Release(irql);
        }
    }
 
    if (m_TagTracker != NULL) {
        //
        // Only track the reference if the call was successful
        // and the counter was actually incremented.
        //
        if (status == STATUS_SUCCESS || status == STATUS_PENDING) {
            m_TagTracker->UpdateTagHistory(Tag, Line, File, TagAddRef, count);
        }
    }
 
    return status;
}

Referenced by PowerReference(), and PowerReferenceWithFlags().

◆ PowerUp()

FxPowerIdleStates FxPowerIdleMachine::PowerUp ( __inout FxPowerIdleMachine * This )

staticprotected

Definition at line 996 of file poweridlestatemachine.cpp.

{
    //
    // FxPowerIdleInDx - we are not longer idle since we are not in the Dx state
    //                   anymore
    // FxPowerIdleIoPresentSent - We can send the io present event again
    //
    This->m_Flags &= ~(FxPowerIdleInDx | FxPowerIdleIoPresentSent);
 
    This->SendD0Notification();
 
    return FxIdlePowerUpComplete;
}

◆ PowerUpComplete()

FxPowerIdleStates FxPowerIdleMachine::PowerUpComplete ( __inout FxPowerIdleMachine * This )

staticprotected

Definition at line 1026 of file poweridlestatemachine.cpp.

{
    if (This->m_Flags & FxPowerIdleTimerEnabled) {
        if (This->m_Flags & FxPowerIdleTimerStarted) {
            COVERAGE_TRAP();
            return FxIdleTimerRunning;
        }
        else {
            return FxIdleCheckIoCount;
        }
    }
    else {
        //
        // Not enabled, better not have a timer running
        //
        ASSERT((This->m_Flags & FxPowerIdleTimerStarted) == 0);
 
        return FxIdleDisabled;
    }
}

◆ ProcessEventLocked()

VOID FxPowerIdleMachine::ProcessEventLocked ( __in FxPowerIdleEvents Event )

protected

Definition at line 1923 of file poweridlestatemachine.cpp.

{
    const FxIdleStateTable* entry;
    FxPowerIdleStates newState;
    FxPkgPnp* pPkgPnp;
 
    pPkgPnp = GetPnpPkg(this);
 
    m_EventHistory[m_EventHistoryIndex] = Event;
    m_EventHistoryIndex = (m_EventHistoryIndex + 1) %
                          (sizeof(m_EventHistory)/sizeof(m_EventHistory[0]));
 
    entry = &m_StateTable[m_CurrentIdleState-FxIdleStopped];
    newState = FxIdleMax;
 
    for (ULONG i = 0; i < entry->TargetStatesCount; i++) {
        if (entry->TargetStates[i].PowerIdleEvent == Event) {
            DO_EVENT_TRAP(&entry->TargetStates[i]);
            newState = entry->TargetStates[i].PowerIdleState;
            break;
        }
    }
 
    if (newState == FxIdleMax) {
        switch (Event) {
        case PowerIdleEventIoIncrement:
        case PowerIdleEventIoDecrement:
            //
            // We always can handle io increment, io decrement, and query return
            // to idle from any state...
            //
            break;
 
        case PowerIdleEventEnabled:
            if (m_Flags & FxPowerIdleTimerEnabled) {
                //
                // Getting an enable event while enabled is OK
                //
                break;
            }
            //  ||   ||  Fall    ||  ||
            //  \/   \/  through \/  \/
 
        default:
            //
            // ...but we should not be dropping any other events from this state.
            //
 
            //
            DoTraceLevelMessage(
                pPkgPnp->GetDriverGlobals(), TRACE_LEVEL_INFORMATION, TRACINGPNP,
                "WDFDEVICE 0x%p !devobj 0x%p power idle state %!FxPowerIdleStates!"
                " dropping event %!FxPowerIdleEvents!",
                pPkgPnp->GetDevice()->GetHandle(),
                pPkgPnp->GetDevice()->GetDeviceObject(),
                m_CurrentIdleState, Event);
 
            COVERAGE_TRAP();
        }
    }
 
    while (newState != FxIdleMax) {
 
        DoTraceLevelMessage(
            pPkgPnp->GetDriverGlobals(), TRACE_LEVEL_INFORMATION, TRACINGPNPPOWERSTATES,
            "WDFDEVICE 0x%p !devobj 0x%p entering power idle state "
            "%!FxPowerIdleStates! from %!FxPowerIdleStates!",
            pPkgPnp->GetDevice()->GetHandle(),
            pPkgPnp->GetDevice()->GetDeviceObject(),
            newState, m_CurrentIdleState);
 
        m_StateHistory[m_StateHistoryIndex] = newState;
        m_StateHistoryIndex = (m_StateHistoryIndex + 1) %
                              (sizeof(m_StateHistory)/sizeof(m_StateHistory[0]));
 
        m_CurrentIdleState = newState;
        entry = &m_StateTable[m_CurrentIdleState-FxIdleStopped];
 
        if (entry->StateFunc != NULL) {
            newState = entry->StateFunc(this);
        }
        else {
            newState = FxIdleMax;
        }
    }
}

Referenced by __drv_maxIRQL(), DisableTimer(), EnableTimer(), IoDecrement(), IoIncrementWithFlags(), PowerReferenceWorker(), ProcessPowerEvent(), Start(), and Stop().

◆ ProcessPowerEvent()

VOID FxPowerIdleMachine::ProcessPowerEvent ( __in FxPowerIdleEvents Event )

Definition at line 1891 of file poweridlestatemachine.cpp.

{
    KIRQL irql;
 
    //
    // All other event types have specialized public functions
    //
    ASSERT(Event == PowerIdleEventPowerUpComplete ||
           Event == PowerIdleEventPowerUpFailed ||
           Event == PowerIdleEventPowerDown ||
           Event == PowerIdleEventPowerDownFailed);
 
    m_Lock.Acquire(&irql);
    ProcessEventLocked(Event);
    m_Lock.Release(irql);
}

Referenced by FxPkgPnp::PowerSendIdlePowerEvent(), FxPkgPnp::PowerSendPowerDownEvents(), and FxPkgPnp::PowerSendPowerDownFailureEvent().

◆ QueryReturnToIdle()

BOOLEAN FxPowerIdleMachine::QueryReturnToIdle ( VOID )

Definition at line 1805 of file poweridlestatemachine.cpp.

{
    KIRQL irql;
    BOOLEAN result;
 
    //
    // To return to idle, the following must be true
    // 1)  the device must be in Dx (FxPowerIdleInDx)
    // 2)  the timer must *NOT*  be running
    // 3)  an IO count of zero
    //
    m_Lock.Acquire(&irql);
 
    //     1
    if ((m_Flags & FxPowerIdleInDx) == FxPowerIdleInDx &&
        // 2                                        3
        (m_Flags & FxPowerIdleTimerStarted) == 0 && m_IoCount == 0x0) {
        result = TRUE;
    }
    else {
        result = FALSE;
    }
 
    //
    // If the caller is querying about returning to idle, then they have
    // processed the io present event that we previously sent.  We must clear
    // the flag, otherwise the following can occur
    // 1)  new io arrives, send the io present message
    // 2)  return to idle (io count goes to zero)
    // 3)  get queried to return to idle, return TRUE
    // 4)  new io arrives, we do not send the new io present message because the
    //     FxPowerIdleIoPresentSent flag is set.
    //
    m_Flags &= ~FxPowerIdleIoPresentSent;
 
    m_Lock.Release(irql);
 
    return result;
}

◆ Reset()

VOID FxPowerIdleMachine::Reset ( VOID )

Definition at line 1313 of file poweridlestatemachine.cpp.

{
    FxPkgPnp* pPkgPnp;
    PFX_DRIVER_GLOBALS pFxDriverGlobals;
 
    ASSERT(m_CurrentIdleState == FxIdleStopped);
 
    m_IoCount = 0;
    m_Flags = 0x0;
 
    pPkgPnp = GetPnpPkg(this);
    pFxDriverGlobals = pPkgPnp->GetDriverGlobals();
 
    if (pFxDriverGlobals->DebugExtension != NULL &&
        pFxDriverGlobals->DebugExtension->TrackPower != FxTrackPowerNone) {
        //
        // Ignore potential failure, power ref tracking is not an essential feature.
        //
        (void)FxTagTracker::CreateAndInitialize(&m_TagTracker,
                                                pFxDriverGlobals,
                                                FxTagTrackerTypePower,
                                                pFxDriverGlobals->DebugExtension->TrackPower == FxTrackPowerRefsAndStack,
                                                pPkgPnp->GetDevice());
    }
 
    SendD0Notification();
}

Referenced by Init().

◆ SendD0Notification()

VOID FxPowerIdleMachine::SendD0Notification ( VOID )

protected

Definition at line 1863 of file poweridlestatemachine.cpp.

{
    m_D0NotificationEvent.Set();
 
    if (m_Flags & FxPowerIdleSendPnpPowerUpEvent) {
 
        m_Flags &= ~FxPowerIdleSendPnpPowerUpEvent;
 
        //
        // Send an event to the Pnp state machine indicating that the device is
        // now in D0.
        //
#if (FX_CORE_MODE==FX_CORE_KERNEL_MODE)
        GetPnpPkg(this)->PnpProcessEvent(PnpEventDeviceInD0);
#else
        GetPnpPkg(this)->PnpProcessEvent(
            PnpEventDeviceInD0,
            TRUE // ProcessEventOnDifferentThread
            );
#endif
 
    }
    return;
}

Referenced by Reset().

◆ Start()

VOID FxPowerIdleMachine::Start ( VOID )

Definition at line 1429 of file poweridlestatemachine.cpp.

{
    KIRQL irql;
    m_Lock.Acquire(&irql);
    ProcessEventLocked(PowerIdleEventStart);
    m_Lock.Release(irql);
}

◆ Started()

FxPowerIdleStates FxPowerIdleMachine::Started ( __inout FxPowerIdleMachine * This )

staticprotected

Definition at line 453 of file poweridlestatemachine.cpp.

{
    This->m_Flags |= FxPowerIdleIsStarted;
 
    //
    // We are in the started state, but we are not powered up.
    //
    This->m_D0NotificationEvent.Clear();
 
    return FxIdleMax;
}

◆ StartedPowerFailed()

FxPowerIdleStates FxPowerIdleMachine::StartedPowerFailed ( __inout FxPowerIdleMachine * This )

staticprotected

Definition at line 506 of file poweridlestatemachine.cpp.

{
    //
    // Failed to initially power up
    //
    This->m_Flags |= FxPowerIdlePowerFailed;
 
    //
    // We assume in the started state that the event is set
    //
    ASSERT(This->m_D0NotificationEvent.ReadState() == 0);
 
    return FxIdleStarted;
}

◆ StartedPowerUp()

FxPowerIdleStates FxPowerIdleMachine::StartedPowerUp ( __inout FxPowerIdleMachine * This )

staticprotected

Definition at line 480 of file poweridlestatemachine.cpp.

{
    //
    // Moving from the started state to the powered on state
    //
    This->SendD0Notification();
 
    return FxIdleDisabled;
}

◆ StartTimer()

FxPowerIdleStates FxPowerIdleMachine::StartTimer ( __inout FxPowerIdleMachine * This )

staticprotected

Definition at line 614 of file poweridlestatemachine.cpp.

{
    ASSERT((This->m_Flags & FxPowerIdleTimerEnabled) && This->m_IoCount == 0);
 
    This->m_Flags |= FxPowerIdleTimerStarted;
    This->m_PowerTimeoutTimer.Start(This->m_PowerTimeout,
                                    m_IdleTimerTolerableDelayMS);
 
    return FxIdleTimerRunning;
}

◆ Stop()

VOID FxPowerIdleMachine::Stop ( VOID )

Definition at line 1454 of file poweridlestatemachine.cpp.

{
    KIRQL irql;
 
    m_Lock.Acquire(&irql);
    ProcessEventLocked(PowerIdleEventStop);
    m_Lock.Release(irql);
}

◆ Stopped()

FxPowerIdleStates FxPowerIdleMachine::Stopped ( __inout FxPowerIdleMachine * This )

staticprotected

Definition at line 431 of file poweridlestatemachine.cpp.

{
    This->m_Flags &= ~FxPowerIdleIsStarted;
 
    return FxIdleMax;
}

◆ TimedOutDisabled()

FxPowerIdleStates FxPowerIdleMachine::TimedOutDisabled ( __inout FxPowerIdleMachine * This )

staticprotected

Definition at line 1063 of file poweridlestatemachine.cpp.

{
    //
    // Notify any waiters that we are now in D0
    //
    This->SendD0Notification();
 
    //
    // We can send the io present event again
    //
    This->m_Flags &= ~FxPowerIdleIoPresentSent;
 
    return FxIdleDisabled;
}

◆ TimedOutEnabled()

FxPowerIdleStates FxPowerIdleMachine::TimedOutEnabled ( __inout FxPowerIdleMachine * This )

staticprotected

Definition at line 1094 of file poweridlestatemachine.cpp.

{
    //
    // Notify any waiters that we are now in D0
    //
    This->SendD0Notification();
 
    //
    // We can send the io present event again
    //
    This->m_Flags &= ~FxPowerIdleIoPresentSent;
 
    return FxIdleCheckIoCount;
}

◆ TimedOutIoIncrement()

FxPowerIdleStates FxPowerIdleMachine::TimedOutIoIncrement ( __inout FxPowerIdleMachine * This )

staticprotected

Definition at line 685 of file poweridlestatemachine.cpp.

{
    FxPkgPnp* pPkgPnp;
 
    pPkgPnp = GetPnpPkg(This);
 
    if (This->m_Flags & FxPowerIdleIoPresentSent) {
        DoTraceLevelMessage(
            pPkgPnp->GetDriverGlobals(), TRACE_LEVEL_INFORMATION, TRACINGPNP,
            "WDFDEVICE %p idle (in D0) not sending io present event (already sent)",
            pPkgPnp->GetDevice()->GetHandle());
    }
    else {
#if (FX_CORE_MODE==FX_CORE_KERNEL_MODE)
        pPkgPnp->PowerPolicyProcessEvent(PwrPolIoPresent);
#else
        pPkgPnp->PowerPolicyProcessEvent(
            PwrPolIoPresent,
            TRUE // ProcessEventOnDifferentThread
            );
#endif
 
        This->m_Flags |= FxPowerIdleIoPresentSent;
    }
 
    return FxIdleTimedOut;
}

◆ TimedOutPowerDown()

FxPowerIdleStates FxPowerIdleMachine::TimedOutPowerDown ( __inout FxPowerIdleMachine * This )

staticprotected

Definition at line 731 of file poweridlestatemachine.cpp.

{
    //
    // We can send the io present event again
    //
    This->m_Flags &= ~FxPowerIdleIoPresentSent;
 
    return FxIdleGoingToDx;
}

◆ TimedOutPowerDownFailed()

FxPowerIdleStates FxPowerIdleMachine::TimedOutPowerDownFailed ( __inout FxPowerIdleMachine * This )

staticprotected

Definition at line 758 of file poweridlestatemachine.cpp.

{
    //
    // We can send the io present event again
    //
    This->m_Flags &= ~FxPowerIdleIoPresentSent;
 
    return FxIdlePowerFailed;
}

◆ TimerExpired()

FxPowerIdleStates FxPowerIdleMachine::TimerExpired ( __inout FxPowerIdleMachine * This )

staticprotected

Definition at line 1138 of file poweridlestatemachine.cpp.

{
    This->m_Flags &= ~FxPowerIdleTimerStarted;
 
    return FxIdleCheckIoCount;
}

◆ TimingOut()

FxPowerIdleStates FxPowerIdleMachine::TimingOut ( __inout FxPowerIdleMachine * This )

staticprotected

Definition at line 642 of file poweridlestatemachine.cpp.

{
#if (FX_CORE_MODE==FX_CORE_KERNEL_MODE)
    GetPnpPkg(This)->PowerPolicyProcessEvent(PwrPolPowerTimeoutExpired);
#else
    GetPnpPkg(This)->PowerPolicyProcessEvent(
        PwrPolPowerTimeoutExpired,
        TRUE // ProcessEventOnDifferentThread
        );
#endif
 
    //
    // Timer is no longer running.  Used when we disable the state machine and
    // need to know the timer's running state.
    //
    //
    This->m_Flags &= ~FxPowerIdleTimerStarted;
 
    //
    // While the device is still powered up, we are no longer in D0 in terms of
    // PowerReference returning immmediately if TRUE is specified to that call.
    //
    This->m_D0NotificationEvent.Clear();
 
    return FxIdleTimedOut;
}

◆ WaitForD0()

VOID FxPowerIdleMachine::WaitForD0 ( VOID )

inline

Definition at line 184 of file fxpoweridlestatemachine.hpp.

    {
        m_D0NotificationEvent.EnterCRAndWaitAndLeave();
    }

Referenced by PowerReferenceWorker().

Member Data Documentation

◆

union { ... } FxPowerIdleMachine::@4814

◆ _PowerTimeoutDpcRoutine

MdDeferredRoutineType FxPowerIdleMachine::_PowerTimeoutDpcRoutine

staticprotected

Definition at line 277 of file fxpoweridlestatemachine.hpp.

Referenced by Init().

◆ InDx

FxPowerIdleStates FxPowerIdleMachine::InDx

Definition at line 494 of file fxpoweridlestatemachine.hpp.

◆ IoPresentSent

UCHAR FxPowerIdleMachine::IoPresentSent

Definition at line 499 of file fxpoweridlestatemachine.hpp.

◆ IsStarted

UCHAR FxPowerIdleMachine::IsStarted

Definition at line 498 of file fxpoweridlestatemachine.hpp.

◆ m_BusyStates

const FxPowerIdleTargetState FxPowerIdleMachine::m_BusyStates

staticprotected

Initial value:

=
{
    { PowerIdleEventIoDecrement, FxIdleDecrementIo DEBUGGED_EVENT },
    { PowerIdleEventDisabled, FxIdleDisabled DEBUGGED_EVENT },
    { PowerIdleEventPowerDown, FxIdleGoingToDx TRAP_ON_EVENT },
    { PowerIdleEventPowerDownFailed, FxIdlePowerFailed TRAP_ON_EVENT },
}

Definition at line 531 of file fxpoweridlestatemachine.hpp.

◆ m_CurrentIdleState

FxPowerIdleStates FxPowerIdleMachine::m_CurrentIdleState

protected

Definition at line 516 of file fxpoweridlestatemachine.hpp.

Referenced by FxPowerIdleMachine(), ProcessEventLocked(), and Reset().

◆ m_D0NotificationEvent

FxCREvent FxPowerIdleMachine::m_D0NotificationEvent

protected

Definition at line 480 of file fxpoweridlestatemachine.hpp.

Referenced by InD0Locked(), Init(), IsTransitioning(), SendD0Notification(), and WaitForD0().

◆ m_DisabledStates

const FxPowerIdleTargetState FxPowerIdleMachine::m_DisabledStates

staticprotected

Initial value:

=
{
    { PowerIdleEventEnabled, FxIdleCheckIoCount DEBUGGED_EVENT },
    { PowerIdleEventDisabled, FxIdleDisabled DEBUGGED_EVENT },
    { PowerIdleEventPowerDown, FxIdleGoingToDx DEBUGGED_EVENT },
    { PowerIdleEventPowerDownFailed, FxIdlePowerFailed DEBUGGED_EVENT },
    { PowerIdleEventPowerUpFailed, FxIdlePowerFailed DEBUGGED_EVENT },
    { PowerIdleEventStop, FxIdleStopped DEBUGGED_EVENT },
}

Definition at line 530 of file fxpoweridlestatemachine.hpp.

◆ m_DisablingWaitForTimeoutStates

const FxPowerIdleTargetState FxPowerIdleMachine::m_DisablingWaitForTimeoutStates

staticprotected

Initial value:

=
{
    { PowerIdleEventTimerExpired, FxIdleDisablingTimerExpired DEBUGGED_EVENT },
}

Definition at line 536 of file fxpoweridlestatemachine.hpp.

◆ m_EventHistory

FxPowerIdleEvents FxPowerIdleMachine::m_EventHistory[FxPowerIdleEventQueueDepth]

protected

Definition at line 521 of file fxpoweridlestatemachine.hpp.

Referenced by FxPowerIdleMachine(), and ProcessEventLocked().

◆ m_EventHistoryIndex

UCHAR FxPowerIdleMachine::m_EventHistoryIndex

protected

Definition at line 507 of file fxpoweridlestatemachine.hpp.

Referenced by FxPowerIdleMachine(), and ProcessEventLocked().

◆ m_Flags

UCHAR FxPowerIdleMachine::m_Flags

Definition at line 486 of file fxpoweridlestatemachine.hpp.

Referenced by CancelIdleTimer(), DisableTimer(), IoIncrementWithFlags(), PowerReferenceWorker(), ProcessEventLocked(), QueryReturnToIdle(), Reset(), and SendD0Notification().

◆

struct { ... } FxPowerIdleMachine::m_FlagsByName

◆ m_IdleTimerTolerableDelayMS

const ULONG FxPowerIdleMachine::m_IdleTimerTolerableDelayMS = 100

staticprotected

Definition at line 547 of file fxpoweridlestatemachine.hpp.

Referenced by StartTimer().

◆ m_InDxStates

const FxPowerIdleTargetState FxPowerIdleMachine::m_InDxStates

staticprotected

Initial value:

=
{
    { PowerIdleEventPowerUpComplete, FxIdlePowerUp DEBUGGED_EVENT },
    { PowerIdleEventPowerUpFailed, FxIdleInDxPowerUpFailure DEBUGGED_EVENT },
    { PowerIdleEventPowerDownFailed, FxIdleInDxPowerUpFailure TRAP_ON_EVENT },
    { PowerIdleEventStop, FxIdleInDxStopped DEBUGGED_EVENT },
    { PowerIdleEventDisabled, FxIdleInDxDisabled DEBUGGED_EVENT },
    { PowerIdleEventIoIncrement, FxIdleInDxIoIncrement DEBUGGED_EVENT },
    { PowerIdleEventIoDecrement, FxIdleInDx DEBUGGED_EVENT },
    { PowerIdleEventPowerDown, FxIdleInDx DEBUGGED_EVENT },
    { PowerIdleEventEnabled, FxIdleInDxEnabled DEBUGGED_EVENT },
}

Definition at line 534 of file fxpoweridlestatemachine.hpp.

◆ m_IoCount

ULONG FxPowerIdleMachine::m_IoCount

protected

Definition at line 465 of file fxpoweridlestatemachine.hpp.

Referenced by IoDecrement(), IoIncrementWithFlags(), PowerReferenceWorker(), QueryReturnToIdle(), and Reset().

◆ m_Lock

MxLock FxPowerIdleMachine::m_Lock

protected

Definition at line 460 of file fxpoweridlestatemachine.hpp.

Referenced by __drv_maxIRQL(), DisableTimer(), EnableTimer(), IoDecrement(), IoIncrementWithFlags(), PowerReferenceWorker(), ProcessPowerEvent(), QueryReturnToIdle(), Start(), and Stop().

◆ m_PowerFailedWaitForTimeoutStates

const FxPowerIdleTargetState FxPowerIdleMachine::m_PowerFailedWaitForTimeoutStates

staticprotected

Initial value:

=
{
    { PowerIdleEventTimerExpired, FxIdlePowerFailed TRAP_ON_EVENT },
}

Definition at line 537 of file fxpoweridlestatemachine.hpp.

◆ m_PowerTimeout

LARGE_INTEGER FxPowerIdleMachine::m_PowerTimeout

Definition at line 454 of file fxpoweridlestatemachine.hpp.

Referenced by FxPowerIdleMachine(), and FxPkgPnp::PowerPolicySetS0IdleSettings().

◆ m_PowerTimeoutTimer

MxTimer FxPowerIdleMachine::m_PowerTimeoutTimer

protected

Definition at line 475 of file fxpoweridlestatemachine.hpp.

Referenced by CancelIdleTimer(), and Init().

◆ m_StartedStates

const FxPowerIdleTargetState FxPowerIdleMachine::m_StartedStates

staticprotected

Initial value:

=
{
    { PowerIdleEventPowerUpComplete, FxIdleStartedPowerUp DEBUGGED_EVENT },
    { PowerIdleEventPowerUpFailed, FxIdleStartedPowerFailed DEBUGGED_EVENT },
    { PowerIdleEventStop, FxIdleStopped DEBUGGED_EVENT },
}

Definition at line 529 of file fxpoweridlestatemachine.hpp.

◆ m_StateHistory

FxPowerIdleStates FxPowerIdleMachine::m_StateHistory[FxPowerIdleEventQueueDepth]

protected

Definition at line 526 of file fxpoweridlestatemachine.hpp.

Referenced by FxPowerIdleMachine(), and ProcessEventLocked().

◆ m_StateHistoryIndex

UCHAR FxPowerIdleMachine::m_StateHistoryIndex

protected

Definition at line 511 of file fxpoweridlestatemachine.hpp.

Referenced by FxPowerIdleMachine(), and ProcessEventLocked().

◆ m_StateTable

const FxIdleStateTable FxPowerIdleMachine::m_StateTable

staticprotected

Definition at line 539 of file fxpoweridlestatemachine.hpp.

Referenced by CheckAssumptions(), and ProcessEventLocked().

◆ m_StoppedStates

const FxPowerIdleTargetState FxPowerIdleMachine::m_StoppedStates

staticprotected

Initial value:

=
{
    { PowerIdleEventStart, FxIdleStarted DEBUGGED_EVENT },
}

Definition at line 528 of file fxpoweridlestatemachine.hpp.

◆ m_TagTracker

FxTagTracker* FxPowerIdleMachine::m_TagTracker

protected

Definition at line 470 of file fxpoweridlestatemachine.hpp.

Referenced by FxPowerIdleMachine(), IoDecrement(), PowerReferenceWorker(), Reset(), and ~FxPowerIdleMachine().

◆ m_TimedOutStates

const FxPowerIdleTargetState FxPowerIdleMachine::m_TimedOutStates

staticprotected

Initial value:

=
{
    { PowerIdleEventPowerDown, FxIdleTimedOutPowerDown DEBUGGED_EVENT },
    { PowerIdleEventPowerDownFailed, FxIdleTimedOutPowerDownFailed DEBUGGED_EVENT },
    { PowerIdleEventDisabled, FxIdleTimedOutDisabled DEBUGGED_EVENT },
    { PowerIdleEventEnabled, FxIdleTimedOutEnabled DEBUGGED_EVENT },
    { PowerIdleEventIoIncrement, FxIdleTimedOutIoIncrement DEBUGGED_EVENT },
}

Definition at line 533 of file fxpoweridlestatemachine.hpp.

◆ m_TimerRunningStates

const FxPowerIdleTargetState FxPowerIdleMachine::m_TimerRunningStates

staticprotected

Initial value:

=
{
    { PowerIdleEventDisabled, FxIdleDisabling DEBUGGED_EVENT },
    { PowerIdleEventIoIncrement, FxIdleCancelTimer DEBUGGED_EVENT },
    { PowerIdleEventEnabled, FxIdleCancelTimer DEBUGGED_EVENT },
    { PowerIdleEventTimerExpired, FxIdleTimingOut DEBUGGED_EVENT },
}

Definition at line 532 of file fxpoweridlestatemachine.hpp.

◆ m_WaitForTimeoutStates

const FxPowerIdleTargetState FxPowerIdleMachine::m_WaitForTimeoutStates

staticprotected

Initial value:

=
{
    { PowerIdleEventTimerExpired, FxIdleTimerExpired DEBUGGED_EVENT },
    { PowerIdleEventPowerDownFailed, FxIdlePowerFailedWaitForTimeout TRAP_ON_EVENT },
    { PowerIdleEventDisabled, FxIdleDisablingWaitForTimeout DEBUGGED_EVENT },
}

Definition at line 535 of file fxpoweridlestatemachine.hpp.

◆ SendPnpPowerUpEvent

UCHAR FxPowerIdleMachine::SendPnpPowerUpEvent

Definition at line 500 of file fxpoweridlestatemachine.hpp.

◆ TimerCanceled

UCHAR FxPowerIdleMachine::TimerCanceled

Definition at line 495 of file fxpoweridlestatemachine.hpp.

◆ TimerEnabled

UCHAR FxPowerIdleMachine::TimerEnabled

Definition at line 493 of file fxpoweridlestatemachine.hpp.

◆ TimerPowerFailed

UCHAR FxPowerIdleMachine::TimerPowerFailed

Definition at line 497 of file fxpoweridlestatemachine.hpp.

◆ TimerStarted

UCHAR FxPowerIdleMachine::TimerStarted

Definition at line 496 of file fxpoweridlestatemachine.hpp.

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

sdk/lib/drivers/wdf/shared/inc/private/common/fxpoweridlestatemachine.hpp
sdk/lib/drivers/wdf/shared/irphandlers/pnp/poweridlestatemachine.cpp

Public Member Functions

Public Attributes

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Static Protected Attributes

Private Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ FxPowerIdleMachine()

◆ ~FxPowerIdleMachine()

Member Function Documentation

◆ CancelIdleTimer()

◆ CancelTimer()

◆ CheckAssumptions()

◆ CheckIoCount()

◆ DecrementIo()

◆ Disabled()

◆ DisableTimer()

◆ Disabling()

◆ DisablingTimerExpired()

◆ EnableTimer()

◆ GoingToDx()

◆ InD0Locked()

◆ InDx()

◆ InDxDisabled()

◆ InDxEnabled()

◆ InDxIoIncrement()

◆ InDxPowerUpFailure()

◆ InDxStopped()

◆ Init()

◆ IoDecrement()

◆ IoIncrement()

◆ IoIncrementWithFlags()

◆ IsTransitioning()

◆ PowerFailed()

◆ PowerReference()

◆ PowerReferenceWithFlags()

◆ PowerReferenceWorker()

◆ PowerUp()

◆ PowerUpComplete()

◆ ProcessEventLocked()

◆ ProcessPowerEvent()

◆ QueryReturnToIdle()

◆ Reset()

◆ SendD0Notification()

◆ Start()

◆ Started()

◆ StartedPowerFailed()

◆ StartedPowerUp()

◆ StartTimer()

◆ Stop()

◆ Stopped()

◆ TimedOutDisabled()

◆ TimedOutEnabled()

◆ TimedOutIoIncrement()

◆ TimedOutPowerDown()

◆ TimedOutPowerDownFailed()

◆ TimerExpired()

◆ TimingOut()

◆ WaitForD0()

Member Data Documentation

◆

◆ _PowerTimeoutDpcRoutine

◆ InDx

◆ IoPresentSent

◆ IsStarted

◆ m_BusyStates

◆ m_CurrentIdleState

◆ m_D0NotificationEvent

◆ m_DisabledStates

◆ m_DisablingWaitForTimeoutStates

◆ m_EventHistory

◆ m_EventHistoryIndex

◆ m_Flags

◆

◆ m_IdleTimerTolerableDelayMS

◆ m_InDxStates

◆ m_IoCount

◆ m_Lock