urbroute.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	UCX_URB_FLAGS_KEEP_HUB_BITS   UCXHUB_URB_FLAGS_HUB_MASK
#define	UCX_URB_FLAG_BUFFER_LOCKED   0x20000000
#define	UCX_MAX_CONTROL_TRANSFER   0xFFFF

Functions
FORCEINLINE VOID NTAPI	UcxStampProcessorNumber (_Inout_ PURB Urb)
FORCEINLINE VOID NTAPI	UcxSetTransferDirection (_Inout_ PURB Urb, _In_ const UcxPipe *Pipe)
VOID NTAPI	UcxLockTransferBuffer (_Inout_ PURB Urb)
VOID NTAPI	UcxUnlockTransferBuffer (_Inout_ PURB Urb)
NTSTATUS NTAPI	UcxUsbdStatusToNtStatus (_In_ USBD_STATUS UsbdStatus)
USBD_STATUS NTAPI	UcxNtStatusToUsbdStatus (_In_ NTSTATUS Status)
NTSTATUS NTAPI	UcxProcessLegacyUrb (_In_ WDFDEVICE RootHubPdo, _In_ PIRP Irp, _In_ PURB Urb)
BOOLEAN NTAPI	UcxValidatePipeHandle (_In_ UcxUsbDevice *Device, _In_ USBD_PIPE_HANDLE Handle)
NTSTATUS NTAPI	UcxForwardIrpToQueue (_In_ WDFDEVICE RootHubPdo, _In_ PIRP Irp, _In_ PIO_COMPLETION_ROUTINE Completion, _In_ PVOID Context, _In_ WDFQUEUE Queue)
NTSTATUS NTAPI	UcxForwardIrpWithRequest (_In_ WDFDEVICE RootHubPdo, _In_ PIRP Irp, _In_ PIO_COMPLETION_ROUTINE Completion, _In_ PVOID Context, _In_ WDFQUEUE Queue, _In_ WDFREQUEST Request)

Macro Definition Documentation

UCX_MAX_CONTROL_TRANSFER

#define UCX_MAX_CONTROL_TRANSFER   0xFFFF

Definition at line 17 of file urbroute.h.

UCX_URB_FLAG_BUFFER_LOCKED

#define UCX_URB_FLAG_BUFFER_LOCKED   0x20000000

Definition at line 14 of file urbroute.h.

UCX_URB_FLAGS_KEEP_HUB_BITS

#define UCX_URB_FLAGS_KEEP_HUB_BITS   UCXHUB_URB_FLAGS_HUB_MASK

Definition at line 11 of file urbroute.h.

Function Documentation

UcxForwardIrpToQueue()

NTSTATUS NTAPI UcxForwardIrpToQueue	(	_In_ WDFDEVICE	RootHubPdo,
		_In_ PIRP	Irp,
		_In_ PIO_COMPLETION_ROUTINE	Completion,
		_In_ PVOID	Context,
		_In_ WDFQUEUE	Queue
	)

Definition at line 308 of file urbroute.cpp.

{
    UcxSetCompletionOnNext(RootHubPdo, Irp, Completion, Context);
 
    WdfDeviceWdmDispatchIrpToIoQueue(RootHubPdo, Irp, Queue, WDF_DISPATCH_IRP_TO_IO_QUEUE_PREPROCESSED_IRP);
    return STATUS_PENDING;
}

Referenced by UcxForwardDefaultPipeRequest(), UcxForwardStreamsUrb(), UcxHandleIsoch(), UcxProcessLegacyUrb(), and UcxXrbSubmitTransfer().

UcxForwardIrpWithRequest()

NTSTATUS NTAPI UcxForwardIrpWithRequest	(	_In_ WDFDEVICE	RootHubPdo,
		_In_ PIRP	Irp,
		_In_ PIO_COMPLETION_ROUTINE	Completion,
		_In_ PVOID	Context,
		_In_ WDFQUEUE	Queue,
		_In_ WDFREQUEST	Request
	)

Definition at line 323 of file urbroute.cpp.

{
    WDF_REQUEST_FORWARD_OPTIONS Options;
    NTSTATUS Status;
 
    UcxSetCompletionOnNext(RootHubPdo, Irp, Completion, Context);
    IoSetNextIrpStackLocation(Irp);
 
    WDF_REQUEST_FORWARD_OPTIONS_INIT(&Options);
    Status = WdfRequestForwardToParentDeviceIoQueue(Request, Queue, &Options);
    if (!NT_SUCCESS(Status))
    {
        /* A purging queue means a controller reset or a concurrent pipe reset */
        if (Status == STATUS_WDF_BUSY)
            Status = STATUS_NO_SUCH_DEVICE;
 
        DPRINT1("Forwarding request %p (IRP %p) to queue %p failed 0x%lx\n", Request, Irp, Queue, Status);
        WdfRequestComplete(Request, Status);
    }
 
    return STATUS_PENDING;
}

Referenced by UcxXrbSubmitTransfer().

UcxLockTransferBuffer()

VOID NTAPI UcxLockTransferBuffer

(

_Inout_ PURB

Urb

)

Below DISPATCH_LEVEL, locks a buffer passed without an MDL so the HCD can map it.

Definition at line 82 of file urbroute.cpp.

{
    struct _URB_CONTROL_TRANSFER* Transfer = &Urb->UrbControlTransfer;
    LOCK_OPERATION Operation;
    PMDL Mdl;
 
    Urb->UrbHeader.UsbdFlags &= ~UCX_URB_FLAG_BUFFER_LOCKED;
 
    /* At DISPATCH_LEVEL the buffer has to be resident already */
    if (KeGetCurrentIrql() >= DISPATCH_LEVEL ||
        Transfer->TransferBufferMDL != NULL ||
        Transfer->TransferBuffer == NULL ||
        Transfer->TransferBufferLength == 0)
    {
        return;
    }
 
    Mdl = IoAllocateMdl(Transfer->TransferBuffer, Transfer->TransferBufferLength, FALSE, FALSE, NULL);
    if (Mdl == NULL)
    {
        DPRINT1("No MDL for the %lu byte buffer of URB %p\n", Transfer->TransferBufferLength, Urb);
        return;
    }
 
    Operation = (Transfer->TransferFlags & USBD_TRANSFER_DIRECTION_IN) ? IoWriteAccess : IoReadAccess;
 
    _SEH2_TRY
    {
        MmProbeAndLockPages(Mdl, KernelMode, Operation);
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        DPRINT1("Locking the buffer of URB %p failed 0x%lx\n", Urb, _SEH2_GetExceptionCode());
        IoFreeMdl(Mdl);
        Mdl = NULL;
    }
    _SEH2_END;
 
    if (Mdl == NULL)
        return;
 
    Transfer->TransferBufferMDL = Mdl;
    Urb->UrbHeader.UsbdFlags |= UCX_URB_FLAG_BUFFER_LOCKED;
}

Referenced by UcxForwardDefaultPipeRequest(), UcxHandleIsoch(), UcxProcessLegacyUrb(), and UcxXrbSubmitTransfer().

UcxNtStatusToUsbdStatus()

USBD_STATUS NTAPI UcxNtStatusToUsbdStatus

(

_In_ NTSTATUS

Status

)

Definition at line 53 of file urbroute.cpp.

{
    switch (Status)
    {
        case STATUS_SUCCESS:
            return USBD_STATUS_SUCCESS;
 
        case STATUS_NO_SUCH_DEVICE:
            return USBD_STATUS_DEVICE_GONE;
 
        case STATUS_INSUFFICIENT_RESOURCES:
            return USBD_STATUS_INSUFFICIENT_RESOURCES;
 
        case STATUS_NOT_SUPPORTED:
            return USBD_STATUS_NOT_SUPPORTED;
 
        case STATUS_CANCELLED:
            return USBD_STATUS_CANCELED;
 
        default:
            return USBD_STATUS_INVALID_PARAMETER;
    }
}

Referenced by UcxEndpoint::AbortPipe(), UcxEndpoint::GetIsochPathDelays(), UcxFailStreamsUrb(), UcxHandleGetCurrentFrame(), and UcxLegacyTransferCompletion().

UcxProcessLegacyUrb()

NTSTATUS NTAPI UcxProcessLegacyUrb	(	_In_ WDFDEVICE	RootHubPdo,
		_In_ PIRP	Irp,
		_In_ PURB	Urb
	)

Validates and routes a URB the way USBPORT did. Owns the IRP afterwards.

Definition at line 760 of file urbroute.cpp.

{
    const UcxUrbFunction* Function;
    UcxUsbDevice* Device;
    UcxPipe* Pipe = NULL;
    USBD_STATUS Error;
    USHORT Code;
 
    /* Short headers are not rejected */
    Urb->UrbHeader.Status = USBD_STATUS_SUCCESS;
    Code = Urb->UrbHeader.Function;
    Urb->UrbHeader.UsbdFlags &= UCX_URB_FLAGS_KEEP_HUB_BITS;
 
    if (Code >= ARRAYSIZE(UcxUrbFunctions))
    {
        DPRINT1("URB %p has unknown function 0x%x\n", Urb, Code);
        return UcxCompleteUrb(Irp, Urb, STATUS_INVALID_PARAMETER, USBD_STATUS_INVALID_URB_FUNCTION);
    }
 
    Function = &UcxUrbFunctions[Code];
 
    if (Function->Length != 0 && Function->Length != Urb->UrbHeader.Length)
    {
        DPRINT1("URB %p function 0x%x has length %u, expected %u\n", Urb, Code, Urb->UrbHeader.Length, Function->Length);
        return UcxCompleteUrb(Irp, Urb, STATUS_INVALID_PARAMETER, USBD_STATUS_INVALID_PARAMETER);
    }
 
    /* The hub fills in its UCXUSBDEVICE */
    if (Urb->UrbHeader.UsbdDeviceHandle == NULL)
    {
        DPRINT1("URB %p function 0x%x has no device handle\n", Urb, Code);
        return UcxCompleteUrb(Irp, Urb, STATUS_INVALID_PARAMETER, USBD_STATUS_INVALID_PARAMETER);
    }
 
    Device = UcxUsbDevice::FromHandle((UCXUSBDEVICE)Urb->UrbHeader.UsbdDeviceHandle);
 
    if (Device->m_Disconnected)
    {
        DPRINT("URB %p function 0x%x for disconnected device %p\n", Urb, Code, Device);
        return UcxCompleteUrb(Irp, Urb, STATUS_NO_SUCH_DEVICE, USBD_STATUS_DEVICE_GONE);
    }
 
    if (Function->Flags & UCX_URB_TRANSFER)
    {
        Error = UcxPrepareTransfer(Urb, Device, Function, &Pipe);
        if (Error != USBD_STATUS_SUCCESS)
        {
            DPRINT1("Transfer URB %p function 0x%x on device %p rejected, USBD status 0x%lx\n", Urb, Code, Device, Error);
            return UcxCompleteUrb(Irp, Urb, UcxUsbdStatusToNtStatus(Error), Error);
        }
    }
    else if (Function->Flags & UCX_URB_PIPE_REQUEST)
    {
        if (!UcxValidatePipeHandle(Device, Urb->UrbPipeRequest.PipeHandle))
        {
            DPRINT1("Pipe URB %p function 0x%x has invalid pipe %p\n", Urb, Code, Urb->UrbPipeRequest.PipeHandle);
            return UcxCompleteUrb(Irp, Urb, STATUS_INVALID_PARAMETER, USBD_STATUS_INVALID_PIPE_HANDLE);
        }
 
        Pipe = UcxPipe::FromHandle(Urb->UrbPipeRequest.PipeHandle);
 
        /* Zero bandwidth pipes are not in the schedule; pipe requests on them just succeed */
        if (Pipe->Kind == UcxEndpointKind::ZeroBandwidth)
            return UcxCompleteUrb(Irp, Urb, STATUS_SUCCESS, USBD_STATUS_SUCCESS);
    }
 
    /* Tells the completion routine whether the HCD ever saw it */
    Urb->UrbHeader.Status = USBD_STATUS_PENDING;
 
    switch (Function->Handler)
    {
        case UcxUrbHandler::NotSupported:
            DPRINT1("URB %p function 0x%x is not supported\n", Urb, Code);
            NT_ASSERT(FALSE);
            return UcxCompleteUrb(Irp, Urb, STATUS_NOT_SUPPORTED, USBD_STATUS_NOT_SUPPORTED);
 
        case UcxUrbHandler::InvalidFunction:
            DPRINT1("URB %p has invalid function 0x%x\n", Urb, Code);
            return UcxCompleteUrb(Irp, Urb, STATUS_INVALID_PARAMETER, USBD_STATUS_INVALID_URB_FUNCTION);
 
        case UcxUrbHandler::AbortPipe:
            return Pipe->Endpoint->AbortPipe(Irp, Urb);
 
        case UcxUrbHandler::GetCurrentFrame:
            return UcxHandleGetCurrentFrame(Irp, Urb, Device);
 
        case UcxUrbHandler::ControlTransfer:
            UcxLockTransferBuffer(Urb);
            return UcxForwardIrpToQueue(RootHubPdo, Irp, UcxLegacyTransferCompletion, Urb, Pipe->Queue);
 
        case UcxUrbHandler::BulkOrInterrupt:
            UcxSetTransferDirection(Urb, Pipe);
            UcxLockTransferBuffer(Urb);
            return UcxForwardIrpToQueue(RootHubPdo, Irp, UcxLegacyTransferCompletion, Urb, Pipe->Queue);
 
        case UcxUrbHandler::Isoch:
            return UcxHandleIsoch(RootHubPdo, Irp, Urb, Pipe->Queue, Pipe);
 
        default:
            return UcxHandleStandardRequest(RootHubPdo, Irp, Urb, Pipe->Queue, Function);
    }
}

Referenced by UcxProcessSubmitUrb().

UcxSetTransferDirection()

FORCEINLINE VOID NTAPI UcxSetTransferDirection	(	_Inout_ PURB	Urb,
		_In_ const UcxPipe *	Pipe
	)

Pins TransferFlags' direction to the pipe; the client's own bit is ignored.

Definition at line 48 of file urbroute.h.

{
    if (Pipe->DirectionIn)
        Urb->UrbControlTransfer.TransferFlags |= USBD_TRANSFER_DIRECTION_IN;
    else
        Urb->UrbControlTransfer.TransferFlags &= ~USBD_TRANSFER_DIRECTION_IN;
}

Referenced by UcxHandleIsoch(), UcxProcessLegacyUrb(), and UcxXrbSubmitTransfer().

UcxStampProcessorNumber()

FORCEINLINE VOID NTAPI UcxStampProcessorNumber

(

_Inout_ PURB

Urb

)

Definition at line 32 of file urbroute.h.

{
    *(PULONG)&Urb->UrbControlTransfer.hca = KeGetCurrentProcessorNumber();
}

Referenced by UcxPrepareTransfer(), and UcxXrbSubmitTransfer().

UcxUnlockTransferBuffer()

VOID NTAPI UcxUnlockTransferBuffer

(

_Inout_ PURB

Urb

)

Definition at line 130 of file urbroute.cpp.

{
    struct _URB_CONTROL_TRANSFER* Transfer = &Urb->UrbControlTransfer;
 
    if (!(Urb->UrbHeader.UsbdFlags & UCX_URB_FLAG_BUFFER_LOCKED))
        return;
 
    MmUnlockPages(Transfer->TransferBufferMDL);
    IoFreeMdl(Transfer->TransferBufferMDL);
    Transfer->TransferBufferMDL = NULL;
    Urb->UrbHeader.UsbdFlags &= ~UCX_URB_FLAG_BUFFER_LOCKED;
}

Referenced by UcxLegacyTransferCompletion(), and UcxXrbTransferCompletion().

UcxUsbdStatusToNtStatus()

NTSTATUS NTAPI UcxUsbdStatusToNtStatus

(

_In_ USBD_STATUS

UsbdStatus

)

Definition at line 18 of file urbroute.cpp.

{
    switch (UsbdStatus)
    {
        case USBD_STATUS_SUCCESS:
        case USBD_STATUS_PORT_OPERATION_PENDING:
            return STATUS_SUCCESS;
 
        case USBD_STATUS_INSUFFICIENT_RESOURCES:
            return STATUS_INSUFFICIENT_RESOURCES;
 
        case USBD_STATUS_INVALID_URB_FUNCTION:
        case USBD_STATUS_INVALID_PARAMETER:
        case USBD_STATUS_INVALID_PIPE_HANDLE:
        case USBD_STATUS_BAD_START_FRAME:
            return STATUS_INVALID_PARAMETER;
 
        case USBD_STATUS_NOT_SUPPORTED:
            return STATUS_NOT_SUPPORTED;
 
        case USBD_STATUS_DEVICE_GONE:
            return STATUS_NO_SUCH_DEVICE;
 
        case USBD_STATUS_CANCELED:
            return STATUS_CANCELLED;
 
        default:
            return STATUS_UNSUCCESSFUL;
    }
}

Referenced by UcxLegacyTransferCompletion(), UcxProcessLegacyUrb(), UcxXrbStreamsCompletion(), and UcxXrbTransferCompletion().

UcxValidatePipeHandle()

BOOLEAN NTAPI UcxValidatePipeHandle	(	_In_ UcxUsbDevice *	Device,
		_In_ USBD_PIPE_HANDLE	Handle
	)

Definition at line 356 of file urbroute.cpp.

{
    UcxPipe* Pipe = UcxPipe::FromHandle(Handle);
    BOOLEAN Valid = FALSE;
    PLIST_ENTRY Entry;
 
    if (Pipe != NULL && !Pipe->BelongsToStream)
    {
        if (Device->m_StalePipeIoAllowed)
        {
            SpinLockGuard Guard(&Device->m_TrackingLock);
 
            for (Entry = Device->m_TrackingList.Flink; Entry != &Device->m_TrackingList; Entry = Entry->Flink)
            {
                if (&CONTAINING_RECORD(Entry, UcxEndpoint, m_TrackingLink)->m_Pipe == Pipe)
                {
                    Valid = TRUE;
                    break;
                }
            }
        }
        else
        {
            Valid = Pipe->IsValid();
        }
    }
 
    if (!Valid && UcxAnyUsbdHandleHasVerifier(Device))
    {
        DPRINT1("Client used invalid pipe handle %p on device %p\n", Handle, Device);
        if (!KdRefreshDebuggerNotPresent())
            DbgBreakPoint();
    }
 
    return Valid;
}

Referenced by UcxPrepareTransfer(), and UcxProcessLegacyUrb().