UcxEndpoint Class Reference

#include <pipe.h>

Collaboration diagram for UcxEndpoint:

Public Member Functions
VOID	SetWdfIoQueue (_In_ WDFQUEUE Queue)
VOID	NeedToCancelTransfers ()
UCXSSTREAMS	GetStaticStreamsReferenced (_In_ PVOID Tag)
VOID	DeleteFromHub ()
VOID	ReleaseCancelSync ()
VOID	HandleHubReset (_In_ WDFREQUEST Request)
NTSTATUS	OnHcdResetDone (_In_ PIRP Irp)
NTSTATUS	OpenStaticStreams (_In_ PIRP Irp, _In_ PURB Urb)
NTSTATUS	CloseStaticStreams (_In_ PIRP Irp, _In_ PURB Urb)
VOID	HandleClientStreamsEnable (_In_ WDFREQUEST Request)
VOID	HandleClientStreamsDisable (_In_ WDFREQUEST Request)
NTSTATUS	OpenStaticStreamsComplete (_In_ PIRP Irp, _In_ PURB Urb)
NTSTATUS	CloseStaticStreamsComplete (_In_ PIRP Irp)
NTSTATUS	AbortPipe (_In_ PIRP Irp, _In_ PURB Urb)
NTSTATUS	GetIsochPathDelays (_In_ PIRP Irp, _In_ PURB Urb)
BOOLEAN	HasMachine () const
BOOLEAN	Post (_In_ EpEvent Event)
PVOID	TakePending ()
VOID	SetPending (_In_ PVOID Pending)

Static Public Member Functions
static _Must_inspect_result_ NTSTATUS	Create (_In_ UCXUSBDEVICE UsbDevice, _Inout_ PUCXENDPOINT_INIT *EndpointInit, _In_opt_ PWDF_OBJECT_ATTRIBUTES Attributes, _Out_ UCXENDPOINT *Endpoint)
static VOID	InitSetEventCallbacks (_Inout_ PUCXENDPOINT_INIT Init, _In_ PUCX_ENDPOINT_EVENT_CALLBACKS Callbacks)
static VOID	InitSetDefaultEventCallbacks (_Inout_ PUCXENDPOINT_INIT Init, _In_ PUCX_DEFAULT_ENDPOINT_EVENT_CALLBACKS Callbacks)
static _Must_inspect_result_ NTSTATUS	CreateDefaultFromHub (_In_ UCXUSBDEVICE UsbDevice, _In_ ULONG MaxPacketSize, _Out_ UCXENDPOINT *Endpoint)
static _Must_inspect_result_ NTSTATUS	CreateFromHub (_In_ UCXUSBDEVICE UsbDevice, _In_ PUSB_ENDPOINT_DESCRIPTOR Descriptor, _In_ ULONG DescriptorBufferLength, _In_opt_ PUSB_SUPERSPEED_ENDPOINT_COMPANION_DESCRIPTOR Companion, _Out_ UCXENDPOINT *Endpoint)
static UcxEndpoint *	FromHandle (_In_ UCXENDPOINT Handle)
static UcxEndpoint *	FromPipe (_In_ USBD_PIPE_HANDLE Handle)

Public Attributes
UCXENDPOINT	m_Handle
UcxController *	m_Controller
UcxUsbDevice *	m_Device
UcxPipe	m_Pipe
UcxStaticStreams *	m_Streams
LONG	m_StreamsOpenCount
UcxEndpointCallbacks	m_Callbacks
USB_ENDPOINT_DESCRIPTOR	m_Descriptor
LIST_ENTRY	m_DeviceLink
LIST_ENTRY	m_TrackingLink
LIST_ENTRY	m_DisconnectLink
LIST_ENTRY	m_ControllerResetLink
LIST_ENTRY	m_TreePurgeLink
LIST_ENTRY	m_OperationLink
EndpointMachine	m_Machine
BOOLEAN	m_HasMachine
PVOID	m_Pending
BOOLEAN	m_OpenFailedOnReset
IO_CSQ_IRP_CONTEXT	m_AbortCsqContext
LONG	m_CancelSync
BOOLEAN	m_ClientHoldsHandle
BOOLEAN	m_ClearTtOnCancel

Private Member Functions
VOID	Initialize (_In_ UcxUsbDevice *Device, _In_ const UcxEndpointInit *Init)

Static Private Member Functions
static NTSTATUS	CreateThroughHcd (_In_ UcxUsbDevice *Device, _Inout_ UcxEndpointInit *Init, _In_ ULONG MaxPacketSize, _In_opt_ PUSB_ENDPOINT_DESCRIPTOR Descriptor, _In_ ULONG DescriptorBufferLength, _In_opt_ PUSB_SUPERSPEED_ENDPOINT_COMPANION_DESCRIPTOR Companion, _Out_ UCXENDPOINT *Endpoint)

Static Private Attributes
static EVT_WDF_OBJECT_CONTEXT_DESTROY	EvtDestroy

Friends
class	EndpointMachine

Detailed Description

Definition at line 121 of file pipe.h.

Member Function Documentation

AbortPipe()

NTSTATUS UcxEndpoint::AbortPipe	(	_In_ PIRP	Irp,
		_In_ PURB	Urb
	)

Only a running endpoint takes the abort; the IRP waits in the cancel safe queue.

Definition at line 38 of file pipeio.cpp.

{
    if (!m_HasMachine || !Post(EpEvent::ClientAbortUrb))
    {
        DPRINT1("Endpoint %p abort pipe failed, endpoint is not running\n", m_Handle);
        return UcxCompleteUrb(Irp,
                              Urb,
                              STATUS_NO_SUCH_DEVICE,
                              UcxNtStatusToUsbdStatus(STATUS_NO_SUCH_DEVICE));
    }
 
    IoCsqInsertIrp(&m_Controller->m_AbortPipeCsq, Irp, &m_AbortCsqContext);
    Post(EpEvent::AbortUrbParked);
 
    return STATUS_PENDING;
}

Referenced by AbortPipe().

CloseStaticStreams()

NTSTATUS UcxEndpoint::CloseStaticStreams	(	_In_ PIRP	Irp,
		_In_ PURB	Urb
	)

Definition at line 267 of file pipeio.cpp.

{
    if (!m_Controller->m_RootHubInD0)
        return UcxCompleteUrb(Irp, Urb, STATUS_SUCCESS, USBD_STATUS_SUCCESS);
 
    if (KeGetCurrentIrql() != PASSIVE_LEVEL)
    {
        DPRINT1("Endpoint %p streams close at IRQL %u\n", m_Handle, KeGetCurrentIrql());
        return UcxFailStreamsUrb(Irp, Urb, STATUS_INVALID_PARAMETER);
    }
 
    if (m_Streams == NULL)
    {
        DPRINT1("Endpoint %p streams close with no streams open\n", m_Handle);
        return UcxFailStreamsUrb(Irp, Urb, STATUS_INVALID_DEVICE_STATE);
    }
 
    return UcxForwardStreamsUrb(m_Controller->m_RootHub->Pdo(), Irp, Urb, m_Controller);
}

Referenced by CloseStaticStreams(), and UcxProcessSubmitUrb().

CloseStaticStreamsComplete()

NTSTATUS UcxEndpoint::CloseStaticStreamsComplete

(

_In_ PIRP

Irp

)

Definition at line 361 of file pipeio.cpp.

{
    SetPending(Irp);
    Post(EpEvent::StreamsClosed);
 
    return STATUS_MORE_PROCESSING_REQUIRED;
}

Referenced by CloseStaticStreamsComplete().

Create()

_Must_inspect_result_ NTSTATUS UcxEndpoint::Create ( _In_ UCXUSBDEVICE  UsbDevice, _Inout_ PUCXENDPOINT_INIT *  EndpointInit, _In_opt_ PWDF_OBJECT_ATTRIBUTES  Attributes, _Out_ UCXENDPOINT *  Endpoint  )

static

Definition at line 195 of file pipe.cpp.

{
    UcxEndpointInit* Init = *EndpointInit;
    UcxUsbDevice* Device = UcxUsbDevice::FromHandle(UsbDevice);
    WDF_OBJECT_ATTRIBUTES Primary;
    UcxEndpoint* Context;
    WDFOBJECT Object;
    NTSTATUS Status = STATUS_SUCCESS;
 
    *Endpoint = NULL;
 
    /* Parented to the init block's device, referenced through the parameter */
    WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&Primary, UcxEndpoint);
    Primary.ParentObject = Init->Device;
    Primary.EvtDestroyCallback = EvtDestroy;
 
    Status = UcxCreateObjectWithTwoContexts(&Primary, Attributes, &Object);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Endpoint object create failed for UsbDevice %p 0x%lx\n", UsbDevice, Status);
        return Status;
    }
 
    WdfObjectReference(UsbDevice);
 
    Context = new (UcxGetEndpointContext(Object)) UcxEndpoint();
    Context->m_Handle = (UCXENDPOINT)Object;
    Context->Initialize(Device, Init);
 
    if (Init->CreateMachine)
    {
        Context->m_Machine.Initialize(Context);
        Context->m_HasMachine = TRUE;
 
        /* Creation reference, dropped by the machine once it deletes the object */
        WdfObjectReference(Object);
    }
 
    /* Recorded before the disconnect check, so a failure leaves them behind */
    if (Init->Kind == UcxEndpointKind::Default)
    {
        NT_ASSERT(Device->m_DefaultEndpoint == NULL);
        Device->m_DefaultEndpoint = Context;
        Device->m_DefaultPipe = &Context->m_Pipe;
    }
 
    {
        SpinLockGuard Guard(&Context->m_Controller->m_TopologyLock);
 
        if (Device->m_Disconnected)
        {
            Status = STATUS_DEVICE_NOT_CONNECTED;
        }
        else
        {
            InsertHeadList(&Device->m_EndpointList, &Context->m_DeviceLink);
            Context->m_Controller->m_ChildEndpointCount++;
        }
    }
 
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Endpoint %p not created, UsbDevice %p is disconnected\n", Object, UsbDevice);
 
        if (Context->m_HasMachine)
            WdfObjectDereference(Object);
 
        WdfObjectDelete(Object);
        return Status;
    }
 
    /* Tracking may have been turned on after the insert above and taken it already */
    if (Device->m_StalePipeIoAllowed)
    {
        SpinLockGuard Guard(&Device->m_TrackingLock);
 
        if (!UcxIsListEntryLinked(&Context->m_TrackingLink))
            InsertTailList(&Device->m_TrackingList, &Context->m_TrackingLink);
    }
 
    DPRINT("Endpoint %p address 0x%x created on UsbDevice %p\n",
           Context->m_Handle, Context->m_Descriptor.bEndpointAddress, UsbDevice);
 
    *Endpoint = Context->m_Handle;
    Init->Created = Context->m_Handle;
    *EndpointInit = NULL;
 
    return STATUS_SUCCESS;
}

Referenced by Create().

CreateDefaultFromHub()

_Must_inspect_result_ NTSTATUS UcxEndpoint::CreateDefaultFromHub ( _In_ UCXUSBDEVICE  UsbDevice, _In_ ULONG  MaxPacketSize, _Out_ UCXENDPOINT *  Endpoint  )

static

Definition at line 451 of file pipe.cpp.

{
    UcxEndpointInit Init;
 
    RtlZeroMemory(&Init, sizeof(Init));
    Init.Kind = UcxEndpointKind::Default;
    Init.TransferType = UcxTransferType::Control;
 
    return CreateThroughHcd(UcxUsbDevice::FromHandle(UsbDevice), &Init, MaxPacketSize, NULL, 0, NULL, Endpoint);
}

Referenced by CreateDefaultFromHub().

CreateFromHub()

_Must_inspect_result_ NTSTATUS UcxEndpoint::CreateFromHub ( _In_ UCXUSBDEVICE  UsbDevice, _In_ PUSB_ENDPOINT_DESCRIPTOR  Descriptor, _In_ ULONG  DescriptorBufferLength, _In_opt_ PUSB_SUPERSPEED_ENDPOINT_COMPANION_DESCRIPTOR  Companion, _Out_ UCXENDPOINT *  Endpoint  )

static

Definition at line 467 of file pipe.cpp.

{
    static const UcxTransferType TypeFromAttributes[4] =
    {
        UcxTransferType::Control,
        UcxTransferType::Isochronous,
        UcxTransferType::Bulk,
        UcxTransferType::Interrupt
    };
    UcxEndpointInit Init;
 
    RtlZeroMemory(&Init, sizeof(Init));
    Init.TransferType = TypeFromAttributes[Descriptor->bmAttributes & USB_ENDPOINT_TYPE_MASK];
    Init.Kind = (Descriptor->wMaxPacketSize == 0) ? UcxEndpointKind::ZeroBandwidth : UcxEndpointKind::Generic;
    RtlCopyMemory(&Init.Descriptor, Descriptor, sizeof(Init.Descriptor));
 
    if (Companion != NULL)
    {
        RtlCopyMemory(&Init.Companion, Companion, sizeof(Init.Companion));
        Init.HasCompanion = TRUE;
 
        /* The SuperSpeedPlus companion follows right after; the buffer length is not checked */
        if (Init.TransferType == UcxTransferType::Isochronous &&
            Companion->bmAttributes.Isochronous.SspCompanion)
        {
            RtlCopyMemory(&Init.IsochCompanion,
                          (PUCHAR)Companion + Companion->bLength,
                          sizeof(Init.IsochCompanion));
            Init.HasIsochCompanion = TRUE;
        }
    }
 
    return CreateThroughHcd(UcxUsbDevice::FromHandle(UsbDevice),
                            &Init,
                            0,
                            Descriptor,
                            DescriptorBufferLength,
                            Companion,
                            Endpoint);
}

Referenced by CreateFromHub().

CreateThroughHcd()

NTSTATUS UcxEndpoint::CreateThroughHcd ( _In_ UcxUsbDevice *  Device, _Inout_ UcxEndpointInit *  Init, _In_ ULONG  MaxPacketSize, _In_opt_ PUSB_ENDPOINT_DESCRIPTOR  Descriptor, _In_ ULONG  DescriptorBufferLength, _In_opt_ PUSB_SUPERSPEED_ENDPOINT_COMPANION_DESCRIPTOR  Companion, _Out_ UCXENDPOINT *  Endpoint  )

staticprivate

Definition at line 392 of file pipe.cpp.

{
    const UCX_USBDEVICE_EVENT_CALLBACKS* Hcd = &Device->m_Callbacks.Public;
    UCXCONTROLLER Controller = Device->m_Controller->m_Handle;
    NTSTATUS Status;
 
    PAGED_CODE();
 
    Init->Device = Device->m_Handle;
    Init->CreateMachine = TRUE;
 
    if (Init->Kind == UcxEndpointKind::Default)
    {
        Status = Hcd->EvtUsbDeviceDefaultEndpointAdd(Controller, Device->m_Handle, MaxPacketSize, Init);
    }
    else
    {
        Status = Hcd->EvtUsbDeviceEndpointAdd(Controller,
                                              Device->m_Handle,
                                              Descriptor,
                                              DescriptorBufferLength,
                                              Companion,
                                              Init);
    }
 
    if (!NT_SUCCESS(Status))
        DPRINT1("UsbDevice %p HCD endpoint add failed 0x%lx\n", Device->m_Handle, Status);
 
    /* Success without an endpoint or a queue leaves nothing to send transfers to */
    if (NT_SUCCESS(Status) &&
        (Init->Created == NULL || FromHandle(Init->Created)->m_Pipe.Queue == NULL))
    {
        DPRINT1("UsbDevice %p HCD endpoint add set no endpoint %p or no queue\n", Device->m_Handle, Init->Created);
        UcxVerifierBreak(Device->m_Controller->m_DriverVerifierEnabled);
        Status = STATUS_INTERNAL_ERROR;
    }
 
    if (NT_SUCCESS(Status))
    {
        *Endpoint = Init->Created;
        return Status;
    }
 
    *Endpoint = NULL;
    if (Init->Created != NULL)
        FromHandle(Init->Created)->DeleteFromHub();
 
    return Status;
}

Referenced by CreateDefaultFromHub(), CreateFromHub(), and CreateThroughHcd().

DeleteFromHub()

VOID UcxEndpoint::DeleteFromHub

(

)

Definition at line 515 of file pipe.cpp.

{
    Post(EpEvent::Delete);
}

Referenced by CreateThroughHcd(), DeleteFromHub(), and UcxHubEndpointDelete().

FromHandle()

UcxEndpoint * UcxEndpoint::FromHandle ( _In_ UCXENDPOINT  Handle )

static

Definition at line 91 of file pipe.cpp.

{
    return UcxGetEndpointContext(Handle);
}

Referenced by CreateThroughHcd(), and FromHandle().

FromPipe()

static UcxEndpoint * UcxEndpoint::FromPipe ( _In_ USBD_PIPE_HANDLE  Handle )

inlinestatic

Definition at line 241 of file pipe.h.

    {
        return UcxPipe::FromHandle(Handle)->Endpoint;
    }

GetIsochPathDelays()

NTSTATUS UcxEndpoint::GetIsochPathDelays	(	_In_ PIRP	Irp,
		_In_ PURB	Urb
	)

Answered by the controller driver when it has the callback, otherwise not supported.

Definition at line 59 of file pipeio.cpp.

{
    struct _URB_GET_ISOCH_PIPE_TRANSFER_PATH_DELAYS* Request = &Urb->UrbGetIsochPipeTransferPathDelays;
    UCX_ENDPOINT_ISOCH_TRANSFER_PATH_DELAYS Delays;
    NTSTATUS Status;
 
    if (m_Pipe.TransferType != UcxTransferType::Isochronous)
    {
        DPRINT1("Endpoint %p path delay query on a non isoch pipe\n", m_Handle);
        return UcxCompleteUrb(Irp, Urb, STATUS_INVALID_PARAMETER, USBD_STATUS_INVALID_PARAMETER);
    }
 
    if (m_Callbacks.GetIsochTransferPathDelays == NULL)
    {
        DPRINT("Endpoint %p has no path delay callback\n", m_Handle);
        return UcxCompleteUrb(Irp, Urb, STATUS_NOT_SUPPORTED, USBD_STATUS_NOT_SUPPORTED);
    }
 
    RtlZeroMemory(&Delays, sizeof(Delays));
    Status = m_Callbacks.GetIsochTransferPathDelays(m_Handle, &Delays);
    if (NT_SUCCESS(Status))
    {
        Request->MaximumSendPathDelayInMilliSeconds = Delays.MaximumSendPathDelayInMilliSeconds;
        Request->MaximumCompletionPathDelayInMilliSeconds = Delays.MaximumCompletionPathDelayInMilliSeconds;
    }
    else
    {
        DPRINT1("Endpoint %p path delay callback failed 0x%lx\n", m_Handle, Status);
    }
 
    return UcxCompleteUrb(Irp, Urb, Status, UcxNtStatusToUsbdStatus(Status));
}

Referenced by GetIsochPathDelays(), and UcxProcessSubmitUrb().

GetStaticStreamsReferenced()

UCXSSTREAMS UcxEndpoint::GetStaticStreamsReferenced

(

_In_ PVOID

Tag

)

Definition at line 370 of file pipe.cpp.

{
    UCXSSTREAMS Streams = NULL;
 
    if (m_Streams == NULL)
        return NULL;
 
    SpinLockGuard Guard(&m_Controller->m_TopologyLock);
 
    if (m_Streams != NULL)
    {
        Streams = m_Streams->m_Handle;
        WdfObjectReferenceWithTag(Streams, Tag);
    }
 
    return Streams;
}

Referenced by GetStaticStreamsReferenced(), and UcxApiEndpointGetStaticStreamsReferenced().

HandleClientStreamsDisable()

VOID UcxEndpoint::HandleClientStreamsDisable

(

_In_ WDFREQUEST

Request

)

Definition at line 298 of file pipeio.cpp.

{
    SetPending(Request);
    Post(EpEvent::ClientStreamsDisable);
}

Referenced by UcxUsbDevice::DispatchManagement(), UcxUsbDevice::FailManagement(), and HandleClientStreamsDisable().

HandleClientStreamsEnable()

VOID UcxEndpoint::HandleClientStreamsEnable

(

_In_ WDFREQUEST

Request

)

Definition at line 290 of file pipeio.cpp.

{
    SetPending(Request);
    Post(EpEvent::ClientStreamsEnable);
}

Referenced by UcxUsbDevice::DispatchManagement(), and HandleClientStreamsEnable().

HandleHubReset()

VOID UcxEndpoint::HandleHubReset

(

_In_ WDFREQUEST

Request

)

Definition at line 16 of file pipeio.cpp.

{
    SetPending(Request);
    Post(EpEvent::HubEndpointReset);
}

Referenced by UcxUsbDevice::DispatchManagement(), and HandleHubReset().

HasMachine()

BOOLEAN UcxEndpoint::HasMachine ( ) const

inline

Definition at line 248 of file pipe.h.

    {
        return m_HasMachine;
    }

Initialize()

VOID UcxEndpoint::Initialize ( _In_ UcxUsbDevice *  Device, _In_ const UcxEndpointInit *  Init  )

private

Definition at line 143 of file pipe.cpp.

{
    USB_DEVICE_SPEED Speed = Device->Speed();
 
    m_Controller = Device->m_Controller;
    m_Device = Device;
    m_Callbacks = Init->Callbacks;
    m_Descriptor = Init->Descriptor;
 
    m_Pipe.Endpoint = this;
    m_Pipe.Kind = Init->Kind;
    m_Pipe.TransferType = Init->TransferType;
    m_Pipe.Self = &m_Pipe;
    m_Pipe.MaximumTransferSize = UcxComputeMaxTransferSize(Speed, Device->m_BcdUsb, Init);
 
    if (Init->TransferType != UcxTransferType::Control)
        m_Pipe.DirectionIn = USB_ENDPOINT_DIRECTION_IN(m_Descriptor.bEndpointAddress) ? TRUE : FALSE;
 
    if (Init->TransferType == UcxTransferType::Isochronous)
    {
        if (UcxIsSlowSpeed(Speed))
        {
            m_Pipe.IsochPacketLimit = 255;
            m_Pipe.IsochPeriodMicroframes = 8;
        }
        else
        {
            /* bInterval 0 wraps to the top bit, as the x86 shift does */
            m_Pipe.IsochPacketLimit = 1024;
            m_Pipe.IsochPeriodMicroframes = 1UL << ((m_Descriptor.bInterval - 1) & 31);
        }
    }
 
    /* Only async transfers of slow devices behind a real TT need the TT cleared */
    m_ClearTtOnCancel = m_Controller->m_ClearTtBufferOnAsyncCancel &&
                        Init->TransferType != UcxTransferType::Interrupt &&
                        Init->TransferType != UcxTransferType::Isochronous &&
                        UcxIsSlowSpeed(Speed) &&
                        Device->m_Info.TtHub != NULL;
 
    UcxClearListEntry(&m_DeviceLink);
    UcxClearListEntry(&m_TrackingLink);
    UcxClearListEntry(&m_DisconnectLink);
    UcxClearListEntry(&m_ControllerResetLink);
    UcxClearListEntry(&m_TreePurgeLink);
    UcxClearListEntry(&m_OperationLink);
}

Referenced by Initialize().

InitSetDefaultEventCallbacks()

VOID UcxEndpoint::InitSetDefaultEventCallbacks ( _Inout_ PUCXENDPOINT_INIT  Init, _In_ PUCX_DEFAULT_ENDPOINT_EVENT_CALLBACKS  Callbacks  )

static

Definition at line 125 of file pipe.cpp.

{
    UcxEndpointCallbacks* Target = &Init->Callbacks;
 
    NT_ASSERT(Callbacks->Size == sizeof(*Callbacks));
    NT_ASSERT(Init->Kind == UcxEndpointKind::Default);
 
    Target->DefaultEndpointUpdate = Callbacks->EvtDefaultEndpointUpdate;
    Target->Purge = Callbacks->EvtEndpointPurge;
    Target->Start = Callbacks->EvtEndpointStart;
    Target->Abort = Callbacks->EvtEndpointAbort;
    Target->OkToCancelTransfers = Callbacks->EvtEndpointOkToCancelTransfers;
    Target->EnableForwardProgress = (PFN_UCX_HCD_ENDPOINT_ENABLE_FORWARD_PROGRESS)Callbacks->Reserved1;
}

Referenced by InitSetDefaultEventCallbacks().

InitSetEventCallbacks()

VOID UcxEndpoint::InitSetEventCallbacks ( _Inout_ PUCXENDPOINT_INIT  Init, _In_ PUCX_ENDPOINT_EVENT_CALLBACKS  Callbacks  )

static

Definition at line 98 of file pipe.cpp.

{
    UcxEndpointCallbacks* Target = &Init->Callbacks;
 
    NT_ASSERT(Init->Kind != UcxEndpointKind::Default);
 
    Target->Purge = Callbacks->EvtEndpointPurge;
    Target->Start = Callbacks->EvtEndpointStart;
    Target->Abort = Callbacks->EvtEndpointAbort;
    Target->Reset = Callbacks->EvtEndpointReset;
    Target->OkToCancelTransfers = Callbacks->EvtEndpointOkToCancelTransfers;
    Target->StaticStreamsAdd = Callbacks->EvtEndpointStaticStreamsAdd;
    Target->StaticStreamsEnable = Callbacks->EvtEndpointStaticStreamsEnable;
    Target->StaticStreamsDisable = Callbacks->EvtEndpointStaticStreamsDisable;
    Target->EnableForwardProgress = (PFN_UCX_HCD_ENDPOINT_ENABLE_FORWARD_PROGRESS)Callbacks->Reserved1;
 
    /* Appended by newer controller drivers, taken only from the full structure */
    if (Callbacks->Size == sizeof(*Callbacks))
    {
        Target->GetIsochTransferPathDelays = Callbacks->EvtEndpointGetIsochTransferPathDelays;
        Target->SetCharacteristic = Callbacks->EvtEndpointSetCharacteristic;
    }
}

Referenced by InitSetEventCallbacks().

NeedToCancelTransfers()

VOID UcxEndpoint::NeedToCancelTransfers

(

)

Clears the TT buffer first for a low or full speed device behind a TT.

Definition at line 328 of file pipe.cpp.

{
    const USB_DEVICE_PORT_PATH* Path = &m_Device->m_Info.PortPath;
    UcxUsbDevice* TtHub;
 
    if (!m_ClearTtOnCancel)
    {
        m_Callbacks.OkToCancelTransfers(m_Handle);
        return;
    }
 
    /* A second call during a clear never gets its OK */
    if (InterlockedCompareExchange(&m_CancelSync, 2, 0) != 0)
    {
        DPRINT1("Endpoint %p HCD asked to cancel transfers again during a TT clear\n", m_Handle);
        NT_ASSERT(FALSE);
        return;
    }
 
    WdfObjectReference(m_Handle);
 
    TtHub = UcxUsbDevice::FromHandle(m_Device->m_Info.TtHub);
    TtHub->m_HubClearTtBuffer(TtHub->m_HubContext,
                              m_Device->m_HubDeviceContext,
                              m_Handle,
                              m_Descriptor.bEndpointAddress,
                              Path->PortPath[Path->TTHubDepth]);
 
    ReleaseCancelSync();
}

Referenced by NeedToCancelTransfers(), and UcxApiEndpointNeedToCancelTransfers().

OnHcdResetDone()

NTSTATUS UcxEndpoint::OnHcdResetDone

(

_In_ PIRP

Irp

)

Definition at line 25 of file pipeio.cpp.

{
    SetPending(Irp);
    Post(EpEvent::EndpointResetDone);
 
    return STATUS_MORE_PROCESSING_REQUIRED;
}

Referenced by OnHcdResetDone(), and UcxDeviceMgmtCompletion().

OpenStaticStreams()

NTSTATUS UcxEndpoint::OpenStaticStreams	(	_In_ PIRP	Irp,
		_In_ PURB	Urb
	)

Definition at line 171 of file pipeio.cpp.

{
    UcxUsbdHandle* Client = UcxXrbFromUrb(Urb)->Handle;
    ULONG Count = Urb->UrbOpenStaticStreams.NumberOfStreams;
    UcxStaticStreams* Streams;
    KIRQL Irql = KeGetCurrentIrql();
    NTSTATUS Status;
 
    if (Irql != PASSIVE_LEVEL)
    {
        DPRINT1("Endpoint %p streams open at IRQL %u\n", m_Handle, Irql);
        if (Client->m_VerifierEnabled)
        {
            KeBugCheckEx(UCX_BUGCHECK_USB3,
                         UCX_USB3_STREAMS_IRQL,
                         Irql,
                         (ULONG_PTR)Irp,
                         (ULONG_PTR)Client->m_ClientDeviceObject);
        }
        return UcxFailStreamsUrb(Irp, Urb, STATUS_INVALID_PARAMETER);
    }
 
    if (!Client->m_StreamsGranted)
    {
        DPRINT1("Endpoint %p streams open without a streams grant\n", m_Handle);
        if (Client->m_VerifierEnabled)
        {
            KeBugCheckEx(UCX_BUGCHECK_USB3,
                         UCX_USB3_STREAMS_NOT_GRANTED,
                         (ULONG_PTR)Irp,
                         (ULONG_PTR)Urb,
                         (ULONG_PTR)Client->m_ClientDeviceObject);
        }
        return UcxFailStreamsUrb(Irp, Urb, STATUS_INVALID_PARAMETER);
    }
 
    if (Count == 0 || Count > Client->m_GrantedStreams)
    {
        DPRINT1("Endpoint %p streams open for %lu streams, %lu granted\n",
                m_Handle, Count, Client->m_GrantedStreams);
        if (Client->m_VerifierEnabled)
        {
            KeBugCheckEx(UCX_BUGCHECK_USB3,
                         UCX_USB3_STREAMS_BAD_COUNT,
                         Client->m_GrantedStreams,
                         Count,
                         (ULONG_PTR)Urb);
        }
        return UcxFailStreamsUrb(Irp, Urb, STATUS_INVALID_PARAMETER);
    }
 
    if (UcxVerifierWantsFailure(Client->m_VerifierFailEnableStaticStreams))
    {
        Status = UcxRandomErrorStatus();
        DPRINT1("Endpoint %p streams open failed by verifier 0x%lx\n", m_Handle, Status);
        return UcxFailStreamsUrb(Irp, Urb, Status);
    }
 
    /* One open at a time per endpoint */
    if (InterlockedIncrement(&m_StreamsOpenCount) != 1)
    {
        InterlockedDecrement(&m_StreamsOpenCount);
        DPRINT1("Endpoint %p static streams are already open\n", m_Handle);
 
        if (Client->m_VerifierEnabled)
        {
            KeBugCheckEx(UCX_BUGCHECK_USB3,
                         UCX_USB3_STREAMS_OPEN,
                         (ULONG_PTR)Irp,
                         (ULONG_PTR)Urb,
                         (ULONG_PTR)Client->m_ClientDeviceObject);
        }
        return UcxFailStreamsUrb(Irp, Urb, STATUS_INVALID_DEVICE_STATE);
    }
 
    Status = UcxCreateStaticStreams(this, Count, &Streams);
    if (!NT_SUCCESS(Status))
    {
        InterlockedDecrement(&m_StreamsOpenCount);
        return UcxFailStreamsUrb(Irp, Urb, Status);
    }
 
    {
        SpinLockGuard Guard(&m_Controller->m_TopologyLock);
 
        NT_ASSERT(m_Streams == NULL);
        m_Streams = Streams;
    }
 
    return UcxForwardStreamsUrb(m_Controller->m_RootHub->Pdo(), Irp, Urb, m_Controller);
}

Referenced by OpenStaticStreams(), and UcxProcessSubmitUrb().

OpenStaticStreamsComplete()

NTSTATUS UcxEndpoint::OpenStaticStreamsComplete	(	_In_ PIRP	Irp,
		_In_ PURB	Urb
	)

Definition at line 306 of file pipeio.cpp.

{
    PUSBD_STREAM_INFORMATION Info = Urb->UrbOpenStaticStreams.Streams;
    UcxStaticStreams* Streams;
    UcxStream* Entry;
    ULONG Index;
 
    if (!NT_SUCCESS(Irp->IoStatus.Status))
    {
        DPRINT1("Endpoint %p HCD streams enable failed 0x%lx\n", m_Handle, Irp->IoStatus.Status);
 
        {
            SpinLockGuard Guard(&m_Controller->m_TopologyLock);
 
            Streams = m_Streams;
            m_Streams = NULL;
        }
 
        if (Streams != NULL)
            WdfObjectDelete(Streams->m_Handle);
    }
    else
    {
        Streams = m_Streams;
 
        for (Index = 0; Index < Streams->m_StreamCount; Index++)
        {
            Entry = Streams->Stream(Index);
 
            Info[Index].PipeHandle = Entry->Pipe.Handle();
            Info[Index].StreamID = Entry->StreamId;
            Info[Index].MaximumTransferSize = Entry->Pipe.MaximumTransferSize;
            Info[Index].PipeFlags = 0;
        }
    }
 
    /* The machine never saw this open; finish it here */
    if (m_OpenFailedOnReset)
    {
        m_OpenFailedOnReset = FALSE;
        InterlockedDecrement(&m_StreamsOpenCount);
        UcxCompleteHeldUrbIrp(Irp);
 
        return STATUS_MORE_PROCESSING_REQUIRED;
    }
 
    SetPending(Irp);
    Post(EpEvent::StreamsOpened);
 
    return STATUS_MORE_PROCESSING_REQUIRED;
}

Referenced by OpenStaticStreamsComplete().

Post()

BOOLEAN UcxEndpoint::Post ( _In_ EpEvent  Event )

inline

FALSE only when the abort URB gate turned the event away.

Definition at line 255 of file pipe.h.

    {
        return m_Machine.SmPost(Event);
    }

Referenced by AbortPipe(), CloseStaticStreamsComplete(), DeleteFromHub(), HandleClientStreamsDisable(), HandleClientStreamsEnable(), UcxUsbDevice::HandleHubDisable(), UcxUsbDevice::HandleHubEndpointsConfigure(), HandleHubReset(), UcxUsbDevice::HandleHubReset(), UcxUsbDevice::OnHcdEnableDone(), UcxUsbDevice::OnHcdEndpointsConfigureDone(), OnHcdResetDone(), UcxUsbDevice::OnHcdResetDone(), OpenStaticStreamsComplete(), EndpointMachine::ParkAsStale(), UcxApiEndpointAbortComplete(), and UcxApiEndpointPurgeComplete().

ReleaseCancelSync()

VOID UcxEndpoint::ReleaseCancelSync

(

)

TT clear handshake: one decrement from the hub callback, one from the hub's ack.

Definition at line 360 of file pipe.cpp.

{
    if (InterlockedDecrement(&m_CancelSync) != 0)
        return;
 
    m_Callbacks.OkToCancelTransfers(m_Handle);
    WdfObjectDereference(m_Handle);
}

Referenced by NeedToCancelTransfers(), ReleaseCancelSync(), and UcxHubClearTtBufferComplete().

SetPending()

VOID UcxEndpoint::SetPending ( _In_ PVOID  Pending )

inline

Definition at line 273 of file pipe.h.

    {
        NT_ASSERT(m_Pending == NULL);
        m_Pending = Pending;
    }

Referenced by CloseStaticStreamsComplete(), HandleClientStreamsDisable(), HandleClientStreamsEnable(), HandleHubReset(), OnHcdResetDone(), and OpenStaticStreamsComplete().

SetWdfIoQueue()

VOID UcxEndpoint::SetWdfIoQueue

(

_In_ WDFQUEUE

Queue

)

Definition at line 313 of file pipe.cpp.

{
    if (m_Pipe.Queue != NULL)
    {
        DPRINT1("Endpoint %p already has queue %p\n", m_Handle, m_Pipe.Queue);
        return;
    }
 
    WdfObjectReference(Queue);
    m_Pipe.Queue = Queue;
}

Referenced by UcxRootHub::CreateEndpoint(), SetWdfIoQueue(), and UcxApiEndpointSetWdfIoQueue().

TakePending()

PVOID UcxEndpoint::TakePending ( )

inline

Definition at line 264 of file pipe.h.

    {
        PVOID Pending = m_Pending;
 
        m_Pending = NULL;
        return Pending;
    }

Referenced by EndpointMachine::FailResetRequest(), EndpointMachine::FinishEndpointResetRequest(), EndpointMachine::FinishStreamsCloseRequest(), EndpointMachine::FinishStreamsOpenRequest(), EndpointMachine::ForwardResetRequest(), EndpointMachine::ForwardStreamsDisableRequest(), EndpointMachine::ForwardStreamsEnableRequest(), EndpointMachine::ParkStreamsDisableRequest(), and EndpointMachine::RejectStreamsEnableRequest().

Friends And Related Function Documentation

EndpointMachine

friend class EndpointMachine

friend

Definition at line 336 of file pipe.h.

Member Data Documentation

EvtDestroy

VOID NTAPI UcxEndpoint::EvtDestroy

staticprivate

Definition at line 334 of file pipe.h.

Referenced by Create().

m_AbortCsqContext

IO_CSQ_IRP_CONTEXT UcxEndpoint::m_AbortCsqContext

Definition at line 308 of file pipe.h.

Referenced by AbortPipe(), and EndpointMachine::CompleteAbortUrb().

m_Callbacks

UcxEndpointCallbacks UcxEndpoint::m_Callbacks

Definition at line 289 of file pipe.h.

Referenced by _IRQL_requires_(), EndpointMachine::AbortEndpoint(), UcxUsbDevice::DispatchManagement(), EndpointMachine::ForwardResetRequest(), EndpointMachine::ForwardStreamsDisableRequest(), EndpointMachine::ForwardStreamsEnableRequest(), GetIsochPathDelays(), Initialize(), NeedToCancelTransfers(), EndpointMachine::PurgeEndpoint(), ReleaseCancelSync(), and EndpointMachine::StartEndpoint().

m_CancelSync

LONG UcxEndpoint::m_CancelSync

Definition at line 311 of file pipe.h.

Referenced by NeedToCancelTransfers(), and ReleaseCancelSync().

m_ClearTtOnCancel

BOOLEAN UcxEndpoint::m_ClearTtOnCancel

Definition at line 314 of file pipe.h.

Referenced by Initialize(), and NeedToCancelTransfers().

m_ClientHoldsHandle

BOOLEAN UcxEndpoint::m_ClientHoldsHandle

Definition at line 313 of file pipe.h.

Referenced by EndpointMachine::ClientHoldsHandle(), and UcxHubEndpointExposed().

m_Controller

UcxController* UcxEndpoint::m_Controller

Definition at line 282 of file pipe.h.

Referenced by EndpointMachine::AbortEndpoint(), AbortPipe(), EndpointMachine::AckControllerReset(), CloseStaticStreams(), EndpointMachine::CompleteAbortUrb(), EndpointMachine::CompleteTreePurge(), EndpointMachine::DeleteEndpoint(), EndpointMachine::FinishStreamsCloseRequest(), EndpointMachine::ForwardResetRequest(), GetStaticStreamsReferenced(), Initialize(), OpenStaticStreams(), OpenStaticStreamsComplete(), EndpointMachine::ParkAsStale(), EndpointMachine::ParkStreamsDisableRequest(), EndpointMachine::PurgeEndpoint(), UcxStaticStreams::SetStreamInfo(), and EndpointMachine::StartEndpoint().

m_ControllerResetLink

LIST_ENTRY UcxEndpoint::m_ControllerResetLink

Definition at line 298 of file pipe.h.

Referenced by Initialize().

m_Descriptor

USB_ENDPOINT_DESCRIPTOR UcxEndpoint::m_Descriptor

Definition at line 290 of file pipe.h.

Referenced by Initialize(), NeedToCancelTransfers(), and EndpointMachine::ParkAsStale().

m_Device

UcxUsbDevice* UcxEndpoint::m_Device

Definition at line 283 of file pipe.h.

Referenced by EndpointMachine::CompleteHubOperation(), EndpointMachine::DeviceAllowsStart(), EndpointMachine::DeviceDeprogrammed(), EndpointMachine::DeviceDisconnected(), Initialize(), NeedToCancelTransfers(), EndpointMachine::ParkAsStale(), and UcxApiEndpointNoPingResponseError().

m_DeviceLink

LIST_ENTRY UcxEndpoint::m_DeviceLink

Definition at line 293 of file pipe.h.

Referenced by EndpointMachine::DeleteEndpoint(), Initialize(), and EndpointMachine::ParkAsStale().

m_DisconnectLink

LIST_ENTRY UcxEndpoint::m_DisconnectLink

Definition at line 297 of file pipe.h.

Referenced by Initialize().

m_Handle

UCXENDPOINT UcxEndpoint::m_Handle

Definition at line 281 of file pipe.h.

Referenced by _IRQL_requires_(), EndpointMachine::AbortEndpoint(), AbortPipe(), CloseStaticStreams(), Create(), EndpointMachine::DeleteEndpoint(), EndpointMachine::DeleteStaleEndpoint(), EndpointMachine::DereferenceEndpoint(), EndpointMachine::FailResetRequest(), EndpointMachine::FinishStreamsOpenRequest(), EndpointMachine::ForwardResetRequest(), EndpointMachine::ForwardStreamsDisableRequest(), EndpointMachine::ForwardStreamsEnableRequest(), GetIsochPathDelays(), NeedToCancelTransfers(), OpenStaticStreams(), OpenStaticStreamsComplete(), EndpointMachine::ParkAsStale(), EndpointMachine::ParkStreamsDisableRequest(), EndpointMachine::PurgeEndpoint(), EndpointMachine::ReferenceEndpoint(), EndpointMachine::RejectStreamsEnableRequest(), ReleaseCancelSync(), SetWdfIoQueue(), and EndpointMachine::StartEndpoint().

m_HasMachine

BOOLEAN UcxEndpoint::m_HasMachine

Definition at line 303 of file pipe.h.

Referenced by AbortPipe(), and HasMachine().

m_Machine

EndpointMachine UcxEndpoint::m_Machine

Definition at line 302 of file pipe.h.

Referenced by Post().

m_OpenFailedOnReset

BOOLEAN UcxEndpoint::m_OpenFailedOnReset

Definition at line 306 of file pipe.h.

Referenced by OpenStaticStreamsComplete().

m_OperationLink

LIST_ENTRY UcxEndpoint::m_OperationLink

Definition at line 300 of file pipe.h.

Referenced by Initialize().

m_Pending

PVOID UcxEndpoint::m_Pending

Definition at line 305 of file pipe.h.

Referenced by SetPending(), and TakePending().

m_Pipe

UcxPipe UcxEndpoint::m_Pipe

Definition at line 284 of file pipe.h.

Referenced by CreateThroughHcd(), UcxRootHub::DispatchGetInfo(), GetIsochPathDelays(), Initialize(), EndpointMachine::ParkAsStale(), UcxStaticStreams::SetStreamInfo(), SetWdfIoQueue(), UcxHubEndpointMaxTransfer(), and UcxHubEndpointPipeHandle().

m_Streams

UcxStaticStreams* UcxEndpoint::m_Streams

Definition at line 286 of file pipe.h.

Referenced by CloseStaticStreams(), EndpointMachine::FinishStreamsCloseRequest(), EndpointMachine::ForwardStreamsDisableRequest(), EndpointMachine::ForwardStreamsEnableRequest(), GetStaticStreamsReferenced(), OpenStaticStreams(), and OpenStaticStreamsComplete().

m_StreamsOpenCount

LONG UcxEndpoint::m_StreamsOpenCount

Definition at line 287 of file pipe.h.

Referenced by EndpointMachine::FinishStreamsCloseRequest(), EndpointMachine::FinishStreamsOpenRequest(), OpenStaticStreams(), and OpenStaticStreamsComplete().

m_TrackingLink

LIST_ENTRY UcxEndpoint::m_TrackingLink

Definition at line 294 of file pipe.h.

Referenced by Initialize().

m_TreePurgeLink

LIST_ENTRY UcxEndpoint::m_TreePurgeLink

Definition at line 299 of file pipe.h.

Referenced by Initialize().

---

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

• drivers/usb/ucx01000/pipe.h
• drivers/usb/ucx01000/pipe.cpp
• drivers/usb/ucx01000/pipeio.cpp