XhciCommandRing Class Reference

#include <cmdring.h>

Collaboration diagram for XhciCommandRing:

Public Member Functions
NTSTATUS	Create (_In_ XhciController *Controller)
NTSTATUS	Prepare ()
VOID	Release ()
NTSTATUS	D0Entry ()
VOID	PostInterruptsEntry ()
VOID	PreReset ()
VOID	PostReset ()
VOID	PostResetSuccess ()
VOID	FailAll ()
VOID	OnHostLost ()
	_IRQL_requires_max_ (DISPATCH_LEVEL) VOID Submit(_Inout_ XhciCommand *Command)
	_IRQL_requires_ (PASSIVE_LEVEL) NTSTATUS SubmitAndWait(_Inout_ XhciCommand *Command)
VOID	OnCompletionEvent (_In_ const XHCI_TRB *Event)

Static Public Attributes
static EVT_WDF_TIMER	EvtTimer

Private Types
enum class	RingState : ULONG { Uninitialized , Prepared , Released }
enum class	ResetPhase : ULONG {   Idle , Requested , Resetting , AfterReset ,   Failed }

Private Member Functions
VOID	InitializeRing ()
VOID	OnTimer ()
VOID	PlaceLocked (_Inout_ XhciCommand *Command, _In_ BOOLEAN FrontOfLine, _Inout_ PLIST_ENTRY Finished)
VOID	PutOnRingLocked (_Inout_ XhciCommand *Command)
VOID	RestartStoppedRingLocked (_Inout_ PLIST_ENTRY Finished)
VOID	HandleRingStopped (_In_ const XHCI_TRB *Event)
VOID	DrainAllLocked (_Inout_ PLIST_ENTRY Finished)
VOID	FailEverything ()
ULONG64	TrbAddress (_In_ ULONG Index) const

Private Attributes
XhciController *	m_Controller
WDFTIMER	m_Timer
KSPIN_LOCK	m_Lock
RingState	m_State
ResetPhase	m_Reset
XhciDmaBuffer *	m_Segment
PXHCI_TRB	m_Trbs
ULONG64	m_RingAddress
ULONG64	m_LinkAddress
ULONG	m_Enqueue
ULONG	m_Dequeue
ULONG	m_Cycle
LIST_ENTRY	m_Pending
LIST_ENTRY	m_Waiting
BOOLEAN	m_OutOfOrderSeen
BOOLEAN	m_Aborting
LONG	m_AbortTicks
BOOLEAN	m_DrainFromTimer

Detailed Description

The command ring.

Definition at line 42 of file cmdring.h.

Member Enumeration Documentation

ResetPhase

enum class XhciCommandRing::ResetPhase : ULONG

strongprivate

Enumerator
Idle
Requested
Resetting
AfterReset
Failed

Definition at line 86 of file cmdring.h.

    {
        Idle,
        Requested,
        Resetting,
        AfterReset,
        Failed
    };

RingState

enum class XhciCommandRing::RingState : ULONG

strongprivate

Enumerator
Uninitialized
Prepared
Released

Definition at line 79 of file cmdring.h.

    {
        Uninitialized,
        Prepared,
        Released
    };

Member Function Documentation

_IRQL_requires_()

XhciCommandRing::_IRQL_requires_

(

PASSIVE_LEVEL

)

PASSIVE_LEVEL helper: submits and waits for Done.

_IRQL_requires_max_()

XhciCommandRing::_IRQL_requires_max_

(

DISPATCH_LEVEL

)

Queues Command; Done always runs exactly once, possibly before this returns.

Create()

NTSTATUS XhciCommandRing::Create

(

_In_ XhciController *

Controller

)

Definition at line 95 of file cmdring.cpp.

{
    WDF_TIMER_CONFIG Config;
    WDF_OBJECT_ATTRIBUTES Attributes;
    NTSTATUS Status;
 
    PAGED_CODE();
 
    m_Controller = Controller;
    m_Timer = NULL;
    KeInitializeSpinLock(&m_Lock);
    m_State = RingState::Uninitialized;
    m_Reset = ResetPhase::Idle;
    m_Segment = NULL;
    m_Trbs = NULL;
    m_RingAddress = 0;
    m_LinkAddress = 0;
    m_Enqueue = 0;
    m_Dequeue = 0;
    m_Cycle = XHCI_TRB_CYCLE;
    InitializeListHead(&m_Pending);
    InitializeListHead(&m_Waiting);
    m_OutOfOrderSeen = FALSE;
    m_Aborting = FALSE;
    m_AbortTicks = 0;
    m_DrainFromTimer = FALSE;
 
    WDF_TIMER_CONFIG_INIT_PERIODIC(&Config, XhciCommandRing::EvtTimer, XhciCmdTickMs);
    Config.TolerableDelay = XhciCmdTickSlackMs;
    Config.AutomaticSerialization = FALSE;
 
    WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&Attributes, XHCI_COMMAND_TIMER_CONTEXT);
    Attributes.ParentObject = Controller->m_Device;
    Attributes.ExecutionLevel = WdfExecutionLevelDispatch;
 
    Status = WdfTimerCreate(&Config, &Attributes, &m_Timer);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Command timer creation failed 0x%lx\n", Status);
        m_Timer = NULL;
        return Status;
    }
 
    XhciGetCommandTimerContext(m_Timer)->Ring = this;
    return STATUS_SUCCESS;
}

Referenced by XhciController::Initialize().

D0Entry()

NTSTATUS XhciCommandRing::D0Entry

(

)

Definition at line 247 of file cmdring.cpp.

{
    InitializeRing();
    return STATUS_SUCCESS;
}

Referenced by XhciController::RunD0Pass().

DrainAllLocked()

VOID XhciCommandRing::DrainAllLocked ( _Inout_ PLIST_ENTRY  Finished )

private

Definition at line 350 of file cmdring.cpp.

{
    XhciCommand* Command;
 
    /* QUIRK: Code keeps whatever it last held, so handlers must check Status first */
    while (!IsListEmpty(&m_Pending))
    {
        Command = XhciCmdFromLink(RemoveHeadList(&m_Pending));
        Command->Status = STATUS_NO_SUCH_DEVICE;
        InsertTailList(Finished, &Command->Link);
    }
 
    while (!IsListEmpty(&m_Waiting))
    {
        Command = XhciCmdFromLink(RemoveHeadList(&m_Waiting));
        Command->Status = STATUS_NO_SUCH_DEVICE;
        InsertTailList(Finished, &Command->Link);
    }
}

Referenced by FailEverything(), OnTimer(), PostReset(), and Release().

FailAll()

VOID XhciCommandRing::FailAll

(

)

Definition at line 807 of file cmdring.cpp.

{
    FailEverything();
}

Referenced by XhciController::InternalReset().

FailEverything()

VOID XhciCommandRing::FailEverything ( )

private

Definition at line 787 of file cmdring.cpp.

{
    LIST_ENTRY Finished;
    KIRQL OldIrql;
 
    InitializeListHead(&Finished);
 
    KeAcquireSpinLock(&m_Lock, &OldIrql);
    m_Reset = ResetPhase::Failed;
    m_Aborting = FALSE;
    m_DrainFromTimer = TRUE;
    DrainAllLocked(&Finished);
    if (m_Timer)
        WdfTimerStop(m_Timer, FALSE);
    KeReleaseSpinLock(&m_Lock, OldIrql);
 
    XhciCmdCompleteList(&Finished);
}

Referenced by FailAll(), and OnHostLost().

HandleRingStopped()

VOID XhciCommandRing::HandleRingStopped ( _In_ const XHCI_TRB *  Event )

private

Definition at line 571 of file cmdring.cpp.

{
    LIST_ENTRY Finished;
    ULONG64 Reported;
    ULONG64 Expected;
    KIRQL OldIrql;
 
    InitializeListHead(&Finished);
    Reported = XhciTrbPointer(Event) & ~0xFULL;
 
    KeAcquireSpinLock(&m_Lock, &OldIrql);
 
    m_Aborting = FALSE;
    Expected = TrbAddress(m_Dequeue);
 
    if (Reported != Expected && !(Reported == m_LinkAddress && m_Dequeue == 0))
    {
        DPRINT1("Command ring stopped at 0x%I64x, expected 0x%I64x; asking for a reset\n",
                Reported, Expected);
        m_Reset = ResetPhase::Requested;
        KeReleaseSpinLock(&m_Lock, OldIrql);
 
        m_Controller->RaiseControllerFault(XhciRecovery::ResetHost, XhciCmdReasonDequeueMismatch);
        return;
    }
 
    RestartStoppedRingLocked(&Finished);
 
    KeReleaseSpinLock(&m_Lock, OldIrql);
 
    XhciCmdCompleteList(&Finished);
}

Referenced by OnCompletionEvent().

InitializeRing()

VOID XhciCommandRing::InitializeRing ( )

private

Definition at line 214 of file cmdring.cpp.

{
    PXHCI_TRB Link;
    KIRQL OldIrql;
 
    if (m_State != RingState::Prepared || !m_Controller->IsAccessible())
        return;
 
    KeAcquireSpinLock(&m_Lock, &OldIrql);
 
    ASSERT(IsListEmpty(&m_Pending));
    ASSERT(IsListEmpty(&m_Waiting));
 
    m_Enqueue = 0;
    m_Dequeue = 0;
    m_Cycle = XHCI_TRB_CYCLE;
    RtlZeroMemory(m_Trbs, XhciCmdTrbCount * sizeof(*m_Trbs));
 
    /* The Link TRB starts with cycle 0, so the xHC does not follow it until we wrap */
    Link = &m_Trbs[XhciCmdUsable];
    Link->Dword[0] = static_cast<ULONG>(m_RingAddress);
    Link->Dword[1] = static_cast<ULONG>(m_RingAddress >> 32);
    Link->Dword[2] = 0;
    Link->Dword[3] = (static_cast<ULONG>(XhciTrbType::Link) << XHCI_TRB_TYPE_SHIFT) |
                     XHCI_LINK_TOGGLE_CYCLE;
 
    KeMemoryBarrier();
    m_Controller->m_Registers.WriteOperational64(XHCI_OP_CRCR, m_RingAddress | m_Cycle);
 
    KeReleaseSpinLock(&m_Lock, OldIrql);
}

Referenced by D0Entry(), and PostReset().

OnCompletionEvent()

VOID XhciCommandRing::OnCompletionEvent

(

_In_ const XHCI_TRB *

Event

)

Definition at line 438 of file cmdring.cpp.

{
    LIST_ENTRY Finished;
    PLIST_ENTRY Entry;
    XhciCommand* Command;
    XhciCompletionCode Code;
    ULONG64 Pointer;
    BOOLEAN Retired;
    BOOLEAN OutOfOrder;
    KIRQL OldIrql;
 
    Code = static_cast<XhciCompletionCode>(XhciTrbCompletionCode(Event));
    if (Code == XhciCompletionCode::CommandRingStopped)
    {
        HandleRingStopped(Event);
        return;
    }
 
    InitializeListHead(&Finished);
    Pointer = XhciTrbPointer(Event) & ~0xFULL;
    Retired = FALSE;
    OutOfOrder = FALSE;
 
    KeAcquireSpinLock(&m_Lock, &OldIrql);
 
    for (Entry = m_Pending.Flink; Entry != &m_Pending; Entry = Entry->Flink)
    {
        Command = XhciCmdFromLink(Entry);
        if (!Command->Matched && TrbAddress(Command->RingIndex) == Pointer)
        {
            Command->Matched = TRUE;
            Command->Code = Code;
            Command->Completion = *Event;
            break;
        }
    }
 
    /* Retire in ring order so the dequeue index stays in step with the xHC */
    while (!IsListEmpty(&m_Pending))
    {
        Command = XhciCmdFromLink(m_Pending.Flink);
        if (!Command->Matched)
            break;
 
        RemoveHeadList(&m_Pending);
        ASSERT(Command->RingIndex == m_Dequeue);
        m_Dequeue = (m_Dequeue + 1) % XhciCmdUsable;
        Command->Status = XhciCmdStatusFromCode(Command->Code);
        InsertTailList(&Finished, &Command->Link);
        Retired = TRUE;
 
        if (!IsListEmpty(&m_Waiting))
            PlaceLocked(XhciCmdFromLink(RemoveHeadList(&m_Waiting)), TRUE, &Finished);
    }
 
    /* QUIRK: an event that matches nothing counts as out of order too */
    if (!Retired && !m_OutOfOrderSeen)
    {
        DPRINT1("Command completion out of order: TRB 0x%I64x code %lu\n",
                Pointer, static_cast<ULONG>(Code));
        m_OutOfOrderSeen = TRUE;
        OutOfOrder = TRUE;
    }
 
    if (IsListEmpty(&m_Pending) && !m_Aborting)
        WdfTimerStop(m_Timer, FALSE);
 
    KeReleaseSpinLock(&m_Lock, OldIrql);
 
    if (OutOfOrder)
        m_Controller->RaiseControllerFault(XhciRecovery::Ignore, XhciCmdReasonOutOfOrder);
 
    XhciCmdCompleteList(&Finished);
}

OnHostLost()

VOID XhciCommandRing::OnHostLost

(

)

Definition at line 813 of file cmdring.cpp.

{
    FailEverything();
}

Referenced by XhciController::RunRecovery().

OnTimer()

VOID XhciCommandRing::OnTimer ( )

private

Definition at line 614 of file cmdring.cpp.

{
    LIST_ENTRY Finished;
    XhciCommand* Head;
    ULONG64 Crcr;
    BOOLEAN Accessible;
    BOOLEAN NewlyGone;
    BOOLEAN WantReset;
    BOOLEAN WantInternal = FALSE;
    KIRQL OldIrql;
 
    InitializeListHead(&Finished);
    Accessible = m_Controller->IsAccessible();
    NewlyGone = FALSE;
    WantReset = FALSE;
 
    KeAcquireSpinLock(&m_Lock, &OldIrql);
 
    if (Accessible && m_Reset == ResetPhase::Idle && m_State == RingState::Prepared)
    {
        Head = IsListEmpty(&m_Pending) ? NULL : XhciCmdFromLink(m_Pending.Flink);
 
        if (!Head && !m_Aborting)
        {
            WdfTimerStop(m_Timer, FALSE);
        }
        else
        {
            Crcr = m_Controller->m_Registers.ReadOperational64(XHCI_OP_CRCR);
 
            if (Crcr == ~0ULL)
            {
                DPRINT1("Command ring control reads all ones, controller is gone\n");
                Accessible = FALSE;
                NewlyGone = TRUE;
            }
            else if (m_Aborting)
            {
                m_AbortTicks--;
                if (m_AbortTicks <= 0)
                {
                    m_Aborting = FALSE;
 
                    if (Crcr & XHCI_CRCR_RUNNING)
                    {
                        DPRINT1("Command abort timed out with the ring running; asking for a reset\n");
                        WdfTimerStop(m_Timer, FALSE);
                        m_Reset = ResetPhase::Requested;
                        WantReset = TRUE;
                        WantInternal = (Head != NULL && Head->Internal);
                    }
                    else
                    {
                        DPRINT1("Command abort timed out with the ring stopped; restarting it\n");
                        RestartStoppedRingLocked(&Finished);
                    }
                }
            }
            else
            {
                if (Head->Countdown > 0)
                    Head->Countdown--;
 
                if (Head->Countdown == XhciCmdTicksFirstAbort || Head->Countdown == 0)
                {
                    if (Crcr & XHCI_CRCR_RUNNING)
                    {
                        DPRINT1("Command type %lu timed out, aborting\n", XhciTrbType(&Head->Trb));
 
                        /* Address Device with BSR clear waits on the bus, so it is not a controller fault */
                        if (XhciTrbType(&Head->Trb) != static_cast<ULONG>(XhciTrbType::AddressDevice) ||
                            (Head->Trb.Dword[3] & XhciCmdBlockSetAddress))
                        {
                            DPRINT1("Controller did not finish a command within %ld s\n",
                                    XhciCmdTicksInitial - Head->Countdown);
                        }
 
                        m_Aborting = TRUE;
                        m_AbortTicks = XhciCmdTicksAbortWait;
                        m_Controller->m_Registers.WriteOperational64(XHCI_OP_CRCR,
                                                                     Crcr | XHCI_CRCR_ABORT);
                    }
                    else
                    {
                        DPRINT1("Command ring not running with a command pending; asking for a reset\n");
                        WdfTimerStop(m_Timer, FALSE);
                        m_Reset = ResetPhase::Requested;
                        WantReset = TRUE;
                        WantInternal = Head->Internal;
                    }
                }
            }
        }
    }
 
    if (!Accessible)
    {
        if (m_DrainFromTimer)
            DrainAllLocked(&Finished);
 
        WdfTimerStop(m_Timer, FALSE);
    }
 
    KeReleaseSpinLock(&m_Lock, OldIrql);
 
    if (NewlyGone)
        m_Controller->MarkGone();
 
    XhciCmdCompleteList(&Finished);
 
    if (WantReset)
    {
        m_Controller->RaiseControllerFault(WantInternal ? XhciRecovery::InternalReset : XhciRecovery::ResetHost,
                                           XhciCmdReasonAbortFailed);
    }
}

PlaceLocked()

VOID XhciCommandRing::PlaceLocked ( _Inout_ XhciCommand *  Command, _In_ BOOLEAN  FrontOfLine, _Inout_ PLIST_ENTRY  Finished  )

private

Definition at line 303 of file cmdring.cpp.

{
    BOOLEAN Park;
 
    if (m_Reset == ResetPhase::AfterReset || m_Reset == ResetPhase::Failed)
    {
        /* Fail at once; Done runs after the ring lock is dropped */
        Command->Status = STATUS_NO_SUCH_DEVICE;
        InsertTailList(Finished, &Command->Link);
        return;
    }
 
    Park = FALSE;
    if (m_Reset == ResetPhase::Requested || m_Reset == ResetPhase::Resetting)
    {
        Park = TRUE;
    }
    else if (m_Aborting)
    {
        Park = TRUE;
    }
    else if (!IsListEmpty(&m_Pending) && m_Controller->HasErrata(XhciErrata::CmdOneInFlight))
    {
        Park = TRUE;
    }
    else if ((m_Enqueue + 1) % XhciCmdUsable == m_Dequeue)
    {
        Command->Countdown = XhciCmdTicksInitial;
        Park = TRUE;
    }
 
    if (!Park)
    {
        PutOnRingLocked(Command);
        return;
    }
 
    if (FrontOfLine)
        InsertHeadList(&m_Waiting, &Command->Link);
    else
        InsertTailList(&m_Waiting, &Command->Link);
}

Referenced by OnCompletionEvent(), PostResetSuccess(), and RestartStoppedRingLocked().

PostInterruptsEntry()

VOID XhciCommandRing::PostInterruptsEntry

(

)

Definition at line 254 of file cmdring.cpp.

{
    /* The controller module issues the vendor firmware queries through SubmitAndWait */
}

Referenced by XhciController::D0EntryPostInterruptsEnabled().

PostReset()

VOID XhciCommandRing::PostReset

(

)

Definition at line 743 of file cmdring.cpp.

{
    LIST_ENTRY Finished;
    KIRQL OldIrql;
 
    InitializeListHead(&Finished);
 
    KeAcquireSpinLock(&m_Lock, &OldIrql);
    DrainAllLocked(&Finished);
    WdfTimerStop(m_Timer, FALSE);
    m_Reset = ResetPhase::AfterReset;
    KeReleaseSpinLock(&m_Lock, OldIrql);
 
    XhciCmdCompleteList(&Finished);
 
    InitializeRing();
}

Referenced by XhciController::InternalReset().

PostResetSuccess()

VOID XhciCommandRing::PostResetSuccess

(

)

Definition at line 762 of file cmdring.cpp.

{
    LIST_ENTRY Finished;
    LIST_ENTRY Requeue;
    KIRQL OldIrql;
 
    InitializeListHead(&Finished);
    InitializeListHead(&Requeue);
 
    KeAcquireSpinLock(&m_Lock, &OldIrql);
 
    m_Reset = ResetPhase::Idle;
 
    while (!IsListEmpty(&m_Waiting))
        InsertTailList(&Requeue, RemoveHeadList(&m_Waiting));
 
    while (!IsListEmpty(&Requeue))
        PlaceLocked(XhciCmdFromLink(RemoveHeadList(&Requeue)), FALSE, &Finished);
 
    KeReleaseSpinLock(&m_Lock, OldIrql);
 
    XhciCmdCompleteList(&Finished);
}

Referenced by XhciController::InternalReset().

Prepare()

NTSTATUS XhciCommandRing::Prepare

(

)

Definition at line 144 of file cmdring.cpp.

{
    PAGED_CODE();
 
    m_Segment = m_Controller->m_Buffers.Acquire(XhciCmdTrbCount * sizeof(*m_Trbs));
    if (!m_Segment)
    {
        DPRINT1("No common buffer for the command ring, 0x%lx\n", STATUS_INSUFFICIENT_RESOURCES);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    m_Trbs = static_cast<PXHCI_TRB>(m_Segment->VirtualAddress);
    m_RingAddress = m_Segment->LogicalAddress.QuadPart;
    m_LinkAddress = TrbAddress(XhciCmdUsable);
    m_Enqueue = 0;
    m_Dequeue = 0;
    m_Cycle = XHCI_TRB_CYCLE;
    InitializeListHead(&m_Pending);
    InitializeListHead(&m_Waiting);
 
    /* A restart after a failed controller must accept commands again */
    m_Reset = ResetPhase::Idle;
    m_Aborting = FALSE;
    m_DrainFromTimer = FALSE;
 
    m_State = RingState::Prepared;
    return STATUS_SUCCESS;
}

Referenced by XhciController::PrepareHardware().

PreReset()

VOID XhciCommandRing::PreReset

(

)

Definition at line 732 of file cmdring.cpp.

{
    KIRQL OldIrql;
 
    KeAcquireSpinLock(&m_Lock, &OldIrql);
    m_Reset = ResetPhase::Resetting;
    m_Aborting = FALSE;
    KeReleaseSpinLock(&m_Lock, OldIrql);
}

Referenced by XhciController::InternalReset().

PutOnRingLocked()

VOID XhciCommandRing::PutOnRingLocked ( _Inout_ XhciCommand *  Command )

private

Definition at line 260 of file cmdring.cpp.

{
    volatile ULONG* Control;
    PXHCI_TRB Slot;
    BOOLEAN WasIdle;
 
    Slot = &m_Trbs[m_Enqueue];
 
    Command->Countdown = XhciCmdTicksInitial;
    Command->Matched = FALSE;
    Command->RingIndex = m_Enqueue;
 
    /* Dword 3 holds the cycle bit, so the xHC may only see it after the rest */
    Slot->Dword[0] = Command->Trb.Dword[0];
    Slot->Dword[1] = Command->Trb.Dword[1];
    Slot->Dword[2] = Command->Trb.Dword[2];
    KeMemoryBarrier();
    Control = &Slot->Dword[3];
    *Control = (Command->Trb.Dword[3] & ~XHCI_TRB_CYCLE) | m_Cycle;
 
    WasIdle = IsListEmpty(&m_Pending);
    InsertTailList(&m_Pending, &Command->Link);
 
    m_Enqueue++;
    if (m_Enqueue == XhciCmdUsable)
    {
        /* Hand the Link TRB over with the cycle of the pass that just ended */
        KeMemoryBarrier();
        Control = &m_Trbs[XhciCmdUsable].Dword[3];
        *Control = *Control ^ XHCI_TRB_CYCLE;
        m_Cycle ^= XHCI_TRB_CYCLE;
        m_Enqueue = 0;
    }
 
    KeMemoryBarrier();
    m_Controller->m_Registers.RingDoorbell(0, 0);
 
    if (WasIdle)
        WdfTimerStart(m_Timer, WDF_REL_TIMEOUT_IN_MS(XhciCmdTickMs));
}

Referenced by PlaceLocked().

Release()

VOID XhciCommandRing::Release

(

)

Definition at line 174 of file cmdring.cpp.

{
    LIST_ENTRY Finished;
    KIRQL OldIrql;
 
    PAGED_CODE();
 
    InitializeListHead(&Finished);
 
    if (m_State == RingState::Prepared)
    {
        if (m_Timer)
            WdfTimerStop(m_Timer, TRUE);
 
        if (m_Controller->IsAccessible())
            m_Controller->m_Registers.WriteOperational64(XHCI_OP_CRCR, 0);
 
        KeAcquireSpinLock(&m_Lock, &OldIrql);
        if (!IsListEmpty(&m_Pending) || !IsListEmpty(&m_Waiting))
        {
            DPRINT1("Command ring released with commands outstanding\n");
            DrainAllLocked(&Finished);
        }
        m_State = RingState::Released;
        KeReleaseSpinLock(&m_Lock, OldIrql);
 
        /* Complete these commands so no caller waits forever */
        XhciCmdCompleteList(&Finished);
 
        m_Controller->m_Buffers.Free(m_Segment);
    }
 
    m_Segment = NULL;
    m_Trbs = NULL;
    m_RingAddress = 0;
    m_LinkAddress = 0;
    m_State = RingState::Released;
}

Referenced by XhciController::ReleaseHardware().

RestartStoppedRingLocked()

VOID XhciCommandRing::RestartStoppedRingLocked ( _Inout_ PLIST_ENTRY  Finished )

private

Definition at line 515 of file cmdring.cpp.

{
    LIST_ENTRY Requeue;
    XhciCommand* Head;
    ULONG RingCycle;
 
    if (!IsListEmpty(&m_Pending))
    {
        Head = XhciCmdFromLink(m_Pending.Flink);
 
        if (Head->Countdown <= 0)
        {
            DPRINT1("Command type %lu aborted twice, failing it\n", XhciTrbType(&Head->Trb));
 
            RemoveHeadList(&m_Pending);
            m_Dequeue = (m_Dequeue + 1) % XhciCmdUsable;
 
            /* TRBs behind a wrapped enqueue index still carry the previous cycle */
            RingCycle = m_Cycle;
            if (m_Dequeue > m_Enqueue)
                RingCycle ^= XHCI_TRB_CYCLE;
 
            m_Controller->m_Registers.WriteOperational64(XHCI_OP_CRCR,
                                                         TrbAddress(m_Dequeue) | RingCycle);
 
            Head->Code = XhciCompletionCode::CommandAborted;
            Head->Status = STATUS_IO_TIMEOUT;
            InsertTailList(Finished, &Head->Link);
        }
        else if (Head->Countdown == XhciCmdTicksFirstAbort)
        {
            DPRINT1("Command type %lu still not done after the first abort, retrying\n",
                    XhciTrbType(&Head->Trb));
        }
        else if (Head->Countdown != XhciCmdTicksInitial)
        {
            DPRINT1("Unexpected command countdown %ld after the ring stopped\n", Head->Countdown);
        }
    }
 
    if (!IsListEmpty(&m_Pending))
    {
        KeMemoryBarrier();
        m_Controller->m_Registers.RingDoorbell(0, 0);
    }
 
    InitializeListHead(&Requeue);
    while (!IsListEmpty(&m_Waiting))
        InsertTailList(&Requeue, RemoveHeadList(&m_Waiting));
 
    while (!IsListEmpty(&Requeue))
        PlaceLocked(XhciCmdFromLink(RemoveHeadList(&Requeue)), FALSE, Finished);
}

Referenced by HandleRingStopped(), and OnTimer().

TrbAddress()

ULONG64 XhciCommandRing::TrbAddress ( _In_ ULONG  Index ) const

inlineprivate

Definition at line 124 of file cmdring.h.

    {
        return m_RingAddress + Index * sizeof(XHCI_TRB);
    }

Referenced by HandleRingStopped(), OnCompletionEvent(), Prepare(), and RestartStoppedRingLocked().

Member Data Documentation

EvtTimer

VOID NTAPI XhciCommandRing::EvtTimer

static

Definition at line 76 of file cmdring.h.

Referenced by Create().

m_Aborting

BOOLEAN XhciCommandRing::m_Aborting

private

Definition at line 145 of file cmdring.h.

Referenced by Create(), FailEverything(), HandleRingStopped(), OnCompletionEvent(), OnTimer(), PlaceLocked(), Prepare(), and PreReset().

m_AbortTicks

LONG XhciCommandRing::m_AbortTicks

private

Definition at line 146 of file cmdring.h.

Referenced by Create(), and OnTimer().

m_Controller

XhciController* XhciCommandRing::m_Controller

private

Definition at line 130 of file cmdring.h.

Referenced by Create(), HandleRingStopped(), InitializeRing(), OnCompletionEvent(), OnTimer(), PlaceLocked(), Prepare(), PutOnRingLocked(), Release(), and RestartStoppedRingLocked().

m_Cycle

ULONG XhciCommandRing::m_Cycle

private

Definition at line 141 of file cmdring.h.

Referenced by Create(), InitializeRing(), Prepare(), PutOnRingLocked(), and RestartStoppedRingLocked().

m_Dequeue

ULONG XhciCommandRing::m_Dequeue

private

Definition at line 140 of file cmdring.h.

Referenced by Create(), HandleRingStopped(), InitializeRing(), OnCompletionEvent(), PlaceLocked(), Prepare(), and RestartStoppedRingLocked().

m_DrainFromTimer

BOOLEAN XhciCommandRing::m_DrainFromTimer

private

Definition at line 147 of file cmdring.h.

Referenced by Create(), FailEverything(), OnTimer(), and Prepare().

m_Enqueue

ULONG XhciCommandRing::m_Enqueue

private

Definition at line 139 of file cmdring.h.

Referenced by Create(), InitializeRing(), PlaceLocked(), Prepare(), PutOnRingLocked(), and RestartStoppedRingLocked().

m_LinkAddress

ULONG64 XhciCommandRing::m_LinkAddress

private

Definition at line 138 of file cmdring.h.

Referenced by Create(), HandleRingStopped(), Prepare(), and Release().

m_Lock

KSPIN_LOCK XhciCommandRing::m_Lock

private

Definition at line 132 of file cmdring.h.

Referenced by Create(), FailEverything(), HandleRingStopped(), InitializeRing(), OnCompletionEvent(), OnTimer(), PostReset(), PostResetSuccess(), PreReset(), and Release().

m_OutOfOrderSeen

BOOLEAN XhciCommandRing::m_OutOfOrderSeen

private

Definition at line 144 of file cmdring.h.

Referenced by Create(), and OnCompletionEvent().

m_Pending

LIST_ENTRY XhciCommandRing::m_Pending

private

Definition at line 142 of file cmdring.h.

Referenced by Create(), DrainAllLocked(), InitializeRing(), OnCompletionEvent(), OnTimer(), PlaceLocked(), Prepare(), PutOnRingLocked(), Release(), and RestartStoppedRingLocked().

m_Reset

ResetPhase XhciCommandRing::m_Reset

private

Definition at line 134 of file cmdring.h.

Referenced by Create(), FailEverything(), HandleRingStopped(), OnTimer(), PlaceLocked(), PostReset(), PostResetSuccess(), Prepare(), and PreReset().

m_RingAddress

ULONG64 XhciCommandRing::m_RingAddress

private

Definition at line 137 of file cmdring.h.

Referenced by Create(), InitializeRing(), Prepare(), Release(), and TrbAddress().

m_Segment

XhciDmaBuffer* XhciCommandRing::m_Segment

private

Definition at line 135 of file cmdring.h.

Referenced by Create(), Prepare(), and Release().

m_State

RingState XhciCommandRing::m_State

private

Definition at line 133 of file cmdring.h.

Referenced by Create(), InitializeRing(), OnTimer(), Prepare(), and Release().

m_Timer

WDFTIMER XhciCommandRing::m_Timer

private

Definition at line 131 of file cmdring.h.

Referenced by Create(), FailEverything(), OnCompletionEvent(), OnTimer(), PostReset(), PutOnRingLocked(), and Release().

m_Trbs

PXHCI_TRB XhciCommandRing::m_Trbs

private

Definition at line 136 of file cmdring.h.

Referenced by Create(), InitializeRing(), Prepare(), PutOnRingLocked(), and Release().

m_Waiting

LIST_ENTRY XhciCommandRing::m_Waiting

private

Definition at line 143 of file cmdring.h.

Referenced by Create(), DrainAllLocked(), InitializeRing(), OnCompletionEvent(), PlaceLocked(), PostResetSuccess(), Prepare(), Release(), and RestartStoppedRingLocked().

---

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

• drivers/usb/usbxhci/cmdring.h
• drivers/usb/usbxhci/cmdring.cpp