#include <epctx.h>

Collaboration diagram for XhciEndpoint:

[legend]

Classes
struct	HaltClearBlock

Public Member Functions
XhciController *	Controller () const

XhciUsbDevice *	Device () const

UCXENDPOINT	Handle () const

ULONG	Dci () const

ULONG	TransferType () const

const USB_ENDPOINT_DESCRIPTOR *	Descriptor () const

USHORT	MaxPacketSize () const

ULONG	MaxBurst () const

ULONG	MaxEsitPayload () const

BOOLEAN	IsStreamsCapable () const

	_IRQL_requires_max_ (DISPATCH_LEVEL) NTSTATUS Enable()

	_IRQL_requires_max_ (DISPATCH_LEVEL) VOID Disable()

VOID	BuildContext (_Out_writes_bytes_(ContextSize) PVOID EndpointContext, _In_ ULONG ContextSize) const

VOID	OnTransferEvent (_In_ const XHCI_TRB *Event)

VOID	ControllerResetStarting ()

	_IRQL_requires_ (PASSIVE_LEVEL) VOID ControllerResetDone()

VOID	ControllerRemoved ()

VOID	OnTransferCanceled ()

VOID	OnHaltedCompletionCode (_In_ ULONG CompletionCode, _In_ BOOLEAN TransferFound)

BOOLEAN	ShouldDropStoppedEvent () const

VOID	OnStoppedEvent ()

VOID	OnExpectedEventsProcessed ()

VOID	OnMappingStopped ()

VOID	OnTransfersReclaimed ()

	_IRQL_requires_max_ (DISPATCH_LEVEL) VOID Disable(_In_ BOOLEAN SlotDisabling)

ULONG64	StreamDequeuePointer (_In_ ULONG StreamId) const

ULONG	StreamTransferLength (_In_ ULONG StreamId) const

ULONG	StreamHaltedCode () const

Static Public Member Functions
static XhciEndpoint *	FromUcx (_In_ UCXENDPOINT Endpoint)

static NTSTATUS	Create (_In_ UCXCONTROLLER UcxController, _In_ UCXUSBDEVICE UcxUsbDevice, _In_ PUCXENDPOINT_INIT EndpointInit, _In_ const USB_ENDPOINT_DESCRIPTOR Descriptor, _In_opt_ const USB_SUPERSPEED_ENDPOINT_COMPANION_DESCRIPTOR Companion, _In_opt_ const USB_SUPERSPEEDPLUS_ISOCH_ENDPOINT_COMPANION_DESCRIPTOR *IsochCompanion)

static NTSTATUS NTAPI	EvtEnableForwardProgress (_In_ UCXENDPOINT Endpoint, _In_ ULONG MaxTransferSize)

Public Attributes
XhciEndpointMachine	m_Machine

Static Public Attributes
static EVT_UCX_ENDPOINT_PURGE	EvtPurge

static EVT_UCX_ENDPOINT_START	EvtStart

static EVT_UCX_ENDPOINT_ABORT	EvtAbort

static EVT_UCX_ENDPOINT_RESET	EvtReset

static EVT_UCX_ENDPOINT_OK_TO_CANCEL_TRANSFERS	EvtOkToCancel

static EVT_UCX_DEFAULT_ENDPOINT_UPDATE	EvtDefaultUpdate

static EVT_UCX_ENDPOINT_STATIC_STREAMS_ADD	EvtStreamsAdd

static EVT_UCX_ENDPOINT_STATIC_STREAMS_ENABLE	EvtStreamsEnable

static EVT_UCX_ENDPOINT_STATIC_STREAMS_DISABLE	EvtStreamsDisable

Private Member Functions
NTSTATUS	Initialize (_In_ XhciController Controller, _In_ UCXUSBDEVICE UcxUsbDevice, _In_ UCXENDPOINT Endpoint, _In_ const USB_ENDPOINT_DESCRIPTOR Descriptor, _In_opt_ const USB_SUPERSPEED_ENDPOINT_COMPANION_DESCRIPTOR Companion, _In_opt_ const USB_SUPERSPEEDPLUS_ISOCH_ENDPOINT_COMPANION_DESCRIPTOR IsochCompanion)

NTSTATUS	CreateClearStall ()

VOID	Cleanup ()

VOID	DisableRings (_In_ BOOLEAN SlotDisabling)

BOOLEAN	UsesStreams () const

ULONG	RingCount () const

XhciTransferRing *	RingAt (_In_ ULONG Index) const

VOID	ForEachRing (_In_ VOID(XhciTransferRing::*Action)())

BOOLEAN	PostWhenAllRings (_In_ XepEvent Event)

BOOLEAN	AnyTransfersPending () const

ULONG64	EndpointDequeuePointer () const

PXHCI_STREAM_CONTEXT	StreamContext (_In_ ULONG StreamId) const

VOID	ResetStreamTransferLength (_In_ ULONG StreamId)

BOOLEAN	StreamRingEmpty (_In_ ULONG StreamId) const

BOOLEAN	StreamCommandDone ()

VOID	PostEvent (_In_ XepEvent Event)

VOID	PostCommandFailure ()

VOID	FatalError (_In_ ULONG Reason)

ULONG	OutputEndpointState () const

PENDPOINT_RESET	ResetPayload () const

VOID	BuildSetDequeue (_Out_ XhciCommand *Command, _In_ ULONG64 DequeuePointer, _In_ ULONG StreamId, _In_ PFN_XHCI_COMMAND_DONE Done)

VOID	BuildEndpointConfigure (_In_ XhciDmaBuffer Input, _In_opt_ const VOID EndpointContext, _In_ BOOLEAN Drop, _In_ BOOLEAN Add, _Out_ XhciCommand *Command, _In_ PFN_XHCI_COMMAND_DONE Done)

PXHCI_ENDPOINT_CONTEXT	InputEndpointContext (_In_ XhciDmaBuffer *Input) const

VOID	DequeueAfterStop (_In_ ULONG StreamId)

VOID	DequeueAfterReset (_In_ ULONG StreamId)

VOID	SendClearStall ()

NTSTATUS	OpenStreams (_In_ XhciStreams *Streams, _In_ WDFREQUEST Request)

NTSTATUS	CloseStreams (_In_ XhciStreams *Streams, _In_ WDFREQUEST Request)

VOID	DisableStreamRings (_In_ XhciStreams *Streams)

VOID	FreeDefaultStreams (_In_opt_ XhciStreams *Streams)

Static Private Member Functions
static VOID NTAPI	StopDone (_In_ XhciCommand *Command)

static VOID NTAPI	CancelDequeueDone (_In_ XhciCommand *Command)

static VOID NTAPI	ControlResetDone (_In_ XhciCommand *Command)

static VOID NTAPI	ControlDequeueDone (_In_ XhciCommand *Command)

static VOID NTAPI	ClientResetDone (_In_ XhciCommand *Command)

static VOID NTAPI	ClientDequeueDone (_In_ XhciCommand *Command)

static VOID NTAPI	ResetDropDone (_In_ XhciCommand *Command)

static VOID NTAPI	ResetConfigureDone (_In_ XhciCommand *Command)

static VOID NTAPI	StopDropDone (_In_ XhciCommand *Command)

static VOID NTAPI	StopAddDone (_In_ XhciCommand *Command)

static VOID NTAPI	DefaultUpdateDone (_In_ XhciCommand *Command)

static VOID NTAPI	StreamsEnableDone (_In_ PVOID Context, _In_ NTSTATUS Status)

static VOID NTAPI	StreamsDisableDone (_In_ PVOID Context, _In_ NTSTATUS Status)

Private Attributes
XhciController *	m_Controller

XhciUsbDevice *	m_Device

UCXUSBDEVICE	m_UcxDevice

UCXENDPOINT	m_Ucx

BOOLEAN	m_Listed

BOOLEAN	m_ForwardProgress

BOOLEAN	m_StreamsCapable

volatile LONG	m_Flags

KEVENT	m_ResetAck

WDFTIMER	m_Timer

XhciTransferRing *	m_MainRing

USB_ENDPOINT_DESCRIPTOR	m_Descriptor

USB_SUPERSPEED_ENDPOINT_COMPANION_DESCRIPTOR	m_Companion

USB_SUPERSPEEDPLUS_ISOCH_ENDPOINT_COMPANION_DESCRIPTOR	m_IsochCompanion

ULONG	m_XhciType

ULONG	m_Dci

ULONG	m_MaxBurst

ULONG	m_MaxPayload

XhciStreams *	m_DefaultStreams

XhciStreams *	m_CurrentStreams

ULONG	m_StopAttempts

XhciCommand	m_Command

XhciDmaBuffer *	m_StopInput

HaltClearBlock *	m_ClearStall

WDFREQUEST volatile	m_ResetRequest

NTSTATUS	m_ResetStatus

Static Private Attributes
static EVT_WDF_OBJECT_CONTEXT_CLEANUP	EvtCleanup

static EVT_WDF_OBJECT_CONTEXT_CLEANUP	EvtStreamsCleanup

static EVT_WDF_TIMER	EvtTimer

static EVT_WDF_IO_QUEUE_STATE	EvtPurgeDone

static EVT_WDF_IO_QUEUE_STATE	EvtAbortDone

static IO_COMPLETION_ROUTINE	ClearStallDone

Friends
class	XhciEndpointMachine

Detailed Description

One endpoint. Lives in the UCXENDPOINT context and owns the endpoint machine.

Definition at line 16 of file epctx.h.

Member Function Documentation

◆ _IRQL_requires_()

XhciEndpoint::_IRQL_requires_ ( PASSIVE_LEVEL )

◆ _IRQL_requires_max_() [1/3]

XhciEndpoint::_IRQL_requires_max_ ( DISPATCH_LEVEL )

◆ _IRQL_requires_max_() [2/3]

XhciEndpoint::_IRQL_requires_max_ ( DISPATCH_LEVEL )

◆ _IRQL_requires_max_() [3/3]

XhciEndpoint::_IRQL_requires_max_ ( DISPATCH_LEVEL )

Endpoint disable; SlotDisabling FALSE keeps forward progress resources.

◆ AnyTransfersPending()

BOOLEAN XhciEndpoint::AnyTransfersPending ( ) const

private

Definition at line 947 of file epctx.cpp.

{
    ULONG Count = RingCount();
    ULONG Index;
 
    for (Index = 0; Index < Count; Index++)
    {
        if (RingAt(Index)->HasQueuedWork())
            return TRUE;
    }
 
    return FALSE;
}

Referenced by XhciEndpointMachine::CanResetAfterHalt(), and XhciEndpointMachine::ShouldReconfigureForReset().

◆ BuildContext()

VOID XhciEndpoint::BuildContext	(	_Out_writes_bytes_(ContextSize) PVOID	EndpointContext,
		_In_ ULONG	ContextSize
	)		const

Initializes this endpoint's input endpoint context.

Definition at line 754 of file epctx.cpp.

{
    PXHCI_ENDPOINT_CONTEXT Context = static_cast<PXHCI_ENDPOINT_CONTEXT>(EndpointContext);
    USB_DEVICE_SPEED Speed = m_Device->Speed();
    ULONG Type = TransferType();
    ULONG Packet = MaxPacketSize();
    ULONG Period = m_Descriptor.bInterval;
    BOOLEAN Periodic;
    ULONG Interval = 0;
    ULONG Burst = 0;
    ULONG Mult = 0;
    ULONG Esit = 0;
 
    NT_ASSERT(ContextSize >= sizeof(*Context));
    UNREFERENCED_PARAMETER(ContextSize);
 
    Periodic = (Type == USB_ENDPOINT_TYPE_INTERRUPT) || (Type == USB_ENDPOINT_TYPE_ISOCHRONOUS);
 
    Context->EndpointType = m_XhciType;
    Context->MaxPacketSize = Packet;
 
    /*
     * Isochronous endpoints never retry. The interrupt IN of one scanner behind an external
     * hub also gets unlimited retries on flagged controllers.
     */
    if (Type == USB_ENDPOINT_TYPE_ISOCHRONOUS)
    {
        Context->ErrorCount = 0;
    }
    else if (Type == USB_ENDPOINT_TYPE_INTERRUPT &&
             USB_ENDPOINT_DIRECTION_IN(m_Descriptor.bEndpointAddress) &&
             m_Controller->HasErrata(XhciErrata::EpInfiniteCerr) &&
             m_Device->DeviceDescriptor()->idVendor == 0x05F9 &&
             m_Device->DeviceDescriptor()->idProduct == 0x1101 &&
             m_Device->PortPath()->PortPathDepth > 1)
    {
        Context->ErrorCount = 0;
    }
    else
    {
        Context->ErrorCount = 3;
    }
 
    if (Speed == UsbLowSpeed)
    {
        if (Type == USB_ENDPOINT_TYPE_INTERRUPT)
        {
            Interval = (Period < 16) ? 6 : ((Period < 32) ? 7 : 8);
            Esit = Packet;
        }
 
        m_MaxPayload = Packet;
    }
    else if (Speed == UsbFullSpeed)
    {
        if (Type == USB_ENDPOINT_TYPE_INTERRUPT)
        {
            /* Frames to 125 us units as a power of two, 1 ms (3) at the least */
            Interval = 3;
            while ((Interval < 8) && (Period >= (2U << (Interval - 3))))
                Interval++;
            Esit = Packet;
        }
        else if (Type == USB_ENDPOINT_TYPE_ISOCHRONOUS)
        {
            /* QUIRK: full speed isoch is always serviced every frame */
            Interval = 3;
            Esit = Packet;
        }
 
        m_MaxPayload = Packet;
    }
    else if (Speed == UsbHighSpeed)
    {
        if (Periodic)
        {
            /* QUIRK: bInterval 6 and up is clamped to 32 microframes */
            Interval = min(max(Period, 1), 6) - 1;
            Burst = (m_Descriptor.wMaxPacketSize >> 11) & 3;
            Esit = Packet * (Burst + 1);
        }
 
        m_MaxPayload = Packet * (Burst + 1);
    }
    else
    {
        Burst = m_Companion.bMaxBurst;
 
        if (Periodic)
        {
            Interval = min(max(Period, 1), 6) - 1;
 
            if (m_Companion.bmAttributes.Isochronous.SspCompanion)
            {
                Esit = m_IsochCompanion.dwBytesPerInterval;
            }
            else
            {
                Esit = m_Companion.wBytesPerInterval;
                Mult = m_Companion.bmAttributes.Isochronous.Mult;
            }
        }
 
        /* QUIRK: everything but isoch ignores the burst here */
        m_MaxPayload = (Type == USB_ENDPOINT_TYPE_ISOCHRONOUS) ? Esit : Packet;
    }
 
    if (m_Controller->HasErrata(XhciErrata::EpClampIntervalTo7) && (Interval > 7))
        Interval = 7;
 
    m_MaxBurst = Burst;
 
    Context->Interval = Interval;
    Context->MaxBurstSize = Burst;
    Context->Mult = Mult;
    Context->MaxEsitPayloadLo = Esit & 0xFFFF;
    Context->MaxEsitPayloadHi = (Esit >> 16) & 0xFF;
 
    /* QUIRK: control and bulk get an Average TRB Length of 0 */
    Context->AverageTrbLength = Esit / 2;
 
    if (m_StreamsCapable && (m_CurrentStreams != NULL))
        Context->MaxPStreams = m_CurrentStreams->MaxPrimary;
 
    Context->TRDequeuePointer = EndpointDequeuePointer();
    Context->LinearStreamArray = (Context->MaxPStreams != 0) ? 1 : 0;
}

Referenced by XhciUsbDevice::BuildAddressContext().

◆ BuildEndpointConfigure()

VOID XhciEndpoint::BuildEndpointConfigure	(	_In_ XhciDmaBuffer *	Input,
		_In_opt_ const VOID *	EndpointContext,
		_In_ BOOLEAN	Drop,
		_In_ BOOLEAN	Add,
		_Out_ XhciCommand *	Command,
		_In_ PFN_XHCI_COMMAND_DONE	Done
	)

private

Configure Endpoint for this DCI only; EndpointContext, when given, replaces the input endpoint context.

Definition at line 1888 of file epctx.cpp.

{
    ULONG Size = m_Controller->m_Registers.ContextSize();
    PUCHAR Base = static_cast<PUCHAR>(Input->VirtualAddress);
    PXHCI_INPUT_CONTROL_CONTEXT Control = reinterpret_cast<PXHCI_INPUT_CONTROL_CONTEXT>(Base);
    PXHCI_SLOT_CONTEXT Slot = reinterpret_cast<PXHCI_SLOT_CONTEXT>(Base + Size);
    ULONG64 InputAddress = Input->LogicalAddress.QuadPart;
 
    RtlZeroMemory(Control, Size);
 
    /* QUIRK: controller owned fields of the output contexts travel along; the xHC ignores them */
    RtlCopyMemory(Slot, m_Device->OutputContext(0), Size);
    if (EndpointContext != NULL)
        RtlCopyMemory(InputEndpointContext(Input), EndpointContext, Size);
 
    /* The cached count, since a temporary drop lowers the controller's own value */
    Slot->ContextEntries = m_Device->ContextEntries();
 
    Control->AddFlags = 1;
    if (Add)
        Control->AddFlags |= 1 << m_Dci;
    if (Drop)
        Control->DropFlags = 1 << m_Dci;
 
    RtlZeroMemory(Command, sizeof(*Command));
    Command->Trb.Dword[0] = static_cast<ULONG>(InputAddress);
    Command->Trb.Dword[1] = static_cast<ULONG>(InputAddress >> 32);
    Command->Trb.Dword[3] = XhciEndpointCommandControl(XhciTrbType::ConfigureEndpoint,
                                                       0, m_Device->SlotId());
    Command->Done = Done;
    Command->Context = this;
}

Referenced by XhciEndpointMachine::ReconfigureAfterStop(), XhciEndpointMachine::ReconfigureForReset(), ResetDropDone(), and StopDropDone().

◆ BuildSetDequeue()

VOID XhciEndpoint::BuildSetDequeue	(	_Out_ XhciCommand *	Command,
		_In_ ULONG64	DequeuePointer,
		_In_ ULONG	StreamId,
		_In_ PFN_XHCI_COMMAND_DONE	Done
	)

private

Definition at line 1860 of file epctx.cpp.

{
    RtlZeroMemory(Command, sizeof(*Command));
    Command->Trb.Dword[0] = static_cast<ULONG>(DequeuePointer);
    Command->Trb.Dword[1] = static_cast<ULONG>(DequeuePointer >> 32);
    Command->Trb.Dword[2] = StreamId << XHCI_CMD_STREAM_ID_SHIFT;
    Command->Trb.Dword[3] = XhciEndpointCommandControl(XhciTrbType::SetTrDequeuePointer,
                                                       m_Dci, m_Device->SlotId());
    Command->Done = Done;
    Command->Context = this;
}

Referenced by ControlResetDone(), DequeueAfterReset(), and DequeueAfterStop().

◆ CancelDequeueDone()

VOID NTAPI XhciEndpoint::CancelDequeueDone ( _In_ XhciCommand * Command )

staticprivate

Definition at line 2026 of file epctx.cpp.

{
    XhciEndpoint* Self = static_cast<XhciEndpoint*>(Command->Context);
 
    if (Command->Status == STATUS_NO_SUCH_DEVICE)
    {
        Self->PostCommandFailure();
        return;
    }
 
    if (Command->Code != XhciCompletionCode::Success)
    {
        DPRINT1("Endpoint %p DCI %lu Set TR Dequeue Pointer after stop failed with code %lu\n",
                Self, Self->m_Dci, static_cast<ULONG>(Command->Code));
        Self->m_Controller->VerifierCheck(XHCI_VERIFY_CANCEL_DEQUEUE);
        Self->FatalError(XHCI_REASON_CANCEL_DEQUEUE);
        Self->PostCommandFailure();
        return;
    }
 
    if ((Command != &Self->m_Command) && !Self->StreamCommandDone())
        return;
 
    Self->PostEvent(XepEvent::CommandSucceeded);
}

Referenced by DequeueAfterStop().

◆ Cleanup()

VOID XhciEndpoint::Cleanup ( )

private

Definition at line 466 of file epctx.cpp.

{
    if (m_ClearStall != NULL)
    {
        if (m_ClearStall->Request != NULL)
            WdfObjectDelete(m_ClearStall->Request);
        if (m_ClearStall->Irp != NULL)
            IoFreeIrp(m_ClearStall->Irp);
 
        ExFreePoolWithTag(m_ClearStall, XHCI_TAG_ENDPOINT);
        m_ClearStall = NULL;
    }
 
    if (m_CurrentStreams == m_DefaultStreams)
        m_CurrentStreams = NULL;
    FreeDefaultStreams(m_DefaultStreams);
    m_DefaultStreams = NULL;
 
    if (m_StopInput != NULL)
    {
        m_Controller->m_Buffers.Free(m_StopInput);
        m_StopInput = NULL;
    }
 
    /* Last: dropping the list reference may free this object */
    if (m_Listed)
    {
        m_Listed = FALSE;
        m_Device->RemoveEndpoint(this);
    }
}

◆ ClientDequeueDone()

VOID NTAPI XhciEndpoint::ClientDequeueDone ( _In_ XhciCommand * Command )

staticprivate

Definition at line 2178 of file epctx.cpp.

{
    XhciEndpoint* Self = static_cast<XhciEndpoint*>(Command->Context);
 
    if (Command->Status == STATUS_NO_SUCH_DEVICE)
    {
        Self->m_ResetStatus = STATUS_UNSUCCESSFUL;
        Self->PostCommandFailure();
        return;
    }
 
    if (Command->Code != XhciCompletionCode::Success)
    {
        DPRINT1("Endpoint %p DCI %lu Set TR Dequeue Pointer for the client reset failed with code %lu\n",
                Self, Self->m_Dci, static_cast<ULONG>(Command->Code));
        Self->m_Controller->VerifierCheck(XHCI_VERIFY_CONTROL_DEQUEUE);
        Self->FatalError(XHCI_REASON_CLIENT_DEQUEUE);
        Self->m_ResetStatus = STATUS_UNSUCCESSFUL;
        Self->PostCommandFailure();
        return;
    }
 
    if ((Command != &Self->m_Command) && !Self->StreamCommandDone())
        return;
 
    Self->m_ResetStatus = STATUS_SUCCESS;
    Self->PostEvent(XepEvent::CommandSucceeded);
}

Referenced by DequeueAfterReset().

◆ ClientResetDone()

VOID NTAPI XhciEndpoint::ClientResetDone ( _In_ XhciCommand * Command )

staticprivate

Definition at line 2111 of file epctx.cpp.

{
    XhciEndpoint* Self = static_cast<XhciEndpoint*>(Command->Context);
    ULONG StreamId;
 
    if (Command->Status == STATUS_NO_SUCH_DEVICE)
    {
        Self->m_ResetStatus = STATUS_UNSUCCESSFUL;
        Self->PostCommandFailure();
        return;
    }
 
    if (Command->Code != XhciCompletionCode::Success)
    {
        DPRINT1("Endpoint %p DCI %lu client Reset Endpoint failed with code %lu\n",
                Self, Self->m_Dci, static_cast<ULONG>(Command->Code));
        Self->m_Controller->VerifierCheck(XHCI_VERIFY_RESET_ENDPOINT);
        Self->FatalError(XHCI_REASON_CLIENT_RESET);
        Self->m_ResetStatus = STATUS_UNSUCCESSFUL;
        Self->PostCommandFailure();
        return;
    }
 
    NT_ASSERT(Self->OutputEndpointState() == XHCI_ENDPOINT_STATE_STOPPED);
 
    if (!Self->UsesStreams())
    {
        Self->DequeueAfterReset(0);
        return;
    }
 
    InterlockedExchange(&Self->m_CurrentStreams->UpdateCount, 0);
    for (StreamId = 1; StreamId <= Self->m_CurrentStreams->Count; StreamId++)
        Self->DequeueAfterReset(StreamId);
}

Referenced by XhciEndpointMachine::ResetEndpoint().

◆ CloseStreams()

NTSTATUS XhciEndpoint::CloseStreams	(	_In_ XhciStreams *	Streams,
		_In_ WDFREQUEST	Request
	)

private

Switches back to a new default record; STATUS_PENDING once the configure is out.

Definition at line 1777 of file epctx.cpp.

{
    PURB Urb = XhciRequestUrb(Request);
    XhciStreams* Default;
    NTSTATUS Status;
 
    XhciGetRequestData(Request)->StreamsConfigure.Streams = Streams;
 
    /* QUIRK: the array is sized for the client stream count, larger than one stream needs */
    Default = XhciNewDefaultStreams(this, m_MainRing, Streams->MaxPrimary);
    if (Default == NULL)
    {
        DPRINT1("Endpoint %p no default stream record for the streams close\n", this);
        Urb->UrbHeader.Status = USBD_STATUS_INSUFFICIENT_RESOURCES;
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    m_DefaultStreams = Default;
    m_CurrentStreams = Default;
 
    Status = m_MainRing->Enable();
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Endpoint %p main ring enable for the streams close failed 0x%lx\n", this, Status);
        Urb->UrbHeader.Status = USBD_STATUS_INSUFFICIENT_RESOURCES;
 
        /* Restore the client record so the freed default record is not left current */
        m_CurrentStreams = Streams;
        FreeDefaultStreams(Default);
        m_DefaultStreams = NULL;
        return Status;
    }
 
    StreamContext(1)->DequeuePointer = m_MainRing->DequeuePointerValue();
 
    m_Device->ReconfigureEndpoint(this, StreamsDisableDone, Request);
    return STATUS_PENDING;
}

◆ ControlDequeueDone()

VOID NTAPI XhciEndpoint::ControlDequeueDone ( _In_ XhciCommand * Command )

staticprivate

Definition at line 2084 of file epctx.cpp.

{
    XhciEndpoint* Self = static_cast<XhciEndpoint*>(Command->Context);
 
    if (Command->Status == STATUS_NO_SUCH_DEVICE)
    {
        Self->PostCommandFailure();
        return;
    }
 
    if (Command->Code != XhciCompletionCode::Success)
    {
        DPRINT1("Endpoint %p DCI %lu Set TR Dequeue Pointer after reset failed with code %lu\n",
                Self, Self->m_Dci, static_cast<ULONG>(Command->Code));
        Self->m_Controller->VerifierCheck(XHCI_VERIFY_CONTROL_DEQUEUE);
        Self->FatalError(XHCI_REASON_CONTROL_DEQUEUE);
        Self->PostCommandFailure();
        return;
    }
 
    Self->m_ResetStatus = STATUS_SUCCESS;
    Self->PostEvent(XepEvent::CommandSucceeded);
}

Referenced by ControlResetDone().

◆ Controller()

XhciController * XhciEndpoint::Controller ( ) const

Definition at line 239 of file epctx.cpp.

{
    return m_Controller;
}

Referenced by Initialize().

◆ ControllerRemoved()

VOID XhciEndpoint::ControllerRemoved ( )

Definition at line 1270 of file epctx.cpp.

{
    PostEvent(XepEvent::ControllerRemoved);
}

Referenced by XhciUsbDevice::OnHostLost().

◆ ControllerResetStarting()

VOID XhciEndpoint::ControllerResetStarting ( )

Definition at line 1253 of file epctx.cpp.

{
    PostEvent(XepEvent::ControllerResetStarting);
}

Referenced by XhciUsbDevice::ControllerResetStarting().

◆ ControlResetDone()

VOID NTAPI XhciEndpoint::ControlResetDone ( _In_ XhciCommand * Command )

staticprivate

Definition at line 2055 of file epctx.cpp.

{
    XhciEndpoint* Self = static_cast<XhciEndpoint*>(Command->Context);
 
    if (Command->Status == STATUS_NO_SUCH_DEVICE)
    {
        Self->PostCommandFailure();
        return;
    }
 
    /* QUIRK: a Context State error is fatal too, although it could go on to the dequeue update */
    if (Command->Code != XhciCompletionCode::Success)
    {
        DPRINT1("Endpoint %p DCI %lu Reset Endpoint failed with code %lu\n",
                Self, Self->m_Dci, static_cast<ULONG>(Command->Code));
        Self->m_Controller->VerifierCheck(XHCI_VERIFY_RESET_ENDPOINT);
        Self->FatalError(XHCI_REASON_CONTROL_RESET);
        Self->PostCommandFailure();
        return;
    }
 
    Self->m_MainRing->InitializeRing();
    Self->BuildSetDequeue(&Self->m_Command, Self->m_MainRing->DequeuePointerValue(), 0, ControlDequeueDone);
    Self->m_Controller->m_Commands.Submit(&Self->m_Command);
}

Referenced by XhciEndpointMachine::ResetDefaultPipe().

◆ Create()

NTSTATUS XhciEndpoint::Create	(	_In_ UCXCONTROLLER	UcxController,
		_In_ UCXUSBDEVICE	UcxUsbDevice,
		_In_ PUCXENDPOINT_INIT	EndpointInit,
		_In_ const USB_ENDPOINT_DESCRIPTOR *	Descriptor,
		_In_opt_ const USB_SUPERSPEED_ENDPOINT_COMPANION_DESCRIPTOR *	Companion,
		_In_opt_ const USB_SUPERSPEEDPLUS_ISOCH_ENDPOINT_COMPANION_DESCRIPTOR *	IsochCompanion
	)

static

Endpoint create for both add callbacks. PASSIVE_LEVEL.

Definition at line 305 of file epctx.cpp.

{
    WDF_OBJECT_ATTRIBUTES Attributes;
    UCXENDPOINT Endpoint;
    XhciEndpoint* Self;
    NTSTATUS Status;
 
    WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&Attributes, XhciEndpoint);
    Attributes.EvtCleanupCallback = EvtCleanup;
 
    Status = UcxEndpointCreate(UcxUsbDevice, &EndpointInit, &Attributes, &Endpoint);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("UcxEndpointCreate for endpoint 0x%02x failed 0x%lx\n",
                Descriptor->bEndpointAddress, Status);
        return Status;
    }
 
    Self = new (XhciGetEndpoint(Endpoint)) XhciEndpoint;
    Self->m_Machine.Initialize(Self);
 
    /* UCX deletes the endpoint on failure; the cleanup callback frees what was made */
    return Self->Initialize(XhciController::FromUcx(UcxController),
                            UcxUsbDevice,
                            Endpoint,
                            Descriptor,
                            Companion,
                            IsochCompanion);
}

Referenced by XhciEvtUsbDeviceDefaultEndpointAdd(), and XhciEvtUsbDeviceEndpointAdd().

◆ CreateClearStall()

NTSTATUS XhciEndpoint::CreateClearStall ( )

private

Definition at line 428 of file epctx.cpp.

{
    WDF_OBJECT_ATTRIBUTES Attributes;
    NTSTATUS Status;
 
    m_ClearStall = static_cast<HaltClearBlock*>(ExAllocatePoolZero(NonPagedPool,
                                                                   sizeof(*m_ClearStall),
                                                                   XHCI_TAG_ENDPOINT));
    if (m_ClearStall == NULL)
        return STATUS_INSUFFICIENT_RESOURCES;
 
    m_ClearStall->Irp = IoAllocateIrp(XHCI_CLEAR_STALL_STACK_SIZE, FALSE);
    if (m_ClearStall->Irp == NULL)
        return STATUS_INSUFFICIENT_RESOURCES;
 
    WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&Attributes, XhciRequestData);
    Status = WdfRequestCreate(&Attributes, NULL, &m_ClearStall->Request);
    if (!NT_SUCCESS(Status))
        m_ClearStall->Request = NULL;
 
    return Status;
}

Referenced by Initialize().

◆ Dci()

ULONG XhciEndpoint::Dci ( ) const

Definition at line 257 of file epctx.cpp.

{
    return m_Dci;
}

Referenced by _IRQL_requires_max_(), XhciTransferRing::Cleanup(), XhciUsbDevice::EndpointsConfigure(), XhciTransferRing::EnsureFreeSegments(), XhciControlRing::OnEventDataEvent(), XhciTransferRing::ReferenceLiveRing(), XhciTransferRing::RingDoorbell(), XhciUsbDevice::StartReconfigure(), XhciUsbDevice::SubmitSecondConfigure(), and XhciTransferRing::TakeSegments().

◆ DefaultUpdateDone()

VOID NTAPI XhciEndpoint::DefaultUpdateDone ( _In_ XhciCommand * Command )

staticprivate

Definition at line 1515 of file epctx.cpp.

{
    WDFREQUEST Request = static_cast<WDFREQUEST>(Command->Context);
    XhciDefaultEndpointUpdate* Data = &XhciGetRequestData(Request)->DefaultEndpointUpdate;
    XhciEndpoint* Self = Data->Endpoint;
    NTSTATUS Status = STATUS_UNSUCCESSFUL;
 
    Self->m_Controller->m_Buffers.Free(Data->InputContext);
    Data->InputContext = NULL;
 
    if (Command->Status == STATUS_NO_SUCH_DEVICE)
    {
        DPRINT1("Endpoint %p max packet size update lost with the controller\n", Self);
    }
    else if (Command->Code != XhciCompletionCode::Success)
    {
        DPRINT1("Endpoint %p Evaluate Context failed with code %lu\n",
                Self, static_cast<ULONG>(Command->Code));
    }
    else
    {
        Self->m_Descriptor.wMaxPacketSize = static_cast<USHORT>(Data->MaxPacketSize);
        Status = STATUS_SUCCESS;
    }
 
    WdfRequestComplete(Request, Status);
}

◆ DequeueAfterReset()

VOID XhciEndpoint::DequeueAfterReset ( _In_ ULONG StreamId )

private

Points the controller at a ring's current position; the pending transfers stay put.

Definition at line 2150 of file epctx.cpp.

{
    XhciTransferRing* Ring = m_MainRing;
    XhciCommand* Command = &m_Command;
 
    if (StreamId != 0)
    {
        Ring = m_CurrentStreams->Entry[StreamId - 1].Ring;
        Command = &m_CurrentStreams->Entry[StreamId - 1].Command;
 
        if (StreamRingEmpty(StreamId))
        {
            if (StreamCommandDone())
            {
                m_ResetStatus = STATUS_SUCCESS;
                PostEvent(XepEvent::CommandSucceeded);
            }
            return;
        }
    }
 
    BuildSetDequeue(Command, Ring->DequeuePointerValue(), StreamId, ClientDequeueDone);
    m_Controller->m_Commands.Submit(Command);
}

Referenced by ClientResetDone().

◆ DequeueAfterStop()

VOID XhciEndpoint::DequeueAfterStop ( _In_ ULONG StreamId )

private

Moves one ring past the canceled transfers after a stop. StreamId 0 is the main ring.

Definition at line 1997 of file epctx.cpp.

{
    XhciTransferRing* Ring = m_MainRing;
    XhciCommand* Command = &m_Command;
 
    if (StreamId != 0)
    {
        Ring = m_CurrentStreams->Entry[StreamId - 1].Ring;
        Command = &m_CurrentStreams->Entry[StreamId - 1].Command;
 
        if (StreamRingEmpty(StreamId) &&
            !m_Controller->HasErrata(XhciErrata::StrmReconfigOnStop))
        {
            if (StreamCommandDone())
                PostEvent(XepEvent::CommandSucceeded);
            return;
        }
 
        ResetStreamTransferLength(StreamId);
    }
 
    Ring->InitializeRing();
    BuildSetDequeue(Command, Ring->DequeuePointerValue(), StreamId, CancelDequeueDone);
    m_Controller->m_Commands.Submit(Command);
}

Referenced by XhciEndpointMachine::UpdateDequeuePointers().

◆ Descriptor()

const USB_ENDPOINT_DESCRIPTOR * XhciEndpoint::Descriptor ( ) const

Definition at line 269 of file epctx.cpp.

{
    return &m_Descriptor;
}

Referenced by Create().

◆ Device()

XhciUsbDevice * XhciEndpoint::Device ( ) const

Definition at line 245 of file epctx.cpp.

{
    return m_Device;
}

◆ DisableRings()

VOID XhciEndpoint::DisableRings ( _In_ BOOLEAN SlotDisabling )

private

Definition at line 715 of file epctx.cpp.

{
    BOOLEAN FreeResources;
    ULONG Index;
 
    /* Forward progress keeps the ring resources unless the whole device goes away */
    FreeResources = !m_ForwardProgress || SlotDisabling;
 
    if (!m_StreamsCapable)
    {
        m_MainRing->Disable(FreeResources);
        return;
    }
 
    if (m_CurrentStreams == NULL)
        return;
 
    for (Index = 0; Index < m_CurrentStreams->Count; Index++)
        m_CurrentStreams->Entry[Index].Ring->Disable(FreeResources);
 
    if (!FreeResources)
        return;
 
    if (m_CurrentStreams == m_DefaultStreams)
    {
        FreeDefaultStreams(m_DefaultStreams);
        m_DefaultStreams = NULL;
    }
    else if (m_CurrentStreams->ContextArray != NULL)
    {
        m_Controller->m_Buffers.Free(m_CurrentStreams->ContextArray);
        m_CurrentStreams->ContextArray = NULL;
    }
 
    m_CurrentStreams = NULL;
}

◆ DisableStreamRings()

VOID XhciEndpoint::DisableStreamRings ( _In_ XhciStreams * Streams )

private

Definition at line 1623 of file epctx.cpp.

{
    ULONG Index;
 
    for (Index = 0; Index < Streams->Count; Index++)
        Streams->Entry[Index].Ring->Disable(TRUE);
}

Referenced by OpenStreams(), StreamsDisableDone(), and StreamsEnableDone().

◆ EndpointDequeuePointer()

ULONG64 XhciEndpoint::EndpointDequeuePointer ( ) const

private

Definition at line 885 of file epctx.cpp.

{
    if (!m_StreamsCapable)
        return m_MainRing->DequeuePointerValue();
 
    if ((m_CurrentStreams == NULL) || (m_CurrentStreams->ContextArray == NULL))
        return 0;
 
    return m_CurrentStreams->ContextArray->LogicalAddress.QuadPart;
}

Referenced by BuildContext(), ResetDropDone(), and StopDropDone().

◆ EvtEnableForwardProgress()

NTSTATUS NTAPI XhciEndpoint::EvtEnableForwardProgress	(	_In_ UCXENDPOINT	Endpoint,
		_In_ ULONG	MaxTransferSize
	)

static

Definition at line 1424 of file epctx.cpp.

{
    XhciEndpoint* Self = FromUcx(Endpoint);
    XhciTransferRing* Ring;
    NTSTATUS Status;
 
    /* QUIRK: UCX may ask again with a larger size; that is not supported */
    NT_ASSERT(!Self->m_ForwardProgress);
 
    /* The main ring serves until a streams record is current */
    Ring = Self->UsesStreams() ? Self->m_CurrentStreams->Entry[0].Ring : Self->m_MainRing;
 
    Status = Ring->EnableForwardProgress(MaxTransferSize);
    if (NT_SUCCESS(Status))
        Self->m_ForwardProgress = TRUE;
    else
        DPRINT1("Endpoint %p forward progress enable failed 0x%lx\n", Self, Status);
 
    return Status;
}

Referenced by XhciEvtUsbDeviceDefaultEndpointAdd(), and XhciEvtUsbDeviceEndpointAdd().

◆ FatalError()

VOID XhciEndpoint::FatalError ( _In_ ULONG Reason )

private

Definition at line 1083 of file epctx.cpp.

{
    m_Controller->RaiseControllerFault(XhciRecovery::ResetHost, Reason);
}

Referenced by CancelDequeueDone(), ClientDequeueDone(), ClientResetDone(), ControlDequeueDone(), ControlResetDone(), OnTransferEvent(), XhciEndpointMachine::RequestControllerReset(), ResetConfigureDone(), ResetDropDone(), StopAddDone(), StopDone(), and StopDropDone().

◆ ForEachRing()

VOID XhciEndpoint::ForEachRing ( _In_ VOID(XhciTransferRing::*)() Action )

private

Definition at line 918 of file epctx.cpp.

{
    ULONG Count = RingCount();
    ULONG Index;
 
    if (UsesStreams())
        InterlockedExchange(&m_CurrentStreams->UpdateCount, 0);
 
    for (Index = 0; Index < Count; Index++)
        (RingAt(Index)->*Action)();
}

Referenced by XhciEndpointMachine::NotifyRingsClientReset(), XhciEndpointMachine::NotifyRingsDrainEvents(), XhciEndpointMachine::NotifyRingsHalted(), XhciEndpointMachine::NotifyRingsReclaim(), XhciEndpointMachine::NotifyRingsReclaimOnCancel(), XhciEndpointMachine::NotifyRingsStoppedEvent(), XhciEndpointMachine::ResumeRingFill(), and XhciEndpointMachine::SuspendRingFill().

◆ FreeDefaultStreams()

VOID XhciEndpoint::FreeDefaultStreams ( _In_opt_ XhciStreams * Streams )

private

Frees a pool allocated default stream record and its array.

Definition at line 499 of file epctx.cpp.

{
    if (Streams == NULL)
        return;
 
    if (Streams->ContextArray != NULL)
        m_Controller->m_Buffers.Free(Streams->ContextArray);
 
    ExFreePoolWithTag(Streams, XHCI_TAG_ENDPOINT);
}

Referenced by Cleanup(), CloseStreams(), DisableRings(), StreamsDisableDone(), and StreamsEnableDone().

◆ FromUcx()

XhciEndpoint * XhciEndpoint::FromUcx ( _In_ UCXENDPOINT Endpoint )

static

Definition at line 232 of file epctx.cpp.

{
    return XhciGetEndpoint(Endpoint);
}

Referenced by XhciUsbDevice::DisableEndpointList(), XhciUsbDevice::EndpointsConfigure(), EvtEnableForwardProgress(), XhciUsbDevice::RecordEnabledEndpoints(), and XhciUsbDevice::SubmitSecondConfigure().

◆ Handle()

UCXENDPOINT XhciEndpoint::Handle ( ) const

Definition at line 251 of file epctx.cpp.

{
    return m_Ucx;
}

◆ Initialize()

NTSTATUS XhciEndpoint::Initialize	(	_In_ XhciController *	Controller,
		_In_ UCXUSBDEVICE	UcxUsbDevice,
		_In_ UCXENDPOINT	Endpoint,
		_In_ const USB_ENDPOINT_DESCRIPTOR *	Descriptor,
		_In_opt_ const USB_SUPERSPEED_ENDPOINT_COMPANION_DESCRIPTOR *	Companion,
		_In_opt_ const USB_SUPERSPEEDPLUS_ISOCH_ENDPOINT_COMPANION_DESCRIPTOR *	IsochCompanion
	)

private

Definition at line 342 of file epctx.cpp.

{
    WDF_OBJECT_ATTRIBUTES Attributes;
    WDF_TIMER_CONFIG TimerConfig;
    ULONG Type;
    ULONG Number;
    NTSTATUS Status;
 
    m_Controller = Controller;
    m_UcxDevice = UcxUsbDevice;
    m_Device = XhciUsbDevice::FromUcx(UcxUsbDevice);
    m_Ucx = Endpoint;
    m_ResetStatus = STATUS_PENDING;
    KeInitializeEvent(&m_ResetAck, NotificationEvent, FALSE);
 
    WDF_TIMER_CONFIG_INIT(&TimerConfig, EvtTimer);
    TimerConfig.AutomaticSerialization = FALSE;
    WDF_OBJECT_ATTRIBUTES_INIT(&Attributes);
    Attributes.ParentObject = Endpoint;
 
    Status = WdfTimerCreate(&TimerConfig, &Attributes, &m_Timer);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Endpoint %p state timer creation failed 0x%lx\n", this, Status);
        return Status;
    }
 
    RtlCopyMemory(&m_Descriptor, Descriptor, sizeof(m_Descriptor));
    if (Companion != NULL)
        RtlCopyMemory(&m_Companion, Companion, sizeof(m_Companion));
    if (IsochCompanion != NULL)
        RtlCopyMemory(&m_IsochCompanion, IsochCompanion, sizeof(m_IsochCompanion));
 
    /* EP Type (xHCI 6.2.3): OUT types are 1..3, IN adds 4, control is 4 either way */
    Type = TransferType();
    m_XhciType = Type;
    if ((Type == USB_ENDPOINT_TYPE_CONTROL) || USB_ENDPOINT_DIRECTION_IN(m_Descriptor.bEndpointAddress))
        m_XhciType += 4;
 
    /* DCI (xHCI 4.5.1): control and IN endpoints are odd */
    Number = m_Descriptor.bEndpointAddress & USB_ENDPOINT_ADDRESS_MASK;
    m_Dci = Number * 2;
    if (m_XhciType >= XHCI_ENDPOINT_TYPE_CONTROL)
        m_Dci++;
 
    /* Streams also need controller support */
    m_StreamsCapable = (m_Device->Speed() >= UsbSuperSpeed) &&
                       (Type == USB_ENDPOINT_TYPE_BULK) &&
                       (m_Companion.bmAttributes.Bulk.MaxStreams != 0) &&
                       (m_Controller->m_Registers.SupportedStreams() != 0);
 
    if (m_StreamsCapable && m_Controller->HasErrata(XhciErrata::StrmReconfigOnStop))
    {
        Status = CreateClearStall();
        if (!NT_SUCCESS(Status))
        {
            DPRINT1("Endpoint %p clear stall context creation failed 0x%lx\n", this, Status);
            return Status;
        }
    }
 
    /* The main ring of a streams capable endpoint is stream 1 of the default record */
    Status = XhciTransferRing::Create(this, Endpoint, m_StreamsCapable ? 1 : 0, &m_MainRing);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Endpoint %p DCI %lu main ring creation failed 0x%lx\n", this, m_Dci, Status);
        return Status;
    }
 
    UcxEndpointSetWdfIoQueue(Endpoint, m_MainRing->Queue());
 
    m_Device->AddEndpoint(this);
    m_Listed = TRUE;
 
    DPRINT("Endpoint %p created, address 0x%02x DCI %lu type %lu\n",
           this, m_Descriptor.bEndpointAddress, m_Dci, m_XhciType);
    return STATUS_SUCCESS;
}

Referenced by Create().

◆ InputEndpointContext()

PXHCI_ENDPOINT_CONTEXT XhciEndpoint::InputEndpointContext ( _In_ XhciDmaBuffer * Input ) const

private

Definition at line 1877 of file epctx.cpp.

{
    ULONG Size = m_Controller->m_Registers.ContextSize();
 
    return reinterpret_cast<PXHCI_ENDPOINT_CONTEXT>(static_cast<PUCHAR>(Input->VirtualAddress) +
                                                    (m_Dci + 1) * Size);
}

Referenced by BuildEndpointConfigure(), XhciEndpointMachine::ReconfigureForReset(), ResetDropDone(), and StopDropDone().

◆ IsStreamsCapable()

BOOLEAN XhciEndpoint::IsStreamsCapable ( ) const

Definition at line 297 of file epctx.cpp.

{
    return m_StreamsCapable;
}

◆ MaxBurst()

ULONG XhciEndpoint::MaxBurst ( ) const

Definition at line 281 of file epctx.cpp.

{
    /* The bulk ring asks at enable, before the first context was built */
    if (m_Device->Speed() >= UsbSuperSpeed)
        return m_Companion.bMaxBurst;
 
    return m_MaxBurst;
}

◆ MaxEsitPayload()

ULONG XhciEndpoint::MaxEsitPayload ( ) const

Definition at line 291 of file epctx.cpp.

{
    return m_MaxPayload;
}

◆ MaxPacketSize()

USHORT XhciEndpoint::MaxPacketSize ( ) const

Definition at line 275 of file epctx.cpp.

{
    return m_Descriptor.wMaxPacketSize & 0x7FF;
}

Referenced by BuildContext(), XhciTransferRing::PacketCount(), and XhciTransferRing::TdSize().

◆ OnExpectedEventsProcessed()

VOID XhciEndpoint::OnExpectedEventsProcessed ( )

Definition at line 1231 of file epctx.cpp.

{
    PostWhenAllRings(XepEvent::ExpectedEventsDone);
}

Referenced by XhciControlRing::OnEventDataEvent().

◆ OnHaltedCompletionCode()

VOID XhciEndpoint::OnHaltedCompletionCode	(	_In_ ULONG	CompletionCode,
		_In_ BOOLEAN	TransferFound
	)

Definition at line 1190 of file epctx.cpp.

{
    if (InterlockedOr(&m_Flags, XHCI_EP_HALT_RECEIVED) & XHCI_EP_HALT_RECEIVED)
    {
        m_Controller->VerifierCheck(XHCI_VERIFY_DUPLICATE_EVENT);
        return;
    }
 
    if (!TransferFound)
    {
        if (UsesStreams())
            m_CurrentStreams->HaltedCode = CompletionCode;
        InterlockedOr(&m_Flags, XHCI_EP_STREAM_HALT_PENDING);
    }
 
    PostEvent(XepEvent::HaltReported);
}

Referenced by XhciControlRing::OnEventDataEvent(), OnTransferEvent(), and XhciControlRing::OnTrbEvent().

◆ OnMappingStopped()

VOID XhciEndpoint::OnMappingStopped ( )

Definition at line 1237 of file epctx.cpp.

{
    PostWhenAllRings(XepEvent::StreamMapStopped);
}

Referenced by XhciControlRing::BuildControlTd(), XhciTransferRing::ChangeMapState(), and XhciControlRing::WriteTd().

◆ OnStoppedEvent()

VOID XhciEndpoint::OnStoppedEvent ( )

Definition at line 1217 of file epctx.cpp.

{
    /* QUIRK: a second stopped event reports the duplicate halt verifier condition */
    if (InterlockedOr(&m_Flags, XHCI_EP_STOPPED_RECEIVED) & XHCI_EP_STOPPED_RECEIVED)
    {
        m_Controller->VerifierCheck(XHCI_VERIFY_DUPLICATE_EVENT);
        return;
    }
 
    if (InterlockedXor(&m_Flags, XHCI_EP_STOPPED_HANDSHAKE) & XHCI_EP_STOPPED_HANDSHAKE)
        PostEvent(XepEvent::StoppedEventSeen);
}

Referenced by XhciControlRing::OnEventDataEvent(), OnTransferEvent(), and XhciControlRing::OnTrbEvent().

◆ OnTransferCanceled()

VOID XhciEndpoint::OnTransferCanceled ( )

Definition at line 1183 of file epctx.cpp.

{
    if (!(InterlockedOr(&m_Flags, XHCI_EP_CANCEL_REPORTED) & XHCI_EP_CANCEL_REPORTED))
        PostEvent(XepEvent::TransferAborted);
}

Referenced by XhciControlRing::Abort().

◆ OnTransferEvent()

VOID XhciEndpoint::OnTransferEvent ( _In_ const XHCI_TRB * Event )

Definition at line 1102 of file epctx.cpp.

{
    ULONG Code = XhciTrbCompletionCode(Event);
    ULONG64 Pointer;
    ULONG64 ArrayStart;
    ULONG Index;
 
    if ((Code == static_cast<ULONG>(XhciCompletionCode::TrbError)) ||
        (Code == static_cast<ULONG>(XhciCompletionCode::UndefinedError)) ||
        ((Code >= 192) && (Code <= 223)))
    {
        DPRINT1("Endpoint %p DCI %lu transfer event with completion code %lu\n", this, m_Dci, Code);
        m_Controller->VerifierCheck(XHCI_VERIFY_EVENT_CODE);
        FatalError(XHCI_REASON_EVENT_CODE);
        return;
    }
 
    if (!UsesStreams())
    {
        m_MainRing->OnTransferEvent(Event);
        return;
    }
 
    Pointer = XhciTrbPointer(Event);
    ArrayStart = m_CurrentStreams->ContextArray->LogicalAddress.QuadPart;
 
    if ((Pointer != 0) &&
        ((Pointer < ArrayStart) || (Pointer >= ArrayStart + m_CurrentStreams->ContextArray->Size)))
    {
        for (Index = 0; Index < m_CurrentStreams->Count; Index++)
        {
            if (m_CurrentStreams->Entry[Index].Ring->OnTransferEvent(Event))
                return;
        }
 
        if (Event->Dword[3] & XHCI_TRANSFER_EVENT_ED)
        {
            DPRINT1("Endpoint %p DCI %lu event data 0x%I64x matched no stream\n", this, m_Dci, Pointer);
            FatalError(XHCI_REASON_EVENT_DATA_POINTER);
            return;
        }
 
        if (!XhciIsStoppedCode(Code))
        {
            for (Index = 0; Index < m_CurrentStreams->Count; Index++)
            {
                if (!m_CurrentStreams->Entry[Index].Ring->IsLikelyDuplicate(Event))
                    continue;
 
                if (m_Controller->HasErrata(XhciErrata::EvtDiscardRepeatedEd0))
                {
                    DPRINT1("Endpoint %p DCI %lu dropping a likely duplicate event at 0x%I64x\n",
                            this, m_Dci, Pointer);
                    return;
                }
 
                DPRINT1("Endpoint %p DCI %lu likely duplicate event at 0x%I64x\n", this, m_Dci, Pointer);
                FatalError(XHCI_REASON_DUPLICATE_POINTER);
                return;
            }
 
            DPRINT1("Endpoint %p DCI %lu event at 0x%I64x matched no stream\n", this, m_Dci, Pointer);
            FatalError(XHCI_REASON_EVENT_POINTER);
            return;
        }
 
        /* Hardware compliance: a stopped event should point into some stream ring */
        DPRINT1("Endpoint %p DCI %lu stopped event at 0x%I64x matched no stream\n", this, m_Dci, Pointer);
    }
 
    /* An event for the endpoint as a whole */
    if (XhciIsHaltedCode(Code))
        OnHaltedCompletionCode(Code, FALSE);
    else if (XhciIsStoppedCode(Code))
        OnStoppedEvent();
    else
        DPRINT1("Endpoint %p DCI %lu ignoring endpoint event code %lu\n", this, m_Dci, Code);
}

◆ OnTransfersReclaimed()

VOID XhciEndpoint::OnTransfersReclaimed ( )

Definition at line 1243 of file epctx.cpp.

{
    /* Drops the reference NotifyRingsReclaim took, once the machine has the event */
    if (PostWhenAllRings(XepEvent::TransfersRecovered))
        WdfObjectDereferenceWithTag(m_Ucx, XHCI_RECLAIM_TAG);
}

◆ OpenStreams()

NTSTATUS XhciEndpoint::OpenStreams	(	_In_ XhciStreams *	Streams,
		_In_ WDFREQUEST	Request
	)

private

Switches from the default record to the client streams; STATUS_PENDING once the configure is out.

Definition at line 1648 of file epctx.cpp.

{
    PURB Urb = XhciRequestUrb(Request);
    WDFQUEUE MainQueue = m_MainRing->Queue();
    XhciTransferRing* Ring;
    ULONG Queued;
    ULONG Owned;
    NTSTATUS Status;
    ULONG Index;
 
    /* The main queue stays drained for as long as client streams are open */
    WdfIoQueueDrain(MainQueue, NULL, NULL);
    WdfIoQueueGetState(MainQueue, &Queued, &Owned);
    if ((Queued != 0) || (Owned != 0))
    {
        DPRINT1("Endpoint %p streams open with requests still on the main queue\n", this);
        Urb->UrbHeader.Status = USBD_STATUS_INVALID_PARAMETER;
        Status = STATUS_INVALID_PARAMETER;
        goto Failure;
    }
 
    if ((Streams->Count == 0) || (Streams->Count > m_Controller->m_Registers.SupportedStreams()))
    {
        DPRINT1("Endpoint %p streams open with bad stream count %lu\n", this, Streams->Count);
        Urb->UrbHeader.Status = USBD_STATUS_INVALID_PARAMETER;
        Status = STATUS_INVALID_PARAMETER;
        goto Failure;
    }
 
    XhciGetRequestData(Request)->StreamsConfigure.Streams = Streams;
 
    Streams->ContextArray = m_Controller->m_Buffers.Acquire(XhciStreamArrayBytes(Streams->MaxPrimary));
    if (Streams->ContextArray == NULL)
    {
        DPRINT1("Endpoint %p no stream context array for %lu streams\n", this, Streams->Count);
        Urb->UrbHeader.Status = USBD_STATUS_INSUFFICIENT_RESOURCES;
        Status = STATUS_INSUFFICIENT_RESOURCES;
        goto Failure;
    }
 
    m_CurrentStreams = Streams;
 
    for (Index = 0; Index < Streams->Count; Index++)
    {
        Ring = Streams->Entry[Index].Ring;
        Status = Ring->Enable();
        if (!NT_SUCCESS(Status))
        {
            DPRINT1("Endpoint %p stream %lu ring enable failed 0x%lx\n", this, Index + 1, Status);
            Urb->UrbHeader.Status = USBD_STATUS_INSUFFICIENT_RESOURCES;
            goto Failure;
        }
 
        StreamContext(Index + 1)->DequeuePointer = Ring->DequeuePointerValue();
    }
 
    m_Device->ReconfigureEndpoint(this, StreamsEnableDone, Request);
    return STATUS_PENDING;
 
Failure:
    DisableStreamRings(Streams);
    m_CurrentStreams = m_DefaultStreams;
    if (Streams->ContextArray != NULL)
    {
        m_Controller->m_Buffers.Free(Streams->ContextArray);
        Streams->ContextArray = NULL;
    }
 
    WdfIoQueueStart(MainQueue);
    return Status;
}

◆ OutputEndpointState()

ULONG XhciEndpoint::OutputEndpointState ( ) const

private

Definition at line 1090 of file epctx.cpp.

{
    return static_cast<PXHCI_ENDPOINT_CONTEXT>(m_Device->OutputContext(m_Dci))->EndpointState;
}

Referenced by ClientResetDone(), and StopDone().

◆ PostCommandFailure()

VOID XhciEndpoint::PostCommandFailure ( )

private

Definition at line 1076 of file epctx.cpp.

{
    if (!(InterlockedOr(&m_Flags, XHCI_EP_FAILURE_REPORTED) & XHCI_EP_FAILURE_REPORTED))
        PostEvent(XepEvent::CommandFailed);
}

Referenced by CancelDequeueDone(), ClientDequeueDone(), ClientResetDone(), ControlDequeueDone(), ControlResetDone(), XhciEndpointMachine::ReconfigureAfterStop(), ResetConfigureDone(), ResetDropDone(), StopAddDone(), StopDone(), and StopDropDone().

◆ PostEvent()

VOID XhciEndpoint::PostEvent ( _In_ XepEvent Event )

private

Definition at line 1069 of file epctx.cpp.

{
    m_Machine.SmPost(Event);
}

Referenced by CancelDequeueDone(), ClientDequeueDone(), ControlDequeueDone(), ControllerRemoved(), ControllerResetStarting(), DequeueAfterReset(), DequeueAfterStop(), OnHaltedCompletionCode(), OnStoppedEvent(), OnTransferCanceled(), PostCommandFailure(), PostWhenAllRings(), XhciEndpointMachine::ReconfigureForReset(), XhciEndpointMachine::ReportStoppedEvent(), ResetConfigureDone(), SendClearStall(), StopDone(), StreamsDisableDone(), and StreamsEnableDone().

◆ PostWhenAllRings()

BOOLEAN XhciEndpoint::PostWhenAllRings ( _In_ XepEvent Event )

private

Stream endpoints report once every stream ring has reported. TRUE when posted.

Definition at line 933 of file epctx.cpp.

{
    if (UsesStreams() &&
        (static_cast<ULONG>(InterlockedIncrement(&m_CurrentStreams->UpdateCount)) != m_CurrentStreams->Count))
    {
        return FALSE;
    }
 
    PostEvent(Event);
    return TRUE;
}

Referenced by OnExpectedEventsProcessed(), OnMappingStopped(), and OnTransfersReclaimed().

◆ ResetConfigureDone()

VOID NTAPI XhciEndpoint::ResetConfigureDone ( _In_ XhciCommand * Command )

staticprivate

Definition at line 2250 of file epctx.cpp.

{
    XhciEndpoint* Self = static_cast<XhciEndpoint*>(Command->Context);
    XhciEndpointReset* Data = &XhciGetRequestData(Self->m_ResetRequest)->EndpointReset;
 
    Self->m_Controller->m_Buffers.Free(Data->InputContext);
    Data->InputContext = NULL;
 
    /* QUIRK: the client reset succeeds even when the configure fails */
    Self->m_ResetStatus = STATUS_SUCCESS;
 
    if (Command->Status == STATUS_NO_SUCH_DEVICE)
    {
        Self->PostCommandFailure();
        return;
    }
 
    if (Command->Code != XhciCompletionCode::Success)
    {
        DPRINT1("Endpoint %p DCI %lu add for the client reset failed with code %lu\n",
                Self, Self->m_Dci, static_cast<ULONG>(Command->Code));
        Self->FatalError(Self->UsesStreams() ? XHCI_REASON_STREAM_RECONFIGURE : XHCI_REASON_RECONFIGURE);
        Self->PostCommandFailure();
        return;
    }
 
    Self->PostEvent(XepEvent::CommandSucceeded);
}

Referenced by XhciEndpointMachine::ReconfigureForReset(), and ResetDropDone().

◆ ResetDropDone()

VOID NTAPI XhciEndpoint::ResetDropDone ( _In_ XhciCommand * Command )

staticprivate

Definition at line 2210 of file epctx.cpp.

{
    XhciEndpoint* Self = static_cast<XhciEndpoint*>(Command->Context);
    XhciEndpointReset* Data = &XhciGetRequestData(Self->m_ResetRequest)->EndpointReset;
    XhciTransferRing* Ring;
    ULONG StreamId;
 
    if ((Command->Status == STATUS_NO_SUCH_DEVICE) || (Command->Code != XhciCompletionCode::Success))
    {
        if (Command->Status != STATUS_NO_SUCH_DEVICE)
        {
            DPRINT1("Endpoint %p DCI %lu drop for the client reset failed with code %lu\n",
                    Self, Self->m_Dci, static_cast<ULONG>(Command->Code));
            Self->FatalError(XHCI_REASON_DROP_FAILED);
        }
 
        Self->m_Controller->m_Buffers.Free(Data->InputContext);
        Data->InputContext = NULL;
        Self->m_ResetStatus = STATUS_SUCCESS;
        Self->PostCommandFailure();
        return;
    }
 
    for (StreamId = 1; StreamId <= Self->m_CurrentStreams->Count; StreamId++)
    {
        Ring = Self->m_CurrentStreams->Entry[StreamId - 1].Ring;
        Self->ResetStreamTransferLength(StreamId);
        Ring->InitializeRing();
        Self->StreamContext(StreamId)->DequeuePointer = Ring->DequeuePointerValue();
    }
 
    /* Add it back with the endpoint context stashed by the drop */
    Self->BuildEndpointConfigure(Data->InputContext, NULL, FALSE, TRUE, &Data->Command, ResetConfigureDone);
    Self->InputEndpointContext(Data->InputContext)->TRDequeuePointer = Self->EndpointDequeuePointer();
    Self->m_Controller->m_Commands.Submit(&Data->Command);
}

Referenced by XhciEndpointMachine::ReconfigureForReset().

◆ ResetPayload()

PENDPOINT_RESET XhciEndpoint::ResetPayload ( ) const

private

Definition at line 1096 of file epctx.cpp.

{
    return reinterpret_cast<PENDPOINT_RESET>(XhciRequestUrb(m_ResetRequest));
}

Referenced by XhciEndpointMachine::ResetEndpoint(), and XhciEndpointMachine::ShouldReconfigureForReset().

◆ ResetStreamTransferLength()

VOID XhciEndpoint::ResetStreamTransferLength ( _In_ ULONG StreamId )

private

Definition at line 1027 of file epctx.cpp.

{
    PXHCI_STREAM_CONTEXT Context;
    BOOLEAN First;
    BOOLEAN Second;
 
    if (!m_Controller->HasErrata(XhciErrata::StrmByteCountRearm))
        return;
 
    Context = StreamContext(StreamId);
    First = m_Controller->HasErrata(XhciErrata::StrmByteCountLayoutA);
    Second = m_Controller->HasErrata(XhciErrata::StrmByteCountLayoutB);
 
    if (!First && !Second)
        Context->Dword2 &= ~XHCI_STREAM_EDTLA_MASK;
    else if (First && !Second)
        Context->Dword2 &= 0xFF;
    else if (!First && Second)
        Context->Dword3 &= ~XHCI_STREAM_EDTLA_MASK;
}

Referenced by DequeueAfterStop(), and ResetDropDone().

◆ RingAt()

XhciTransferRing * XhciEndpoint::RingAt ( _In_ ULONG Index ) const

private

Definition at line 911 of file epctx.cpp.

{
    return UsesStreams() ? m_CurrentStreams->Entry[Index].Ring : m_MainRing;
}

Referenced by AnyTransfersPending(), and ForEachRing().

◆ RingCount()

ULONG XhciEndpoint::RingCount ( ) const

private

Definition at line 905 of file epctx.cpp.

{
    return UsesStreams() ? m_CurrentStreams->Count : 1;
}

Referenced by AnyTransfersPending(), and ForEachRing().

◆ SendClearStall()

VOID XhciEndpoint::SendClearStall ( )

private

Resets the device side sequence number with CLEAR_FEATURE(ENDPOINT_HALT) on our default endpoint queue.

Definition at line 2338 of file epctx.cpp.

{
    PUSB_DEFAULT_PIPE_SETUP_PACKET Setup;
    WDF_REQUEST_REUSE_PARAMS Reuse;
    struct _URB_CONTROL_TRANSFER_EX* Urb;
    PIO_STACK_LOCATION Stack;
    XhciEndpoint* Control;
    NTSTATUS Status;
    PIRP Irp;
 
    if (m_ClearStall == NULL)
    {
        PostEvent(XepEvent::CommandSucceeded);
        return;
    }
 
    Control = m_Device->EndpointAt(1);
    if (Control == NULL)
    {
        /* Post anyway so the endpoint machine does not wait forever */
        DPRINT1("Endpoint %p DCI %lu has no default endpoint for the clear stall\n", this, m_Dci);
        PostEvent(XepEvent::CommandSucceeded);
        return;
    }
 
    Irp = m_ClearStall->Irp;
    IoReuseIrp(Irp, STATUS_SUCCESS);
 
    Urb = &m_ClearStall->Urb;
    RtlZeroMemory(Urb, sizeof(*Urb));
    Urb->Hdr.Length = sizeof(*Urb);
    Urb->Hdr.Function = URB_FUNCTION_CONTROL_TRANSFER_EX;
    Urb->TransferFlags = USBD_DEFAULT_PIPE_TRANSFER | USB3_URB_RESERVED_RESOURCES;
    Urb->Timeout = XHCI_CLEAR_STALL_TIMEOUT_MS;
 
    /* UCX never sees this URB, so the control ring picks the current processor's interrupter */
    *(PULONG)&Urb->hca = XHCI_URB_NO_PROCESSOR;
 
    Setup = reinterpret_cast<PUSB_DEFAULT_PIPE_SETUP_PACKET>(Urb->SetupPacket);
    Setup->bmRequestType.B = BMREQUEST_HOST_TO_DEVICE | (BMREQUEST_STANDARD << 5) | BMREQUEST_TO_ENDPOINT;
    Setup->bRequest = USB_REQUEST_CLEAR_FEATURE;
    Setup->wValue.W = USB_FEATURE_ENDPOINT_STALL;
    Setup->wIndex.W = m_Descriptor.bEndpointAddress;
    Setup->wLength = 0;
 
    /* Make the top location look like a dispatched internal IOCTL with our routine attached */
    Stack = IoGetNextIrpStackLocation(Irp);
    RtlZeroMemory(Stack, sizeof(*Stack));
    Stack->MajorFunction = IRP_MJ_INTERNAL_DEVICE_CONTROL;
    Stack->Parameters.DeviceIoControl.IoControlCode = IOCTL_INTERNAL_USB_SUBMIT_URB;
    Stack->Parameters.Others.Argument1 = Urb;
 
    Status = IoSetCompletionRoutineEx(m_Controller->m_WdmDevice, Irp, ClearStallDone, this, TRUE, TRUE, TRUE);
    if (!NT_SUCCESS(Status))
        IoSetCompletionRoutine(Irp, ClearStallDone, this, TRUE, TRUE, TRUE);
 
    IoSetNextIrpStackLocation(Irp);
 
    WDF_REQUEST_REUSE_PARAMS_INIT(&Reuse,
                                  WDF_REQUEST_REUSE_SET_NEW_IRP | XHCI_REQUEST_REUSE_MUST_COMPLETE,
                                  STATUS_SUCCESS);
    Reuse.NewIrp = Irp;
    WdfRequestReuse(m_ClearStall->Request, &Reuse);
 
    Status = WdfRequestForwardToIoQueue(m_ClearStall->Request, Control->m_MainRing->Queue());
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Endpoint %p clear stall forward failed 0x%lx\n", this, Status);
        WdfRequestComplete(m_ClearStall->Request, Status);
    }
}

Referenced by StopAddDone().

◆ ShouldDropStoppedEvent()

BOOLEAN XhciEndpoint::ShouldDropStoppedEvent ( ) const

Definition at line 1211 of file epctx.cpp.

{
    return (m_Flags & XHCI_EP_IGNORE_STOPPED) != 0;
}

Referenced by XhciControlRing::OnTrbEvent().

◆ StopAddDone()

VOID NTAPI XhciEndpoint::StopAddDone ( _In_ XhciCommand * Command )

staticprivate

Definition at line 2310 of file epctx.cpp.

{
    XhciEndpoint* Self = static_cast<XhciEndpoint*>(Command->Context);
 
    Self->m_Controller->m_Buffers.Free(Self->m_StopInput);
    Self->m_StopInput = NULL;
 
    if (Command->Status == STATUS_NO_SUCH_DEVICE)
    {
        Self->PostCommandFailure();
        return;
    }
 
    if (Command->Code != XhciCompletionCode::Success)
    {
        DPRINT1("Endpoint %p DCI %lu add after stop failed with code %lu\n",
                Self, Self->m_Dci, static_cast<ULONG>(Command->Code));
        Self->FatalError(XHCI_REASON_STOP_ADD_FAILED);
        Self->PostCommandFailure();
        return;
    }
 
    Self->SendClearStall();
}

Referenced by StopDropDone().

◆ StopDone()

VOID NTAPI XhciEndpoint::StopDone ( _In_ XhciCommand * Command )

staticprivate

Definition at line 1929 of file epctx.cpp.

{
    XhciEndpoint* Self = static_cast<XhciEndpoint*>(Command->Context);
    ULONG State = Self->OutputEndpointState();
 
    if (Command->Status == STATUS_NO_SUCH_DEVICE)
    {
        Self->PostCommandFailure();
        return;
    }
 
    if (Command->Code == XhciCompletionCode::Success)
    {
        if (State == XHCI_ENDPOINT_STATE_STOPPED)
        {
            Self->PostEvent(XepEvent::CommandSucceeded);
            return;
        }
 
        DPRINT1("Endpoint %p DCI %lu in state %lu after a successful stop\n", Self, Self->m_Dci, State);
        Self->FatalError(XHCI_REASON_NOT_STOPPED);
        Self->PostCommandFailure();
        return;
    }
 
    if (Command->Code == XhciCompletionCode::ContextStateError)
    {
        switch (State)
        {
            case XHCI_ENDPOINT_STATE_RUNNING:
                /* A doorbell raced the stop */
                Self->PostEvent(XepEvent::StopFailedRunning);
                return;
 
            case XHCI_ENDPOINT_STATE_STOPPED:
                Self->PostEvent(XepEvent::StopFailedStopped);
                return;
 
            case XHCI_ENDPOINT_STATE_HALTED:
                if (Self->TransferType() != USB_ENDPOINT_TYPE_ISOCHRONOUS)
                {
                    Self->PostEvent(XepEvent::StopFailedHalted);
                    return;
                }
 
                DPRINT1("Endpoint %p DCI %lu isoch endpoint halted on stop\n", Self, Self->m_Dci);
                Self->FatalError(XHCI_REASON_STOP_ERROR);
                Self->PostCommandFailure();
                return;
 
            default:
                DPRINT1("Endpoint %p DCI %lu stop context error in state %lu\n", Self, Self->m_Dci, State);
                Self->FatalError(XHCI_REASON_STOP_CONTEXT);
                Self->PostCommandFailure();
                return;
        }
    }
 
    DPRINT1("Endpoint %p DCI %lu Stop Endpoint failed with code %lu\n",
            Self, Self->m_Dci, static_cast<ULONG>(Command->Code));
    Self->m_Controller->VerifierCheck(XHCI_VERIFY_STOP_ENDPOINT);
    Self->FatalError(XHCI_REASON_STOP_ERROR);
    Self->PostCommandFailure();
}

Referenced by XhciEndpointMachine::SendStopCommand().

◆ StopDropDone()

VOID NTAPI XhciEndpoint::StopDropDone ( _In_ XhciCommand * Command )

staticprivate

Definition at line 2282 of file epctx.cpp.

{
    XhciEndpoint* Self = static_cast<XhciEndpoint*>(Command->Context);
 
    if ((Command->Status == STATUS_NO_SUCH_DEVICE) || (Command->Code != XhciCompletionCode::Success))
    {
        if (Command->Status != STATUS_NO_SUCH_DEVICE)
        {
            DPRINT1("Endpoint %p DCI %lu drop after stop failed with code %lu\n",
                    Self, Self->m_Dci, static_cast<ULONG>(Command->Code));
            Self->FatalError(XHCI_REASON_DROP_FAILED);
        }
 
        Self->m_Controller->m_Buffers.Free(Self->m_StopInput);
        Self->m_StopInput = NULL;
        Self->PostCommandFailure();
        return;
    }
 
    /* Leave the stream context array alone; pending events are matched against the old ring contents */
    Self->BuildEndpointConfigure(Self->m_StopInput, NULL, FALSE, TRUE, &Self->m_Command, StopAddDone);
    Self->InputEndpointContext(Self->m_StopInput)->TRDequeuePointer = Self->EndpointDequeuePointer();
    Self->m_Controller->m_Commands.Submit(&Self->m_Command);
}

Referenced by XhciEndpointMachine::ReconfigureAfterStop().

◆ StreamCommandDone()

BOOLEAN XhciEndpoint::StreamCommandDone ( )

private

Definition at line 962 of file epctx.cpp.

{
    return static_cast<ULONG>(InterlockedIncrement(&m_CurrentStreams->UpdateCount)) ==
           m_CurrentStreams->Count;
}

Referenced by CancelDequeueDone(), ClientDequeueDone(), DequeueAfterReset(), and DequeueAfterStop().

◆ StreamContext()

PXHCI_STREAM_CONTEXT XhciEndpoint::StreamContext ( _In_ ULONG StreamId ) const

private

Definition at line 969 of file epctx.cpp.

{
    return static_cast<PXHCI_STREAM_CONTEXT>(m_CurrentStreams->ContextArray->VirtualAddress) + StreamId;
}

Referenced by CloseStreams(), OpenStreams(), ResetDropDone(), ResetStreamTransferLength(), StreamDequeuePointer(), StreamRingEmpty(), and StreamTransferLength().

◆ StreamDequeuePointer()

ULONG64 XhciEndpoint::StreamDequeuePointer ( _In_ ULONG StreamId ) const

Definition at line 976 of file epctx.cpp.

{
    if (!UsesStreams() || (m_CurrentStreams->ContextArray == NULL))
        return 0;
 
    return StreamContext(StreamId)->DequeuePointer;
}

◆ StreamHaltedCode()

ULONG XhciEndpoint::StreamHaltedCode ( ) const

Last halted code that matched no stream transfer, 0 when none.

Definition at line 1061 of file epctx.cpp.

{
    return UsesStreams() ? m_CurrentStreams->HaltedCode : 0;
}

◆ StreamRingEmpty()

BOOLEAN XhciEndpoint::StreamRingEmpty ( _In_ ULONG StreamId ) const

private

Only a ring nobody has queued to since its last reset counts as empty.

Definition at line 1051 of file epctx.cpp.

{
    XhciTransferRing* Ring = m_CurrentStreams->Entry[StreamId - 1].Ring;
    ULONG64 Pointer = StreamContext(StreamId)->DequeuePointer & ~XHCI_DEQUEUE_FLAGS_MASK;
 
    return (Pointer == Ring->SegmentBase()) && (Pointer == Ring->EnqueuePointer());
}

Referenced by DequeueAfterReset(), and DequeueAfterStop().

◆ StreamsDisableDone()

VOID NTAPI XhciEndpoint::StreamsDisableDone	(	_In_ PVOID	Context,
		_In_ NTSTATUS	Status
	)

staticprivate

Definition at line 1820 of file epctx.cpp.

{
    WDFREQUEST Request = static_cast<WDFREQUEST>(Context);
    XhciStreams* Streams = XhciGetRequestData(Request)->StreamsConfigure.Streams;
    XhciEndpoint* Self = Streams->Endpoint;
    PURB Urb = XhciRequestUrb(Request);
 
    if (NT_SUCCESS(Status))
    {
        Self->DisableStreamRings(Streams);
        if (Streams->ContextArray != NULL)
        {
            Self->m_Controller->m_Buffers.Free(Streams->ContextArray);
            Streams->ContextArray = NULL;
        }
 
        WdfIoQueueStart(Self->m_MainRing->Queue());
        Urb->UrbHeader.Status = USBD_STATUS_SUCCESS;
    }
    else
    {
        /* QUIRK: the main ring enabled for the close stays enabled */
        DPRINT1("Endpoint %p streams close reconfigure failed 0x%lx\n", Self, Status);
        Self->m_CurrentStreams = Streams;
        Self->FreeDefaultStreams(Self->m_DefaultStreams);
        Self->m_DefaultStreams = NULL;
        Urb->UrbHeader.Status = USBD_STATUS_INTERNAL_HC_ERROR;
    }
 
    if (NT_SUCCESS(Status))
        Self->PostEvent(XepEvent::StreamsOff);
 
    WdfRequestComplete(Request, Status);
}

Referenced by CloseStreams().

◆ StreamsEnableDone()

VOID NTAPI XhciEndpoint::StreamsEnableDone	(	_In_ PVOID	Context,
		_In_ NTSTATUS	Status
	)

staticprivate

Definition at line 1724 of file epctx.cpp.

{
    WDFREQUEST Request = static_cast<WDFREQUEST>(Context);
    XhciStreams* Streams = XhciGetRequestData(Request)->StreamsConfigure.Streams;
    XhciEndpoint* Self = Streams->Endpoint;
    PURB Urb = XhciRequestUrb(Request);
 
    if (NT_SUCCESS(Status))
    {
        Self->m_MainRing->Disable(TRUE);
        Self->FreeDefaultStreams(Self->m_DefaultStreams);
        Self->m_DefaultStreams = NULL;
        Urb->UrbHeader.Status = USBD_STATUS_SUCCESS;
    }
    else
    {
        DPRINT1("Endpoint %p streams open reconfigure failed 0x%lx\n", Self, Status);
        Self->DisableStreamRings(Streams);
        if (Streams->ContextArray != NULL)
        {
            Self->m_Controller->m_Buffers.Free(Streams->ContextArray);
            Streams->ContextArray = NULL;
        }
 
        Self->m_CurrentStreams = Self->m_DefaultStreams;
        Urb->UrbHeader.Status = USBD_STATUS_INTERNAL_HC_ERROR;
        WdfIoQueueStart(Self->m_MainRing->Queue());
    }
 
    if (NT_SUCCESS(Status))
        Self->PostEvent(XepEvent::StreamsOn);
 
    WdfRequestComplete(Request, Status);
}

Referenced by OpenStreams().

◆ StreamTransferLength()

ULONG XhciEndpoint::StreamTransferLength ( _In_ ULONG StreamId ) const

Bytes a stopped stream moved, from wherever this controller keeps its EDTLA.

Definition at line 987 of file epctx.cpp.

{
    PXHCI_STREAM_CONTEXT Context;
    BOOLEAN First;
    BOOLEAN Second;
    ULONG Length = 0;
 
    if (!UsesStreams() || (m_CurrentStreams->ContextArray == NULL))
        return 0;
 
    Context = StreamContext(StreamId);
    First = m_Controller->HasErrata(XhciErrata::StrmByteCountLayoutA);
    Second = m_Controller->HasErrata(XhciErrata::StrmByteCountLayoutB);
 
    if (!First && !Second)
    {
        Length = Context->Dword2 & XHCI_STREAM_EDTLA_MASK;
    }
    else if (First && !Second)
    {
        Length = Context->Dword2 >> 8;
        if (m_Controller->HasErrata(XhciErrata::StrmByteCountHasValidFlag) && !(Context->Dword2 & 0x80))
            Length = 0;
    }
    else if (!First && Second)
    {
        Length = Context->Dword3 & XHCI_STREAM_EDTLA_MASK;
    }
 
    if (m_Controller->HasErrata(XhciErrata::StrmByteCountTruncated))
    {
        NT_ASSERT(!Second);
        Length += Context->Dword3 & 0x1FFFF;
    }
 
    return Length;
}

◆ TransferType()

ULONG XhciEndpoint::TransferType ( ) const

USB transfer type, bmAttributes bits 1:0.

Definition at line 263 of file epctx.cpp.

{
    return m_Descriptor.bmAttributes & USB_ENDPOINT_TYPE_MASK;
}

Referenced by BuildContext(), Initialize(), XhciEndpointMachine::ShouldReconfigureForReset(), and StopDone().

◆ UsesStreams()

BOOLEAN XhciEndpoint::UsesStreams ( ) const

private

Friends And Related Function Documentation

◆ XhciEndpointMachine

friend class XhciEndpointMachine

friend

Definition at line 116 of file epctx.h.

Member Data Documentation

◆ ClearStallDone

NTSTATUS NTAPI XhciEndpoint::ClearStallDone

staticprivate

Definition at line 125 of file epctx.h.

Referenced by SendClearStall().

◆ EvtAbort

VOID NTAPI XhciEndpoint::EvtAbort

static

Definition at line 101 of file epctx.h.

Referenced by XhciEvtUsbDeviceDefaultEndpointAdd(), and XhciEvtUsbDeviceEndpointAdd().

◆ EvtAbortDone

VOID NTAPI XhciEndpoint::EvtAbortDone

staticprivate

Definition at line 124 of file epctx.h.

◆ EvtCleanup

VOID NTAPI XhciEndpoint::EvtCleanup

staticprivate

Definition at line 120 of file epctx.h.

Referenced by Create().

◆ EvtDefaultUpdate

VOID NTAPI XhciEndpoint::EvtDefaultUpdate

static

Definition at line 104 of file epctx.h.

Referenced by XhciEvtUsbDeviceDefaultEndpointAdd().

◆ EvtOkToCancel

VOID NTAPI XhciEndpoint::EvtOkToCancel

static

Definition at line 103 of file epctx.h.

Referenced by XhciEvtUsbDeviceDefaultEndpointAdd(), and XhciEvtUsbDeviceEndpointAdd().

◆ EvtPurge

VOID NTAPI XhciEndpoint::EvtPurge

static

Definition at line 99 of file epctx.h.

Referenced by XhciEvtUsbDeviceDefaultEndpointAdd(), and XhciEvtUsbDeviceEndpointAdd().

◆ EvtPurgeDone

VOID NTAPI XhciEndpoint::EvtPurgeDone

staticprivate

Definition at line 123 of file epctx.h.

◆ EvtReset

VOID NTAPI XhciEndpoint::EvtReset

static

Definition at line 102 of file epctx.h.

Referenced by XhciEvtUsbDeviceEndpointAdd().

◆ EvtStart

VOID NTAPI XhciEndpoint::EvtStart

static

Definition at line 100 of file epctx.h.

Referenced by XhciEvtUsbDeviceDefaultEndpointAdd(), and XhciEvtUsbDeviceEndpointAdd().

◆ EvtStreamsAdd

NTSTATUS NTAPI XhciEndpoint::EvtStreamsAdd

static

Definition at line 105 of file epctx.h.

Referenced by XhciEvtUsbDeviceEndpointAdd().

◆ EvtStreamsCleanup

VOID NTAPI XhciEndpoint::EvtStreamsCleanup

staticprivate

Definition at line 121 of file epctx.h.

◆ EvtStreamsDisable

VOID NTAPI XhciEndpoint::EvtStreamsDisable

static

Definition at line 107 of file epctx.h.

Referenced by XhciEvtUsbDeviceEndpointAdd().

◆ EvtStreamsEnable

VOID NTAPI XhciEndpoint::EvtStreamsEnable

static

Definition at line 106 of file epctx.h.

Referenced by XhciEvtUsbDeviceEndpointAdd().

◆ EvtTimer

VOID NTAPI XhciEndpoint::EvtTimer

staticprivate

Definition at line 122 of file epctx.h.

Referenced by Initialize().

◆ m_ClearStall

HaltClearBlock* XhciEndpoint::m_ClearStall

private

Definition at line 306 of file epctx.h.

Referenced by Cleanup(), CreateClearStall(), and SendClearStall().

◆ m_Command

XhciCommand XhciEndpoint::m_Command

private

Definition at line 304 of file epctx.h.

Referenced by CancelDequeueDone(), ClientDequeueDone(), ControlResetDone(), DequeueAfterReset(), DequeueAfterStop(), XhciEndpointMachine::ReconfigureAfterStop(), XhciEndpointMachine::ResetDefaultPipe(), XhciEndpointMachine::SendStopCommand(), and StopDropDone().

◆ m_Companion

USB_SUPERSPEED_ENDPOINT_COMPANION_DESCRIPTOR XhciEndpoint::m_Companion

private

Definition at line 291 of file epctx.h.

Referenced by BuildContext(), Initialize(), and MaxBurst().

◆ m_Controller

XhciController* XhciEndpoint::m_Controller

private

Definition at line 278 of file epctx.h.

◆ m_CurrentStreams

XhciStreams* XhciEndpoint::m_CurrentStreams

private

◆ m_Dci

◆ m_DefaultStreams

XhciStreams* XhciEndpoint::m_DefaultStreams

private

Definition at line 300 of file epctx.h.

Referenced by Cleanup(), CloseStreams(), DisableRings(), OpenStreams(), StreamsDisableDone(), and StreamsEnableDone().

◆ m_Descriptor

USB_ENDPOINT_DESCRIPTOR XhciEndpoint::m_Descriptor

private

Definition at line 290 of file epctx.h.

Referenced by BuildContext(), DefaultUpdateDone(), Descriptor(), Initialize(), MaxPacketSize(), SendClearStall(), and TransferType().

◆ m_Device

XhciUsbDevice* XhciEndpoint::m_Device

private

Definition at line 279 of file epctx.h.

Referenced by BuildContext(), BuildEndpointConfigure(), BuildSetDequeue(), Cleanup(), CloseStreams(), Device(), Initialize(), MaxBurst(), OpenStreams(), OutputEndpointState(), XhciEndpointMachine::ReconfigureAfterStop(), XhciEndpointMachine::ReconfigureForReset(), XhciEndpointMachine::ResetDefaultPipe(), XhciEndpointMachine::ResetEndpoint(), SendClearStall(), and XhciEndpointMachine::SendStopCommand().

◆ m_Flags

volatile LONG XhciEndpoint::m_Flags

private

Definition at line 285 of file epctx.h.

Referenced by XhciEndpointMachine::AckControllerReset(), XhciEndpointMachine::CompleteResetRequest(), XhciEndpointMachine::CompleteResetRequestIfAllowed(), XhciEndpointMachine::DropStoppedEvent(), OnHaltedCompletionCode(), OnStoppedEvent(), OnTransferCanceled(), PostCommandFailure(), XhciEndpointMachine::PurgeStreamQueues(), XhciEndpointMachine::ReportStoppedEvent(), XhciEndpointMachine::RestartStreamQueues(), XhciEndpointMachine::ResumeRingFill(), and ShouldDropStoppedEvent().

◆ m_ForwardProgress

BOOLEAN XhciEndpoint::m_ForwardProgress

private

Definition at line 283 of file epctx.h.

Referenced by DisableRings(), and EvtEnableForwardProgress().

◆ m_IsochCompanion

USB_SUPERSPEEDPLUS_ISOCH_ENDPOINT_COMPANION_DESCRIPTOR XhciEndpoint::m_IsochCompanion

private

Definition at line 292 of file epctx.h.

Referenced by BuildContext(), and Initialize().

◆ m_Listed

BOOLEAN XhciEndpoint::m_Listed

private

Definition at line 282 of file epctx.h.

Referenced by Cleanup(), and Initialize().

◆ m_Machine

XhciEndpointMachine XhciEndpoint::m_Machine

Definition at line 69 of file epctx.h.

Referenced by Create(), and PostEvent().

◆ m_MainRing

XhciTransferRing* XhciEndpoint::m_MainRing

private

Definition at line 288 of file epctx.h.

Referenced by CloseStreams(), ControlResetDone(), DequeueAfterReset(), DequeueAfterStop(), DisableRings(), XhciEndpointMachine::DoorbellRungSinceFill(), EndpointDequeuePointer(), EvtEnableForwardProgress(), Initialize(), OnTransferEvent(), OpenStreams(), XhciEndpointMachine::ReconfigureForReset(), RingAt(), StreamsDisableDone(), and StreamsEnableDone().

◆ m_MaxBurst

ULONG XhciEndpoint::m_MaxBurst

mutableprivate

Definition at line 297 of file epctx.h.

Referenced by BuildContext(), and MaxBurst().

◆ m_MaxPayload

ULONG XhciEndpoint::m_MaxPayload

mutableprivate

Definition at line 298 of file epctx.h.

Referenced by BuildContext(), and MaxEsitPayload().

◆ m_ResetAck

KEVENT XhciEndpoint::m_ResetAck

private

Definition at line 286 of file epctx.h.

Referenced by XhciEndpointMachine::AckControllerReset(), and Initialize().

◆ m_ResetRequest

WDFREQUEST volatile XhciEndpoint::m_ResetRequest

private

Definition at line 308 of file epctx.h.

Referenced by XhciEndpointMachine::CompleteResetRequest(), XhciEndpointMachine::ReconfigureForReset(), ResetConfigureDone(), ResetDropDone(), XhciEndpointMachine::ResetEndpoint(), and ResetPayload().

◆ m_ResetStatus

NTSTATUS XhciEndpoint::m_ResetStatus

private

Definition at line 309 of file epctx.h.

Referenced by XhciEndpointMachine::CanResetAfterHalt(), ClientDequeueDone(), ClientResetDone(), XhciEndpointMachine::CompleteResetRequest(), ControlDequeueDone(), DequeueAfterReset(), Initialize(), XhciEndpointMachine::ReconfigureForReset(), ResetConfigureDone(), ResetDropDone(), and XhciEndpointMachine::ShouldReconfigureForReset().

◆ m_StopAttempts

ULONG XhciEndpoint::m_StopAttempts

private

Definition at line 303 of file epctx.h.

Referenced by XhciEndpointMachine::CountStopAttempt(), XhciEndpointMachine::RequestControllerReset(), XhciEndpointMachine::ResetStopAttempts(), and XhciEndpointMachine::StopAttemptsExhausted().

◆ m_StopInput

XhciDmaBuffer* XhciEndpoint::m_StopInput

private

Definition at line 305 of file epctx.h.

Referenced by Cleanup(), XhciEndpointMachine::ReconfigureAfterStop(), StopAddDone(), and StopDropDone().

◆ m_StreamsCapable

BOOLEAN XhciEndpoint::m_StreamsCapable

private

Definition at line 284 of file epctx.h.

Referenced by BuildContext(), XhciEndpointMachine::CanResetAfterHalt(), DisableRings(), EndpointDequeuePointer(), Initialize(), IsStreamsCapable(), XhciEndpointMachine::NeedsContextRebuildAfterStop(), XhciEndpointMachine::ShouldReconfigureForReset(), and UsesStreams().

◆ m_Timer

WDFTIMER XhciEndpoint::m_Timer

private

Definition at line 287 of file epctx.h.

Referenced by Initialize(), XhciEndpointMachine::StartTimer(), and XhciEndpointMachine::StopTimer().

◆ m_Ucx

UCXENDPOINT XhciEndpoint::m_Ucx

private

Definition at line 281 of file epctx.h.

Referenced by XhciEndpointMachine::AskUcxToCancel(), XhciEndpointMachine::DereferenceEndpoint(), Handle(), Initialize(), XhciEndpointMachine::NotifyRingsReclaim(), OnTransfersReclaimed(), and XhciEndpointMachine::ReferenceEndpoint().

◆ m_UcxDevice

UCXUSBDEVICE XhciEndpoint::m_UcxDevice

private

Definition at line 280 of file epctx.h.

Referenced by Initialize().

◆ m_XhciType

ULONG XhciEndpoint::m_XhciType

private

Definition at line 293 of file epctx.h.

Referenced by BuildContext(), Initialize(), and XhciEndpointMachine::IsControlEndpoint().

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

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

Classes

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Friends

Detailed Description

Member Function Documentation

◆ _IRQL_requires_()

◆ _IRQL_requires_max_() [1/3]

◆ _IRQL_requires_max_() [2/3]

◆ _IRQL_requires_max_() [3/3]

◆ AnyTransfersPending()

◆ BuildContext()

◆ BuildEndpointConfigure()

◆ BuildSetDequeue()

◆ CancelDequeueDone()

◆ Cleanup()

◆ ClientDequeueDone()

◆ ClientResetDone()

◆ CloseStreams()

◆ ControlDequeueDone()

◆ Controller()

◆ ControllerRemoved()

◆ ControllerResetStarting()

◆ ControlResetDone()

◆ Create()

◆ CreateClearStall()

◆ Dci()

◆ DefaultUpdateDone()

◆ DequeueAfterReset()

◆ DequeueAfterStop()

◆ Descriptor()

◆ Device()

◆ DisableRings()

◆ DisableStreamRings()

◆ EndpointDequeuePointer()

◆ EvtEnableForwardProgress()

◆ FatalError()

◆ ForEachRing()

◆ FreeDefaultStreams()

◆ FromUcx()

◆ Handle()

◆ Initialize()

◆ InputEndpointContext()

◆ IsStreamsCapable()

◆ MaxBurst()

◆ MaxEsitPayload()

◆ MaxPacketSize()

◆ OnExpectedEventsProcessed()

◆ OnHaltedCompletionCode()

◆ OnMappingStopped()

◆ OnStoppedEvent()

◆ OnTransferCanceled()

◆ OnTransferEvent()

◆ OnTransfersReclaimed()

◆ OpenStreams()

◆ OutputEndpointState()

◆ PostCommandFailure()

◆ PostEvent()

◆ PostWhenAllRings()

◆ ResetConfigureDone()

◆ ResetDropDone()

◆ ResetPayload()

◆ ResetStreamTransferLength()

◆ RingAt()

◆ RingCount()

◆ SendClearStall()

◆ ShouldDropStoppedEvent()

◆ StopAddDone()

◆ StopDone()

◆ StopDropDone()

◆ StreamCommandDone()

◆ StreamContext()

◆ StreamDequeuePointer()

◆ StreamHaltedCode()