#include <fxusbpipe.hpp>

Inheritance diagram for FxUsbPipe:

[legend]

Collaboration diagram for FxUsbPipe:

[legend]

Public Member Functions
	FxUsbPipe (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in FxUsbDevice *UsbDevice)

VOID	InitPipe (__in PUSBD_PIPE_INFORMATION PipeInfo, __in UCHAR InterfaceNumber, __in FxUsbInterface *UsbInterface)

VOID	InitPipe (__in PWINUSB_PIPE_INFORMATION PipeInfo, __in UCHAR InterfaceNumber, __in FxUsbInterface *UsbInterface)

virtual _Must_inspect_result_ NTSTATUS	GotoStartState (__in PLIST_ENTRY RequestListHead, __in BOOLEAN Lock=TRUE)

virtual VOID	GotoStopState (__in WDF_IO_TARGET_SENT_IO_ACTION Action, __in PSINGLE_LIST_ENTRY SentRequestListHead, __out PBOOLEAN Wait, __in BOOLEAN LockSelf)

VOID	GotoPurgeState (__in WDF_IO_TARGET_PURGE_IO_ACTION Action, __in PLIST_ENTRY PendedRequestListHead, __in PSINGLE_LIST_ENTRY SentRequestListHead, __out PBOOLEAN Wait, __in BOOLEAN LockSelf)

virtual VOID	GotoRemoveState (__in WDF_IO_TARGET_STATE NewState, __in PLIST_ENTRY PendedRequestListHead, __in PSINGLE_LIST_ENTRY SentRequestListHead, __in BOOLEAN Lock, __out PBOOLEAN Wait)

virtual VOID	WaitForSentIoToComplete (VOID)

__inline VOID	SetNoCheckPacketSize (VOID)

VOID	GetInformation (__out PWDF_USB_PIPE_INFORMATION PipeInformation)

BOOLEAN	IsType (__in WDF_USB_PIPE_TYPE Type)

WDF_USB_PIPE_TYPE	GetType (VOID)

WDFUSBPIPE	GetHandle (VOID)

__inline BOOLEAN	IsInEndpoint (VOID)

__inline BOOLEAN	IsOutEndpoint (VOID)

_Must_inspect_result_ NTSTATUS	InitContinuousReader (__in PWDF_USB_CONTINUOUS_READER_CONFIG Config, __in size_t TotalBufferLength)

ULONG	GetMaxPacketSize (VOID)

_Must_inspect_result_ NTSTATUS	ValidateTransferLength (__in size_t Length)

_Must_inspect_result_ NTSTATUS	FormatTransferRequest (__in FxRequestBase Request, __in FxRequestBuffer Buffer, __in ULONG TransferFlags=0)

_Must_inspect_result_ NTSTATUS	FormatAbortRequest (__in FxRequestBase *Request)

_Must_inspect_result_ NTSTATUS	FormatResetRequest (__in FxRequestBase *Request)

USBD_PIPE_HANDLE	WdmGetPipeHandle (VOID)

NTSTATUS	Reset (VOID)

USBD_HANDLE	GetUSBDHandle (VOID)

FX_URB_TYPE	GetUrbType (VOID)

Public Member Functions inherited from FxIoTarget
	FxIoTarget (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in USHORT ObjectSize)

	FxIoTarget (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in USHORT ObjectSize, __in WDFTYPE WdfType)

virtual _Must_inspect_result_ NTSTATUS	Start (VOID)

virtual VOID	Stop (__in WDF_IO_TARGET_SENT_IO_ACTION Action)

virtual VOID	Purge (__in WDF_IO_TARGET_PURGE_IO_ACTION Action)

virtual VOID	Remove (VOID)

NTSTATUS _Must_inspect_result_	QueryInterface (__inout FxQueryInterfaceParams *Params)

__inline WDF_IO_TARGET_STATE	GetState (VOID)

__inline MdDeviceObject	GetTargetDevice (VOID)

__inline MdDeviceObject	GetTargetPDO (VOID)

__inline MdFileObject	GetTargetFileObject (VOID)

__inline WDFDEVICE	GetDeviceHandle (VOID)

WDFIOTARGET	GetHandle (VOID)

__inline FxDriver *	GetDriver (VOID)

virtual _Must_inspect_result_ MdDeviceObject	GetTargetDeviceObject (_In_ CfxDeviceBase *Device)

_Must_inspect_result_ NTSTATUS	Init (__in CfxDeviceBase *Device)

ULONG	Submit (__in FxRequestBase *Request, __in_opt PWDF_REQUEST_SEND_OPTIONS Options, __in_opt ULONG Flags)

	FX_DECLARE_VF_FUNCTION_P1 (NTSTATUS, VerifySubmitLocked, _In_ FxRequestBase *)

ULONG	SubmitLocked (__in FxRequestBase *Request, __in_opt PWDF_REQUEST_SEND_OPTIONS Options, __in ULONG Flags)

_Must_inspect_result_ NTSTATUS	SubmitSync (__in FxRequestBase *Request, __in_opt PWDF_REQUEST_SEND_OPTIONS Options=NULL, __out_opt PULONG Action=NULL)

VOID	TimerCallback (__in FxRequestBase *Request)

VOID	CompleteCanceledRequest (__in FxRequestBase *Request)

VOID	SubmitPendedRequest (__in FxRequestBase *Request)

VOID	CompletePendedRequest (__in FxRequestBase *Request)

BOOLEAN __inline	HasEnoughStackLocations (__in FxIrp *Irp)

_Must_inspect_result_ NTSTATUS	FormatIoRequest (__inout FxRequestBase Request, __in UCHAR MajorCode, __in FxRequestBuffer IoBuffer, __in_opt PLONGLONG StartingOffset, __in_opt FxFileObject *FileObject=NULL)

_Must_inspect_result_ NTSTATUS	FormatIoctlRequest (__in FxRequestBase Request, __in ULONG Ioctl, __in BOOLEAN Internal, __in FxRequestBuffer InputBuffer, __in FxRequestBuffer OutputBuffer, __in_opt FxFileObject FileObject=NULL)

_Must_inspect_result_ NTSTATUS	FormatInternalIoctlOthersRequest (__in FxRequestBase Request, __in ULONG Ioctl, __in FxRequestBuffer Buffers)

VOID	CancelSentIo (VOID)

_Must_inspect_result_ NTSTATUS	SubmitSyncRequestIgnoreTargetState (__in FxRequestBase *Request, __in_opt PWDF_REQUEST_SEND_OPTIONS RequestOptions)

VOID	UpdateTargetIoType (VOID)

BOOLEAN	HasValidStackSize (VOID)

virtual VOID	Send (_In_ MdIrp Irp)

Public Member Functions inherited from FxNonPagedObject
	FxNonPagedObject (__in WDFTYPE Type, __in USHORT Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals)

	FxNonPagedObject (__in WDFTYPE Type, __in USHORT Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in FxObjectType ObjectType)

virtual	~FxNonPagedObject (VOID)

	_Acquires_lock_ (this->m_NPLock.m_Lock) __drv_maxIRQL(DISPATCH_LEVEL) __drv_setsIRQL(DISPATCH_LEVEL) VOID Lock(__out __drv_deref(__drv_savesIRQL) PKIRQL PreviousIrql)

	_Releases_lock_ (this->m_NPLock.m_Lock) __drv_requiresIRQL(DISPATCH_LEVEL) __inline VOID Unlock(__in __drv_restoresIRQL KIRQL PreviousIrql)

	_Acquires_lock_ (this->m_NPLock.m_Lock) __drv_requiresIRQL(DISPATCH_LEVEL) VOID LockAtDispatch(VOID)

	_Requires_lock_held_ (this->m_NPLock.m_Lock) _Releases_lock_(this -> m_NPLock.m_Lock) __drv_requiresIRQL(DISPATCH_LEVEL) __inline VOID UnlockFromDispatch(VOID)

Public Member Functions inherited from FxObject
PVOID	GetCOMWrapper ()

void	SetCOMWrapper (__drv_aliasesMem PVOID Wrapper)

	FxObject (__in WDFTYPE Type, __in USHORT Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals)

virtual	~FxObject (VOID)

PVOID __inline	operator new (__in size_t Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in FxObjectType Type)

PVOID __inline	operator new (__in size_t Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in_opt PWDF_OBJECT_ATTRIBUTES Attributes, __in USHORT ExtraSize=0)

VOID	operator delete (__in PVOID Memory)

VOID	SetNoContextHeader (VOID)

PVOID __inline	GetObjectHandle (VOID)

__inline FxContextHeader *	GetContextHeader (VOID)

__inline PFX_DRIVER_GLOBALS	GetDriverGlobals (VOID)

WDFTYPE	GetType (VOID)

USHORT	GetObjectSize (VOID)

LONG	GetRefCnt (VOID)

FxTagTracker *	GetTagTracker (VOID)

CfxDevice *	GetDevice (VOID)

CfxDeviceBase *	GetDeviceBase (VOID)

VOID	SetDeviceBase (__in CfxDeviceBase *DeviceBase)

__inline VOID	CallCleanup (VOID)

ULONG __inline	AddRef (__in_opt PVOID Tag=NULL, __in LONG Line=0, __in_opt PSTR File=NULL)

virtual ULONG	Release (__in_opt PVOID Tag=NULL, __in LONG Line=0, __in_opt PSTR File=NULL)

virtual ULONG	AddRefOverride (__in WDFOBJECT_OFFSET Offset, __in_opt PVOID Tag=NULL, __in LONG Line=0, __in_opt PSTR File=NULL)

virtual ULONG	ReleaseOverride (__in WDFOBJECT_OFFSET Offset, __in_opt PVOID Tag=NULL, __in LONG Line=0, __in_opt PSTR File=NULL)

virtual _Must_inspect_result_ NTSTATUS	QueryInterface (__in FxQueryInterfaceParams *Params)

VOID	MarkTraceState (VOID)

BOOLEAN __inline	IsTraceState (VOID)

VOID __inline	TraceDroppedEvent (__in FxObjectDroppedEvent Event)

VOID	MarkPassiveDispose (__in FxObjectLockState State=ObjectLock)

VOID	MarkPassiveCallbacks (__in FxObjectLockState State=ObjectLock)

VOID	MarkForceDisposeThread (__in FxObjectLockState State=ObjectLock)

BOOLEAN	IsPassiveCallbacks (__in BOOLEAN AcquireLock=TRUE)

BOOLEAN	IsPassiveDispose (__in BOOLEAN AcquireLock=TRUE)

BOOLEAN	IsForceDisposeThread (__in BOOLEAN AcquireLock=TRUE)

VOID	MarkCommitted (VOID)

BOOLEAN	IsCommitted (VOID)

VOID	MarkDisposeOverride (__in FxObjectLockState State=ObjectLock)

VOID	MarkNoDeleteDDI (__in FxObjectLockState State=ObjectLock)

BOOLEAN	IsNoDeleteDDI (VOID)

_Must_inspect_result_ NTSTATUS	Commit (__in_opt PWDF_OBJECT_ATTRIBUTES Attributes, __out_opt WDFOBJECT ObjectHandle, __in_opt FxObject Parent=NULL, __in BOOLEAN AssignDriverAsDefaultParent=TRUE)

VOID	DeleteFromFailedCreate (VOID)

VOID	ClearEvtCallbacks (VOID)

BOOLEAN	EarlyDispose (VOID)

virtual VOID	DeleteObject (VOID)

virtual BOOLEAN	Dispose (VOID)

_Must_inspect_result_ NTSTATUS	AssignParentObject (__in FxObject *ParentObject)

_Must_inspect_result_ NTSTATUS	AddContext (__in FxContextHeader Header, __in PVOID Context, __in PWDF_OBJECT_ATTRIBUTES Attributes)

_Must_inspect_result_ NTSTATUS	RemoveParentAssignment (VOID)

_Must_inspect_result_ FxObject *	GetParentObjectReferenced (__in PVOID Tag)

BOOLEAN	IsDisposed (VOID)

Static Public Member Functions
static _Must_inspect_result_ NTSTATUS	_FormatTransfer (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in WDFUSBPIPE Pipe, __in WDFREQUEST Request, __in_opt WDFMEMORY TransferMemory, __in_opt PWDFMEMORY_OFFSET TransferOffsets, __in ULONG Flags)

static _Must_inspect_result_ NTSTATUS	_SendTransfer (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in WDFUSBPIPE Pipe, __in_opt WDFREQUEST Request, __in_opt PWDF_REQUEST_SEND_OPTIONS RequestOptions, __in_opt PWDF_MEMORY_DESCRIPTOR MemoryDescriptor, __out_opt PULONG BytesTransferred, __in ULONG Flags)

static WDF_USB_PIPE_TYPE	_UsbdPipeTypeToWdf (__in USBD_PIPE_TYPE UsbdPipeType)

Static Public Member Functions inherited from FxIoTarget
static VOID	_CancelSentRequest (__in FxRequestBase *Request)

static FxIoTarget *	_FromEntry (__in FxTransactionedEntry *Entry)

Static Public Member Functions inherited from FxObject
static FxObject *	_FromDisposeEntry (__in PSINGLE_LIST_ENTRY Entry)

static FxObject *	_GetObjectFromHandle (__in WDFOBJECT Handle, __inout PWDFOBJECT_OFFSET ObjectOffset)

static PVOID __inline	_ToHandle (__in FxObject *Object)

static VOID __inline	_ReferenceActual (__in WDFOBJECT Object, __in_opt PVOID Tag, __in LONG Line, __in PSTR File)

static VOID __inline	_DereferenceActual (__in WDFOBJECT Object, __in_opt PVOID Tag, __in LONG Line, __in PSTR File)

static PVOID	_GetDebugBase (__in FxObject *Object)

static PFX_POOL_HEADER	_CleanupPointer (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in FxObject *Object)

static _Must_inspect_result_ NTSTATUS	_GetEffectiveLock (__in FxObject Object, __in_opt IFxHasCallbacks Callbacks, __in BOOLEAN AutomaticLocking, __in BOOLEAN PassiveCallbacks, __out FxCallbackLock CallbackLock, __out_opt FxObject CallbackLockObject)

static _Must_inspect_result_ NTSTATUS	_ObjectQuery (_In_ FxObject Object, _In_ CONST GUID Guid, _In_ ULONG QueryBufferLength, _Out_writes_bytes_(QueryBufferLength) PVOID QueryBuffer)

Public Attributes
friend	FxUsbDevice

friend	FxUsbInterface

friend	FxUsbPipeContinuousReader

LIST_ENTRY	m_ListEntry

Public Attributes inherited from FxIoTarget
FxTransactionedEntry	m_TransactionedEntry

BOOLEAN	m_InStack

BOOLEAN	m_AddedToDeviceList

Protected Member Functions
	~FxUsbPipe ()

virtual BOOLEAN	Dispose (VOID)

Protected Member Functions inherited from FxIoTarget
	~FxIoTarget ()

_Must_inspect_result_ NTSTATUS	InitModeSpecific (__in CfxDeviceBase *Device)

virtual BOOLEAN	Dispose (VOID)

VOID	FailPendedRequest (__in FxRequestBase *Request, __in NTSTATUS Status)

VOID	DrainPendedRequestsLocked (__in PLIST_ENTRY RequestListHead, __in BOOLEAN RequestWillBeResent)

VOID	CompletePendedRequestList (__in PLIST_ENTRY RequestListHead)

VOID	SubmitPendedRequests (__in PLIST_ENTRY RequestListHeadHead)

VOID	GetSentRequestsListLocked (__in PSINGLE_LIST_ENTRY RequestListHead, __in PLIST_ENTRY SendList, __out PBOOLEAN AddedToList)

virtual _Must_inspect_result_ NTSTATUS	GotoStartState (__in PLIST_ENTRY RequestListHead, __in BOOLEAN Lock=TRUE)

virtual VOID	GotoStopState (__in WDF_IO_TARGET_SENT_IO_ACTION Action, __in PSINGLE_LIST_ENTRY SentRequestListHead, __out PBOOLEAN Wait, __in BOOLEAN LockSelf)

virtual VOID	GotoPurgeState (__in WDF_IO_TARGET_PURGE_IO_ACTION Action, __in PLIST_ENTRY PendedRequestListHead, __in PSINGLE_LIST_ENTRY SentRequestListHead, __out PBOOLEAN Wait, __in BOOLEAN LockSelf)

_Must_inspect_result_ NTSTATUS	PendRequestLocked (__in FxRequestBase *Request)

__inline VOID	CompleteRequest (__in FxRequestBase *Request)

VOID	HandleFailedResubmit (__in FxRequestBase *Request)

VOID	RequestCompletionRoutine (__in FxRequestBase *Request)

BOOLEAN	RemoveCompletedRequestLocked (__in FxRequestBase *Request)

virtual VOID	ClearTargetPointers (VOID)

UCHAR	GetTargetIoType (VOID)

virtual VOID	GotoRemoveState (__in WDF_IO_TARGET_STATE NewState, __in PLIST_ENTRY PendedRequestListHead, __in PSINGLE_LIST_ENTRY SentRequestListHead, __in BOOLEAN Lock, __out PBOOLEAN Wait)

virtual VOID	WaitForSentIoToComplete (VOID)

virtual VOID	WaitForDisposeEvent (VOID)

virtual VOID	Forward (__in MdIrp Irp)

__inline VOID	CopyFileObjectAndFlags (__in FxRequestBase *Request)

__inline VOID	IncrementIoCount (VOID)

__inline VOID	DecrementIoCount (VOID)

VOID	PrintDisposeMessage (VOID)

Protected Member Functions inherited from FxObject
	FxObject (__in WDFTYPE Type, __in USHORT Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in FxObjectType ObjectType)

FxObjectDebugExtension *	GetDebugExtension (VOID)

BOOLEAN	IsDebug (VOID)

VOID	AllocateTagTracker (__in WDFTYPE Type)

virtual VOID	SelfDestruct (VOID)

PVOID __inline	GetObjectHandleUnchecked (VOID)

VOID __inline	DestroyChildren (VOID)

VOID	DeleteEarlyDisposedObject (VOID)

Protected Attributes
FxUsbDevice *	m_UsbDevice

FxUsbInterface *	m_UsbInterface

FxUsbPipeContinuousReader *	m_Reader

USBD_PIPE_INFORMATION	m_PipeInformation

WINUSB_PIPE_INFORMATION	m_PipeInformationUm

UCHAR	m_InterfaceNumber

BOOLEAN	m_CheckPacketSize

USBD_HANDLE	m_USBDHandle

FX_URB_TYPE	m_UrbType

Protected Attributes inherited from FxIoTarget
LIST_ENTRY	m_SentIoListHead

LIST_ENTRY	m_IgnoredIoListHead

FxCREvent	m_SentIoEvent

FxCREvent *	m_DisposeEvent

FxCREvent	m_DisposeEventUm

FxIrpQueue	m_PendedQueue

FxDriver *	m_Driver

MdDeviceObject	m_InStackDevice

MdDeviceObject	m_TargetDevice

MdDeviceObject	m_TargetPdo

MdFileObject	m_TargetFileObject

WDF_IO_TARGET_STATE	m_State

LONG	m_IoCount

CCHAR	m_TargetStackSize

UCHAR	m_TargetIoType

BOOLEAN	m_WaitingForSentIo

BOOLEAN	m_Removing

Protected Attributes inherited from FxObject
union {
CfxDeviceBase * m_DeviceBase

CfxDevice * m_Device

};

Additional Inherited Members
Static Public Attributes inherited from FxIoTarget
static const PVOID	m_SentRequestTag = (PVOID) 'lcnC'

Static Protected Member Functions inherited from FxIoTarget
static VOID	_CancelSentRequests (__in PSINGLE_LIST_ENTRY RequestListHead)

static VOID	_RequestCancelled (__in FxIrpQueue *Queue, __in MdIrp Irp, __in PMdIoCsqIrpContext pCsqContext, __in KIRQL CallerIrql)

Static Protected Member Functions inherited from FxObject
static PVOID	_GetBase (__in FxObject *Object)

Static Protected Attributes inherited from FxIoTarget
static MdCompletionRoutineType	_RequestCompletionRoutine

static EVT_WDF_REQUEST_COMPLETION_ROUTINE	_SyncCompletionRoutine

Detailed Description

Definition at line 409 of file fxusbpipe.hpp.

Constructor & Destructor Documentation

◆ FxUsbPipe()

FxUsbPipe::FxUsbPipe	(	__in PFX_DRIVER_GLOBALS	FxDriverGlobals,
		__in FxUsbDevice *	UsbDevice
	)

Definition at line 1050 of file fxusbpipe.cpp.

      :
    FxIoTarget(FxDriverGlobals, sizeof(FxUsbPipe), FX_TYPE_IO_TARGET_USB_PIPE),
    m_UsbDevice(UsbDevice)
{
    InitializeListHead(&m_ListEntry);
    RtlZeroMemory(&m_PipeInformation, sizeof(m_PipeInformation));
#if (FX_CORE_MODE == FX_CORE_USER_MODE)
    RtlZeroMemory(&m_PipeInformationUm, sizeof(m_PipeInformationUm));
#endif
    m_InterfaceNumber = 0;
    m_Reader = NULL;
    m_UsbInterface = NULL;
    m_CheckPacketSize = TRUE;
    m_USBDHandle = UsbDevice->m_USBDHandle;
    m_UrbType = UsbDevice->m_UrbType;
 
    MarkNoDeleteDDI(ObjectDoNotLock);
}

◆ ~FxUsbPipe()

FxUsbPipe::~FxUsbPipe ( )

protected

Definition at line 1091 of file fxusbpipe.cpp.

{
    if (m_UsbInterface != NULL) {
        m_UsbInterface->RemoveDeletedPipe(this);
        m_UsbInterface->RELEASE(this);
    }
 
    ASSERT(IsListEmpty(&m_ListEntry));
}

Member Function Documentation

◆ _FormatTransfer()

return FxUsbPipe::_FormatTransfer	(	__in PFX_DRIVER_GLOBALS	FxDriverGlobals,
		__in WDFUSBPIPE	Pipe,
		__in WDFREQUEST	Request,
		__in_opt WDFMEMORY	TransferMemory,
		__in_opt PWDFMEMORY_OFFSET	TransferOffsets,
		__in ULONG	Flags
	)

static

Definition at line 1536 of file fxusbpipe.cpp.

{
    FxRequestBuffer buf;
    IFxMemory* pMemory;
    FxUsbPipe* pUsbPipe;
    FxRequest* pRequest;
    NTSTATUS status;
 
    FxObjectHandleGetPtrAndGlobals(FxDriverGlobals,
                                   Pipe,
                                   FX_TYPE_IO_TARGET_USB_PIPE,
                                   (PVOID*) &pUsbPipe,
                                   &FxDriverGlobals);
 
    FxObjectHandleGetPtr(FxDriverGlobals,
                         Request,
                         FX_TYPE_REQUEST,
                         (PVOID*) &pRequest);
 
    //
    // We allow zero length transfers (which are indicated by TransferMemory == NULL)
    //
    if (TransferMemory != NULL) {
        FxObjectHandleGetPtr(FxDriverGlobals,
                             TransferMemory,
                             IFX_TYPE_MEMORY,
                             (PVOID*) &pMemory);
 
        status = pMemory->ValidateMemoryOffsets(TransferOffsets);
        if (!NT_SUCCESS(status)) {
            goto Done;
        }
 
        buf.SetMemory(pMemory, TransferOffsets);
    }
    else {
        pMemory = NULL;
    }
 
    status = pUsbPipe->FormatTransferRequest(pRequest,  &buf, Flags);
 
    if (NT_SUCCESS(status)) {
        FxUsbPipeTransferContext* pContext;
 
        pContext = (FxUsbPipeTransferContext*) pRequest->GetContext();
 
        //
        // By assuming the fields are at the same offset, we can use simpler
        // logic (w/out comparisons for type) to set them.
        //
        WDFCASSERT(
            FIELD_OFFSET(WDF_USB_REQUEST_COMPLETION_PARAMS, Parameters.PipeWrite.Buffer) ==
            FIELD_OFFSET(WDF_USB_REQUEST_COMPLETION_PARAMS, Parameters.PipeRead.Buffer)
            );
 
        WDFCASSERT(
            FIELD_OFFSET(WDF_USB_REQUEST_COMPLETION_PARAMS, Parameters.PipeWrite.Offset) ==
            FIELD_OFFSET(WDF_USB_REQUEST_COMPLETION_PARAMS, Parameters.PipeRead.Offset)
            );
 
        pContext->m_UsbParameters.Parameters.PipeWrite.Buffer = TransferMemory;
        pContext->m_UsbParameters.Parameters.PipeWrite.Length = buf.GetBufferLength();
 
        pContext->m_UsbParameters.Parameters.PipeWrite.Offset =
            (TransferOffsets != NULL) ? TransferOffsets->BufferOffset
                                      : 0;
        pContext->SetUsbType(
            (Flags & USBD_TRANSFER_DIRECTION_IN) ? WdfUsbRequestTypePipeRead
                                                 : WdfUsbRequestTypePipeWrite
            );
    }
 
Done:
    DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGIOTARGET,
                        "WDFUSBPIPE %p, WDFREQUEST %p, WDFMEMORY %p, %!STATUS!",
                        Pipe, Request, TransferMemory, status);
 
    return status;
}

Referenced by ValidateTransferLength().

◆ _SendTransfer()

return FxUsbPipe::_SendTransfer	(	__in PFX_DRIVER_GLOBALS	FxDriverGlobals,
		__in WDFUSBPIPE	Pipe,
		__in_opt WDFREQUEST	Request,
		__in_opt PWDF_REQUEST_SEND_OPTIONS	RequestOptions,
		__in_opt PWDF_MEMORY_DESCRIPTOR	MemoryDescriptor,
		__out_opt PULONG	BytesTransferred,
		__in ULONG	Flags
	)

static

Definition at line 1625 of file fxusbpipe.cpp.

{
    FxRequestBuffer buf;
    FxUsbPipe* pUsbPipe;
    NTSTATUS status;
 
    FxObjectHandleGetPtrAndGlobals(FxDriverGlobals,
                                   Pipe,
                                   FX_TYPE_IO_TARGET_USB_PIPE,
                                   (PVOID*) &pUsbPipe,
                                   &FxDriverGlobals);
 
    FxUsbPipeTransferContext context(FxUrbTypeLegacy);
 
    FxSyncRequest request(FxDriverGlobals, &context, Request);
 
    //
    // FxSyncRequest always succeesds for KM but can fail for UM.
    //
    status = request.Initialize();
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                            "Failed to initialize FxSyncRequest");
        return status;
    }
 
    if (BytesTransferred != NULL) {
        *BytesTransferred = 0;
    }
 
    status = FxVerifierCheckIrqlLevel(FxDriverGlobals, PASSIVE_LEVEL);
    if (!NT_SUCCESS(status)) {
        return status;
    }
 
    status = FxValidateRequestOptions(FxDriverGlobals, RequestOptions);
    if (!NT_SUCCESS(status)) {
        return status;
    }
 
    //
    // We allow zero length writes (which are indicated by MemoryDescriptor == NULL)
    //
    if (MemoryDescriptor != NULL) {
        status = buf.ValidateMemoryDescriptor(FxDriverGlobals, MemoryDescriptor);
        if (!NT_SUCCESS(status)) {
            return status;
        }
    }
 
    status = pUsbPipe->FormatTransferRequest(request.m_TrueRequest, &buf, Flags);
 
    if (NT_SUCCESS(status)) {
        DoTraceLevelMessage(
            FxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGIOTARGET,
            "WDFUSBPIPE %p, WDFREQUEST %p being submitted",
            Pipe, request.m_TrueRequest->GetTraceObjectHandle());
 
        status = pUsbPipe->SubmitSync(request.m_TrueRequest, RequestOptions);
 
        //
        // Even on error we want to set this value.  USBD should be clearing
        // it if the transfer fails.
        //
        if (BytesTransferred != NULL) {
            *BytesTransferred = context.GetUrbTransferLength();
        }
    }
 
    DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGIOTARGET,
                        "WDFUSBPIPE %p, %!STATUS!", Pipe, status);
 
    return status;
}

Referenced by ValidateTransferLength().

◆ _UsbdPipeTypeToWdf()

static WDF_USB_PIPE_TYPE FxUsbPipe::_UsbdPipeTypeToWdf ( __in USBD_PIPE_TYPE UsbdPipeType )

inlinestatic

Definition at line 643 of file fxusbpipe.hpp.

    {
        const static WDF_USB_PIPE_TYPE types[] = {
            WdfUsbPipeTypeControl,              // UsbdPipeTypeControl
            WdfUsbPipeTypeIsochronous,          // UsbdPipeTypeIsochronous
            WdfUsbPipeTypeBulk,                 // UsbdPipeTypeBulk
            WdfUsbPipeTypeInterrupt,            // UsbdPipeTypeInterrupt
        };
 
        if (UsbdPipeType < sizeof(types)/sizeof(types[0])) {
            return types[UsbdPipeType];
        }
        else {
            return WdfUsbPipeTypeInvalid;
        }
    }

Referenced by FxUsbInterface::CopyEndpointFieldsFromDescriptor(), GetInformation(), GetType(), and IsType().

◆ Dispose()

BOOLEAN FxUsbPipe::Dispose ( VOID )

protectedvirtual

Reimplemented from FxIoTarget.

Definition at line 1102 of file fxusbpipe.cpp.

{
    BOOLEAN callCleanup;
 
    //
    // Call base class: callbacks, terminates I/Os, etc.
    //
    callCleanup = FxIoTarget::Dispose(); // __super call
 
    //
    // Don't need the reader anymore. The reader is deleted after calling the
    // parent class Dispose() to preserve the existing deletion order (it was
    // deleted in the Pipe's dtor() before this change).
    //
    if (m_Reader != NULL)
    {
        delete m_Reader;
 
        //
        // By doing this assignment we prevent misbehaved drivers
        // from crashing the system when they call WdfIoTargetStop from their
        // usb pipe's destroy callback.
        //
        m_Reader = NULL;
    }
 
    return callCleanup;
}

◆ FormatAbortRequest()

_Must_inspect_result_ NTSTATUS FxUsbPipe::FormatAbortRequest ( __in FxRequestBase * Request )

Definition at line 1710 of file fxusbpipe.cpp.

{
    FxUsbPipeRequestContext* pContext;
    NTSTATUS status;
    FX_URB_TYPE urbType;
 
    status = Request->ValidateTarget(this);
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                            "Pipe %p, Request %p, setting target failed, "
                            "status %!STATUS!", this, Request, status);
 
        return status;
    }
 
    if (Request->HasContextType(FX_RCT_USB_PIPE_REQUEST)) {
        pContext = (FxUsbPipeRequestContext*) Request->GetContext();
    }
    else {
 
        urbType = m_UsbDevice->GetFxUrbTypeForRequest(Request);
        pContext = new(GetDriverGlobals()) FxUsbPipeRequestContext(urbType);
        if (pContext == NULL) {
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
#if (FX_CORE_MODE == FX_CORE_KERNEL_MODE)
        if (urbType == FxUrbTypeUsbdAllocated) {
            status = pContext->AllocateUrb(m_USBDHandle);
            if (!NT_SUCCESS(status)) {
                delete pContext;
                return status;
            }
            //
            // Since the AllocateUrb routine calls USBD_xxxUrbAllocate APIs to allocate an Urb, it is
            // important to release those resorces before the devnode is removed. Those
            // resoruces are removed at the time Request is disposed.
            //
            Request->EnableContextDisposeNotification();
        }
#endif
 
        Request->SetContext(pContext);
    }
 
#if (FX_CORE_MODE == FX_CORE_KERNEL_MODE)
    pContext->SetInfo(WdfUsbRequestTypePipeAbort,
                      m_PipeInformation.PipeHandle,
                      URB_FUNCTION_ABORT_PIPE);
 
    if (pContext->m_Urb == &pContext->m_UrbLegacy) {
        urbType = FxUrbTypeLegacy;
    }
    else {
        urbType = FxUrbTypeUsbdAllocated;
    }
 
    FxFormatUsbRequest(Request, (PURB)pContext->m_Urb, urbType, m_USBDHandle);
#elif (FX_CORE_MODE == FX_CORE_USER_MODE)
    pContext->SetInfo(WdfUsbRequestTypePipeAbort,
                      m_UsbInterface->m_WinUsbHandle,
                      m_PipeInformationUm.PipeId,
                      UMURB_FUNCTION_ABORT_PIPE);
    FxUsbUmFormatRequest(Request, &pContext->m_UmUrb.UmUrbPipeRequest.Hdr, m_UsbDevice->m_pHostTargetFile);
#endif
 
    return STATUS_SUCCESS;
}

Referenced by ValidateTransferLength().

◆ FormatResetRequest()

_Must_inspect_result_ NTSTATUS FxUsbPipe::FormatResetRequest ( __in FxRequestBase * Request )

Definition at line 1783 of file fxusbpipe.cpp.

{
    FxUsbPipeRequestContext* pContext;
    NTSTATUS status;
    FX_URB_TYPE urbType;
 
    status = Request->ValidateTarget(this);
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                            "Pipe %p, Request %p, setting target failed, "
                            "status %!STATUS!", this, Request, status);
 
        return status;
    }
 
    if (Request->HasContextType(FX_RCT_USB_PIPE_REQUEST)) {
        pContext = (FxUsbPipeRequestContext*) Request->GetContext();
    }
    else {
        urbType = m_UsbDevice->GetFxUrbTypeForRequest(Request);
        pContext = new(GetDriverGlobals()) FxUsbPipeRequestContext(urbType);
        if (pContext == NULL) {
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
#if (FX_CORE_MODE == FX_CORE_KERNEL_MODE)
        if (urbType == FxUrbTypeUsbdAllocated) {
            status = pContext->AllocateUrb(m_USBDHandle);
            if (!NT_SUCCESS(status)) {
                delete pContext;
                return status;
            }
            //
            // Since the AllocateUrb routine calls USBD_xxxUrbAllocate APIs to allocate an Urb, it is
            // important to release those resorces before the devnode is removed. Those
            // resoruces are removed at the time Request is disposed.
            //
            Request->EnableContextDisposeNotification();
        }
#endif
 
        Request->SetContext(pContext);
    }
 
#if (FX_CORE_MODE == FX_CORE_KERNEL_MODE)
    //
    // URB_FUNCTION_RESET_PIPE and URB_FUNCTION_SYNC_RESET_PIPE_AND_CLEAR_STALL
    // are the same value
    //
    pContext->SetInfo(WdfUsbRequestTypePipeReset,
                      m_PipeInformation.PipeHandle,
                      URB_FUNCTION_RESET_PIPE);
 
    if (pContext->m_Urb == &pContext->m_UrbLegacy) {
        urbType = FxUrbTypeLegacy;
    }
    else {
        urbType = FxUrbTypeUsbdAllocated;
    }
 
    FxFormatUsbRequest(Request, (PURB)pContext->m_Urb, urbType, m_USBDHandle);
#elif (FX_CORE_MODE == FX_CORE_USER_MODE)
    pContext->SetInfo(WdfUsbRequestTypePipeReset,
                      m_UsbInterface->m_WinUsbHandle,
                      m_PipeInformationUm.PipeId,
                      UMURB_FUNCTION_SYNC_RESET_PIPE_AND_CLEAR_STALL);
    FxUsbUmFormatRequest(Request, &pContext->m_UmUrb.UmUrbPipeRequest.Hdr, m_UsbDevice->m_pHostTargetFile);
#endif
 
    return STATUS_SUCCESS;
}

Referenced by Reset(), and ValidateTransferLength().

◆ FormatTransferRequest()

_Must_inspect_result_ NTSTATUS FxUsbPipe::FormatTransferRequest	(	__in FxRequestBase *	Request,
		__in FxRequestBuffer *	Buffer,
		__in ULONG	TransferFlags = `0`
	)

Definition at line 204 of file fxusbpipekm.cpp.

{
    FxUsbPipeTransferContext* pContext;
    NTSTATUS status;
    size_t bufferSize;
    ULONG dummyLength;
    FX_URB_TYPE urbType;
 
    //
    // Make sure request is for the right type
    //
    if (!(IsType(WdfUsbPipeTypeBulk) || IsType(WdfUsbPipeTypeInterrupt))) {
        status = STATUS_INVALID_DEVICE_REQUEST;
 
        DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                            "WDFUSBPIPE %p not the right type, %!STATUS!",
                            GetHandle(), status);
 
        return status;
    }
 
    bufferSize = Buffer->GetBufferLength();
 
    status = RtlSizeTToULong(bufferSize, &dummyLength);
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                            "WDFUSBPIPE %p, buffer size truncated, %!STATUS!",
                            GetHandle(), status);
        return status;
    }
 
    //
    // On reads, check to make sure the read in value is an integral number of
    // packet sizes
    //
    if (TransferFlags & USBD_TRANSFER_DIRECTION_IN) {
        if (IsInEndpoint() == FALSE) {
            DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                                "Pipe %p, sending __in transaction on a __out endpoint",
                                this);
 
            return STATUS_INVALID_DEVICE_REQUEST;
        }
 
        if (m_CheckPacketSize &&
            (bufferSize % m_PipeInformation.MaximumPacketSize) != 0) {
            return STATUS_INVALID_BUFFER_SIZE;
        }
    }
    else {
        if (IsOutEndpoint() == FALSE) {
            DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                                "Pipe %p, sending __out transaction on an __in endpoint",
                                this);
 
            return STATUS_INVALID_DEVICE_REQUEST;
        }
    }
 
    status = Request->ValidateTarget(this);
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                            "Pipe %p, Request %p, setting target failed, "
                            "status %!STATUS!", this, Request, status);
 
        return status;
    }
 
    if (Request->HasContextType(FX_RCT_USB_PIPE_XFER)) {
        pContext = (FxUsbPipeTransferContext*) Request->GetContext();
    }
    else {
        urbType = m_UsbDevice->GetFxUrbTypeForRequest(Request);
 
        pContext = new(GetDriverGlobals()) FxUsbPipeTransferContext(urbType);
        if (pContext == NULL) {
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
        if (urbType == FxUrbTypeUsbdAllocated) {
            status = pContext->AllocateUrb(m_USBDHandle);
            if (!NT_SUCCESS(status)) {
                delete pContext;
                return status;
            }
            //
            // Since the AllocateUrb routine calls USBD_xxxUrbAllocate APIs to allocate an Urb, it is
            // important to release those resorces before the devnode is removed. Those
            // resoruces are removed at the time Request is disposed.
            //
            Request->EnableContextDisposeNotification();
        }
 
        Request->SetContext(pContext);
    }
 
    //
    // Always set the memory after determining the context.  This way we can
    // free a previously referenced memory object if necessary.
    //
    if (Buffer->HasMdl()) {
        PMDL pMdl;
 
        pMdl=NULL;
        ASSERT(pContext->m_PartialMdl == NULL);
 
        //
        // If it is an __in endpoint, the buffer will be written to by the
        // controller, so request IoWriteAccess locking.
        //
        status = Buffer->GetOrAllocateMdl(
            GetDriverGlobals(),
            &pMdl,
            &pContext->m_PartialMdl,
            &pContext->m_UnlockPages,
            IsInEndpoint() ? IoWriteAccess : IoReadAccess);
 
        if (!NT_SUCCESS(status)) {
            return status;
        }
 
        ASSERT(pMdl != NULL);
    }
 
    pContext->StoreAndReferenceMemory(Buffer);
 
    pContext->SetUrbInfo(m_PipeInformation.PipeHandle, TransferFlags);
 
    if (pContext->m_Urb == &pContext->m_UrbLegacy) {
        urbType = FxUrbTypeLegacy;
    }
    else {
        urbType = FxUrbTypeUsbdAllocated;
    }
 
    FxFormatUsbRequest(Request, (PURB)pContext->m_Urb, urbType, m_USBDHandle);
 
    return STATUS_SUCCESS;
}

Referenced by _FormatTransfer(), _SendTransfer(), FxUsbPipeContinuousReader::FormatRepeater(), and ValidateTransferLength().

◆ GetHandle()

WDFUSBPIPE FxUsbPipe::GetHandle ( VOID )

inline

Definition at line 504 of file fxusbpipe.hpp.

    {
        return (WDFUSBPIPE) GetObjectHandle();
    }

Referenced by FxUsbPipeContinuousReader::CancelRepeaters(), FxUsbPipeContinuousReader::FxUsbPipeRequestWorkItemHandler(), FxUsbInterface::GetConfiguredPipe(), FxUsbPipeContinuousReader::QueueWorkItemLocked(), and FxUsbPipeContinuousReader::ResubmitRepeater().

◆ GetInformation()

VOID FxUsbPipe::GetInformation ( __out PWDF_USB_PIPE_INFORMATION PipeInformation )

Definition at line 349 of file fxusbpipekm.cpp.

{
    //
    // Do a field by field copy for the WDF structure, since fields could change.
    //
    PipeInformation->MaximumPacketSize = m_PipeInformation.MaximumPacketSize;
    PipeInformation->EndpointAddress = m_PipeInformation.EndpointAddress;
    PipeInformation->Interval = m_PipeInformation.Interval;
    PipeInformation->PipeType = _UsbdPipeTypeToWdf(m_PipeInformation.PipeType);
    PipeInformation->MaximumTransferSize = m_PipeInformation.MaximumTransferSize;
    PipeInformation->SettingIndex = m_UsbInterface->GetConfiguredSettingIndex();
}

Referenced by FxUsbInterface::GetConfiguredPipe().

◆ GetMaxPacketSize()

ULONG FxUsbPipe::GetMaxPacketSize ( VOID )

inline

Definition at line 555 of file fxusbpipe.hpp.

    {
#if (FX_CORE_MODE == FX_CORE_KERNEL_MODE)
        return  m_PipeInformation.MaximumPacketSize;
#elif (FX_CORE_MODE == FX_CORE_USER_MODE)
        return  m_PipeInformationUm.MaximumPacketSize;
#endif
    }

◆ GetType()

WDF_USB_PIPE_TYPE FxUsbPipe::GetType ( VOID )

Definition at line 365 of file fxusbpipekm.cpp.

{
    return _UsbdPipeTypeToWdf(m_PipeInformation.PipeType);
}

Referenced by if().

◆ GetUrbType()

FX_URB_TYPE FxUsbPipe::GetUrbType ( VOID )

inline

Definition at line 676 of file fxusbpipe.hpp.

    {
        return m_UrbType;
    }

Referenced by __in_xcount().

◆ GetUSBDHandle()

USBD_HANDLE FxUsbPipe::GetUSBDHandle ( VOID )

inline

Definition at line 668 of file fxusbpipe.hpp.

    {
        return m_USBDHandle;
    }

Referenced by __in_xcount().

◆ GotoPurgeState()

VOID FxUsbPipe::GotoPurgeState	(	__in WDF_IO_TARGET_PURGE_IO_ACTION	Action,
		__in PLIST_ENTRY	PendedRequestListHead,
		__in PSINGLE_LIST_ENTRY	SentRequestListHead,
		__out PBOOLEAN	Wait,
		__in BOOLEAN	LockSelf
	)

virtual

Reimplemented from FxIoTarget.

Definition at line 1294 of file fxusbpipe.cpp.

{
    KIRQL irql;
    PFX_DRIVER_GLOBALS pFxDriverGlobals;
 
    irql = PASSIVE_LEVEL;
    pFxDriverGlobals = GetDriverGlobals();
 
    if (LockSelf) {
        Lock(&irql);
    }
 
    if (m_Reader != NULL) {
        //
        // If we are a continuous reader, always wait for the sent io, so that we
        // can resubmit it later on a restart.
        //
        DoTraceLevelMessage(
            pFxDriverGlobals, TRACE_LEVEL_INFORMATION, TRACINGIOTARGET,
            "WDFUSBPIPE %p converting purge action %!WDF_IO_TARGET_PURGE_IO_ACTION!"
            " to %!WDF_IO_TARGET_PURGE_IO_ACTION!", GetHandle(), Action,
            WdfIoTargetPurgeIoAndWait);
 
        Action = WdfIoTargetPurgeIoAndWait;
    }
 
    FxIoTarget::GotoPurgeState(Action, // __super call
                            PendedRequestListHead,
                            SentRequestListHead,
                            Wait,
                            FALSE);
 
    if (m_Reader != NULL) {
        //
        // The continuous reader requests are no longer enqueued.  Remember that
        // state, so when we restart, we resend them.
        //
        m_Reader->m_ReadersSubmitted = FALSE;
 
        //
        // Log a message when misbehaved drivers call WdfIoTargetPurge
        // from EvtUsbTargetPipeReadersFailed callback.
        //
        if (m_Reader->m_WorkItemThread == Mx::MxGetCurrentThread()) {
            DoTraceLevelMessage(
                pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                "WDFUSBPIPE %p is purged from EvtUsbTargetPipeReadersFailed"
                " callback", GetHandle());
 
            FxVerifierDbgBreakPoint(pFxDriverGlobals);
        }
 
        //
        // Make sure work item is done. It is possible for the upper class
        // to return wait = false if the list of sent requests is empty. We
        // still want to wait anyway for making sure work item is not about
        // to run or it is running.
        //
        *Wait = TRUE;
    }
 
    if (LockSelf) {
        Unlock(irql);
    }
}

Referenced by FxUsbDevice::Purge().

◆ GotoRemoveState()

VOID FxUsbPipe::GotoRemoveState	(	__in WDF_IO_TARGET_STATE	NewState,
		__in PLIST_ENTRY	PendedRequestListHead,
		__in PSINGLE_LIST_ENTRY	SentRequestListHead,
		__in BOOLEAN	Lock,
		__out PBOOLEAN	Wait
	)

virtual

Reimplemented from FxIoTarget.

Definition at line 1367 of file fxusbpipe.cpp.

{
    KIRQL irql;
 
    irql = PASSIVE_LEVEL;
 
    if (LockSelf) {
        Lock(&irql);
    }
 
    if (m_Reader != NULL && m_Reader->m_ReadersSubmitted &&
        WdfIoTargetStarted == m_State) {
        //
        // Driver forgot to stop the pipe on D0Exit.
        //
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
            "WDFUSBPIPE %p was not stopped in EvtDeviceD0Exit callback",
            GetHandle());
 
        if (GetDriverGlobals()->IsVerificationEnabled(1,9,OkForDownLevel)) {
            FxVerifierDbgBreakPoint(GetDriverGlobals());
        }
    }
 
    FxIoTarget::GotoRemoveState(NewState, // __super call
                             PendedRequestListHead,
                             SentRequestListHead,
                             FALSE,
                             Wait);
    if (m_Reader != NULL) {
        //
        // Make sure work item is done. It is possible for the upper class to
        // return wait = false if the list of sent requests is empty. We still
        // want to wait anyway for making sure work item is not about to run or
        // it is running.
        //
        *Wait = TRUE;
    }
 
    if (LockSelf) {
        Unlock(irql);
    }
}

Referenced by FxUsbDevice::CleanupInterfacePipesAndDelete(), and FxUsbDevice::PipesGotoRemoveState().

◆ GotoStartState()

_Must_inspect_result_ NTSTATUS FxUsbPipe::GotoStartState	(	__in PLIST_ENTRY	RequestListHead,
		__in BOOLEAN	Lock = `TRUE`
	)

virtual

Reimplemented from FxIoTarget.

Definition at line 1133 of file fxusbpipe.cpp.

{
    NTSTATUS status;
    LONG i;
 
    if (m_Reader != NULL) {
        if (m_Reader->m_ReadersSubmitted == FALSE) {
            ASSERT(IsListEmpty(&m_SentIoListHead));
 
            for (i = 0; i < m_Reader->m_NumReaders; i++) {
                FxRequest* pRequest;
 
                pRequest = m_Reader->m_Readers[i].Request;
 
                UNREFERENCED_PARAMETER(pRequest); //for fre build
                ASSERT(IsListEmpty(&pRequest->m_ListEntry));
                ASSERT(pRequest->m_DrainSingleEntry.Next == NULL);
            }
        }
    }
 
    status = FxIoTarget::GotoStartState(RequestListHead, Lock);
 
    if (m_Reader == NULL || !NT_SUCCESS(status)) {
        return status;
    }
 
    //
    // Add the repeater requests to the list head so that they are sent by the
    // caller of this function when this function returns IFF they have not yet
    // been queued.  (They can be queued on a start -> start transition.)
    //
    if (m_Reader->m_ReadersSubmitted == FALSE) {
        for (i = 0; i < m_Reader->m_NumReaders; i++) {
            //
            // This will clear ReadCompletedEvent as well
            //
            status = m_Reader->FormatRepeater(&m_Reader->m_Readers[i]);
 
            if (!NT_SUCCESS(status)) {
                return status;
            }
        }
 
        //
        // Reset the number of failed readers in case we had failure in a
        // previously started state.
        //
        m_Reader->m_NumFailedReaders = 0;
 
        for (i = 0; i < m_Reader->m_NumReaders; i++) {
            FxRequest* pRequest;
 
            pRequest = m_Reader->m_Readers[i].Request;
            pRequest->SetTarget(this);
            pRequest->ADDREF(this);
 
            //
            // NOTE: This is an elusive backdoor to send the Request down
            // since it is inserted directly into the IoTargets pended list.
            // The IoTarget is not started so we add the request to the
            // pended list so that it is processed when the IoTarget starts.
            //
            m_Reader->m_Pipe->IncrementIoCount();
            InsertTailList(RequestListHead, &pRequest->m_ListEntry);
 
            //
            // Clear the event only when we know it will be submitted to the
            // target.  It will be set when  the request is submitted to the
            // target and the submit fails or if it is cancelled.
            //
            m_Reader->m_Readers[i].ReadCompletedEvent.Clear();
        }
 
        m_Reader->m_ReadersSubmitted = TRUE;
    }
 
    return status;
}

Referenced by FxUsbDevice::Start().

◆ GotoStopState()

VOID FxUsbPipe::GotoStopState	(	__in WDF_IO_TARGET_SENT_IO_ACTION	Action,
		__in PSINGLE_LIST_ENTRY	SentRequestListHead,
		__out PBOOLEAN	Wait,
		__in BOOLEAN	LockSelf
	)

virtual

Reimplemented from FxIoTarget.

Definition at line 1217 of file fxusbpipe.cpp.

{
    KIRQL irql;
    PFX_DRIVER_GLOBALS pFxDriverGlobals;
 
    irql = PASSIVE_LEVEL;
    pFxDriverGlobals = GetDriverGlobals();
 
    if (LockSelf) {
        Lock(&irql);
    }
 
    if (m_Reader != NULL) {
        //
        // If we are a continuous reader, always cancel the sent io so that we
        // can resubmit it later on a restart.
        //
        DoTraceLevelMessage(
            pFxDriverGlobals, TRACE_LEVEL_INFORMATION, TRACINGIOTARGET,
            "WDFUSBPIPE %p converting stop action %!WDF_IO_TARGET_SENT_IO_ACTION!"
            " to %!WDF_IO_TARGET_SENT_IO_ACTION!", GetHandle(), Action,
            WdfIoTargetCancelSentIo);
 
        Action = WdfIoTargetCancelSentIo;
    }
 
    FxIoTarget::GotoStopState(Action, SentRequestListHead, Wait, FALSE); // __super call
 
    if (m_Reader != NULL) {
        //
        // The continuous reader requests are no longer enqueued.  Remember that
        // state, so when we restart, we resend them.
        //
        m_Reader->m_ReadersSubmitted = FALSE;
 
        //
        // Log a message when misbehaved drivers call WdfIoTargetStop
        // from EvtUsbTargetPipeReadersFailed callback.
        //
        if (m_Reader->m_WorkItemThread == Mx::MxGetCurrentThread()) {
            DoTraceLevelMessage(
                pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                "WDFUSBPIPE %p is stopped from EvtUsbTargetPipeReadersFailed"
                " callback", GetHandle());
 
            if (pFxDriverGlobals->IsVerificationEnabled(1, 9, OkForDownLevel)) {
                FxVerifierDbgBreakPoint(pFxDriverGlobals);
            }
        }
 
        //
        // Do not deadlock when misbehaved drivers (< v1.9) call
        // WdfIoTargetStop from EvtUsbTargetPipeReadersFailed callback.
        //
        if (m_Reader->m_WorkItemThread != Mx::MxGetCurrentThread() ||
            pFxDriverGlobals->IsVersionGreaterThanOrEqualTo(1,9)) {
            //
            // Make sure work item is done. It is possible for the upper class
            // to return wait = false if the list of sent requests is empty. We
            // still want to wait anyway for making sure work item is not about
            // to run or it is running.
            //
            *Wait = TRUE;
        }
    }
 
    if (LockSelf) {
        Unlock(irql);
    }
}

Referenced by FxUsbDevice::Stop().

◆ InitContinuousReader()

_Must_inspect_result_ NTSTATUS FxUsbPipe::InitContinuousReader	(	__in PWDF_USB_CONTINUOUS_READER_CONFIG	Config,
		__in size_t	TotalBufferLength
	)

Definition at line 1463 of file fxusbpipe.cpp.

{
    FxUsbPipeContinuousReader* pReader;
    NTSTATUS status;
    UCHAR numReaders;
 
    pReader = NULL;
 
    if (m_Reader != NULL) {
        status = STATUS_INVALID_DEVICE_STATE;
 
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
            "Continuous reader already initialized on WDFUSBPIPE %p %!STATUS!",
            GetHandle(), status);
 
        return status;
    }
 
    numReaders = Config->NumPendingReads;
 
    if (numReaders == 0) {
        numReaders = NUM_PENDING_READS_DEFAULT;
    }
    else if (numReaders > NUM_PENDING_READS_MAX) {
        numReaders = NUM_PENDING_READS_MAX;
    }
 
    pReader = new(GetDriverGlobals(), numReaders)
        FxUsbPipeContinuousReader(this, numReaders);
 
    if (pReader == NULL) {
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    //
    // Allocate all of the structurs and objects required
    //
    status = pReader->Config(Config, TotalBufferLength);
 
    if (!NT_SUCCESS(status)) {
        delete pReader;
        return status;
    }
 
    pReader->m_ReadCompleteCallback = Config->EvtUsbTargetPipeReadComplete;
    pReader->m_ReadCompleteContext = Config->EvtUsbTargetPipeReadCompleteContext;
 
    pReader->m_ReadersFailedCallback = Config->EvtUsbTargetPipeReadersFailed;
 
    if (InterlockedCompareExchangePointer((PVOID*) &m_Reader,
                                          pReader,
                                          NULL) == NULL) {
        //
        // We set the field, do nothing.
        //
        DO_NOTHING();
    }
    else {
        //
        // Some other thread came in and set the field, free our allocation.
        //
        delete pReader;
    }
 
    return STATUS_SUCCESS;
}

◆ InitPipe() [1/2]

VOID FxUsbPipe::InitPipe	(	__in PUSBD_PIPE_INFORMATION	PipeInfo,
		__in UCHAR	InterfaceNumber,
		__in FxUsbInterface *	UsbInterface
	)

Definition at line 1073 of file fxusbpipe.cpp.

{
    RtlCopyMemory(&m_PipeInformation, PipeInfo, sizeof(m_PipeInformation));
    m_InterfaceNumber = InterfaceNumber;
 
    if (m_UsbInterface != NULL) {
        m_UsbInterface->RELEASE(this);
        m_UsbInterface = NULL;
    }
 
    m_UsbInterface = UsbInterface;
    m_UsbInterface->ADDREF(this);
}

Referenced by FxUsbInterface::MakeAndConfigurePipes(), and FxUsbInterface::SetInfo().

◆ InitPipe() [2/2]

VOID FxUsbPipe::InitPipe	(	__in PWINUSB_PIPE_INFORMATION	PipeInfo,
		__in UCHAR	InterfaceNumber,
		__in FxUsbInterface *	UsbInterface
	)

Definition at line 199 of file fxusbpipeum.cpp.

{
    RtlCopyMemory(&m_PipeInformationUm, PipeInfo, sizeof(m_PipeInformationUm));
    m_InterfaceNumber = InterfaceNumber;
 
    if (m_UsbInterface != NULL) {
        m_UsbInterface->RELEASE(this);
        m_UsbInterface = NULL;
    }
 
    m_UsbInterface = UsbInterface;
    m_UsbInterface->ADDREF(this);
}

◆ IsInEndpoint()

__inline BOOLEAN FxUsbPipe::IsInEndpoint ( VOID )

inline

Definition at line 513 of file fxusbpipe.hpp.

    {
        //
        // USB_ENDPOINT_DIRECTION_IN just does a bitwise compre so it could
        // return 0 or some non zero value.  Make sure the non zero value is
        // TRUE
        //
#if (FX_CORE_MODE == FX_CORE_KERNEL_MODE)
        return USB_ENDPOINT_DIRECTION_IN(m_PipeInformation.EndpointAddress) ? TRUE : FALSE;
#elif (FX_CORE_MODE == FX_CORE_USER_MODE)
        return USB_ENDPOINT_DIRECTION_IN(m_PipeInformationUm.PipeId) ? TRUE : FALSE;
#endif
    }

◆ IsOutEndpoint()

__inline BOOLEAN FxUsbPipe::IsOutEndpoint ( VOID )

inline

Definition at line 531 of file fxusbpipe.hpp.

    {
        //
        // USB_ENDPOINT_DIRECTION_OUT just does a bitwise compre so it could
        // return 0 or some non zero value.  Make sure the non zero value is
        // TRUE
        //
#if (FX_CORE_MODE == FX_CORE_KERNEL_MODE)
        return USB_ENDPOINT_DIRECTION_OUT(m_PipeInformation.EndpointAddress) ? TRUE : FALSE;
#elif (FX_CORE_MODE == FX_CORE_USER_MODE)
        return USB_ENDPOINT_DIRECTION_OUT(m_PipeInformationUm.PipeId) ? TRUE : FALSE;
#endif
    }

◆ IsType()

BOOLEAN FxUsbPipe::IsType ( __in WDF_USB_PIPE_TYPE Type )

Definition at line 373 of file fxusbpipekm.cpp.

{
    return _UsbdPipeTypeToWdf(m_PipeInformation.PipeType) == Type ? TRUE : FALSE;
}

Referenced by FormatTransferRequest().

◆ Reset()

NTSTATUS FxUsbPipe::Reset ( VOID )

Definition at line 1858 of file fxusbpipe.cpp.

{
    FxUsbPipeRequestContext context(FxUrbTypeLegacy);
 
    FxSyncRequest request(GetDriverGlobals(), &context);
    NTSTATUS status;
 
    //
    // FxSyncRequest always succeesds for KM but can fail for UM.
    //
    status = request.Initialize();
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                            "Failed to initialize FxSyncRequest");
        return status;
    }
 
    status = FormatResetRequest(request.m_TrueRequest);
    if (NT_SUCCESS(status)) {
        if (m_Reader != NULL) {
            //
            // This assumes that no other I/O besides reader I/O is going on.
            //
            m_Reader->CancelRepeaters();
        }
        else {
             CancelSentIo();
        }
        status = SubmitSyncRequestIgnoreTargetState(request.m_TrueRequest, NULL);
    }
    return status;
}

Referenced by FxUsbPipeContinuousReader::FxUsbPipeRequestWorkItemHandler().

◆ SetNoCheckPacketSize()

__inline VOID FxUsbPipe::SetNoCheckPacketSize ( VOID )

inline

Definition at line 480 of file fxusbpipe.hpp.

    {
        m_CheckPacketSize = FALSE;
    }

◆ ValidateTransferLength()

_Must_inspect_result_ NTSTATUS FxUsbPipe::ValidateTransferLength ( __in size_t Length )

inline

Definition at line 568 of file fxusbpipe.hpp.

    {
        //
        // Assumes this is not a control pipe
        //
        if (m_CheckPacketSize &&
#if (FX_CORE_MODE == FX_CORE_KERNEL_MODE)
            (Length % m_PipeInformation.MaximumPacketSize) != 0) {
#elif (FX_CORE_MODE == FX_CORE_USER_MODE)
            (Length % m_PipeInformationUm.MaximumPacketSize) != 0) {
#endif
            return STATUS_INVALID_BUFFER_SIZE;
        }
        else {
            return STATUS_SUCCESS;
        }
    }

◆ WaitForSentIoToComplete()

VOID FxUsbPipe::WaitForSentIoToComplete ( VOID )

virtual

Reimplemented from FxIoTarget.

Definition at line 1419 of file fxusbpipe.cpp.

{
    if (m_Reader != NULL) {
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGIOTARGET,
            "WDFUSBPIPE %p, waiting for continuous reader work item to complete",
            GetHandle());
 
        //
        // First, wait for the work item to complete if it is running.
        //
        // NOTE: We don't wait for the DPC  to complete because
        //  they are flushed in FxUsbDevice::Dispose
        //
        m_Reader->m_WorkItem->WaitForExit();
 
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGIOTARGET,
            "WDFUSBPIPE %p, cancelling for continuous reader (max of %d)",
            GetHandle(), m_Reader->m_NumReaders);
 
        //
        // Now that the work item is not running, make sure all the readers are
        // truly canceled and *NOT* in the pended queue.  In between the call to
        // GotoStopState and here, the work item could have run and retried to
        // send the I/O.
        //
        m_Reader->CancelRepeaters();
    }
 
    DoTraceLevelMessage(
        GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGIOTARGET,
        "WDFUSBPIPE %p, waiting for all i/o to complete", GetHandle());
 
    //
    // Finally, let the parent class wait for all I/O to complete
    //
    FxIoTarget::WaitForSentIoToComplete(); // __super call
}

Referenced by FxUsbDevice::CleanupInterfacePipesAndDelete().

◆ WdmGetPipeHandle()

USBD_PIPE_HANDLE FxUsbPipe::WdmGetPipeHandle ( VOID )

inline

Definition at line 634 of file fxusbpipe.hpp.

    {
        return m_PipeInformation.PipeHandle;
    }

Member Data Documentation

◆ FxUsbDevice

friend FxUsbPipe::FxUsbDevice

Definition at line 411 of file fxusbpipe.hpp.

◆ FxUsbInterface

friend FxUsbPipe::FxUsbInterface

Definition at line 412 of file fxusbpipe.hpp.

◆ FxUsbPipeContinuousReader

friend FxUsbPipe::FxUsbPipeContinuousReader

Definition at line 413 of file fxusbpipe.hpp.

Referenced by InitContinuousReader().

◆ m_CheckPacketSize

BOOLEAN FxUsbPipe::m_CheckPacketSize

protected

Definition at line 732 of file fxusbpipe.hpp.

Referenced by FormatTransferRequest(), FxUsbPipe(), SetNoCheckPacketSize(), and ValidateTransferLength().

◆ m_InterfaceNumber

UCHAR FxUsbPipe::m_InterfaceNumber

protected

Definition at line 726 of file fxusbpipe.hpp.

Referenced by FxUsbPipe(), and InitPipe().

◆ m_ListEntry

LIST_ENTRY FxUsbPipe::m_ListEntry

Definition at line 687 of file fxusbpipe.hpp.

Referenced by FxUsbPipe(), and ~FxUsbPipe().

◆ m_PipeInformation

USBD_PIPE_INFORMATION FxUsbPipe::m_PipeInformation

protected

Definition at line 714 of file fxusbpipe.hpp.

Referenced by FormatAbortRequest(), FormatResetRequest(), FormatTransferRequest(), FxUsbPipe(), GetInformation(), GetMaxPacketSize(), GetType(), InitPipe(), IsInEndpoint(), IsOutEndpoint(), IsType(), ValidateTransferLength(), and WdmGetPipeHandle().

◆ m_PipeInformationUm

WINUSB_PIPE_INFORMATION FxUsbPipe::m_PipeInformationUm

protected

Definition at line 720 of file fxusbpipe.hpp.

Referenced by FormatAbortRequest(), FormatResetRequest(), FxUsbPipe(), GetMaxPacketSize(), InitPipe(), IsInEndpoint(), IsOutEndpoint(), and ValidateTransferLength().

◆ m_Reader

FxUsbPipeContinuousReader* FxUsbPipe::m_Reader

protected

Definition at line 709 of file fxusbpipe.hpp.

Referenced by Dispose(), FxUsbPipe(), GotoPurgeState(), GotoRemoveState(), GotoStartState(), GotoStopState(), InitContinuousReader(), Reset(), and WaitForSentIoToComplete().

◆ m_UrbType

FX_URB_TYPE FxUsbPipe::m_UrbType

protected

Definition at line 743 of file fxusbpipe.hpp.

Referenced by FxUsbPipe(), and GetUrbType().

◆ m_UsbDevice

FxUsbDevice* FxUsbPipe::m_UsbDevice

protected

Definition at line 698 of file fxusbpipe.hpp.

Referenced by FormatAbortRequest(), FormatResetRequest(), FormatTransferRequest(), and FxUsbPipeContinuousReader::FxUsbPipeRequestWorkItemHandler().

◆ m_USBDHandle

USBD_HANDLE FxUsbPipe::m_USBDHandle

protected

Definition at line 737 of file fxusbpipe.hpp.

Referenced by FormatAbortRequest(), FormatResetRequest(), FormatTransferRequest(), FxUsbPipe(), and GetUSBDHandle().

◆ m_UsbInterface

FxUsbInterface* FxUsbPipe::m_UsbInterface

protected

Definition at line 700 of file fxusbpipe.hpp.

Referenced by FormatAbortRequest(), FormatResetRequest(), FxUsbPipe(), GetInformation(), InitPipe(), and ~FxUsbPipe().

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

sdk/lib/drivers/wdf/shared/inc/private/common/fxusbpipe.hpp
sdk/lib/drivers/wdf/shared/targets/usb/fxusbpipe.cpp
sdk/lib/drivers/wdf/shared/targets/usb/fxusbpipeapi.cpp
sdk/lib/drivers/wdf/shared/targets/usb/km/fxusbpipekm.cpp
sdk/lib/drivers/wdf/shared/targets/usb/um/fxusbpipeum.cpp

Public Member Functions

Static Public Member Functions

Public Attributes

Protected Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ FxUsbPipe()

◆ ~FxUsbPipe()

Member Function Documentation

◆ _FormatTransfer()

◆ _SendTransfer()

◆ _UsbdPipeTypeToWdf()

◆ Dispose()

◆ FormatAbortRequest()

◆ FormatResetRequest()

◆ FormatTransferRequest()

◆ GetHandle()

◆ GetInformation()

◆ GetMaxPacketSize()

◆ GetType()

◆ GetUrbType()

◆ GetUSBDHandle()

◆ GotoPurgeState()

◆ GotoRemoveState()

◆ GotoStartState()

◆ GotoStopState()

◆ InitContinuousReader()

◆ InitPipe() [1/2]

◆ InitPipe() [2/2]

◆ IsInEndpoint()

◆ IsOutEndpoint()

◆ IsType()

◆ Reset()

◆ SetNoCheckPacketSize()

◆ ValidateTransferLength()

◆ WaitForSentIoToComplete()

◆ WdmGetPipeHandle()

Member Data Documentation

◆ FxUsbDevice

◆ FxUsbInterface

◆ FxUsbPipeContinuousReader

◆ m_CheckPacketSize

◆ m_InterfaceNumber

◆ m_ListEntry

◆ m_PipeInformation

◆ m_PipeInformationUm

◆ m_Reader

◆ m_UrbType

◆ m_UsbDevice

◆ m_USBDHandle

◆ m_UsbInterface