#include <epstate.h>

Inheritance diagram for XhciEndpointMachine:

Collaboration diagram for XhciEndpointMachine:

[legend]

Public Member Functions
VOID	Initialize (_In_ XhciEndpoint *Endpoint)

XhciEndpoint *	Endpoint () const

Public Member Functions inherited from SmMachine< XhciEndpointMachine, XepEvent >
VOID	SmInitialize (_In_ const State *Initial)

BOOLEAN	SmPost (_In_ XepEvent Ev)

VOID	SmContinueOnPassive ()

const State *	SmCurrent () const

ULONG	SmDepth () const

const State *	SmFrame (_In_ ULONG Index) const

BOOLEAN	SmIsIn (_In_ const State *Ancestor) const

BOOLEAN	SmIsPaused () const

BOOLEAN	SmIsWaitingForTimer () const

ULONG	SmUnexpectedCount () const

Static Public Attributes
static const SM_EVENT_INFO	EventInfo []

Private Types
enum	MAPPING_STOP_REASON { MappingStopForCancel , MappingStopForHalt , MappingStopForReset , MappingStopForRemoval }

enum	RECLAIM_REASON { ReclaimAfterStop , ReclaimAfterAutoReset , ReclaimAfterHaltClear , ReclaimAfterControllerReset }

enum	TIMER_EXIT { TimerExitHalt , TimerExitStoppedEvent , TimerExitStopDrained , TimerExitHaltDrained }

Private Member Functions
VOID	SmReference ()

VOID	SmDereference ()

BOOLEAN	SmCancelTimer ()

SM_RESULT	OnDisabled (_In_ XepEvent Event)

SM_RESULT	OnActive (_In_ XepEvent Event)

SM_RESULT	OnRunning (_In_ XepEvent Event)

SM_RESULT	OnMapping (_In_ XepEvent Event)

SM_RESULT	OnParked (_In_ XepEvent Event)

SM_RESULT	OnAwaitingClientReset (_In_ XepEvent Event)

SM_RESULT	OnAwaitingControllerReset (_In_ XepEvent Event)

SM_RESULT	OnHaltingRingFill (_In_ XepEvent Event)

SM_RESULT	OnAwaitingCancelOk (_In_ XepEvent Event)

SM_RESULT	OnCommanding (_In_ XepEvent Event)

SM_RESULT	OnStoppingPipe (_In_ XepEvent Event)

SM_RESULT	OnRebuildingContextAfterStop (_In_ XepEvent Event)

SM_RESULT	OnUpdatingDequeue (_In_ XepEvent Event)

SM_RESULT	OnResettingDefaultPipe (_In_ XepEvent Event)

SM_RESULT	OnClientResetCommand (_In_ XepEvent Event)

SM_RESULT	OnResettingPipe (_In_ XepEvent Event)

SM_RESULT	OnRebuildingContextForReset (_In_ XepEvent Event)

SM_RESULT	OnReclaiming (_In_ XepEvent Event)

SM_RESULT	OnAwaitingStopRetry (_In_ XepEvent Event)

SM_RESULT	OnAwaitingHalt (_In_ XepEvent Event)

SM_RESULT	OnAwaitingStoppedEvent (_In_ XepEvent Event)

SM_RESULT	OnDraining (_In_ XepEvent Event)

SM_RESULT	EnterAwaitingControllerReset ()

SM_RESULT	EnterRemoved ()

SM_RESULT	EnterHaltingRingFill ()

SM_RESULT	EnterAwaitingCancelOk ()

SM_RESULT	EnterStoppingPipe ()

SM_RESULT	EnterRebuildingContextAfterStop ()

SM_RESULT	EnterUpdatingDequeue ()

SM_RESULT	EnterResettingDefaultPipe ()

SM_RESULT	EnterResettingPipe ()

SM_RESULT	EnterRebuildingContextForReset ()

SM_RESULT	EnterReclaiming ()

SM_RESULT	EnterAwaitingStopRetry ()

SM_RESULT	EnterAwaitingHalt ()

SM_RESULT	EnterAwaitingStoppedEvent ()

SM_RESULT	EnterDraining ()

SM_RESULT	EnterLeavingTimer ()
	Runs the timer exit; the engine already stopped the timer, so it cannot fire after this.

SM_RESULT	Remap ()

SM_RESULT	SuspendRingFillFor (_In_ MAPPING_STOP_REASON Reason)

SM_RESULT	ReclaimFor (_In_ RECLAIM_REASON Reason)

SM_RESULT	RetryStopAfter (_In_ ULONG Milliseconds)

SM_RESULT	DrainFor (_In_ BOOLEAN AfterHalt)

SM_RESULT	LeaveTimerFor (_In_ TIMER_EXIT Exit)

SM_RESULT	RunTimerExit (_In_ TIMER_EXIT Exit)

SM_RESULT	BeginStop ()

SM_RESULT	AfterStopCommand ()

SM_RESULT	AfterStopDrained ()

SM_RESULT	AfterHalt ()

SM_RESULT	AfterStoppedEvent ()

SM_RESULT	AfterHaltDrained ()

BOOLEAN	ReclaimIgnoresCancel () const

VOID	ReferenceEndpoint ()

VOID	DereferenceEndpoint ()

BOOLEAN	StopTimer ()

VOID	StartTimer (_In_ ULONG Milliseconds)

VOID	ReportTimeout (_In_ XEP_TIMEOUT Timeout)

VOID	ResumeRingFill ()

VOID	SuspendRingFill ()

VOID	AckControllerReset ()

VOID	CompleteResetRequest ()

VOID	CompleteResetRequestIfAllowed ()

VOID	ReportStoppedEvent ()

VOID	DropStoppedEvent ()

VOID	ResetStopAttempts ()

VOID	CountStopAttempt ()

VOID	SendStopCommand ()

VOID	NotifyRingsHalted ()

VOID	NotifyRingsClientReset ()

VOID	NotifyRingsStoppedEvent ()

VOID	NotifyRingsReclaimOnCancel ()

VOID	NotifyRingsDrainEvents ()

VOID	NotifyRingsReclaim ()

VOID	AskUcxToCancel ()

VOID	PurgeStreamQueues ()

VOID	RestartStreamQueues ()

VOID	ReconfigureForReset ()

VOID	ReconfigureAfterStop ()

VOID	UpdateDequeuePointers ()

VOID	ResetDefaultPipe ()

VOID	ResetEndpoint ()

VOID	RequestControllerReset ()

BOOLEAN	IsControlEndpoint ()

BOOLEAN	OnPrimaryInterrupterOnly ()

BOOLEAN	DelaysFirstStop ()

BOOLEAN	IgnoresStopContextError ()

BOOLEAN	StopAttemptsExhausted ()

BOOLEAN	DoorbellRungSinceFill ()

BOOLEAN	NeedsContextRebuildAfterStop ()

BOOLEAN	ShouldReconfigureForReset ()

BOOLEAN	CanResetAfterHalt ()

Private Attributes
XhciEndpoint *	m_Endpoint

MAPPING_STOP_REASON	m_AfterMapping

RECLAIM_REASON	m_AfterReclaim

TIMER_EXIT	m_AfterTimer

ULONG	m_RetryDelay

BOOLEAN	m_DrainAfterHalt

Static Private Attributes
static const State	Disabled

static const State	Active

static const State	Running

static const State	Mapping

static const State	ResetWhileMapping

static const State	AwaitingDisable

static const State	Parked

static const State	AwaitingClientReset

static const State	AwaitingRecovery

static const State	Fenced

static const State	AwaitingControllerReset

static const State	Removed

static const State	HaltingRingFill

static const State	AwaitingCancelOk

static const State	Commanding

static const State	StoppingPipe

static const State	RebuildingContextAfterStop

static const State	UpdatingDequeue

static const State	ResettingDefaultPipe

static const State	ClientResetCommand

static const State	ResettingPipe

static const State	RebuildingContextForReset

static const State	Reclaiming

static const State	Timed

static const State	AwaitingStopRetry

static const State	AwaitingHalt

static const State	AwaitingStoppedEvent

static const State	Draining

static const State	LeavingTimer

static const BOOLEAN	SmCompletionsFirst = FALSE

static const USHORT	SmTimerEventId = static_cast<USHORT>(XepEvent::TimerFired)

Friends
class	SmMachine< XhciEndpointMachine, XepEvent >

class	XhciEndpointProbe

Additional Inherited Members
Public Types inherited from SmMachine< XhciEndpointMachine, XepEvent >
typedef SmState< XhciEndpointMachine, XepEvent >	State

Protected Member Functions inherited from SmMachine< XhciEndpointMachine, XepEvent >
VOID	SmBeginPause ()

VOID	SmDiscardQueued (_In_ XepEvent Ev)

BOOLEAN	SmAccepts (_In_ XepEvent Ev)

VOID	SmReference ()

VOID	SmDereference ()

VOID	SmQueuePassive ()

VOID	SmOnDequeue (_In_ XepEvent Ev)

VOID	SmStateChanged ()

BOOLEAN	SmCancelTimer ()

Static Protected Member Functions inherited from SmMachine< XhciEndpointMachine, XepEvent >
static SM_RESULT	SmMakeResult (_In_ SM_RESULT_KIND Kind, _In_ USHORT Ev, _In_opt_ const VOID *Target)

static SM_RESULT	SmHandled ()

static SM_RESULT	SmUnhandled ()

static SM_RESULT	SmTransition (_In_ const State *Target)

static SM_RESULT	SmPaused ()

static SM_RESULT	SmCall (_In_ const State *Start)

static SM_RESULT	SmReturn (_In_ XepEvent Ev)

Static Protected Attributes inherited from SmMachine< XhciEndpointMachine, XepEvent >
static const BOOLEAN	SmCompletionsFirst

static const USHORT	SmTimerEventId

Detailed Description

Definition at line 56 of file epstate.h.

Member Enumeration Documentation

◆ MAPPING_STOP_REASON

enum XhciEndpointMachine::MAPPING_STOP_REASON

private

Enumerator
MappingStopForCancel
MappingStopForHalt
MappingStopForReset
MappingStopForRemoval

Definition at line 75 of file epstate.h.

    {
        MappingStopForCancel,
        MappingStopForHalt,
        MappingStopForReset,
        MappingStopForRemoval
    };

◆ RECLAIM_REASON

enum XhciEndpointMachine::RECLAIM_REASON

private

Enumerator
ReclaimAfterStop
ReclaimAfterAutoReset
ReclaimAfterHaltClear
ReclaimAfterControllerReset

Definition at line 83 of file epstate.h.

    {
        ReclaimAfterStop,
        ReclaimAfterAutoReset,
        ReclaimAfterHaltClear,
        ReclaimAfterControllerReset
    };

◆ TIMER_EXIT

enum XhciEndpointMachine::TIMER_EXIT

private

Enumerator
TimerExitHalt
TimerExitStoppedEvent
TimerExitStopDrained
TimerExitHaltDrained

Definition at line 91 of file epstate.h.

    {
        TimerExitHalt,
        TimerExitStoppedEvent,
        TimerExitStopDrained,
        TimerExitHaltDrained
    };

Member Function Documentation

◆ AckControllerReset()

VOID XhciEndpointMachine::AckControllerReset ( )

private

Definition at line 2502 of file epctx.cpp.

{
    XhciEndpoint* Ep = m_Endpoint;
 
    if (InterlockedXor(&Ep->m_Flags, XHCI_EP_RESET_ACK_HANDSHAKE) & XHCI_EP_RESET_ACK_HANDSHAKE)
        KeSetEvent(&Ep->m_ResetAck, IO_NO_INCREMENT, FALSE);
}

Referenced by OnDisabled(), OnReclaiming(), and OnRunning().

◆ AfterHalt()

SM_RESULT XhciEndpointMachine::AfterHalt ( )

private

Definition at line 800 of file epstate.cpp.

{
    NotifyRingsHalted();
 
    /* Control endpoints are reset here, others wait for the client */
    if (IsControlEndpoint())
        return SmTransition(&ResettingDefaultPipe);
 
    return DrainFor(TRUE);
}

Referenced by DrainFor(), OnAwaitingHalt(), OnHaltingRingFill(), and RunTimerExit().

◆ AfterHaltDrained()

SM_RESULT XhciEndpointMachine::AfterHaltDrained ( )

private

Definition at line 819 of file epstate.cpp.

{
    PurgeStreamQueues();
    NotifyRingsReclaimOnCancel();
    return SmTransition(&AwaitingClientReset);
}

Referenced by OnDraining(), and RunTimerExit().

◆ AfterStopCommand()

SM_RESULT XhciEndpointMachine::AfterStopCommand ( )

private

Definition at line 781 of file epstate.cpp.

{
    if (!OnPrimaryInterrupterOnly())
        return SmTransition(&AwaitingStoppedEvent);
 
    DropStoppedEvent();
    return AfterStopDrained();
}

Referenced by OnAwaitingStopRetry(), and OnStoppingPipe().

◆ AfterStopDrained()

SM_RESULT XhciEndpointMachine::AfterStopDrained ( )

private

Definition at line 791 of file epstate.cpp.

{
    if (NeedsContextRebuildAfterStop())
        return SmTransition(&RebuildingContextAfterStop);
 
    return SmTransition(&UpdatingDequeue);
}

Referenced by AfterStopCommand(), OnDraining(), and RunTimerExit().

◆ AfterStoppedEvent()

SM_RESULT XhciEndpointMachine::AfterStoppedEvent ( )

private

Definition at line 812 of file epstate.cpp.

{
    NotifyRingsStoppedEvent();
    return DrainFor(FALSE);
}

Referenced by OnAwaitingStoppedEvent(), and RunTimerExit().

◆ AskUcxToCancel()

VOID XhciEndpointMachine::AskUcxToCancel ( )

private

Definition at line 2625 of file epctx.cpp.

{
    UcxEndpointNeedToCancelTransfers(m_Endpoint->m_Ucx);
}

Referenced by EnterAwaitingCancelOk().

◆ BeginStop()

SM_RESULT XhciEndpointMachine::BeginStop ( )

private

Definition at line 770 of file epstate.cpp.

{
    ResetStopAttempts();
    if (DelaysFirstStop())
        return RetryStopAfter(XEP_STOP_RETRY_LONG_MS);
 
    return SmTransition(&StoppingPipe);
}

Referenced by OnHaltingRingFill().

◆ CanResetAfterHalt()

BOOLEAN XhciEndpointMachine::CanResetAfterHalt ( )

private

Definition at line 2864 of file epctx.cpp.

{
    XhciEndpoint* Ep = m_Endpoint;
 
    if (Ep->m_StreamsCapable && Ep->AnyTransfersPending())
    {
        Ep->m_ResetStatus = STATUS_UNSUCCESSFUL;
        return FALSE;
    }
 
    return TRUE;
}

Referenced by OnAwaitingClientReset().

◆ CompleteResetRequest()

VOID XhciEndpointMachine::CompleteResetRequest ( )

private

Definition at line 2511 of file epctx.cpp.

{
    XhciEndpoint* Ep = m_Endpoint;
    WDFREQUEST Request;
    NTSTATUS Status;
 
    InterlockedAnd(&Ep->m_Flags, ~XHCI_EP_CLIENT_RESET_HANDSHAKE);
 
    Status = Ep->m_ResetStatus;
    Ep->m_ResetStatus = STATUS_PENDING;
    Request = static_cast<WDFREQUEST>(
        InterlockedExchangePointer(reinterpret_cast<PVOID volatile*>(&Ep->m_ResetRequest), NULL));
 
    if (Request == NULL)
        return;
 
    /* A controller reset or removal got here first; complete with success, not STATUS_PENDING */
    if (Status == STATUS_PENDING)
        Status = STATUS_SUCCESS;
 
    DPRINT("Endpoint %p client reset completed with 0x%lx\n", Ep, Status);
    WdfRequestComplete(Request, Status);
}

Referenced by CompleteResetRequestIfAllowed(), OnAwaitingClientReset(), OnClientResetCommand(), OnMapping(), OnRebuildingContextForReset(), and OnReclaiming().

◆ CompleteResetRequestIfAllowed()

VOID XhciEndpointMachine::CompleteResetRequestIfAllowed ( )

private

Definition at line 2536 of file epctx.cpp.

{
    XhciEndpoint* Ep = m_Endpoint;
 
    if (InterlockedXor(&Ep->m_Flags, XHCI_EP_CLIENT_RESET_HANDSHAKE) & XHCI_EP_CLIENT_RESET_HANDSHAKE)
        CompleteResetRequest();
}

Referenced by EnterAwaitingControllerReset(), and EnterRemoved().

◆ CountStopAttempt()

VOID XhciEndpointMachine::CountStopAttempt ( )

private

Definition at line 2566 of file epctx.cpp.

{
    m_Endpoint->m_StopAttempts++;
}

Referenced by EnterStoppingPipe().

◆ DelaysFirstStop()

BOOLEAN XhciEndpointMachine::DelaysFirstStop ( )

private

Definition at line 2790 of file epctx.cpp.

{
    return m_Endpoint->m_Controller->HasErrata(XhciErrata::EpDeferFirstStop);
}

Referenced by BeginStop().

◆ DereferenceEndpoint()

VOID XhciEndpointMachine::DereferenceEndpoint ( )

private

Definition at line 2438 of file epctx.cpp.

{
    WdfObjectDereference(m_Endpoint->m_Ucx);
}

Referenced by SmDereference().

◆ DoorbellRungSinceFill()

BOOLEAN XhciEndpointMachine::DoorbellRungSinceFill ( )

private

Definition at line 2814 of file epctx.cpp.

{
    XhciEndpoint* Ep = m_Endpoint;
    ULONG Index;
 
    if (!Ep->UsesStreams())
        return Ep->m_MainRing->DoorbellRungSinceFill();
 
    /* QUIRK: asking also resets the shared stream counter */
    InterlockedExchange(&Ep->m_CurrentStreams->UpdateCount, 0);
    for (Index = 0; Index < Ep->m_CurrentStreams->Count; Index++)
    {
        if (Ep->m_CurrentStreams->Entry[Index].Ring->DoorbellRungSinceFill())
            return TRUE;
    }
 
    return FALSE;
}

Referenced by OnHaltingRingFill().

◆ DrainFor()

SM_RESULT XhciEndpointMachine::DrainFor ( _In_ BOOLEAN AfterHalt )

private

Definition at line 734 of file epstate.cpp.

{
    m_DrainAfterHalt = AfterHalt;
    return SmTransition(&Draining);
}

Referenced by AfterHalt(), and AfterStoppedEvent().

◆ DropStoppedEvent()

VOID XhciEndpointMachine::DropStoppedEvent ( )

private

Definition at line 2554 of file epctx.cpp.

{
    InterlockedOr(&m_Endpoint->m_Flags, XHCI_EP_IGNORE_STOPPED);
}

Referenced by AfterStopCommand().

◆ Endpoint()

XhciEndpoint * XhciEndpointMachine::Endpoint ( ) const

inline

Definition at line 67 of file epstate.h.

    {
        return m_Endpoint;
    }

Referenced by Initialize().

◆ EnterAwaitingCancelOk()

SM_RESULT XhciEndpointMachine::EnterAwaitingCancelOk ( )

private

Definition at line 380 of file epstate.cpp.

{
    AskUcxToCancel();
    return SmHandled();
}

◆ EnterAwaitingControllerReset()

SM_RESULT XhciEndpointMachine::EnterAwaitingControllerReset ( )

private

Definition at line 319 of file epstate.cpp.

{
    CompleteResetRequestIfAllowed();
    return SmHandled();
}

◆ EnterAwaitingHalt()

SM_RESULT XhciEndpointMachine::EnterAwaitingHalt ( )

private

Definition at line 604 of file epstate.cpp.

{
    StartTimer(XEP_STOP_TIMEOUT_MS);
    return SmHandled();
}

◆ EnterAwaitingStoppedEvent()

SM_RESULT XhciEndpointMachine::EnterAwaitingStoppedEvent ( )

private

Definition at line 629 of file epstate.cpp.

{
    ReportStoppedEvent();
    StartTimer(XEP_STOP_TIMEOUT_MS);
    return SmHandled();
}

◆ EnterAwaitingStopRetry()

SM_RESULT XhciEndpointMachine::EnterAwaitingStopRetry ( )

private

Definition at line 572 of file epstate.cpp.

{
    StartTimer(m_RetryDelay);
    return SmHandled();
}

◆ EnterDraining()

SM_RESULT XhciEndpointMachine::EnterDraining ( )

private

Definition at line 655 of file epstate.cpp.

{
    NotifyRingsDrainEvents();
    StartTimer(XEP_STOP_TIMEOUT_MS);
    if (m_DrainAfterHalt)
        SmDiscardQueued(XepEvent::TransferAborted);
 
    return SmHandled();
}

◆ EnterHaltingRingFill()

SM_RESULT XhciEndpointMachine::EnterHaltingRingFill ( )

private

Definition at line 344 of file epstate.cpp.

{
    SuspendRingFill();
    if (m_AfterMapping == MappingStopForHalt)
        SmDiscardQueued(XepEvent::TransferAborted);
 
    return SmHandled();
}

◆ EnterLeavingTimer()

SM_RESULT XhciEndpointMachine::EnterLeavingTimer ( )

private

Runs the timer exit; the engine already stopped the timer, so it cannot fire after this.

Definition at line 697 of file epstate.cpp.

{
    return RunTimerExit(m_AfterTimer);
}

◆ EnterRebuildingContextAfterStop()

SM_RESULT XhciEndpointMachine::EnterRebuildingContextAfterStop ( )

private

Definition at line 438 of file epstate.cpp.

{
    ReconfigureAfterStop();
    return SmHandled();
}

◆ EnterRebuildingContextForReset()

SM_RESULT XhciEndpointMachine::EnterRebuildingContextForReset ( )

private

Definition at line 517 of file epstate.cpp.

{
    ReconfigureForReset();
    return SmHandled();
}

◆ EnterReclaiming()

SM_RESULT XhciEndpointMachine::EnterReclaiming ( )

private

Definition at line 536 of file epstate.cpp.

{
    NotifyRingsReclaim();
    if (ReclaimIgnoresCancel())
        SmDiscardQueued(XepEvent::TransferAborted);
 
    return SmHandled();
}

◆ EnterRemoved()

SM_RESULT XhciEndpointMachine::EnterRemoved ( )

private

Definition at line 336 of file epstate.cpp.

{
    NotifyRingsReclaimOnCancel();
    CompleteResetRequestIfAllowed();
    return SmHandled();
}

◆ EnterResettingDefaultPipe()

SM_RESULT XhciEndpointMachine::EnterResettingDefaultPipe ( )

private

Definition at line 472 of file epstate.cpp.

{
    ResetDefaultPipe();
    return SmHandled();
}

◆ EnterResettingPipe()

SM_RESULT XhciEndpointMachine::EnterResettingPipe ( )

private

Definition at line 500 of file epstate.cpp.

{
    ResetEndpoint();
    return SmHandled();
}

◆ EnterStoppingPipe()

SM_RESULT XhciEndpointMachine::EnterStoppingPipe ( )

private

Definition at line 407 of file epstate.cpp.

{
    CountStopAttempt();
    SendStopCommand();
    return SmHandled();
}

◆ EnterUpdatingDequeue()

SM_RESULT XhciEndpointMachine::EnterUpdatingDequeue ( )

private

Definition at line 455 of file epstate.cpp.

{
    UpdateDequeuePointers();
    return SmHandled();
}

◆ IgnoresStopContextError()

BOOLEAN XhciEndpointMachine::IgnoresStopContextError ( )

private

Definition at line 2796 of file epctx.cpp.

{
    XhciController* Controller = m_Endpoint->m_Controller;
 
    if (!Controller->HasErrata(XhciErrata::EpStopContextErrorIsStopped))
        return FALSE;
 
    NT_ASSERT(Controller->HasErrata(XhciErrata::IntPrimaryOnly));
    return TRUE;
}

Referenced by OnAwaitingStopRetry().

◆ Initialize()

VOID XhciEndpointMachine::Initialize ( _In_ XhciEndpoint * Endpoint )

Definition at line 181 of file epstate.cpp.

{
    m_Endpoint = Endpoint;
    m_AfterMapping = MappingStopForCancel;
    m_AfterReclaim = ReclaimAfterStop;
    m_AfterTimer = TimerExitHalt;
    m_RetryDelay = XEP_STOP_RETRY_SHORT_MS;
    m_DrainAfterHalt = FALSE;
 
    SmInitialize(&Disabled);
}

Referenced by XhciEndpoint::Create().

◆ IsControlEndpoint()

BOOLEAN XhciEndpointMachine::IsControlEndpoint ( )

private

Definition at line 2778 of file epctx.cpp.

{
    return m_Endpoint->m_XhciType == XHCI_ENDPOINT_TYPE_CONTROL;
}

Referenced by AfterHalt().

◆ LeaveTimerFor()

SM_RESULT XhciEndpointMachine::LeaveTimerFor ( _In_ TIMER_EXIT Exit )

private

Definition at line 742 of file epstate.cpp.

{
    m_AfterTimer = Exit;
    return SmTransition(&LeavingTimer);
}

Referenced by OnAwaitingHalt(), OnAwaitingStoppedEvent(), OnAwaitingStopRetry(), and OnDraining().

◆ NeedsContextRebuildAfterStop()

BOOLEAN XhciEndpointMachine::NeedsContextRebuildAfterStop ( )

private

Definition at line 2834 of file epctx.cpp.

{
    return m_Endpoint->m_StreamsCapable &&
           m_Endpoint->m_Controller->HasErrata(XhciErrata::StrmReconfigOnStop);
}

Referenced by AfterStopDrained().

◆ NotifyRingsClientReset()

VOID XhciEndpointMachine::NotifyRingsClientReset ( )

private

Definition at line 2593 of file epctx.cpp.

{
    m_Endpoint->ForEachRing(&XhciTransferRing::OnClientPipeReset);
}

Referenced by OnMapping().

◆ NotifyRingsDrainEvents()

VOID XhciEndpointMachine::NotifyRingsDrainEvents ( )

private

Definition at line 2611 of file epctx.cpp.

{
    m_Endpoint->ForEachRing(&XhciTransferRing::ConsumePendingEvents);
}

Referenced by EnterDraining().

◆ NotifyRingsHalted()

VOID XhciEndpointMachine::NotifyRingsHalted ( )

private

Definition at line 2587 of file epctx.cpp.

{
    m_Endpoint->ForEachRing(&XhciTransferRing::OnPipeHalted);
}

Referenced by AfterHalt().

◆ NotifyRingsReclaim()

VOID XhciEndpointMachine::NotifyRingsReclaim ( )

private

Definition at line 2618 of file epctx.cpp.

{
    WdfObjectReferenceWithTag(m_Endpoint->m_Ucx, XHCI_RECLAIM_TAG);
    m_Endpoint->ForEachRing(&XhciTransferRing::RecoverTransfers);
}

Referenced by EnterReclaiming().

◆ NotifyRingsReclaimOnCancel()

VOID XhciEndpointMachine::NotifyRingsReclaimOnCancel ( )

private

Definition at line 2605 of file epctx.cpp.

{
    m_Endpoint->ForEachRing(&XhciTransferRing::AllowReclaimOnCancel);
}

Referenced by AfterHaltDrained(), and EnterRemoved().

◆ NotifyRingsStoppedEvent()

VOID XhciEndpointMachine::NotifyRingsStoppedEvent ( )

private

Definition at line 2599 of file epctx.cpp.

{
    m_Endpoint->ForEachRing(&XhciTransferRing::StoppedEventReceived);
}

Referenced by AfterStoppedEvent().

◆ OnActive()

SM_RESULT XhciEndpointMachine::OnActive ( _In_ XepEvent Event )

private

Definition at line 232 of file epstate.cpp.

{
    if (Event == XepEvent::Disable)
        return SmTransition(&Disabled);
 
    return SmUnhandled();
}

◆ OnAwaitingCancelOk()

SM_RESULT XhciEndpointMachine::OnAwaitingCancelOk ( _In_ XepEvent Event )

private

Definition at line 387 of file epstate.cpp.

{
    if (Event == XepEvent::CancelAllowed)
        return ReclaimFor(ReclaimAfterStop);
 
    return SmUnhandled();
}

◆ OnAwaitingClientReset()

SM_RESULT XhciEndpointMachine::OnAwaitingClientReset ( _In_ XepEvent Event )

private

Definition at line 305 of file epstate.cpp.

{
    if (Event != XepEvent::ClientReset)
        return SmUnhandled();
 
    if (CanResetAfterHalt())
        return SmTransition(&ResettingPipe);
 
    CompleteResetRequest();
    return SmTransition(&AwaitingClientReset);
}

◆ OnAwaitingControllerReset()

SM_RESULT XhciEndpointMachine::OnAwaitingControllerReset ( _In_ XepEvent Event )

private

Definition at line 326 of file epstate.cpp.

{
    if (Event == XepEvent::ControllerResetDone)
        return ReclaimFor(ReclaimAfterControllerReset);
 
    return SmUnhandled();
}

◆ OnAwaitingHalt()

SM_RESULT XhciEndpointMachine::OnAwaitingHalt ( _In_ XepEvent Event )

private

Definition at line 611 of file epstate.cpp.

{
    switch (Event)
    {
        case XepEvent::TimerFired:
            ReportTimeout(XepTimeoutHalt);
            return AfterHalt();
 
        case XepEvent::HaltReported:
            return LeaveTimerFor(TimerExitHalt);
 
        default:
            return SmUnhandled();
    }
}

◆ OnAwaitingStoppedEvent()

SM_RESULT XhciEndpointMachine::OnAwaitingStoppedEvent ( _In_ XepEvent Event )

private

Definition at line 637 of file epstate.cpp.

{
    switch (Event)
    {
        case XepEvent::TimerFired:
            ReportTimeout(XepTimeoutStoppedEvent);
            return AfterStoppedEvent();
 
        case XepEvent::StoppedEventSeen:
            return LeaveTimerFor(TimerExitStoppedEvent);
 
        default:
            return SmUnhandled();
    }
}

◆ OnAwaitingStopRetry()

SM_RESULT XhciEndpointMachine::OnAwaitingStopRetry ( _In_ XepEvent Event )

private

Definition at line 579 of file epstate.cpp.

{
    switch (Event)
    {
        case XepEvent::TimerFired:
            if (!StopAttemptsExhausted())
                return SmTransition(&StoppingPipe);
 
            /* Controllers with this quirk report a context error for a stopped endpoint */
            if (IgnoresStopContextError())
                return AfterStopCommand();
 
            RequestControllerReset();
            return SmTransition(&AwaitingRecovery);
 
        case XepEvent::HaltReported:
            return LeaveTimerFor(TimerExitHalt);
 
        default:
            return SmUnhandled();
    }
}

◆ OnClientResetCommand()

SM_RESULT XhciEndpointMachine::OnClientResetCommand ( _In_ XepEvent Event )

private

Definition at line 489 of file epstate.cpp.

{
    if (Event != XepEvent::CommandFailed)
        return SmUnhandled();
 
    CompleteResetRequest();
    return SmTransition(&AwaitingRecovery);
}

◆ OnCommanding()

SM_RESULT XhciEndpointMachine::OnCommanding ( _In_ XepEvent Event )

private

Definition at line 397 of file epstate.cpp.

{
    if (Event == XepEvent::CommandFailed)
        return SmTransition(&AwaitingRecovery);
 
    return SmUnhandled();
}

◆ OnDisabled()

SM_RESULT XhciEndpointMachine::OnDisabled ( _In_ XepEvent Event )

private

Definition at line 213 of file epstate.cpp.

{
    switch (Event)
    {
        case XepEvent::ControllerResetDone:
            /* Enter again so the discards are purged once more */
            AckControllerReset();
            return SmTransition(&Disabled);
 
        case XepEvent::Enable:
            return Remap();
 
        default:
            return SmUnhandled();
    }
}

◆ OnDraining()

SM_RESULT XhciEndpointMachine::OnDraining ( _In_ XepEvent Event )

private

Definition at line 666 of file epstate.cpp.

{
    switch (Event)
    {
        case XepEvent::TimerFired:
            if (m_DrainAfterHalt)
            {
                ReportTimeout(XepTimeoutDrainAfterHalt);
                return AfterHaltDrained();
            }
 
            ReportTimeout(XepTimeoutDrainAfterStop);
            return AfterStopDrained();
 
        case XepEvent::ExpectedEventsDone:
            return LeaveTimerFor(m_DrainAfterHalt ? TimerExitHaltDrained : TimerExitStopDrained);
 
        case XepEvent::TransferAborted:
            return m_DrainAfterHalt ? SmHandled() : SmUnhandled();
 
        default:
            return SmUnhandled();
    }
}

◆ OnHaltingRingFill()

SM_RESULT XhciEndpointMachine::OnHaltingRingFill ( _In_ XepEvent Event )

private

Definition at line 354 of file epstate.cpp.

{
    if (Event != XepEvent::StreamMapStopped)
        return SmUnhandled();
 
    switch (m_AfterMapping)
    {
        case MappingStopForCancel:
            if (DoorbellRungSinceFill())
                return BeginStop();
 
            return ReclaimFor(ReclaimAfterStop);
 
        case MappingStopForHalt:
            return AfterHalt();
 
        case MappingStopForReset:
            return SmTransition(&RebuildingContextForReset);
 
        default:
            return SmTransition(&Removed);
    }
}

◆ OnMapping()

SM_RESULT XhciEndpointMachine::OnMapping ( _In_ XepEvent Event )

private

Definition at line 253 of file epstate.cpp.

{
    switch (Event)
    {
        case XepEvent::ControllerResetStarting:
            return SmTransition(&ResetWhileMapping);
 
        case XepEvent::StreamsOn:
        case XepEvent::StreamsOff:
            return Remap();
 
        case XepEvent::TransferAborted:
            return SuspendRingFillFor(MappingStopForCancel);
 
        case XepEvent::HaltReported:
            return SuspendRingFillFor(MappingStopForHalt);
 
        case XepEvent::ControllerRemoved:
            return SuspendRingFillFor(MappingStopForRemoval);
 
        case XepEvent::ClientReset:
            NotifyRingsClientReset();
            if (ShouldReconfigureForReset())
                return SuspendRingFillFor(MappingStopForReset);
 
            CompleteResetRequest();
            return SmTransition(&Mapping);
 
        default:
            return SmUnhandled();
    }
}

◆ OnParked()

SM_RESULT XhciEndpointMachine::OnParked ( _In_ XepEvent Event )

private

Definition at line 288 of file epstate.cpp.

{
    switch (Event)
    {
        case XepEvent::ControllerResetStarting:
            return SmTransition(&AwaitingControllerReset);
 
        case XepEvent::ControllerRemoved:
            return SmTransition(&Removed);
 
        default:
            return SmUnhandled();
    }
}

◆ OnPrimaryInterrupterOnly()

BOOLEAN XhciEndpointMachine::OnPrimaryInterrupterOnly ( )

private

Definition at line 2784 of file epctx.cpp.

{
    return m_Endpoint->m_Controller->HasErrata(XhciErrata::IntPrimaryOnly);
}

Referenced by AfterStopCommand().

◆ OnRebuildingContextAfterStop()

SM_RESULT XhciEndpointMachine::OnRebuildingContextAfterStop ( _In_ XepEvent Event )

private

Definition at line 445 of file epstate.cpp.

{
    if (Event == XepEvent::CommandSucceeded)
        return SmTransition(&UpdatingDequeue);
 
    return SmUnhandled();
}

◆ OnRebuildingContextForReset()

SM_RESULT XhciEndpointMachine::OnRebuildingContextForReset ( _In_ XepEvent Event )

private

Definition at line 524 of file epstate.cpp.

{
    if ((Event != XepEvent::CommandSucceeded) && (Event != XepEvent::BufferAllocFailed))
        return SmUnhandled();
 
    /* A buffer failure already set the request status, the request completes either way */
    CompleteResetRequest();
    return Remap();
}

◆ OnReclaiming()

SM_RESULT XhciEndpointMachine::OnReclaiming ( _In_ XepEvent Event )

private

Definition at line 546 of file epstate.cpp.

{
    if (Event == XepEvent::TransferAborted)
        return ReclaimIgnoresCancel() ? SmHandled() : SmUnhandled();
 
    if (Event != XepEvent::TransfersRecovered)
        return SmUnhandled();
 
    switch (m_AfterReclaim)
    {
        case ReclaimAfterHaltClear:
            RestartStreamQueues();
            CompleteResetRequest();
            return Remap();
 
        case ReclaimAfterControllerReset:
            AckControllerReset();
            return SmTransition(&AwaitingDisable);
 
        default:
            return Remap();
    }
}

◆ OnResettingDefaultPipe()

SM_RESULT XhciEndpointMachine::OnResettingDefaultPipe ( _In_ XepEvent Event )

private

Definition at line 479 of file epstate.cpp.

{
    if (Event == XepEvent::CommandSucceeded)
        return ReclaimFor(ReclaimAfterAutoReset);
 
    return SmUnhandled();
}

◆ OnResettingPipe()

SM_RESULT XhciEndpointMachine::OnResettingPipe ( _In_ XepEvent Event )

private

Definition at line 507 of file epstate.cpp.

{
    if (Event == XepEvent::CommandSucceeded)
        return ReclaimFor(ReclaimAfterHaltClear);
 
    return SmUnhandled();
}

◆ OnRunning()

SM_RESULT XhciEndpointMachine::OnRunning ( _In_ XepEvent Event )

private

Definition at line 242 of file epstate.cpp.

{
    if (Event != XepEvent::ControllerResetDone)
        return SmUnhandled();
 
    AckControllerReset();
    return SmTransition(&AwaitingDisable);
}

◆ OnStoppingPipe()

SM_RESULT XhciEndpointMachine::OnStoppingPipe ( _In_ XepEvent Event )

private

Definition at line 415 of file epstate.cpp.

{
    switch (Event)
    {
        case XepEvent::CommandSucceeded:
            return AfterStopCommand();
 
        case XepEvent::StopFailedHalted:
            return SmTransition(&AwaitingHalt);
 
        case XepEvent::StopFailedRunning:
            return RetryStopAfter(XEP_STOP_RETRY_LONG_MS);
 
        case XepEvent::StopFailedStopped:
            return RetryStopAfter(XEP_STOP_RETRY_SHORT_MS);
 
        default:
            return SmUnhandled();
    }
}

◆ OnUpdatingDequeue()

SM_RESULT XhciEndpointMachine::OnUpdatingDequeue ( _In_ XepEvent Event )

private

Definition at line 462 of file epstate.cpp.

{
    if (Event == XepEvent::CommandSucceeded)
        return SmTransition(&AwaitingCancelOk);
 
    return SmUnhandled();
}

◆ PurgeStreamQueues()

VOID XhciEndpointMachine::PurgeStreamQueues ( )

private

Definition at line 2632 of file epctx.cpp.

{
    XhciEndpoint* Ep = m_Endpoint;
    ULONG Index;
 
    if (!(Ep->m_Flags & XHCI_EP_STREAM_HALT_PENDING) || !Ep->UsesStreams())
        return;
 
    for (Index = 0; Index < Ep->m_CurrentStreams->Count; Index++)
        WdfIoQueuePurge(Ep->m_CurrentStreams->Entry[Index].Ring->Queue(), NULL, NULL);
}

Referenced by AfterHaltDrained().

◆ ReclaimFor()

SM_RESULT XhciEndpointMachine::ReclaimFor ( _In_ RECLAIM_REASON Reason )

private

Definition at line 718 of file epstate.cpp.

{
    m_AfterReclaim = Reason;
    return SmTransition(&Reclaiming);
}

Referenced by OnAwaitingCancelOk(), OnAwaitingControllerReset(), OnHaltingRingFill(), OnResettingDefaultPipe(), and OnResettingPipe().

◆ ReclaimIgnoresCancel()

BOOLEAN XhciEndpointMachine::ReclaimIgnoresCancel ( ) const

inlineprivate

Definition at line 265 of file epstate.h.

    {
        return (m_AfterReclaim == ReclaimAfterAutoReset) ||
               (m_AfterReclaim == ReclaimAfterControllerReset);
    }

Referenced by EnterReclaiming(), and OnReclaiming().

◆ ReconfigureAfterStop()

VOID XhciEndpointMachine::ReconfigureAfterStop ( )

private

Definition at line 2694 of file epctx.cpp.

{
    XhciEndpoint* Ep = m_Endpoint;
    PVOID Original = Ep->m_Device->OutputContext(Ep->m_Dci);
    ULONG Size = Ep->m_Controller->m_Registers.ContextSize();
 
    Ep->m_StopInput = Ep->m_Controller->m_Buffers.Acquire(Size * XHCI_INPUT_CONTEXT_COUNT);
    if (Ep->m_StopInput == NULL)
    {
        DPRINT1("Endpoint %p DCI %lu no input context for the reconfigure after stop\n", Ep, Ep->m_Dci);
        Ep->m_Controller->RaiseControllerFault(XhciRecovery::ResetHost, XHCI_REASON_NO_LIVE_DUMP);
        Ep->PostCommandFailure();
        return;
    }
 
    Ep->BuildEndpointConfigure(Ep->m_StopInput, Original, TRUE, FALSE,
                               &Ep->m_Command, XhciEndpoint::StopDropDone);
    Ep->m_Controller->m_Commands.Submit(&Ep->m_Command);
}

Referenced by EnterRebuildingContextAfterStop().

◆ ReconfigureForReset()

VOID XhciEndpointMachine::ReconfigureForReset ( )

private

Definition at line 2659 of file epctx.cpp.

{
    XhciEndpoint* Ep = m_Endpoint;
    XhciEndpointReset* Data = &XhciGetRequestData(Ep->m_ResetRequest)->EndpointReset;
    PVOID Original = Ep->m_Device->OutputContext(Ep->m_Dci);
    ULONG Size = Ep->m_Controller->m_Registers.ContextSize();
 
    Data->InputContext = Ep->m_Controller->m_Buffers.Acquire(Size * XHCI_INPUT_CONTEXT_COUNT);
    if (Data->InputContext == NULL)
    {
        DPRINT1("Endpoint %p DCI %lu no input context for the client reset\n", Ep, Ep->m_Dci);
        Ep->m_ResetStatus = STATUS_INSUFFICIENT_RESOURCES;
        Ep->PostEvent(XepEvent::BufferAllocFailed);
        return;
    }
 
    if (Ep->UsesStreams())
    {
        /* Drop first; the copied endpoint context waits in the buffer for the add */
        Ep->BuildEndpointConfigure(Data->InputContext, Original, TRUE, FALSE,
                                   &Data->Command, XhciEndpoint::ResetDropDone);
    }
    else
    {
        Ep->BuildEndpointConfigure(Data->InputContext, Original, TRUE, TRUE,
                                   &Data->Command, XhciEndpoint::ResetConfigureDone);
        Ep->m_MainRing->InitializeRing();
        Ep->InputEndpointContext(Data->InputContext)->TRDequeuePointer = Ep->m_MainRing->DequeuePointerValue();
    }
 
    Ep->m_Controller->m_Commands.Submit(&Data->Command);
}

Referenced by EnterRebuildingContextForReset().

◆ ReferenceEndpoint()

VOID XhciEndpointMachine::ReferenceEndpoint ( )

private

Definition at line 2432 of file epctx.cpp.

{
    WdfObjectReference(m_Endpoint->m_Ucx);
}

Referenced by SmReference().

◆ Remap()

SM_RESULT XhciEndpointMachine::Remap ( )

private

Definition at line 703 of file epstate.cpp.

{
    ResumeRingFill();
    return SmTransition(&Mapping);
}

Referenced by OnDisabled(), OnMapping(), OnRebuildingContextForReset(), and OnReclaiming().

◆ ReportStoppedEvent()

VOID XhciEndpointMachine::ReportStoppedEvent ( )

private

Definition at line 2545 of file epctx.cpp.

{
    XhciEndpoint* Ep = m_Endpoint;
 
    if (InterlockedXor(&Ep->m_Flags, XHCI_EP_STOPPED_HANDSHAKE) & XHCI_EP_STOPPED_HANDSHAKE)
        Ep->PostEvent(XepEvent::StoppedEventSeen);
}

Referenced by EnterAwaitingStoppedEvent().

◆ ReportTimeout()

VOID XhciEndpointMachine::ReportTimeout ( _In_ XEP_TIMEOUT Timeout )

private

Definition at line 2458 of file epctx.cpp.

{
    XhciEndpoint* Ep = m_Endpoint;
 
    switch (Timeout)
    {
        case XepTimeoutHalt:
            DPRINT1("Endpoint %p DCI %lu stop failed as halted but no halt event came\n", Ep, Ep->m_Dci);
            break;
 
        case XepTimeoutStoppedEvent:
            DPRINT1("Endpoint %p DCI %lu got no stopped event after the stop\n", Ep, Ep->m_Dci);
            break;
 
        case XepTimeoutDrainAfterStop:
            DPRINT1("Endpoint %p DCI %lu expected events still missing after the stop\n", Ep, Ep->m_Dci);
            break;
 
        default:
            DPRINT1("Endpoint %p DCI %lu expected events still missing after the halt\n", Ep, Ep->m_Dci);
            break;
    }
}

Referenced by OnAwaitingHalt(), OnAwaitingStoppedEvent(), and OnDraining().

◆ RequestControllerReset()

VOID XhciEndpointMachine::RequestControllerReset ( )

private

Definition at line 2766 of file epctx.cpp.

{
    XhciEndpoint* Ep = m_Endpoint;
 
    DPRINT1("Endpoint %p DCI %lu would not stop after %lu attempts\n", Ep, Ep->m_Dci, Ep->m_StopAttempts);
    Ep->m_Controller->VerifierCheck(XHCI_VERIFY_STOP_EXHAUSTED);
    Ep->FatalError(XHCI_REASON_STOP_CONTEXT);
}

Referenced by OnAwaitingStopRetry().

◆ ResetDefaultPipe()

VOID XhciEndpointMachine::ResetDefaultPipe ( )

private

Definition at line 2733 of file epctx.cpp.

{
    XhciEndpoint* Ep = m_Endpoint;
    XhciCommand* Command = &Ep->m_Command;
 
    RtlZeroMemory(Command, sizeof(*Command));
    Command->Trb.Dword[3] = XhciEndpointCommandControl(XhciTrbType::ResetEndpoint,
                                                       Ep->m_Dci, Ep->m_Device->SlotId());
    Command->Done = XhciEndpoint::ControlResetDone;
    Command->Context = Ep;
 
    Ep->m_Controller->m_Commands.Submit(Command);
}

Referenced by EnterResettingDefaultPipe().

◆ ResetEndpoint()

VOID XhciEndpointMachine::ResetEndpoint ( )

private

Definition at line 2748 of file epctx.cpp.

{
    XhciEndpoint* Ep = m_Endpoint;
    XhciCommand* Command = &XhciGetRequestData(Ep->m_ResetRequest)->EndpointReset.Command;
 
    RtlZeroMemory(Command, sizeof(*Command));
    Command->Trb.Dword[3] = XhciEndpointCommandControl(XhciTrbType::ResetEndpoint,
                                                       Ep->m_Dci, Ep->m_Device->SlotId());
    if (Ep->ResetPayload()->Flags & FlagEndpointResetPreserveTransferState)
        Command->Trb.Dword[3] |= XHCI_CMD_TRANSFER_STATE_PRESERVE;
 
    Command->Done = XhciEndpoint::ClientResetDone;
    Command->Context = Ep;
 
    Ep->m_Controller->m_Commands.Submit(Command);
}

Referenced by EnterResettingPipe().

◆ ResetStopAttempts()

VOID XhciEndpointMachine::ResetStopAttempts ( )

private

Definition at line 2560 of file epctx.cpp.

{
    m_Endpoint->m_StopAttempts = 0;
}

Referenced by BeginStop().

◆ RestartStreamQueues()

VOID XhciEndpointMachine::RestartStreamQueues ( )

private

Definition at line 2645 of file epctx.cpp.

{
    XhciEndpoint* Ep = m_Endpoint;
    ULONG Index;
 
    if (!(Ep->m_Flags & XHCI_EP_STREAM_HALT_PENDING) || !Ep->UsesStreams())
        return;
 
    for (Index = 0; Index < Ep->m_CurrentStreams->Count; Index++)
        WdfIoQueueStart(Ep->m_CurrentStreams->Entry[Index].Ring->Queue());
}

Referenced by OnReclaiming().

◆ ResumeRingFill()

VOID XhciEndpointMachine::ResumeRingFill ( )

private

Definition at line 2484 of file epctx.cpp.

{
    XhciEndpoint* Ep = m_Endpoint;
 
    InterlockedExchange(&Ep->m_Flags, 0);
    if (Ep->UsesStreams())
        Ep->m_CurrentStreams->HaltedCode = 0;
 
    Ep->ForEachRing(&XhciTransferRing::ResumeRingFill);
}

Referenced by Remap().

◆ RetryStopAfter()

SM_RESULT XhciEndpointMachine::RetryStopAfter ( _In_ ULONG Milliseconds )

private

Definition at line 726 of file epstate.cpp.

{
    m_RetryDelay = Milliseconds;
    return SmTransition(&AwaitingStopRetry);
}

Referenced by BeginStop(), and OnStoppingPipe().

◆ RunTimerExit()

SM_RESULT XhciEndpointMachine::RunTimerExit ( _In_ TIMER_EXIT Exit )

private

Definition at line 750 of file epstate.cpp.

{
    switch (Exit)
    {
        case TimerExitHalt:
            return AfterHalt();
 
        case TimerExitStoppedEvent:
            return AfterStoppedEvent();
 
        case TimerExitStopDrained:
            return AfterStopDrained();
 
        default:
            return AfterHaltDrained();
    }
}

Referenced by EnterLeavingTimer().

◆ SendStopCommand()

VOID XhciEndpointMachine::SendStopCommand ( )

private

Definition at line 2572 of file epctx.cpp.

{
    XhciEndpoint* Ep = m_Endpoint;
    XhciCommand* Command = &Ep->m_Command;
 
    RtlZeroMemory(Command, sizeof(*Command));
    Command->Trb.Dword[3] = XhciEndpointCommandControl(XhciTrbType::StopEndpoint,
                                                       Ep->m_Dci, Ep->m_Device->SlotId());
    Command->Done = XhciEndpoint::StopDone;
    Command->Context = Ep;
 
    Ep->m_Controller->m_Commands.Submit(Command);
}

Referenced by EnterStoppingPipe().

◆ ShouldReconfigureForReset()

BOOLEAN XhciEndpointMachine::ShouldReconfigureForReset ( )

private

Definition at line 2841 of file epctx.cpp.

{
    XhciEndpoint* Ep = m_Endpoint;
    ULONG Type = Ep->TransferType();
 
    /* Like the USB 2.0 stack: nothing to do for a preserved state, control or isoch */
    if ((Ep->ResetPayload()->Flags & FlagEndpointResetPreserveTransferState) ||
        (Type == USB_ENDPOINT_TYPE_CONTROL) ||
        (Type == USB_ENDPOINT_TYPE_ISOCHRONOUS))
    {
        Ep->m_ResetStatus = STATUS_SUCCESS;
        return FALSE;
    }
 
    if (!Ep->AnyTransfersPending())
        return TRUE;
 
    /* QUIRK: with transfers pending a bulk or interrupt reset succeeds without a toggle reset */
    Ep->m_ResetStatus = Ep->m_StreamsCapable ? STATUS_UNSUCCESSFUL : STATUS_SUCCESS;
    return FALSE;
}

Referenced by OnMapping().

◆ SmCancelTimer()

BOOLEAN XhciEndpointMachine::SmCancelTimer ( )

private

Definition at line 207 of file epstate.cpp.

{
    return StopTimer();
}

◆ SmDereference()

VOID XhciEndpointMachine::SmDereference ( )

private

Definition at line 201 of file epstate.cpp.

{
    DereferenceEndpoint();
}

◆ SmReference()

VOID XhciEndpointMachine::SmReference ( )

private

Definition at line 195 of file epstate.cpp.

{
    ReferenceEndpoint();
}

◆ StartTimer()

VOID XhciEndpointMachine::StartTimer ( _In_ ULONG Milliseconds )

private

Definition at line 2450 of file epctx.cpp.

{
    WdfTimerStart(m_Endpoint->m_Timer, WDF_REL_TIMEOUT_IN_MS(Milliseconds));
}

Referenced by EnterAwaitingHalt(), EnterAwaitingStoppedEvent(), EnterAwaitingStopRetry(), and EnterDraining().

◆ StopAttemptsExhausted()

BOOLEAN XhciEndpointMachine::StopAttemptsExhausted ( )

private

Definition at line 2808 of file epctx.cpp.

{
    return m_Endpoint->m_StopAttempts >= XHCI_STOP_ATTEMPTS_MAX;
}

Referenced by OnAwaitingStopRetry().

◆ StopTimer()

BOOLEAN XhciEndpointMachine::StopTimer ( )

private

Definition at line 2444 of file epctx.cpp.

{
    return WdfTimerStop(m_Endpoint->m_Timer, FALSE);
}

Referenced by SmCancelTimer().

◆ SuspendRingFill()

VOID XhciEndpointMachine::SuspendRingFill ( )

private

Definition at line 2496 of file epctx.cpp.

{
    m_Endpoint->ForEachRing(&XhciTransferRing::SuspendRingFill);
}

Referenced by EnterHaltingRingFill().

◆ SuspendRingFillFor()

SM_RESULT XhciEndpointMachine::SuspendRingFillFor ( _In_ MAPPING_STOP_REASON Reason )

private

Definition at line 710 of file epstate.cpp.

{
    m_AfterMapping = Reason;
    return SmTransition(&HaltingRingFill);
}

Referenced by OnMapping().

◆ UpdateDequeuePointers()

VOID XhciEndpointMachine::UpdateDequeuePointers ( )

private

Definition at line 2716 of file epctx.cpp.

{
    XhciEndpoint* Ep = m_Endpoint;
    ULONG StreamId;
 
    if (!Ep->UsesStreams())
    {
        Ep->DequeueAfterStop(0);
        return;
    }
 
    InterlockedExchange(&Ep->m_CurrentStreams->UpdateCount, 0);
    for (StreamId = 1; StreamId <= Ep->m_CurrentStreams->Count; StreamId++)
        Ep->DequeueAfterStop(StreamId);
}

Referenced by EnterUpdatingDequeue().

Friends And Related Function Documentation

◆ SmMachine< XhciEndpointMachine, XepEvent >

friend class SmMachine< XhciEndpointMachine, XepEvent >

friend

Definition at line 1 of file epstate.h.

◆ XhciEndpointProbe

friend class XhciEndpointProbe

friend

Definition at line 59 of file epstate.h.

Member Data Documentation

◆ Active

const Xep::State Xep::Active

staticprivate

Initial value:

=

{ NULL, "Active", 0, &Xep::OnActive, NULL }

XhciEndpointMachine::OnActive

SM_RESULT OnActive(_In_ XepEvent Event)

Definition: epstate.cpp:232

Definition at line 101 of file epstate.h.

◆ AwaitingCancelOk

const Xep::State Xep::AwaitingCancelOk

staticprivate

Initial value:

=
    { &Active, "AwaitingCancelOk", SM_STATE_CRITICAL_ONLY,
      &Xep::OnAwaitingCancelOk, &Xep::EnterAwaitingCancelOk }

Definition at line 113 of file epstate.h.

Referenced by OnUpdatingDequeue().

◆ AwaitingClientReset

const Xep::State Xep::AwaitingClientReset

staticprivate

Initial value:

=

{ &Parked, "AwaitingClientReset", 0, &Xep::OnAwaitingClientReset, NULL, CancelDiscards }

XhciEndpointMachine::OnAwaitingClientReset

SM_RESULT OnAwaitingClientReset(_In_ XepEvent Event)

Definition: epstate.cpp:305

XhciEndpointMachine::Parked

static const State Parked

Definition: epstate.h:106

CancelDiscards

static const XepEvent CancelDiscards[]

Definition: epstate.cpp:58

Definition at line 107 of file epstate.h.

Referenced by AfterHaltDrained(), and OnAwaitingClientReset().

◆ AwaitingControllerReset

const Xep::State Xep::AwaitingControllerReset

staticprivate

Initial value:

=
    { &Fenced, "AwaitingControllerReset", 0,
      &Xep::OnAwaitingControllerReset, &Xep::EnterAwaitingControllerReset }

Definition at line 110 of file epstate.h.

Referenced by OnParked().

◆ AwaitingDisable

const Xep::State Xep::AwaitingDisable

staticprivate

Initial value:

=

{ &Active, "AwaitingDisable", SM_STATE_TAKES_REQUESTS, NULL, NULL, AwaitingDisableDiscards }

AwaitingDisableDiscards

static const XepEvent AwaitingDisableDiscards[]

Definition: epstate.cpp:55

SM_STATE_TAKES_REQUESTS

#define SM_STATE_TAKES_REQUESTS

Definition: smengine.h:39

Definition at line 105 of file epstate.h.

Referenced by OnReclaiming(), and OnRunning().

◆ AwaitingHalt

const Xep::State Xep::AwaitingHalt

staticprivate

Initial value:

=

{ &Timed, "AwaitingHalt", 0, &Xep::OnAwaitingHalt, &Xep::EnterAwaitingHalt }

XhciEndpointMachine::OnAwaitingHalt

SM_RESULT OnAwaitingHalt(_In_ XepEvent Event)

Definition: epstate.cpp:611

XhciEndpointMachine::Timed

static const State Timed

Definition: epstate.h:123

XhciEndpointMachine::EnterAwaitingHalt

SM_RESULT EnterAwaitingHalt()

Definition: epstate.cpp:604

Definition at line 125 of file epstate.h.

Referenced by OnStoppingPipe().

◆ AwaitingRecovery

const Xep::State Xep::AwaitingRecovery

staticprivate

Initial value:

=

{ &Parked, "AwaitingRecovery", 0, NULL, NULL, AwaitingRecoveryDiscards }

AwaitingRecoveryDiscards

static const XepEvent AwaitingRecoveryDiscards[]

Definition: epstate.cpp:61

Definition at line 108 of file epstate.h.

Referenced by OnAwaitingStopRetry(), OnClientResetCommand(), and OnCommanding().

◆ AwaitingStoppedEvent

const Xep::State Xep::AwaitingStoppedEvent

staticprivate

Initial value:

=
    { &Timed, "AwaitingStoppedEvent", 0,
      &Xep::OnAwaitingStoppedEvent, &Xep::EnterAwaitingStoppedEvent }

Definition at line 126 of file epstate.h.

Referenced by AfterStopCommand().

◆ AwaitingStopRetry

const Xep::State Xep::AwaitingStopRetry

staticprivate

Initial value:

=

{ &Timed, "AwaitingStopRetry", 0, &Xep::OnAwaitingStopRetry, &Xep::EnterAwaitingStopRetry }

XhciEndpointMachine::OnAwaitingStopRetry

SM_RESULT OnAwaitingStopRetry(_In_ XepEvent Event)

Definition: epstate.cpp:579

XhciEndpointMachine::EnterAwaitingStopRetry

SM_RESULT EnterAwaitingStopRetry()

Definition: epstate.cpp:572

Definition at line 124 of file epstate.h.

Referenced by RetryStopAfter().

◆ ClientResetCommand

const Xep::State Xep::ClientResetCommand

staticprivate

Initial value:

=

{ &Commanding, "ClientResetCommand", 0, &Xep::OnClientResetCommand, NULL }

XhciEndpointMachine::Commanding

static const State Commanding

Definition: epstate.h:114

XhciEndpointMachine::OnClientResetCommand

SM_RESULT OnClientResetCommand(_In_ XepEvent Event)

Definition: epstate.cpp:489

Definition at line 119 of file epstate.h.

◆ Commanding

const Xep::State Xep::Commanding

staticprivate

Initial value:

=

{ &Active, "Commanding", 0, &Xep::OnCommanding, NULL }

XhciEndpointMachine::OnCommanding

SM_RESULT OnCommanding(_In_ XepEvent Event)

Definition: epstate.cpp:397

Definition at line 114 of file epstate.h.

◆ Disabled

const Xep::State Xep::Disabled

staticprivate

Initial value:

=

{ NULL, "Disabled", SM_STATE_TAKES_REQUESTS, &Xep::OnDisabled, NULL, DisabledDiscards }

XhciEndpointMachine::OnDisabled

SM_RESULT OnDisabled(_In_ XepEvent Event)

Definition: epstate.cpp:213

DisabledDiscards

static const XepEvent DisabledDiscards[]

Definition: epstate.cpp:52

Definition at line 100 of file epstate.h.

Referenced by Initialize(), OnActive(), and OnDisabled().

◆ Draining

const Xep::State Xep::Draining

staticprivate

Initial value:

=

{ &Timed, "Draining", 0, &Xep::OnDraining, &Xep::EnterDraining }

XhciEndpointMachine::OnDraining

SM_RESULT OnDraining(_In_ XepEvent Event)

Definition: epstate.cpp:666

XhciEndpointMachine::EnterDraining

SM_RESULT EnterDraining()

Definition: epstate.cpp:655

Definition at line 127 of file epstate.h.

Referenced by DrainFor().

◆ EventInfo

const SM_EVENT_INFO XhciEndpointMachine::EventInfo

static

Initial value:

=
{
    { "CommandSucceeded",        SmEventCritical,   FALSE, FALSE },
    { "CommandFailed",           SmEventCritical,   FALSE, FALSE },
    { "StreamMapStopped",        SmEventCritical,   FALSE, FALSE },
    { "CancelAllowed",           SmEventCritical,   FALSE, FALSE },
    { "StopFailedHalted",        SmEventCritical,   FALSE, FALSE },
    { "StopFailedRunning",       SmEventCritical,   FALSE, FALSE },
    { "StopFailedStopped",       SmEventCritical,   FALSE, FALSE },
    { "BufferAllocFailed",       SmEventCompletion, FALSE, FALSE },
    { "ExpectedEventsDone",      SmEventCompletion, FALSE, FALSE },
    { "StoppedEventSeen",        SmEventCompletion, FALSE, FALSE },
    { "HaltReported",            SmEventCompletion, FALSE, FALSE },
    { "StreamsOff",              SmEventCompletion, FALSE, FALSE },
    { "StreamsOn",               SmEventCompletion, FALSE, FALSE },
    { "TimerFired",              SmEventCompletion, FALSE, FALSE },
    { "TransferAborted",         SmEventCompletion, FALSE, FALSE },
    { "TransfersRecovered",      SmEventCompletion, FALSE, FALSE },
    { "ControllerResetStarting", SmEventRequest,    FALSE, FALSE },
    { "ControllerResetDone",     SmEventRequest,    FALSE, FALSE },
    { "ControllerRemoved",       SmEventRequest,    FALSE, FALSE },
    { "Disable",                 SmEventRequest,    FALSE, FALSE },
    { "Enable",                  SmEventRequest,    FALSE, FALSE },
    { "ClientReset",             SmEventRequest,    FALSE, FALSE },
}

Definition at line 72 of file epstate.h.

◆ Fenced

const Xep::State Xep::Fenced

staticprivate

Initial value:

=

{ &Active, "Fenced", SM_STATE_TAKES_REQUESTS, NULL, NULL, FencedDiscards }

FencedDiscards

static const XepEvent FencedDiscards[]

Definition: epstate.cpp:64

Definition at line 109 of file epstate.h.

◆ HaltingRingFill

const Xep::State Xep::HaltingRingFill

staticprivate

Initial value:

=
    { &Active, "HaltingRingFill", SM_STATE_CRITICAL_ONLY,
      &Xep::OnHaltingRingFill, &Xep::EnterHaltingRingFill }

Definition at line 112 of file epstate.h.

Referenced by SuspendRingFillFor().

◆ LeavingTimer

const Xep::State Xep::LeavingTimer

staticprivate

Initial value:

=

{ &Active, "LeavingTimer", 0, NULL, &Xep::EnterLeavingTimer }

XhciEndpointMachine::EnterLeavingTimer

SM_RESULT EnterLeavingTimer()

Runs the timer exit; the engine already stopped the timer, so it cannot fire after this.

Definition: epstate.cpp:697

Definition at line 128 of file epstate.h.

Referenced by LeaveTimerFor().

◆ m_AfterMapping

MAPPING_STOP_REASON XhciEndpointMachine::m_AfterMapping

private

Definition at line 319 of file epstate.h.

Referenced by EnterHaltingRingFill(), Initialize(), OnHaltingRingFill(), and SuspendRingFillFor().

◆ m_AfterReclaim

RECLAIM_REASON XhciEndpointMachine::m_AfterReclaim

private

Definition at line 320 of file epstate.h.

Referenced by Initialize(), OnReclaiming(), ReclaimFor(), and ReclaimIgnoresCancel().

◆ m_AfterTimer

TIMER_EXIT XhciEndpointMachine::m_AfterTimer

private

Definition at line 321 of file epstate.h.

Referenced by EnterLeavingTimer(), Initialize(), and LeaveTimerFor().

◆ m_DrainAfterHalt

BOOLEAN XhciEndpointMachine::m_DrainAfterHalt

private

Definition at line 323 of file epstate.h.

Referenced by DrainFor(), EnterDraining(), Initialize(), and OnDraining().

◆ m_Endpoint

XhciEndpoint* XhciEndpointMachine::m_Endpoint

private

Definition at line 318 of file epstate.h.

Referenced by AckControllerReset(), AskUcxToCancel(), CanResetAfterHalt(), CompleteResetRequest(), CompleteResetRequestIfAllowed(), CountStopAttempt(), DelaysFirstStop(), DereferenceEndpoint(), DoorbellRungSinceFill(), DropStoppedEvent(), Endpoint(), IgnoresStopContextError(), Initialize(), IsControlEndpoint(), NeedsContextRebuildAfterStop(), NotifyRingsClientReset(), NotifyRingsDrainEvents(), NotifyRingsHalted(), NotifyRingsReclaim(), NotifyRingsReclaimOnCancel(), NotifyRingsStoppedEvent(), OnPrimaryInterrupterOnly(), PurgeStreamQueues(), ReconfigureAfterStop(), ReconfigureForReset(), ReferenceEndpoint(), ReportStoppedEvent(), ReportTimeout(), RequestControllerReset(), ResetDefaultPipe(), ResetEndpoint(), ResetStopAttempts(), RestartStreamQueues(), ResumeRingFill(), SendStopCommand(), ShouldReconfigureForReset(), StartTimer(), StopAttemptsExhausted(), StopTimer(), SuspendRingFill(), and UpdateDequeuePointers().

◆ m_RetryDelay

ULONG XhciEndpointMachine::m_RetryDelay

private

Definition at line 322 of file epstate.h.

Referenced by EnterAwaitingStopRetry(), Initialize(), and RetryStopAfter().

◆ Mapping

const Xep::State Xep::Mapping

staticprivate

Initial value:

=

{ &Running, "Mapping", 0, &Xep::OnMapping, NULL }

XhciEndpointMachine::OnMapping

SM_RESULT OnMapping(_In_ XepEvent Event)

Definition: epstate.cpp:253

XhciEndpointMachine::Running

static const State Running

Definition: epstate.h:102

Definition at line 103 of file epstate.h.

Referenced by OnMapping(), and Remap().

◆ Parked

const Xep::State Xep::Parked

staticprivate

Initial value:

=

{ &Active, "Parked", SM_STATE_TAKES_REQUESTS, &Xep::OnParked, NULL }

XhciEndpointMachine::OnParked

SM_RESULT OnParked(_In_ XepEvent Event)

Definition: epstate.cpp:288

Definition at line 106 of file epstate.h.

◆ RebuildingContextAfterStop

const Xep::State Xep::RebuildingContextAfterStop

staticprivate

Initial value:

=
    { &Commanding, "RebuildingContextAfterStop", SM_STATE_CRITICAL_ONLY,
      &Xep::OnRebuildingContextAfterStop, &Xep::EnterRebuildingContextAfterStop }

Definition at line 116 of file epstate.h.

Referenced by AfterStopDrained().

◆ RebuildingContextForReset

const Xep::State Xep::RebuildingContextForReset

staticprivate

Initial value:

=
    { &ClientResetCommand, "RebuildingContextForReset", 0,
      &Xep::OnRebuildingContextForReset, &Xep::EnterRebuildingContextForReset }

Definition at line 121 of file epstate.h.

Referenced by OnHaltingRingFill().

◆ Reclaiming

const Xep::State Xep::Reclaiming

staticprivate

Initial value:

=

{ &Active, "Reclaiming", 0, &Xep::OnReclaiming, &Xep::EnterReclaiming }

XhciEndpointMachine::EnterReclaiming

SM_RESULT EnterReclaiming()

Definition: epstate.cpp:536

XhciEndpointMachine::OnReclaiming

SM_RESULT OnReclaiming(_In_ XepEvent Event)

Definition: epstate.cpp:546

Definition at line 122 of file epstate.h.

Referenced by ReclaimFor().

◆ Removed

const Xep::State Xep::Removed

staticprivate

Initial value:

=

{ &Fenced, "Removed", 0, NULL, &Xep::EnterRemoved }

XhciEndpointMachine::EnterRemoved

SM_RESULT EnterRemoved()

Definition: epstate.cpp:336

Definition at line 111 of file epstate.h.

Referenced by OnHaltingRingFill(), and OnParked().

◆ ResettingDefaultPipe

const Xep::State Xep::ResettingDefaultPipe

staticprivate

Initial value:

=
    { &Commanding, "ResettingDefaultPipe", 0,
      &Xep::OnResettingDefaultPipe, &Xep::EnterResettingDefaultPipe, CancelDiscards }

Definition at line 118 of file epstate.h.

Referenced by AfterHalt().

◆ ResettingPipe

const Xep::State Xep::ResettingPipe

staticprivate

Initial value:

=
    { &ClientResetCommand, "ResettingPipe", 0,
      &Xep::OnResettingPipe, &Xep::EnterResettingPipe }

Definition at line 120 of file epstate.h.

Referenced by OnAwaitingClientReset().

◆ ResetWhileMapping

const Xep::State Xep::ResetWhileMapping

staticprivate

Initial value:

=

{ &Running, "ResetWhileMapping", 0, NULL, NULL }

Definition at line 104 of file epstate.h.

Referenced by OnMapping().

◆ Running

const Xep::State Xep::Running

staticprivate

Initial value:

=

{ &Active, "Running", SM_STATE_TAKES_REQUESTS, &Xep::OnRunning, NULL }

XhciEndpointMachine::OnRunning

SM_RESULT OnRunning(_In_ XepEvent Event)

Definition: epstate.cpp:242

Definition at line 102 of file epstate.h.

◆ SmCompletionsFirst

const BOOLEAN XhciEndpointMachine::SmCompletionsFirst = FALSE

staticprivate

Definition at line 131 of file epstate.h.

◆ SmTimerEventId

const USHORT XhciEndpointMachine::SmTimerEventId = static_cast<USHORT>(XepEvent::TimerFired)

staticprivate

Definition at line 132 of file epstate.h.

◆ StoppingPipe

const Xep::State Xep::StoppingPipe

staticprivate

Initial value:

=
    { &Commanding, "StoppingPipe", SM_STATE_CRITICAL_ONLY,
      &Xep::OnStoppingPipe, &Xep::EnterStoppingPipe }

Definition at line 115 of file epstate.h.

Referenced by BeginStop(), and OnAwaitingStopRetry().

◆ Timed

const Xep::State Xep::Timed

staticprivate

Initial value:

=

{ &Active, "Timed", SM_STATE_STOP_TIMER_ON_EXIT, NULL, NULL }

SM_STATE_STOP_TIMER_ON_EXIT

#define SM_STATE_STOP_TIMER_ON_EXIT

Definition: smengine.h:43

Definition at line 123 of file epstate.h.

◆ UpdatingDequeue

const Xep::State Xep::UpdatingDequeue

staticprivate

Initial value:

=
    { &Commanding, "UpdatingDequeue", SM_STATE_CRITICAL_ONLY,
      &Xep::OnUpdatingDequeue, &Xep::EnterUpdatingDequeue }

Definition at line 117 of file epstate.h.

Referenced by AfterStopDrained(), and OnRebuildingContextAfterStop().

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

drivers/usb/usbxhci/epstate.h
drivers/usb/usbxhci/epctx.cpp
drivers/usb/usbxhci/epstate.cpp

Public Member Functions

Static Public Attributes

Private Types

Private Member Functions

Private Attributes

Static Private Attributes

Friends

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ MAPPING_STOP_REASON

◆ RECLAIM_REASON

◆ TIMER_EXIT

Member Function Documentation

◆ AckControllerReset()

◆ AfterHalt()

◆ AfterHaltDrained()

◆ AfterStopCommand()

◆ AfterStopDrained()

◆ AfterStoppedEvent()

◆ AskUcxToCancel()

◆ BeginStop()

◆ CanResetAfterHalt()

◆ CompleteResetRequest()

◆ CompleteResetRequestIfAllowed()

◆ CountStopAttempt()

◆ DelaysFirstStop()

◆ DereferenceEndpoint()

◆ DoorbellRungSinceFill()

◆ DrainFor()

◆ DropStoppedEvent()

◆ Endpoint()

◆ EnterAwaitingCancelOk()

◆ EnterAwaitingControllerReset()

◆ EnterAwaitingHalt()

◆ EnterAwaitingStoppedEvent()

◆ EnterAwaitingStopRetry()

◆ EnterDraining()

◆ EnterHaltingRingFill()

◆ EnterLeavingTimer()

◆ EnterRebuildingContextAfterStop()

◆ EnterRebuildingContextForReset()

◆ EnterReclaiming()

◆ EnterRemoved()

◆ EnterResettingDefaultPipe()

◆ EnterResettingPipe()

◆ EnterStoppingPipe()

◆ EnterUpdatingDequeue()

◆ IgnoresStopContextError()

◆ Initialize()

◆ IsControlEndpoint()

◆ LeaveTimerFor()

◆ NeedsContextRebuildAfterStop()

◆ NotifyRingsClientReset()

◆ NotifyRingsDrainEvents()

◆ NotifyRingsHalted()

◆ NotifyRingsReclaim()

◆ NotifyRingsReclaimOnCancel()

◆ NotifyRingsStoppedEvent()

◆ OnActive()

◆ OnAwaitingCancelOk()

◆ OnAwaitingClientReset()

◆ OnAwaitingControllerReset()

◆ OnAwaitingHalt()

◆ OnAwaitingStoppedEvent()

◆ OnAwaitingStopRetry()

◆ OnClientResetCommand()

◆ OnCommanding()

◆ OnDisabled()

◆ OnDraining()

◆ OnHaltingRingFill()

◆ OnMapping()

◆ OnParked()

◆ OnPrimaryInterrupterOnly()

◆ OnRebuildingContextAfterStop()

◆ OnRebuildingContextForReset()

◆ OnReclaiming()

◆ OnResettingDefaultPipe()

◆ OnResettingPipe()

◆ OnRunning()