FxUsbDevice Class Reference

#include <fxusbdevice.hpp>

Inheritance diagram for FxUsbDevice:

Collaboration diagram for FxUsbDevice:

Public Member Functions
	FxUsbDevice (__in PFX_DRIVER_GLOBALS FxDriverGlobals)
_Must_inspect_result_ NTSTATUS	InitDevice (__in ULONG USBDClientContractVersionForWdfClient)
_Must_inspect_result_ NTSTATUS	GetConfigDescriptor (__out PVOID ConfigDescriptor, __inout PUSHORT ConfigDescriptorLength)
_Must_inspect_result_ NTSTATUS	GetString (__in_ecount(*NumCharacters) PUSHORT String, __in PUSHORT NumCharacters, __in UCHAR StringIndex, __in_opt USHORT LangID, __in_opt WDFREQUEST Request=NULL, __in_opt PWDF_REQUEST_SEND_OPTIONS Options=NULL)
__inline VOID	CopyDeviceDescriptor (__out PUSB_DEVICE_DESCRIPTOR UsbDeviceDescriptor)
VOID	GetInformation (__out PWDF_USB_DEVICE_INFORMATION Information)
__inline USBD_CONFIGURATION_HANDLE	GetConfigHandle (VOID)
_Must_inspect_result_ __inline NTSTATUS	GetCurrentFrameNumber (__in PULONG Current)
_Must_inspect_result_ NTSTATUS	SelectConfigAuto (__in PWDF_OBJECT_ATTRIBUTES PipeAttributes)
_Must_inspect_result_ NTSTATUS	SelectConfigInterfaces (__in PWDF_OBJECT_ATTRIBUTES PipesAttributes, __in PUSB_CONFIGURATION_DESCRIPTOR ConfigurationDescriptor, __in_ecount(NumInterfaces) PUSB_INTERFACE_DESCRIPTOR *InterfaceDescriptors, __in ULONG NumInterfaces)
_Must_inspect_result_ NTSTATUS	SelectConfig (__in PWDF_OBJECT_ATTRIBUTES PipesAttributes, __in PURB Urb, __in FX_URB_TYPE FxUrbType, __out_opt PUCHAR NumConfiguredInterfaces)
_Must_inspect_result_ NTSTATUS	Deconfig (VOID)
_Must_inspect_result_ NTSTATUS	SelectInterfaceByInterface (__in PWDF_OBJECT_ATTRIBUTES PipesAttributes, __in PUSB_INTERFACE_DESCRIPTOR InterfaceDescriptor)
_Must_inspect_result_ NTSTATUS	SelectInterface (__in PWDF_OBJECT_ATTRIBUTES PipesAttributes, __in PURB Urb)
UCHAR	GetNumInterfaces (VOID)
UCHAR	GetInterfaceNumEndpoints (__in UCHAR InterfaceNumber)
WDFUSBPIPE	GetInterfacePipeReferenced (__in UCHAR InterfaceNumber, __in UCHAR EndpointNumber)
_Must_inspect_result_ NTSTATUS	FormatStringRequest (__in FxRequestBase *Request, __in FxRequestBuffer *RequestBuffer, __in UCHAR StringIndex, __in USHORT LangID)
_Must_inspect_result_ NTSTATUS	FormatControlRequest (__in FxRequestBase *Request, __in PWDF_USB_CONTROL_SETUP_PACKET Packet, __in FxRequestBuffer *RequestBuffer)
_Must_inspect_result_ NTSTATUS	IsConnected (VOID)
_Must_inspect_result_ NTSTATUS	Reset (VOID)
_Must_inspect_result_ NTSTATUS	CyclePort (VOID)
_Must_inspect_result_ NTSTATUS	FormatCycleRequest (__in FxRequestBase *Request)
BOOLEAN	OnUSBD (VOID)
USBD_PIPE_HANDLE	GetControlPipeHandle (VOID)
_Must_inspect_result_ NTSTATUS	CreateInterfaces (VOID)
_Must_inspect_result_ NTSTATUS	SelectConfigSingle (__in PWDF_OBJECT_ATTRIBUTES PipeAttributes, __in PWDF_USB_DEVICE_SELECT_CONFIG_PARAMS Params)
_Must_inspect_result_ NTSTATUS	SelectConfigMulti (__in PWDF_OBJECT_ATTRIBUTES PipeAttributes, __in PWDF_USB_DEVICE_SELECT_CONFIG_PARAMS Params)
_Must_inspect_result_ NTSTATUS	SelectConfigDescriptor (__in PWDF_OBJECT_ATTRIBUTES PipeAttributes, __in PWDF_USB_DEVICE_SELECT_CONFIG_PARAMS Params)
FxUsbInterface *	GetInterfaceFromIndex (__in UCHAR InterfaceIndex)
BOOLEAN	HasMismatchedInterfacesInConfigDescriptor (VOID)
VOID	CancelSentIo (VOID)
BOOLEAN	IsEnabled (VOID)
_Must_inspect_result_ NTSTATUS	QueryUsbCapability (__in CONST GUID *CapabilityType, __in ULONG CapabilityBufferLength, __drv_when(CapabilityBufferLength==0, __out_opt) __drv_when(CapabilityBufferLength !=0 &&ResultLength==NULL, __out_bcount(CapabilityBufferLength)) __drv_when(CapabilityBufferLength !=0 &&ResultLength !=NULL, __out_bcount_part_opt(CapabilityBufferLength, *ResultLength)) PVOID CapabilityBuffer, __out_opt __drv_when(ResultLength !=NULL, __deref_out_range(<=, CapabilityBufferLength)) PULONG ResultLength)
__checkReturn NTSTATUS	CreateUrb (__in_opt PWDF_OBJECT_ATTRIBUTES Attributes, __out WDFMEMORY *UrbMemory, __deref_opt_out_bcount(sizeof(URB)) PURB *Urb)
__checkReturn NTSTATUS	CreateIsochUrb (__in_opt PWDF_OBJECT_ATTRIBUTES Attributes, __in ULONG NumberOfIsochPackets, __out WDFMEMORY *UrbMemory, __deref_opt_out_bcount(GET_ISOCH_URB_SIZE(NumberOfIsochPackets)) PURB *Urb)
USBD_HANDLE	GetUSBDHandle (VOID)
FX_URB_TYPE	GetUrbType (VOID)
FX_URB_TYPE	GetFxUrbTypeForRequest (__in FxRequestBase *Request)
BOOLEAN	IsObjectDisposedOnRemove (__in FxObject *Object)
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)

Public Attributes
friend	FxUsbPipe
friend	FxUsbInterface
Public Attributes inherited from FxIoTarget
FxTransactionedEntry	m_TransactionedEntry
BOOLEAN	m_InStack
BOOLEAN	m_AddedToDeviceList

Protected Member Functions
	~FxUsbDevice (VOID)
VOID	RemoveDeletedInterface (__in FxUsbInterface *Interface)
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)
VOID	PipesGotoRemoveState (__in BOOLEAN ForceRemovePipes)
FxUsbInterface *	GetInterfaceFromNumber (__in UCHAR InterfaceNumber)
_Must_inspect_result_ NTSTATUS	GetInterfaceNumberFromInterface (__in WDFUSBINTERFACE UsbInterface, __out PUCHAR InterfaceNumber)
VOID	CleanupInterfacePipesAndDelete (__in FxUsbInterface *UsbInterface)
	_Acquires_lock_ (_Global_critical_region_) VOID AcquireInterfaceIterationLock(VOID)
	_Releases_lock_ (_Global_critical_region_) VOID ReleaseInterfaceIterationLock(VOID)
ULONG	GetDefaultMaxTransferSize (VOID)
VOID	FormatInterfaceSelectSettingUrb (__in PURB Urb, __in USHORT NumEndpoints, __in UCHAR InterfaceNumber, __in UCHAR SettingNumber)
virtual BOOLEAN	Dispose (VOID)
_Must_inspect_result_ NTSTATUS	GetPortStatus (__out PULONG PortStatus)
_Must_inspect_result_ NTSTATUS	SendSyncRequest (__in FxSyncRequest *Request, __in ULONGLONG Time)
_Must_inspect_result_ NTSTATUS	SendSyncUmUrb (__inout PUMURB Urb, __in ULONGLONG Time, __in_opt WDFREQUEST Request=NULL, __in_opt PWDF_REQUEST_SEND_OPTIONS Options=NULL)
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)

Static Protected Member Functions
static VOID	_CleanupPipesRequests (__in PLIST_ENTRY PendHead, __in PSINGLE_LIST_ENTRY SentHead)
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)

Protected Attributes
USBD_HANDLE	m_USBDHandle
USBD_PIPE_HANDLE	m_ControlPipe
FxUsbInterface **	m_Interfaces
USBD_CONFIGURATION_HANDLE	m_ConfigHandle
USB_DEVICE_DESCRIPTOR	m_DeviceDescriptor
PUSB_CONFIGURATION_DESCRIPTOR	m_ConfigDescriptor
USBD_VERSION_INFORMATION	m_UsbdVersionInformation
PUSB_BUSIFFN_QUERY_BUS_TIME	m_QueryBusTime
PVOID	m_BusInterfaceContext
PINTERFACE_DEREFERENCE	m_BusInterfaceDereference
FxWaitLockInternal	m_InterfaceIterationLock
ULONG	m_HcdPortCapabilities
ULONG	m_Traits
BOOLEAN	m_OnUSBD
UCHAR	m_NumInterfaces
BOOLEAN	m_MismatchedInterfacesInConfigDescriptor
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
};

Private Attributes
IWudfFile *	m_pHostTargetFile
WINUSB_INTERFACE_HANDLE	m_WinUsbHandle

Additional Inherited Members
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)
Static Public Attributes inherited from FxIoTarget
static const PVOID	m_SentRequestTag = (PVOID) 'lcnC'
Static Protected Attributes inherited from FxIoTarget
static MdCompletionRoutineType	_RequestCompletionRoutine
static EVT_WDF_REQUEST_COMPLETION_ROUTINE	_SyncCompletionRoutine

Detailed Description

Definition at line 183 of file fxusbdevice.hpp.

Constructor & Destructor Documentation

FxUsbDevice()

FxUsbDevice::FxUsbDevice

(

__in PFX_DRIVER_GLOBALS

FxDriverGlobals

)

Definition at line 375 of file fxusbdevice.cpp.

      :
    FxIoTarget(FxDriverGlobals, sizeof(FxUsbDevice), FX_TYPE_IO_TARGET_USB_DEVICE)
{
    RtlZeroMemory(&m_DeviceDescriptor, sizeof(m_DeviceDescriptor));
    RtlZeroMemory(&m_UsbdVersionInformation, sizeof(m_UsbdVersionInformation));
 
    m_OnUSBD = FALSE;
    m_Interfaces = NULL;;
    m_NumInterfaces = 0;
 
    m_Traits = 0;
    m_HcdPortCapabilities = 0;
    m_ControlPipe = NULL;
    m_QueryBusTime = NULL;
    m_BusInterfaceContext = NULL;
    m_BusInterfaceDereference = NULL;
    m_ConfigHandle = NULL;
    m_ConfigDescriptor = NULL;
 
    m_MismatchedInterfacesInConfigDescriptor = FALSE;
 
    m_USBDHandle = NULL;
    m_UrbType = FxUrbTypeLegacy;
 
#if (FX_CORE_MODE == FX_CORE_USER_MODE)
    m_pHostTargetFile = NULL;
    m_WinUsbHandle = NULL;
#endif
 
    MarkDisposeOverride(ObjectDoNotLock);
}

~FxUsbDevice()

FxUsbDevice::~FxUsbDevice ( VOID  )

protected

Definition at line 439 of file fxusbdevice.cpp.

{
    UCHAR i;
 
    if (m_BusInterfaceDereference != NULL) {
        m_BusInterfaceDereference(m_BusInterfaceContext);
        m_BusInterfaceDereference = NULL;
    }
 
    if (m_ConfigDescriptor != NULL) {
        FxPoolFree(m_ConfigDescriptor);
        m_ConfigDescriptor = NULL;
    }
 
    for (i = 0; i < m_NumInterfaces; i++) {
        ASSERT(m_Interfaces[i] == NULL);
    }
 
    if (m_Interfaces != NULL){
        FxPoolFree(m_Interfaces);
        m_Interfaces = NULL;
    }
 
    m_NumInterfaces = 0;
}

Member Function Documentation

_Acquires_lock_()

FxUsbDevice::_Acquires_lock_ ( _Global_critical_region_  )

inlineprotected

Definition at line 557 of file fxusbdevice.hpp.

    {
        m_InterfaceIterationLock.AcquireLock(GetDriverGlobals());
    }

_CleanupPipesRequests()

VOID FxUsbDevice::_CleanupPipesRequests ( __in PLIST_ENTRY  PendHead, __in PSINGLE_LIST_ENTRY  SentHead  )

staticprotected

Definition at line 796 of file fxusbdevice.cpp.

{
    while (!IsListEmpty(PendHead)) {
        PLIST_ENTRY ple;
        FxRequestBase* pRequest;
 
        ple = RemoveHeadList(PendHead);
 
        InitializeListHead(ple);
 
        pRequest = FxRequestBase::_FromListEntry(ple);
        pRequest->GetTarget()->CompletePendedRequest(pRequest);
    }
 
    _CancelSentRequests(SentHead);
}

Referenced by CleanupInterfacePipesAndDelete(), and PipesGotoRemoveState().

_Releases_lock_()

FxUsbDevice::_Releases_lock_ ( _Global_critical_region_  )

inlineprotected

Definition at line 566 of file fxusbdevice.hpp.

    {
        m_InterfaceIterationLock.ReleaseLock(GetDriverGlobals());
    }

CancelSentIo()

VOID FxUsbDevice::CancelSentIo

(

VOID

)

Definition at line 2100 of file fxusbdevice.cpp.

{
    FxUsbInterface *pUsbInterface;
    ULONG iInterface, iPipe;
 
    for (iInterface = 0; iInterface < m_NumInterfaces; iInterface++) {
        pUsbInterface = m_Interfaces[iInterface];
 
        if (pUsbInterface->m_ConfiguredPipes != NULL) {
            for (iPipe = 0;
                 iPipe < pUsbInterface->m_NumberOfConfiguredPipes;
                 iPipe++) {
 
                if (pUsbInterface->m_ConfiguredPipes[iPipe] != NULL) {
                    pUsbInterface->m_ConfiguredPipes[iPipe]->CancelSentIo();
                }
 
            }
        }
    }
    FxIoTarget::CancelSentIo(); // __super call
}

Referenced by CyclePort(), and Reset().

CleanupInterfacePipesAndDelete()

VOID FxUsbDevice::CleanupInterfacePipesAndDelete ( __in FxUsbInterface *  UsbInterface )

protected

Definition at line 2057 of file fxusbdevice.cpp.

{
    SINGLE_LIST_ENTRY sentHead;
    LIST_ENTRY pendHead;
    ULONG iPipe;
    FxUsbPipe *pPipe;
    KIRQL irql;
 
    sentHead.Next = NULL;
    InitializeListHead(&pendHead);
 
    AcquireInterfaceIterationLock();
 
    Lock(&irql);
    for (iPipe = 0; iPipe < UsbInterface->m_NumberOfConfiguredPipes; iPipe++) {
        BOOLEAN wait;
 
        wait = FALSE;
        pPipe = UsbInterface->m_ConfiguredPipes[iPipe];
        pPipe->GotoRemoveState(
            WdfIoTargetDeleted,
            &pendHead,
            &sentHead,
            TRUE,
            &wait);
    }
    Unlock(irql);
 
    _CleanupPipesRequests(&pendHead, &sentHead);
 
    for (iPipe = 0; iPipe < UsbInterface->m_NumberOfConfiguredPipes; iPipe++) {
        pPipe = UsbInterface->m_ConfiguredPipes[iPipe];
        pPipe->WaitForSentIoToComplete();
    }
 
    UsbInterface->CleanUpAndDelete(FALSE);
 
    ReleaseInterfaceIterationLock();
}

Referenced by FxUsbInterface::MakeAndConfigurePipes(), SelectConfig(), and FxUsbInterface::SelectSetting().

CopyDeviceDescriptor()

__inline VOID FxUsbDevice::CopyDeviceDescriptor ( __out PUSB_DEVICE_DESCRIPTOR  UsbDeviceDescriptor )

inline

Definition at line 218 of file fxusbdevice.hpp.

    {
        RtlCopyMemory(UsbDeviceDescriptor,
                      &m_DeviceDescriptor,
                      sizeof(m_DeviceDescriptor));
    }

CreateInterfaces()

_Must_inspect_result_ NTSTATUS FxUsbDevice::CreateInterfaces

(

VOID

)

Definition at line 902 of file fxusbdevice.cpp.

{
    PFX_DRIVER_GLOBALS pFxDriverGlobals;
    UCHAR descCountBitMap[UCHAR_MAX / sizeof(UCHAR)];
    PUSB_INTERFACE_DESCRIPTOR  pInterfaceDescriptor;
    UCHAR iInterface, numFound;
    NTSTATUS status;
    ULONG size;
    ULONG totalLength;
 
    pFxDriverGlobals = GetDriverGlobals();
    status = STATUS_SUCCESS;
    totalLength = m_ConfigDescriptor->wTotalLength;
 
    //
    // Make sure each PCOMMON_DESCRIPTOR_HEADER within the entire config descriptor is well formed.
    // If successful, we can walk the config descriptor using common headers without any more top
    // level error checking. Task specific checking of the specialized header types must still occur.
    //
    status = FxUsbValidateConfigDescriptorHeaders(
        pFxDriverGlobals,
        m_ConfigDescriptor,
        m_ConfigDescriptor->wTotalLength
        );
 
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(
            pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIOTARGET,
            "Validation of the config descriptor failed due to a bad common descriptor header, %!STATUS!",
            status);
        return status;
    }
 
    //
    // Validate all interface descriptors in config descriptor are at least
    // sizeof(USB_INTERFACE_DESCRIPTOR).
    //
 
 
 
 
 
    status =  FxUsbValidateDescriptorType(
        pFxDriverGlobals,
        m_ConfigDescriptor,
        m_ConfigDescriptor,
        WDF_PTR_ADD_OFFSET(m_ConfigDescriptor, m_ConfigDescriptor->wTotalLength),
        USB_INTERFACE_DESCRIPTOR_TYPE,
        sizeof(USB_INTERFACE_DESCRIPTOR),
        FxUsbValidateDescriptorOpAtLeast,
        0
        );
 
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(
            pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIOTARGET,
            "Validation of interface descriptors in config descriptor failed, %!STATUS!",
            status);
 
        return status;
    }
 
    if (m_ConfigDescriptor->bNumInterfaces == 0) {
        //
        // Use an array of one in the zero case
        //
        size = sizeof(FxUsbInterface*);
    }
    else {
        size = sizeof(FxUsbInterface*) * m_ConfigDescriptor->bNumInterfaces;
    }
 
    //
    // Allocate an array large enough to hold pointers to interfaces
    //
    m_Interfaces = (FxUsbInterface**)
        FxPoolAllocate(pFxDriverGlobals, NonPagedPool, size);
 
    if (m_Interfaces == NULL) {
        status = STATUS_INSUFFICIENT_RESOURCES;
 
        DoTraceLevelMessage(
            pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIOTARGET,
            "Could not allocate memory for %d interfaces, %!STATUS!",
            m_ConfigDescriptor->bNumInterfaces, status);
 
        goto Done;
    }
 
    RtlZeroMemory(m_Interfaces, size);
    m_NumInterfaces = m_ConfigDescriptor->bNumInterfaces;
 
    //
    // Iterate over the desciptors again, this time allocating an FxUsbInterface
    // for each one and capturing the interface information.
    //
    RtlZeroMemory(descCountBitMap, sizeof(descCountBitMap));
    iInterface = 0;
    numFound = 0;
    UNREFERENCED_PARAMETER(numFound);
 
    pInterfaceDescriptor = (PUSB_INTERFACE_DESCRIPTOR) FxUsbFindDescriptorType(
        m_ConfigDescriptor,
        m_ConfigDescriptor->wTotalLength,
        m_ConfigDescriptor,
        USB_INTERFACE_DESCRIPTOR_TYPE
        );
 
    while (pInterfaceDescriptor != NULL &&
           iInterface < m_ConfigDescriptor->bNumInterfaces) {
 
        //
        // This function will retun false if the bit wasn't already set
        //
        if (FxBitArraySet(descCountBitMap,
                          pInterfaceDescriptor->bInterfaceNumber) == FALSE) {
            FxUsbInterface* pInterface;
 
            pInterface = new (GetDriverGlobals(), WDF_NO_OBJECT_ATTRIBUTES)
                FxUsbInterface(pFxDriverGlobals,
                               this,
                               pInterfaceDescriptor);
 
            if (pInterface == NULL) {
                status = STATUS_INSUFFICIENT_RESOURCES;
                DoTraceLevelMessage(
                    GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                    "Could not allocate memory for interface object #%d, %!STATUS!",
                    iInterface, status);
                goto Done;
            }
 
            status = pInterface->Commit(WDF_NO_OBJECT_ATTRIBUTES, NULL, this);
 
            //
            // This should never fail
            //
            ASSERT(NT_SUCCESS(status));
 
            if (!NT_SUCCESS(status)) {
                goto Done;
            }
 
            status = pInterface->CreateSettings();
            if (!NT_SUCCESS(status)) {
                goto Done;
            }
 
#if (FX_CORE_MODE == FX_CORE_USER_MODE)
            status = pInterface->SetWinUsbHandle(iInterface);
            if (!NT_SUCCESS(status)) {
                goto Done;
            }
 
            status = pInterface->MakeAndConfigurePipes(WDF_NO_OBJECT_ATTRIBUTES,
                                                       pInterfaceDescriptor->bNumEndpoints);
            if (!NT_SUCCESS(status)) {
                goto Done;
            }
#endif
 
            m_Interfaces[iInterface] = pInterface;
 
            iInterface++;
        }
 
        pInterfaceDescriptor = (PUSB_INTERFACE_DESCRIPTOR) FxUsbFindDescriptorType(
            m_ConfigDescriptor,
            totalLength,
            WDF_PTR_ADD_OFFSET(pInterfaceDescriptor,
                               pInterfaceDescriptor->bLength),
            USB_INTERFACE_DESCRIPTOR_TYPE
            );
    }
 
    //
    // We cannot check for the error case of
    //
    // pInterfaceDescriptor != NULL &&
    //  iInterface == m_ConfigDescriptor->bNumInterfaces
    //
    // Because if there are multiple alternative settings for the last interface
    // in the config descriptor, we will have hit the limit of interfaces
    // (correctly), but have found another pInterfaceDescriptor (the next alt
    // setting).
    //
 
    //
    // We already logged and found the case where iInterface >= m_NumInterfaces.
    // Check for the case where we found too few interfaces and when we found
    // no interfaces even though the config descriptor says otherwise.
    //
    //
    if (iInterface == 0 && m_NumInterfaces > 0) {
        status = STATUS_INVALID_DEVICE_REQUEST;
 
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
            "Config descriptor indicated there were %d interfaces, but did not "
            "find any interface descriptors in config descriptor %p, %!STATUS!",
            m_NumInterfaces, m_ConfigDescriptor, status);
    }
    else if (pInterfaceDescriptor != NULL && m_NumInterfaces == 0) {
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_WARNING, TRACINGIOTARGET,
            "Config descriptor indicated there were 0 interfaces, but an interface "
            "descriptor was found");
 
        m_MismatchedInterfacesInConfigDescriptor = TRUE;
    }
    else if (iInterface < m_NumInterfaces) {
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
            "Config descriptor indicated there were %d interfaces, only found "
            "%d interfaces", m_NumInterfaces, iInterface);
 
        //
        // Instead of considering this an error, just use the number found.
        // This will not have an adverse affect elsewhere and since the framework
        // is probably more strict then previous USB code, this would have not
        // been found earlier by a WDM driver.
        //
        m_NumInterfaces = iInterface;
    }
 
Done:
    return status;
}

CreateIsochUrb()

__checkReturn NTSTATUS FxUsbDevice::CreateIsochUrb	(	__in_opt PWDF_OBJECT_ATTRIBUTES	Attributes,
		__in ULONG	NumberOfIsochPackets,
		__out WDFMEMORY *	UrbMemory,
		__deref_opt_out_bcount(GET_ISOCH_URB_SIZE(NumberOfIsochPackets)) PURB *	Urb
	)

Definition at line 2242 of file fxusbdevice.cpp.

{
    NTSTATUS status;
    PURB urbLocal = NULL;
    PFX_DRIVER_GLOBALS pFxDriverGlobals;
    FxUsbUrb * pUrb = NULL;
    WDFMEMORY hMemory;
    ULONG size;
    FxObject* pParent;
 
    //
    // Get the parent's globals if it is present, else use the ones for FxUsbDevice
    //
    pFxDriverGlobals = GetDriverGlobals();
    status = FxValidateObjectAttributesForParentHandle(pFxDriverGlobals, Attributes);
 
    if (NT_SUCCESS(status)) {
 
        FxObjectHandleGetPtrAndGlobals(pFxDriverGlobals,
                                       Attributes->ParentObject,
                                       FX_TYPE_OBJECT,
                                       (PVOID*)&pParent,
                                       &pFxDriverGlobals);
 
        if (FALSE == IsObjectDisposedOnRemove(pParent)) {
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                "Urb must be parented to FxDevice or IoAllocated Request");
            status = STATUS_INVALID_PARAMETER;
            goto Done;
        }
 
    }
    else if (status == STATUS_WDF_PARENT_NOT_SPECIFIED) {
 
        pFxDriverGlobals = GetDriverGlobals();
        pParent = this;
        status = STATUS_SUCCESS;
 
    }
    else {
 
        goto Done;
    }
 
    status = FxValidateObjectAttributes(pFxDriverGlobals, Attributes);
    if (!NT_SUCCESS(status)) {
        goto Done;
    }
 
    FxPointerNotNull(pFxDriverGlobals, UrbMemory);
 
    *UrbMemory = NULL;
 
    status = USBD_IsochUrbAllocate(m_USBDHandle, NumberOfIsochPackets, &urbLocal);
 
    if (!NT_SUCCESS(status)) {
 
        urbLocal = NULL;
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
            "USBDEVICE Must have been created with Client Contract Version Info, %!STATUS!",
            status);
 
        goto Done;
 
    }
 
    size = GET_ISO_URB_SIZE(NumberOfIsochPackets);
 
    pUrb = new(pFxDriverGlobals, Attributes)
            FxUsbUrb(pFxDriverGlobals, m_USBDHandle, urbLocal, size);
 
    if (pUrb == NULL) {
        status = STATUS_INSUFFICIENT_RESOURCES;
        goto Done;
    }
 
    urbLocal = NULL;
 
    status = pUrb->Commit(Attributes, (WDFOBJECT*)&hMemory, pParent);
 
    if (!NT_SUCCESS(status)) {
        goto Done;
    }
 
    *UrbMemory = hMemory;
 
    if (Urb) {
        *Urb = (PURB) pUrb->GetBuffer();
    }
 
Done:
 
    if (!NT_SUCCESS(status)) {
 
        if (pUrb) {
            pUrb->DeleteFromFailedCreate();
        }
 
        if (urbLocal) {
            USBD_UrbFree(m_USBDHandle, urbLocal);
        }
 
    }
 
    return status;
}

CreateUrb()

__checkReturn NTSTATUS FxUsbDevice::CreateUrb	(	__in_opt PWDF_OBJECT_ATTRIBUTES	Attributes,
		__out WDFMEMORY *	UrbMemory,
		__deref_opt_out_bcount(sizeof(URB)) PURB *	Urb
	)

Definition at line 2127 of file fxusbdevice.cpp.

{
    NTSTATUS status;
    PURB urbLocal = NULL;
    PFX_DRIVER_GLOBALS pFxDriverGlobals;
    FxUsbUrb * pUrb = NULL;
    WDFMEMORY hMemory;
    FxObject* pParent;
 
    //
    // Get the parent's globals if it is present, else use the ones for FxUsbDevice
    //
    pFxDriverGlobals = GetDriverGlobals();
    status = FxValidateObjectAttributesForParentHandle(pFxDriverGlobals, Attributes);
 
    if (NT_SUCCESS(status)) {
 
        FxObjectHandleGetPtrAndGlobals(pFxDriverGlobals,
                                       Attributes->ParentObject,
                                       FX_TYPE_OBJECT,
                                       (PVOID*)&pParent,
                                       &pFxDriverGlobals);
 
        if (FALSE == IsObjectDisposedOnRemove(pParent)) {
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                "Urb must be parented to FxDevice or an IoAllocated Request");
            status = STATUS_INVALID_PARAMETER;
            goto Done;
        }
 
    }
    else if (status == STATUS_WDF_PARENT_NOT_SPECIFIED) {
 
        pFxDriverGlobals = GetDriverGlobals();
        pParent = this;
        status = STATUS_SUCCESS;
 
    }
    else {
 
        goto Done;
    }
 
    status = FxValidateObjectAttributes(pFxDriverGlobals, Attributes);
    if (!NT_SUCCESS(status)) {
        goto Done;
    }
 
    FxPointerNotNull(pFxDriverGlobals, UrbMemory);
 
    *UrbMemory = NULL;
 
    status = USBD_UrbAllocate(m_USBDHandle, &urbLocal);
 
    if (!NT_SUCCESS(status)) {
 
        urbLocal = NULL;
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
            "USBDEVICE Must have been created with Client Contract Version Info, %!STATUS!",
            status);
 
        goto Done;
 
    }
 
    pUrb = new(pFxDriverGlobals, Attributes)
            FxUsbUrb(pFxDriverGlobals, m_USBDHandle, urbLocal, sizeof(URB));
 
    if (pUrb == NULL) {
        status = STATUS_INSUFFICIENT_RESOURCES;
        goto Done;
    }
 
    urbLocal = NULL;
 
    status = pUrb->Commit(Attributes, (WDFOBJECT*)&hMemory, pParent);
 
    if (!NT_SUCCESS(status)) {
        goto Done;
    }
 
    *UrbMemory = hMemory;
 
    if (Urb) {
        *Urb = (PURB) pUrb->GetBuffer();
    }
 
Done:
 
    if (!NT_SUCCESS(status)) {
 
        if (pUrb) {
            pUrb->DeleteFromFailedCreate();
        }
 
        if (urbLocal) {
            USBD_UrbFree(m_USBDHandle, urbLocal);
        }
 
    }
 
    return status;
}

Referenced by __deref_opt_out_bcount().

CyclePort()

_Must_inspect_result_ NTSTATUS FxUsbDevice::CyclePort

(

VOID

)

Definition at line 1232 of file fxusbdevice.cpp.

{
    FxIoContext context;
    FxSyncRequest request(GetDriverGlobals(), &context);
    NTSTATUS status;
 
    //
    // FxSyncRequest always succeesds for KM.
    //
    status = request.Initialize();
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                            "Failed to initialize FxSyncRequest");
        return status;
    }
 
    status = FormatCycleRequest(request.m_TrueRequest);
 
    if (NT_SUCCESS(status)) {
        CancelSentIo();
        status = SubmitSyncRequestIgnoreTargetState(request.m_TrueRequest, NULL);
        //
        // NOTE: CyclePort causes the device to be removed and re-enumerated so
        // don't do anymore operations after this point.
        //
    }
 
    return status;
}

Deconfig()

_Must_inspect_result_ NTSTATUS FxUsbDevice::Deconfig

(

VOID

)

Definition at line 1882 of file fxusbdevice.cpp.

{
    WDF_REQUEST_SEND_OPTIONS options;
    _URB_SELECT_CONFIGURATION urb;
 
    FxSyncRequest request(GetDriverGlobals(), NULL);
    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 = request.m_TrueRequest->ValidateTarget(this);
    if (!NT_SUCCESS(status)) {
        return status;
    }
 
    //
    // This will remove and free all interfaces and associated pipes
    //
    PipesGotoRemoveState(TRUE);
 
    RtlZeroMemory(&urb, sizeof(urb));
 
#pragma prefast(suppress: __WARNING_BUFFER_OVERFLOW, "this annotation change in usb.h is communicated to usb team");
    UsbBuildSelectConfigurationRequest((PURB) &urb, sizeof(urb), NULL);
#pragma prefast(suppress: __WARNING_BUFFER_OVERFLOW, "this annotation change in usb.h is communicated to usb team");
    FxFormatUsbRequest(request.m_TrueRequest, (PURB) &urb, FxUrbTypeLegacy, NULL);
 
    WDF_REQUEST_SEND_OPTIONS_INIT(
        &options, WDF_REQUEST_SEND_OPTION_IGNORE_TARGET_STATE);
 
    status = SubmitSync(request.m_TrueRequest, &options);
 
    return status;
}

Dispose()

BOOLEAN FxUsbDevice::Dispose ( VOID  )

protectedvirtual

Reimplemented from FxIoTarget.

Definition at line 410 of file fxusbdevice.cpp.

{
#if ((FX_CORE_MODE)==(FX_CORE_KERNEL_MODE))
    KeFlushQueuedDpcs();
#endif
 
    if (m_USBDHandle) {
        USBD_CloseHandle(m_USBDHandle);
        m_USBDHandle = NULL;
    }
 
#if (FX_CORE_MODE == FX_CORE_USER_MODE)
    IWudfDevice* device = NULL;
    IWudfDeviceStack* devstack = NULL;
 
    device = m_DeviceBase->GetDeviceObject();
    devstack = device->GetDeviceStackInterface();
 
    if (m_pHostTargetFile) {
        devstack->CloseFile(m_pHostTargetFile);
        SAFE_RELEASE(m_pHostTargetFile);
    }
#endif
 
    return FxIoTarget::Dispose(); // __super call
}

FormatControlRequest()

_Must_inspect_result_ NTSTATUS FxUsbDevice::FormatControlRequest	(	__in FxRequestBase *	Request,
		__in PWDF_USB_CONTROL_SETUP_PACKET	Packet,
		__in FxRequestBuffer *	RequestBuffer
	)

Definition at line 591 of file fxusbdevicekm.cpp.

{
    FxUsbDeviceControlContext* pContext;
    NTSTATUS status;
    size_t bufferSize;
    FX_URB_TYPE urbType;
 
    bufferSize = RequestBuffer->GetBufferLength();
 
    //
    // We can only transfer 2 bytes worth of data, so if the buffer is larger,
    // fail here.
    //
    if (bufferSize > 0xFFFF) {
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
            "Control transfer buffer is limited to 0xFFFF bytes in size, "
            "%I64d requested ", bufferSize);
 
        return STATUS_INVALID_PARAMETER;
    }
 
    status = Request->ValidateTarget(this);
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                            "WDFUSBDEVICE %p, Request %p, setting target failed, "
                            "%!STATUS!", GetHandle(), Request, status);
 
        return status;
    }
 
    if (Request->HasContextType(FX_RCT_USB_CONTROL_REQUEST)) {
        pContext = (FxUsbDeviceControlContext*) Request->GetContext();
    }
    else {
 
        urbType = GetFxUrbTypeForRequest(Request);
        pContext = new(GetDriverGlobals()) FxUsbDeviceControlContext(urbType);
        if (pContext == NULL) {
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
        if (urbType == FxUrbTypeUsbdAllocated) {
            status = pContext->AllocateUrb(m_USBDHandle);
            if (!NT_SUCCESS(status)) {
                DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                                    "FxUsbDeviceControlContext::AllocateUrb Failed, %!STATUS!", 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);
    }
 
    if (RequestBuffer->HasMdl()) {
        PMDL pMdl;
 
        pMdl = NULL;
        ASSERT(pContext->m_PartialMdl == NULL);
 
        status = RequestBuffer->GetOrAllocateMdl(GetDriverGlobals(),
                                                 &pMdl,
                                                 &pContext->m_PartialMdl,
                                                 &pContext->m_UnlockPages,
                                                 IoModifyAccess);
 
        if (!NT_SUCCESS(status)) {
            return status;
        }
 
        ASSERT(pMdl != NULL);
    }
 
    pContext->StoreAndReferenceMemory(this, RequestBuffer, SetupPacket);
 
    if (pContext->m_Urb == &pContext->m_UrbLegacy) {
        urbType = FxUrbTypeLegacy;
    }
    else {
        urbType = FxUrbTypeUsbdAllocated;
    }
 
    FxFormatUsbRequest(Request, (PURB)pContext->m_Urb, urbType, m_USBDHandle);
 
    return STATUS_SUCCESS;
}

FormatCycleRequest()

_Must_inspect_result_ NTSTATUS FxUsbDevice::FormatCycleRequest

(

__in FxRequestBase *

Request

)

Definition at line 1266 of file fxusbdevice.cpp.

{
    FxRequestBuffer emptyBuffer;
 
    return FormatIoctlRequest(Request,
                              IOCTL_INTERNAL_USB_CYCLE_PORT,
                              TRUE,
                              &emptyBuffer,
                              &emptyBuffer);
}

Referenced by CyclePort().

FormatInterfaceSelectSettingUrb()

VOID FxUsbDevice::FormatInterfaceSelectSettingUrb ( __in PURB  Urb, __in USHORT  NumEndpoints, __in UCHAR  InterfaceNumber, __in UCHAR  SettingNumber  )

protected

FormatStringRequest()

_Must_inspect_result_ NTSTATUS FxUsbDevice::FormatStringRequest	(	__in FxRequestBase *	Request,
		__in FxRequestBuffer *	RequestBuffer,
		__in UCHAR	StringIndex,
		__in USHORT	LangID
	)

Definition at line 499 of file fxusbdevicekm.cpp.

{
    FxUsbDeviceStringContext* pContext;
    NTSTATUS status;
    FX_URB_TYPE urbType;
 
    status = Request->ValidateTarget(this);
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                            "WDFUSBDEVICE %p, Request %p, setting target failed, "
                            "%!STATUS!", GetHandle(), Request, status);
 
        return status;
    }
 
    if (Request->HasContextType(FX_RCT_USB_STRING_REQUEST)) {
        pContext = (FxUsbDeviceStringContext*) Request->GetContext();
    }
    else {
 
        urbType = GetFxUrbTypeForRequest(Request);
        pContext = new(GetDriverGlobals()) FxUsbDeviceStringContext(urbType);
        if (pContext == NULL) {
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
        if (urbType == FxUrbTypeUsbdAllocated) {
            status = pContext->AllocateUrb(m_USBDHandle);
            if (!NT_SUCCESS(status)) {
                DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                    "FxUsbDeviceStringContext::AllocateUrb failed, %!STATUS!", 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);
    }
 
    status = pContext->AllocateDescriptor(GetDriverGlobals(),
                                          RequestBuffer->GetBufferLength());
    if (!NT_SUCCESS(status)) {
        return status;
    }
 
    pContext->StoreAndReferenceMemory(RequestBuffer);
    pContext->SetUrbInfo(StringIndex, LangID);
 
    if (pContext->m_Urb == &pContext->m_UrbLegacy) {
        urbType = FxUrbTypeLegacy;
    }
    else {
        urbType = FxUrbTypeUsbdAllocated;
    }
 
    FxFormatUsbRequest(Request, (PURB)pContext->m_Urb, urbType, m_USBDHandle);
 
    return STATUS_SUCCESS;
}

GetConfigDescriptor()

_Must_inspect_result_ NTSTATUS FxUsbDevice::GetConfigDescriptor	(	__out PVOID	ConfigDescriptor,
		__inout PUSHORT	ConfigDescriptorLength
	)

Definition at line 1281 of file fxusbdevice.cpp.

{
    NTSTATUS status;
    USHORT copyLength;
 
    if (ConfigDescriptor == NULL) {
        //
        // Caller wants length to allocate
        //
        *ConfigDescriptorLength = m_ConfigDescriptor->wTotalLength;
        return STATUS_BUFFER_TOO_SMALL;
    }
 
    if (*ConfigDescriptorLength < m_ConfigDescriptor->wTotalLength) {
        //
        // Valid ConfigDescriptor passed in, but its too small.  Copy as many
        // bytes as we can.
        //
        copyLength = *ConfigDescriptorLength;
        status = STATUS_BUFFER_TOO_SMALL;
    }
    else {
        copyLength = m_ConfigDescriptor->wTotalLength;
        status = STATUS_SUCCESS;
    }
 
    //
    // Always indicate to the caller the number of required bytes or the
    // number of bytes we copied.
    //
    RtlCopyMemory(ConfigDescriptor, m_ConfigDescriptor, copyLength);
    *ConfigDescriptorLength = m_ConfigDescriptor->wTotalLength;
 
    return status;
}

GetConfigHandle()

__inline USBD_CONFIGURATION_HANDLE FxUsbDevice::GetConfigHandle ( VOID  )

inline

Definition at line 234 of file fxusbdevice.hpp.

    {
        return m_ConfigHandle;
    }

GetControlPipeHandle()

USBD_PIPE_HANDLE FxUsbDevice::GetControlPipeHandle ( VOID  )

inline

Definition at line 369 of file fxusbdevice.hpp.

    {
        return m_ControlPipe;
    }

GetCurrentFrameNumber()

_Must_inspect_result_ __inline NTSTATUS FxUsbDevice::GetCurrentFrameNumber ( __in PULONG  Current )

inline

Definition at line 244 of file fxusbdevice.hpp.

    {
        if (m_QueryBusTime != NULL) {
            return m_QueryBusTime(m_BusInterfaceContext, Current);
        }
        else {
            return STATUS_UNSUCCESSFUL;
        }
    }

GetDefaultMaxTransferSize()

ULONG FxUsbDevice::GetDefaultMaxTransferSize ( VOID  )

protected

Definition at line 498 of file fxusbdevice.cpp.

{
    //
    // On a usbport serviced stack (which can be running on Win2k) or on a
    // usbd stack on XP and later.  In any case, always use the current max
    // transfer size definition.
    //
    return USBD_DEFAULT_MAXIMUM_TRANSFER_SIZE;
}

Referenced by FxUsbInterface::FormatSelectSettingUrb(), SelectConfigDescriptor(), SelectConfigInterfaces(), SelectConfigMulti(), and SelectConfigSingle().

GetFxUrbTypeForRequest()

FX_URB_TYPE FxUsbDevice::GetFxUrbTypeForRequest

(

__in FxRequestBase *

Request

)

Definition at line 2439 of file fxusbdevice.cpp.

{
    if (m_UrbType == FxUrbTypeLegacy) {
        return FxUrbTypeLegacy;
    }
 
    if (Request->IsAllocatedFromIo()) {
        return FxUrbTypeUsbdAllocated;
    }
 
    if (IsObjectDisposedOnRemove((FxObject*) Request)) {
        return FxUrbTypeUsbdAllocated;
    }
 
    return FxUrbTypeLegacy;
}

Referenced by FxUsbPipe::FormatAbortRequest(), FormatControlRequest(), FxUsbPipe::FormatResetRequest(), FormatStringRequest(), and FxUsbPipe::FormatTransferRequest().

GetInformation()

VOID FxUsbDevice::GetInformation

(

__out PWDF_USB_DEVICE_INFORMATION

Information

)

Definition at line 485 of file fxusbdevice.cpp.

{
    Information->Traits = m_Traits;
    Information->HcdPortCapabilities = m_HcdPortCapabilities;
 
    RtlCopyMemory(&Information->UsbdVersionInformation,
                  &m_UsbdVersionInformation,
                  sizeof(m_UsbdVersionInformation));
}

GetInterfaceFromIndex()

FxUsbInterface * FxUsbDevice::GetInterfaceFromIndex

(

__in UCHAR

InterfaceIndex

)

Definition at line 2010 of file fxusbdevice.cpp.

{
    if (InterfaceIndex < m_NumInterfaces){
        return m_Interfaces[InterfaceIndex];
    }
 
    return NULL;
}

GetInterfaceFromNumber()

FxUsbInterface * FxUsbDevice::GetInterfaceFromNumber ( __in UCHAR  InterfaceNumber )

protected

Definition at line 2041 of file fxusbdevice.cpp.

{
    ULONG i;
 
    for (i = 0; i < m_NumInterfaces; i++) {
        if (m_Interfaces[i]->GetInterfaceNumber() == InterfaceNumber) {
            return m_Interfaces[i];
        }
    }
 
    return NULL;
}

Referenced by SelectConfig().

GetInterfaceNumberFromInterface()

_Must_inspect_result_ NTSTATUS FxUsbDevice::GetInterfaceNumberFromInterface ( __in WDFUSBINTERFACE  UsbInterface, __out PUCHAR  InterfaceNumber  )

protected

Definition at line 2023 of file fxusbdevice.cpp.

{
     FxUsbInterface * pUsbInterface;
 
     FxObjectHandleGetPtr(GetDriverGlobals(),
                          UsbInterface,
                          FX_TYPE_USB_INTERFACE ,
                          (PVOID*) &pUsbInterface);
 
     *InterfaceNumber = pUsbInterface->GetInterfaceNumber();
 
     return STATUS_SUCCESS;
}

Referenced by SelectConfigMulti().

GetInterfaceNumEndpoints()

UCHAR FxUsbDevice::GetInterfaceNumEndpoints

(

__in UCHAR

InterfaceNumber

)

GetInterfacePipeReferenced()

WDFUSBPIPE FxUsbDevice::GetInterfacePipeReferenced	(	__in UCHAR	InterfaceNumber,
		__in UCHAR	EndpointNumber
	)

GetNumInterfaces()

UCHAR FxUsbDevice::GetNumInterfaces ( VOID  )

inline

Definition at line 301 of file fxusbdevice.hpp.

    {
        return m_NumInterfaces;
    }

GetPortStatus()

_Must_inspect_result_ NTSTATUS FxUsbDevice::GetPortStatus ( __out PULONG  PortStatus )

protected

Definition at line 1136 of file fxusbdevice.cpp.

{
    NTSTATUS status;
 
    FxInternalIoctlOthersContext context;
    FxRequestBuffer args[FX_REQUEST_NUM_OTHER_PARAMS];
    FxSyncRequest syncRequest(GetDriverGlobals(), &context);
 
    //
    // FxSyncRequest always succeesds for KM.
    //
    status = syncRequest.Initialize();
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                            "Failed to initialize FxSyncRequest");
        return status;
    }
 
    *PortStatus = 0;
    args[0].SetBuffer(PortStatus, 0);
    args[1].SetBuffer(NULL, 0);
    args[2].SetBuffer(NULL, 0);
 
    status = FormatInternalIoctlOthersRequest(syncRequest.m_TrueRequest,
                                              IOCTL_INTERNAL_USB_GET_PORT_STATUS,
                                              args);
 
    if (NT_SUCCESS(status)) {
        WDF_REQUEST_SEND_OPTIONS options;
 
        WDF_REQUEST_SEND_OPTIONS_INIT(
            &options, WDF_REQUEST_SEND_OPTION_IGNORE_TARGET_STATE);
 
        status = SubmitSync(syncRequest.m_TrueRequest, &options);
    }
 
    return status;
}

Referenced by IsConnected(), and IsEnabled().

GetString()

_Must_inspect_result_ NTSTATUS FxUsbDevice::GetString	(	__in_ecount *NumCharacters PUSHORT	String,
		__in PUSHORT	NumCharacters,
		__in UCHAR	StringIndex,
		__in_opt USHORT	LangID,
		__in_opt WDFREQUEST	Request = NULL,
		__in_opt PWDF_REQUEST_SEND_OPTIONS	Options = NULL
	)

Definition at line 368 of file fxusbdevicekm.cpp.

{
    PUSB_STRING_DESCRIPTOR pDescriptor;
    PVOID buffer;
    _URB_CONTROL_DESCRIPTOR_REQUEST urb;
    WDF_REQUEST_SEND_OPTIONS options, *pOptions;
    USB_COMMON_DESCRIPTOR common;
    ULONG length;
    NTSTATUS status;
 
    FxSyncRequest request(GetDriverGlobals(), NULL, Request);
 
    //
    // FxSyncRequest always succeesds for KM.
    //
    status = request.Initialize();
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                            "Failed to initialize FxSyncRequest");
        return status;
    }
 
    buffer = NULL;
 
    status = request.m_TrueRequest->ValidateTarget(this);
    if (!NT_SUCCESS(status)) {
        goto Done;
    }
 
    RtlZeroMemory(&urb, sizeof(urb));
 
    if (String != NULL) {
        length = sizeof(USB_STRING_DESCRIPTOR) + (*NumCharacters - 1) * sizeof(WCHAR);
 
        buffer = FxPoolAllocate(GetDriverGlobals(),
                                NonPagedPool,
                                length);
 
        if (buffer == NULL) {
            status = STATUS_INSUFFICIENT_RESOURCES;
            goto Done;
        }
 
        RtlZeroMemory(buffer, length);
        pDescriptor = (PUSB_STRING_DESCRIPTOR) buffer;
    }
    else {
        RtlZeroMemory(&common, sizeof(common));
 
        length = sizeof(USB_COMMON_DESCRIPTOR);
        pDescriptor = (PUSB_STRING_DESCRIPTOR) &common;
    }
 
    UsbBuildGetDescriptorRequest((PURB) &urb,
                                 sizeof(_URB_CONTROL_DESCRIPTOR_REQUEST),
                                 USB_STRING_DESCRIPTOR_TYPE,
                                 StringIndex,
                                 LangID,
                                 pDescriptor,
                                 NULL,
                                 length,
                                 NULL);
 
    if (Options != NULL) {
        pOptions = Options;
    }
    else {
        WDF_REQUEST_SEND_OPTIONS_INIT(&options, 0);
        WDF_REQUEST_SEND_OPTIONS_SET_TIMEOUT(&options,
                                             WDF_REL_TIMEOUT_IN_SEC(2));
 
        pOptions = &options;
    }
#pragma prefast(suppress: __WARNING_BUFFER_OVERFLOW, "this annotation change in usb.h is communicated to usb team")
    FxFormatUsbRequest(request.m_TrueRequest, (PURB) &urb, FxUrbTypeLegacy, NULL);
    status = SubmitSync(request.m_TrueRequest, pOptions);
 
    if (NT_SUCCESS(status)) {
        USHORT numChars;
 
        //
        // Make sure we got an even number of bytes and that we got a header
        //
        if ((pDescriptor->bLength & 0x1) ||
            pDescriptor->bLength < sizeof(USB_COMMON_DESCRIPTOR)) {
            status = STATUS_DEVICE_DATA_ERROR;
        }
        else {
            //
            // bLength is the length of the entire descriptor.  Subtract off
            // the descriptor header and then divide by the size of a WCHAR.
            //
            numChars =
                (pDescriptor->bLength - sizeof(USB_COMMON_DESCRIPTOR)) / sizeof(WCHAR);
 
            if (String != NULL) {
                if (*NumCharacters >= numChars) {
                    length = numChars * sizeof(WCHAR);
                }
                else {
                    length = *NumCharacters * sizeof(WCHAR);
                    status = STATUS_BUFFER_OVERFLOW;
                }
 
                *NumCharacters = numChars;
                RtlCopyMemory(String, pDescriptor->bString, length);
            }
            else {
                *NumCharacters = numChars;
            }
        }
    }
 
    if (buffer != NULL) {
        FxPoolFree(buffer);
    }
 
Done:
 
    return status;
}

GetUrbType()

FX_URB_TYPE FxUsbDevice::GetUrbType ( VOID  )

inline

Definition at line 478 of file fxusbdevice.hpp.

    {
        return m_UrbType;
    }

Referenced by __in_xcount().

GetUSBDHandle()

USBD_HANDLE FxUsbDevice::GetUSBDHandle ( VOID  )

inline

Definition at line 470 of file fxusbdevice.hpp.

    {
        return m_USBDHandle;
    }

Referenced by __deref_opt_out_bcount(), __in_xcount(), and QueryUsbCapability().

HasMismatchedInterfacesInConfigDescriptor()

BOOLEAN FxUsbDevice::HasMismatchedInterfacesInConfigDescriptor ( VOID  )

inline

Definition at line 409 of file fxusbdevice.hpp.

    {
        return m_MismatchedInterfacesInConfigDescriptor;
    }

InitDevice()

_Must_inspect_result_ NTSTATUS FxUsbDevice::InitDevice

(

__in ULONG

USBDClientContractVersionForWdfClient

)

Definition at line 45 of file fxusbdevicekm.cpp.

{
    URB urb;
    FxSyncRequest request(GetDriverGlobals(), NULL);
    WDF_REQUEST_SEND_OPTIONS options;
    NTSTATUS status;
    ULONG size;
    ULONG paddedSize;
 
    RtlZeroMemory(&urb, sizeof(urb));
 
    if (USBDClientContractVersionForWdfClient != USBD_CLIENT_CONTRACT_VERSION_INVALID) {
 
        //
        // Register with USBDEX.lib
        //
        status = USBD_CreateHandle(m_InStackDevice,
                                   m_TargetDevice,
                                   USBDClientContractVersionForWdfClient,
                                   GetDriverGlobals()->Tag,
                                   &m_USBDHandle);
 
        if (!NT_SUCCESS(status)) {
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                "USBD_CreateHandle failed, %!STATUS!", status);
            goto Done;
        }
 
        m_UrbType = FxUrbTypeUsbdAllocated;
    }
 
    status = request.m_TrueRequest->ValidateTarget(this);
    if (!NT_SUCCESS(status)) {
        goto Done;
    }
 
    UsbBuildGetDescriptorRequest(&urb,
                                 sizeof(struct _URB_CONTROL_DESCRIPTOR_REQUEST),
                                 USB_DEVICE_DESCRIPTOR_TYPE,
                                 0,
                                 0,
                                 &m_DeviceDescriptor,
                                 NULL,
                                 sizeof(m_DeviceDescriptor),
                                 NULL);
 
    FxFormatUsbRequest(request.m_TrueRequest, &urb, FxUrbTypeLegacy, NULL);
 
    WDF_REQUEST_SEND_OPTIONS_INIT(&options, 0);
    WDF_REQUEST_SEND_OPTIONS_SET_TIMEOUT(&options, WDF_REL_TIMEOUT_IN_SEC(5));
 
    status = SubmitSync(request.m_TrueRequest, &options);
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
            "Could not retrieve device descriptor, %!STATUS!", status);
        goto Done;
    }
 
    //
    // After successfully completing any default control URB, USBD/usbport fills
    // in the PipeHandle field of the URB (it is the same offset in every URB,
    // which this CASSERT verifies.  Since USBD_DEFAULT_PIPE_TRANSFER is not
    // supported by USBD (it is by USBPORT), this is the prescribed way of getting
    // the default control pipe so that you can set the PipeHandle field in
    // _URB_CONTROL_TRANSFER.
    //
    WDFCASSERT(FIELD_OFFSET(_URB_CONTROL_TRANSFER, PipeHandle) ==
               FIELD_OFFSET(_URB_CONTROL_DESCRIPTOR_REQUEST, Reserved));
 
    m_ControlPipe = urb.UrbControlDescriptorRequest.Reserved;
 
    USB_CONFIGURATION_DESCRIPTOR config;
 
    RtlZeroMemory(&config, sizeof(config));
    size = sizeof(config);
 
    UsbBuildGetDescriptorRequest(&urb,
                                 sizeof(_URB_CONTROL_DESCRIPTOR_REQUEST),
                                 USB_CONFIGURATION_DESCRIPTOR_TYPE,
                                 0,
                                 0,
                                 &config,
                                 NULL,
                                 size,
                                 NULL);
 
    request.m_TrueRequest->GetSubmitFxIrp()->Reuse(STATUS_SUCCESS);
    request.m_TrueRequest->ClearFieldsForReuse();
    FxFormatUsbRequest(request.m_TrueRequest, &urb, FxUrbTypeLegacy, NULL);
 
    status = SubmitSync(request.m_TrueRequest, &options);
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
            "Could not retrieve config descriptor size, %!STATUS!", status);
        goto Done;
    }
    else if (urb.UrbControlDescriptorRequest.TransferBufferLength == 0) {
        //
        // Not enough info returned
        //
        status = STATUS_UNSUCCESSFUL;
 
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
            "Could not retrieve config descriptor size, zero bytes transferred, "
            " %!STATUS!", status);
 
        goto Done;
    }
    else if (config.wTotalLength < size) {
        //
        // Not enough info returned
        //
        status = STATUS_UNSUCCESSFUL;
 
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
            "Could not retrieve config descriptor size, config.wTotalLength %d < "
            "sizeof(config descriptor) (%d), %!STATUS!",
            config.wTotalLength, size, status);
 
        goto Done;
    }
 
    //
    // Allocate an additional memory at the end of the buffer so if we
    // accidentily access fields beyond the end of the buffer we don't crash
 
    //
 
 
 
 
 
    size = config.wTotalLength;
    paddedSize = size + sizeof(USB_DEVICE_DESCRIPTOR);
 
    m_ConfigDescriptor = (PUSB_CONFIGURATION_DESCRIPTOR)
        FxPoolAllocate(GetDriverGlobals(),
                       NonPagedPool,
                       paddedSize);
 
    if (m_ConfigDescriptor == NULL) {
        status = STATUS_INSUFFICIENT_RESOURCES;
 
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
            "Could not allocate %d bytes for config descriptor, %!STATUS!",
            paddedSize, status);
 
        goto Done;
    }
 
    RtlZeroMemory(m_ConfigDescriptor, paddedSize);
 
    UsbBuildGetDescriptorRequest(&urb,
                                 sizeof(_URB_CONTROL_DESCRIPTOR_REQUEST),
                                 USB_CONFIGURATION_DESCRIPTOR_TYPE,
                                 0,
                                 0,
                                 m_ConfigDescriptor,
                                 NULL,
                                 size,
                                 NULL);
 
    request.m_TrueRequest->GetSubmitFxIrp()->Reuse(STATUS_SUCCESS);
    request.m_TrueRequest->ClearFieldsForReuse();
    FxFormatUsbRequest(request.m_TrueRequest, &urb, FxUrbTypeLegacy, NULL);
 
    status = SubmitSync(request.m_TrueRequest, &options);
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
            "Could not retrieve config descriptor, %!STATUS!", status);
        goto Done;
    } else if(m_ConfigDescriptor->wTotalLength != size) {
        //
        // Invalid wTotalLength
        //
        status = STATUS_DEVICE_DATA_ERROR;
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
            "Defective USB device reported two different config descriptor "
            "wTotalLength values: %d and %d, %!STATUS!",
            size, m_ConfigDescriptor->wTotalLength, status);
        goto Done;
    }
 
    //
    // Check to see if we are wait wake capable
    //
    if (m_ConfigDescriptor->bmAttributes & USB_CONFIG_REMOTE_WAKEUP) {
        m_Traits |= WDF_USB_DEVICE_TRAIT_REMOTE_WAKE_CAPABLE;
    }
 
    //
    // Check to see if we are self or bus powered
    //
    USHORT deviceStatus;
 
    UsbBuildGetStatusRequest(&urb,
                             URB_FUNCTION_GET_STATUS_FROM_DEVICE,
                             0,
                             &deviceStatus,
                             NULL,
                             NULL);
 
    request.m_TrueRequest->GetSubmitFxIrp()->Reuse(STATUS_SUCCESS);
    request.m_TrueRequest->ClearFieldsForReuse();
    FxFormatUsbRequest(request.m_TrueRequest, &urb, FxUrbTypeLegacy, NULL);
 
    status = SubmitSync(request.m_TrueRequest, &options);
    if (NT_SUCCESS(status) && (deviceStatus & USB_GETSTATUS_SELF_POWERED)) {
        m_Traits |= WDF_USB_DEVICE_TRAIT_SELF_POWERED;
    }
 
    //
    // Revert back to success b/c we don't care if the usb device get status
    // fails
    //
    status = STATUS_SUCCESS;
 
    USB_BUS_INTERFACE_USBDI_V1 busIf;
 
    RtlZeroMemory(&busIf, sizeof(busIf));
 
    //
    // All PNP irps must have this initial status
    //
    request.m_TrueRequest->GetSubmitFxIrp()->Reuse(STATUS_NOT_SUPPORTED);
    request.m_TrueRequest->ClearFieldsForReuse();
 
    FxQueryInterface::_FormatIrp(
        request.m_TrueRequest->GetSubmitFxIrp()->GetIrp(),
        &USB_BUS_INTERFACE_USBDI_GUID,
        (PINTERFACE) &busIf,
        sizeof(busIf),
        USB_BUSIF_USBDI_VERSION_1);
 
    request.m_TrueRequest->VerifierSetFormatted();
 
    status = SubmitSync(request.m_TrueRequest);
 
    if (!NT_SUCCESS(status)) {
        //
        // Retry with the older interface
        //
        RtlZeroMemory(&busIf, sizeof(busIf));
 
        //
        // All PNP irps must have this initial status
        //
 
        request.m_TrueRequest->GetSubmitFxIrp()->Reuse(STATUS_NOT_SUPPORTED);
        request.m_TrueRequest->ClearFieldsForReuse();
 
        FxQueryInterface::_FormatIrp(
            request.m_TrueRequest->GetSubmitFxIrp()->GetIrp(),
            &USB_BUS_INTERFACE_USBDI_GUID,
            (PINTERFACE) &busIf,
            sizeof(USB_BUS_INTERFACE_USBDI_V0),
            USB_BUSIF_USBDI_VERSION_0);
 
        request.m_TrueRequest->VerifierSetFormatted();
 
        status = SubmitSync(request.m_TrueRequest);
    }
 
    if (NT_SUCCESS(status)) {
        //
        // Need to check for NULL b/c we may have only retrieved the V0 interface
        //
        if (busIf.IsDeviceHighSpeed != NULL &&
            busIf.IsDeviceHighSpeed(busIf.BusContext)) {
            m_Traits |= WDF_USB_DEVICE_TRAIT_AT_HIGH_SPEED;
        }
 
        //
        // Stash these off for later
        //
        m_QueryBusTime = busIf.QueryBusTime;
        m_BusInterfaceContext = busIf.BusContext;
        m_BusInterfaceDereference = busIf.InterfaceDereference;
 
        ASSERT(busIf.GetUSBDIVersion != NULL);
        busIf.GetUSBDIVersion(busIf.BusContext,
                              &m_UsbdVersionInformation,
                              &m_HcdPortCapabilities);
    }
    else if (status == STATUS_NOT_SUPPORTED) {
        //
        // We will only use m_ControlPipe on stacks which do not support
        // USBD_DEFAULT_PIPE_TRANSFER.  If all the QIs failed, then we know
        // definitively that we are running on USBD and we need m_ControlPipe
        // to be != NULL for later control transfers
        //
        ASSERT(m_ControlPipe != NULL);
 
        m_OnUSBD = TRUE;
 
        //
        // The QI failed with not supported, do not return error
        //
        status = STATUS_SUCCESS;
    }
    else {
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
            "Query Interface for bus returned error, %!STATUS!", status);
    }
 
Done:
 
    return status;
}

IsConnected()

_Must_inspect_result_ NTSTATUS FxUsbDevice::IsConnected

(

VOID

)

Definition at line 1207 of file fxusbdevice.cpp.

{
#if (FX_CORE_MODE == FX_CORE_USER_MODE)
 
 
 
 
    return STATUS_UNSUCCESSFUL;
#elif (FX_CORE_MODE == FX_CORE_KERNEL_MODE)
    NTSTATUS status;
    ULONG portStatus;
 
    status = GetPortStatus(&portStatus);
    if (NT_SUCCESS(status) && (portStatus & USBD_PORT_CONNECTED) == 0) {
        status = STATUS_DEVICE_DOES_NOT_EXIST;
    }
 
    return status;
#endif
}

IsEnabled()

BOOLEAN FxUsbDevice::IsEnabled

(

VOID

)

Definition at line 1180 of file fxusbdevice.cpp.

{
    NTSTATUS status;
    ULONG portStatus;
    BOOLEAN enabled;
 
    enabled = TRUE;
    status = GetPortStatus(&portStatus);
 
    //
    // Inability to get STATUS_SUCCESS from GetPortStatus is more likely a resource
    // issue rather than a device issue so return FALSE from this function only if
    // we were able to read the PortStatus and the port was disabled.
    // What you don't want is to continuosly reset the device (by returning FALSE)
    // instead of resetting pipe (by returning TRUE) under low memory conditions.
    //
    if (NT_SUCCESS(status) && (portStatus & USBD_PORT_ENABLED) == 0) {
        enabled = FALSE;
    }
 
    return enabled;
}

IsObjectDisposedOnRemove()

BOOLEAN FxUsbDevice::IsObjectDisposedOnRemove

(

__in FxObject *

Object

)

Definition at line 2361 of file fxusbdevice.cpp.

{
    FxObject * obj;
    FxObject * parent;
    BOOLEAN isObjectDisposedOnRemove = FALSE;
 
    obj = Object;
 
    //
    // By adding a reference now, we simulate what GetParentObjectReferenced
    // does later, thus allowing simple logic on when/how to release the
    // reference on exit.
    //
    obj->ADDREF(Object);
 
    while (obj != NULL) {
 
        if (obj == (FxObject*) m_Device) {
 
            isObjectDisposedOnRemove = TRUE;
            break;
        }
 
        if (FxObjectCheckType(obj, FX_TYPE_REQUEST)) {
 
            FxRequestBase* request = (FxRequestBase*) obj;
            if (request->IsAllocatedFromIo()) {
 
                isObjectDisposedOnRemove = TRUE;
                break;
            }
        }
 
        parent = obj->GetParentObjectReferenced(Object);
 
        //
        // Release the reference previously taken by the top of the function
        // or GetParentObjectReferenced in a previous pass in the loop.
        //
        obj->RELEASE(Object);
        obj = parent;
    }
 
    if (obj != NULL) {
 
        //
        // Release the reference previously taken by the top of the function
        // or GetParentObjectReferenced in a last pass in the loop.
        //
        obj->RELEASE(Object);
    }
 
    return isObjectDisposedOnRemove;
}

Referenced by CreateIsochUrb(), CreateUrb(), and GetFxUrbTypeForRequest().

OnUSBD()

BOOLEAN FxUsbDevice::OnUSBD ( VOID  )

inline

Definition at line 361 of file fxusbdevice.hpp.

    {
        return m_OnUSBD;
    }

PipesGotoRemoveState()

VOID FxUsbDevice::PipesGotoRemoveState ( __in BOOLEAN  ForceRemovePipes )

protected

Definition at line 817 of file fxusbdevice.cpp.

{
    SINGLE_LIST_ENTRY sentHead;
    LIST_ENTRY pendHead, interfaceHead;
    FxUsbInterface* pUsbInterface;
    ULONG iPipe, intfIndex;
    KIRQL irql;
 
    sentHead.Next = NULL;
    InitializeListHead(&pendHead);
    InitializeListHead(&interfaceHead);
 
    AcquireInterfaceIterationLock();
 
    Lock(&irql);
    for (intfIndex = 0; intfIndex < m_NumInterfaces;  intfIndex++  ) {
        pUsbInterface = m_Interfaces[intfIndex];
 
        if (pUsbInterface->m_ConfiguredPipes != NULL) {
            for (iPipe = 0;
                 iPipe < pUsbInterface->m_NumberOfConfiguredPipes;
                 iPipe++) {
                BOOLEAN wait;
 
                wait = FALSE;
 
                //
                // Pipe can be NULL if the interface is half initialized
                //
                if (pUsbInterface->m_ConfiguredPipes[iPipe] != NULL) {
                    pUsbInterface->m_ConfiguredPipes[iPipe]->GotoRemoveState(
                        WdfIoTargetDeleted,
                        &pendHead,
                        &sentHead,
                        TRUE,
                        &wait);
 
                }
            }
        }
    }
    Unlock(irql);
 
    //
    // We cleanup requests no matter what the new state is because we complete all
    // pended requests in the surprise removed case.
    //
    _CleanupPipesRequests(&pendHead, &sentHead);
 
    //
    // Only destroy child pipe objects when the parent is going away or the
    // caller indicates that this is the desired action.
    //
    if (m_State == WdfIoTargetDeleted || ForceRemovePipes) {
        for (intfIndex = 0; intfIndex < m_NumInterfaces;  intfIndex++) {
            pUsbInterface = m_Interfaces[intfIndex];
 
            if (pUsbInterface->m_ConfiguredPipes != NULL) {
                //
                // Iterate over the pipes and clean each one up
                //
                for (iPipe = 0;
                     iPipe < pUsbInterface->m_NumberOfConfiguredPipes;
                     iPipe++) {
                    //
                    // Same reason as above
                    //
                    if (pUsbInterface->m_ConfiguredPipes[iPipe] != NULL) {
                        pUsbInterface->m_ConfiguredPipes[iPipe]->
                            WaitForSentIoToComplete();
                    }
                }
            }
 
            pUsbInterface->CleanUpAndDelete(FALSE);
        }
    }
 
    ReleaseInterfaceIterationLock();
}

Referenced by Deconfig().

Purge()

VOID FxUsbDevice::Purge ( __in WDF_IO_TARGET_PURGE_IO_ACTION  Action )

protectedvirtual

Reimplemented from FxIoTarget.

Definition at line 698 of file fxusbdevice.cpp.

{
    FxUsbInterface      *pUsbInterface;
    SINGLE_LIST_ENTRY   sentHead;
    ULONG               iPipe, iInterface;
    KIRQL               irql;
 
    sentHead.Next = NULL;
 
    //
    // Purge all of our own I/O first
    //
    FxIoTarget::Purge(Action);
 
    //
    // if we are just canceling i/o, then we just acquire the spin lock b/c
    // we can be called at dispatch level for this action code.
    //
    if (Action != WdfIoTargetPurgeIo) {
        ASSERT(Mx::MxGetCurrentIrql() == PASSIVE_LEVEL);
 
        AcquireInterfaceIterationLock();
    }
 
    //
    // Since we don't have to synchronize on the I/O already sent, just set
    // each pipe's state to purged.
    //
    Lock(&irql);
 
    for (iInterface = 0; iInterface < m_NumInterfaces; iInterface++) {
        pUsbInterface = m_Interfaces[iInterface];
 
        if (pUsbInterface->m_ConfiguredPipes != NULL) {
            for (iPipe = 0;
                 iPipe < pUsbInterface->m_NumberOfConfiguredPipes;
                 iPipe++) {
 
                if (pUsbInterface->m_ConfiguredPipes[iPipe] != NULL) {
                    BOOLEAN wait;
                    LIST_ENTRY pendedHead;
 
                    wait = FALSE;
                    InitializeListHead(&pendedHead);
 
                    pUsbInterface->m_ConfiguredPipes[iPipe]->GotoPurgeState(
                        Action,
                        &pendedHead,
                        &sentHead,
                        &wait,
                        TRUE
                        );
 
                    //
                    // Complete any requests pulled off from this pipe.
                    //
                    pUsbInterface->m_ConfiguredPipes[iPipe]->
                        CompletePendedRequestList(&pendedHead);
                }
            }
        }
    }
    Unlock(irql);
 
    //
    // Cancel all sent requests.
    //
    _CancelSentRequests(&sentHead);
 
    for (iInterface = 0; iInterface < m_NumInterfaces;  iInterface++) {
        pUsbInterface = m_Interfaces[iInterface];
 
        if (pUsbInterface->m_ConfiguredPipes != NULL) {
            //
            // Iterate over the pipes and clean each one up
            //
            for (iPipe = 0;
                 iPipe < pUsbInterface->m_NumberOfConfiguredPipes;
                 iPipe++) {
                //
                // Same reason as above
                //
                if (pUsbInterface->m_ConfiguredPipes[iPipe] != NULL) {
                    pUsbInterface->m_ConfiguredPipes[iPipe]->
                        WaitForSentIoToComplete();
                }
            }
        }
    }
 
    if (Action != WdfIoTargetPurgeIo) {
        ReleaseInterfaceIterationLock();
    }
}

QueryUsbCapability()

_Must_inspect_result_ NTSTATUS FxUsbDevice::QueryUsbCapability	(	__in CONST GUID *	CapabilityType,
		__in ULONG	CapabilityBufferLength,
		__drv_when(CapabilityBufferLength==0, __out_opt) __drv_when(CapabilityBufferLength !=0 &&ResultLength==NULL, __out_bcount(CapabilityBufferLength)) __drv_when(CapabilityBufferLength !=0 &&ResultLength !=NULL, __out_bcount_part_opt(CapabilityBufferLength, *ResultLength)) PVOID	CapabilityBuffer,
		__out_opt __drv_when(ResultLength !=NULL, __deref_out_range(<=, CapabilityBufferLength)) PULONG	ResultLength
	)

Definition at line 758 of file fxusbdevicekm.cpp.

{
    NTSTATUS status;
 
    if (ResultLength != NULL) {
        *ResultLength = 0;
    }
 
    if (GetUSBDHandle() == NULL) {
        status = STATUS_INVALID_DEVICE_STATE;
 
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
            "WDFUSBDEVICE must have been created using WdfUsbTargetDeviceCreateWithParameters, %!STATUS!",
            status);
 
        return status;
    }
 
    status = USBD_QueryUsbCapability(m_USBDHandle,
                                     CapabilityType,
                                     CapabilityBufferLength,
                                     (PUCHAR) CapabilityBuffer,
                                     ResultLength);
 
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
            "Could not retrieve capability %!GUID!, %!STATUS!",
            CapabilityType, status);
        goto exit;
    }
 
exit:
    return status;
}

RemoveDeletedInterface()

VOID FxUsbDevice::RemoveDeletedInterface ( __in FxUsbInterface *  Interface )

protected

Definition at line 466 of file fxusbdevice.cpp.

{
    UCHAR i;
 
    if (m_Interfaces == NULL) {
        return;
    }
 
    for (i = 0; i < m_NumInterfaces; i++) {
        if (m_Interfaces[i] == Interface) {
            m_Interfaces[i] = NULL;
            return;
        }
    }
}

Referenced by FxUsbInterface::~FxUsbInterface().

Reset()

_Must_inspect_result_ NTSTATUS FxUsbDevice::Reset

(

VOID

)

Definition at line 1078 of file fxusbdevicekm.cpp.

{
    FxIoContext context;
    FxSyncRequest request(GetDriverGlobals(), &context);
    FxRequestBuffer emptyBuffer;
    NTSTATUS status;
 
    //
    // FxSyncRequest always succeesds for KM.
    //
    status = request.Initialize();
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                            "Failed to initialize FxSyncRequest");
        return status;
    }
 
    status = FormatIoctlRequest(request.m_TrueRequest,
                                IOCTL_INTERNAL_USB_RESET_PORT,
                                TRUE,
                                &emptyBuffer,
                                &emptyBuffer);
    if (NT_SUCCESS(status)) {
        CancelSentIo();
        status = SubmitSyncRequestIgnoreTargetState(request.m_TrueRequest, NULL);
    }
 
    return status;
}

SelectConfig()

_Must_inspect_result_ NTSTATUS FxUsbDevice::SelectConfig	(	__in PWDF_OBJECT_ATTRIBUTES	PipesAttributes,
		__in PURB	Urb,
		__in FX_URB_TYPE	FxUrbType,
		__out_opt PUCHAR	NumConfiguredInterfaces
	)

Definition at line 1429 of file fxusbdevice.cpp.

{
    WDF_REQUEST_SEND_OPTIONS options;
    PUCHAR pCur, pEnd;
    PUSBD_INTERFACE_INFORMATION pIface;
    FxUsbPipe* pPipe;
    PURB pSelectUrb;
    NTSTATUS status;
    ULONG iPipe;
    USHORT maxNumPipes, size;
    UCHAR numPipes;
    FxInterfacePipeInformation* pPipeInfo;
    PFX_DRIVER_GLOBALS pFxDriverGlobals;
    FxUsbInterface * pUsbInterface ;
    UCHAR intfIndex;
    FxIrp* irp;
 
    pFxDriverGlobals = GetDriverGlobals();
    FxSyncRequest request(GetDriverGlobals(), NULL);
 
    pIface = NULL;
    maxNumPipes = 0;
    size = 0;
    pPipeInfo = NULL;
    pSelectUrb = NULL;
 
    //
    // Callers to this function have guaranteed that there are interfaces
    // reported on this device.
    //
    ASSERT(m_NumInterfaces != 0);
 
    if (NumConfiguredInterfaces != NULL) {
        *NumConfiguredInterfaces = 0;
    }
 
    //
    // 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");
        goto Done;
    }
 
    //
    // Allocate a PIRP for the select config and possible select interface(s)
    //
    status = request.m_TrueRequest->ValidateTarget(this);
    if (!NT_SUCCESS(status)) {
        goto Done;
    }
 
    //
    // Allocate a pool for storing the FxUsbPipe ** before we
    // assign them to the Interfaces just in case all doesn't go well.
    //
    if (m_NumInterfaces == 0) {
        //
        // Use one in the zero case to make the logic simpler
        //
        size = sizeof(FxInterfacePipeInformation);
    }
    else {
        size = m_NumInterfaces * sizeof(FxInterfacePipeInformation);
    }
 
    pPipeInfo = (FxInterfacePipeInformation*) FxPoolAllocate(
        pFxDriverGlobals, NonPagedPool, size
        );
 
    if (pPipeInfo == NULL) {
        status = STATUS_INSUFFICIENT_RESOURCES;
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
            "Could not internal allocate tracking info for selecting a config on "
            "WDFUSBDEVICE 0x%p, %!STATUS!", GetHandle(), status);
        goto Done;
    }
 
    RtlZeroMemory(pPipeInfo, size);
 
    //
    // The following code and the one in select setting have a lot in common
    // but can't leverage on that as that sends the select interface URB down
    // Our goal is allocate the resources -- the pipes and the select setting URB
    // before sending down the select config URB so that the tear down is simpler.
    //
 
    //
    // Each FxUsbInterface will need a FxUsbPipe* for each pipe contained in
    // the interface.
    //
    pCur = (PUCHAR) &Urb->UrbSelectConfiguration.Interface;
    pEnd = ((PUCHAR) Urb) + Urb->UrbSelectConfiguration.Hdr.Length;
    intfIndex = 0;
 
    for ( ; pCur < pEnd; pCur += pIface->Length, intfIndex++) {
        FxUsbPipe** ppPipes;
 
        pIface = (PUSBD_INTERFACE_INFORMATION) pCur;
        if (pIface->NumberOfPipes > UCHAR_MAX) {
            status = STATUS_INVALID_DEVICE_REQUEST;
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                "WDFUSBDEVICE supports a maximum of %d pipes per interface, "
                "USBD_INTERFACE_INFORMATION %p specified %d, %!STATUS!",
                UCHAR_MAX, pIface, pIface->NumberOfPipes, status);
            goto Done;
        }
 
        pUsbInterface = GetInterfaceFromNumber(pIface->InterfaceNumber);
        if (pUsbInterface == NULL) {
            status = STATUS_INVALID_DEVICE_REQUEST;
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                "Could not find an instance of an interface descriptor with "
                "InterfaceNumber %d, %!STATUS!",
                pIface->InterfaceNumber, status);
            goto Done;
        }
 
        numPipes = (UCHAR) pIface->NumberOfPipes;
 
        //
        // Track the maximum number of pipes we have seen in an interface in
        // case we need to allocate a select interface URB.
        //
        if (numPipes > maxNumPipes) {
            maxNumPipes = (USHORT) numPipes;
        }
 
        if (numPipes > 0) {
            size = numPipes * sizeof(FxUsbPipe *);
        }
        else {
            //
            // It is valid to have an interface with zero pipes in it.  In that
            // case, we just allocate one entry so that we have a valid array
            // and keep the remaining code simple.
            //
            size = sizeof(FxUsbPipe*);
        }
 
        ppPipes = (FxUsbPipe**) FxPoolAllocate(
            pFxDriverGlobals,
            NonPagedPool,
            size
            );
 
        if (ppPipes == NULL) {
            status = STATUS_INSUFFICIENT_RESOURCES;
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                "Could not allocate memory for Pipes "
                "InterfaceNumber %d, %!STATUS!",
                pIface->InterfaceNumber, status);
            goto Done;
        }
 
        RtlZeroMemory(ppPipes, size);
 
        //
        // We store the pointer to the newly allocated arary in a temporary b/c
        // we can still fail and we don't want a half baked interface.
        //
 
        pPipeInfo[intfIndex].Pipes = ppPipes;
        pPipeInfo[intfIndex].NumPipes = numPipes;
 
        for (iPipe = 0; iPipe < numPipes; iPipe++) {
            ppPipes[iPipe] = new (GetDriverGlobals(), PipesAttributes)
                FxUsbPipe(GetDriverGlobals(),this);
 
            if (ppPipes[iPipe] == NULL) {
                status = STATUS_INSUFFICIENT_RESOURCES;
                DoTraceLevelMessage(
                    GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                    "Could not allocate a pipe object, %!STATUS!", status);
                goto Done;
            }
 
            pPipe = ppPipes[iPipe];
            status = pPipe->Init(m_Device);
            if (!NT_SUCCESS(status)) {
                DoTraceLevelMessage(
                    GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                    "Could not Init the pipe object, %!STATUS!", status);
                goto Done;
            }
 
            status = pPipe->Commit(PipesAttributes, NULL, pUsbInterface);
            if (!NT_SUCCESS(status)) {
                DoTraceLevelMessage(
                    GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                    "Could not commit the pipe object, %!STATUS!", status);
                goto Done;
            }
        }
 
 
 
 
 
 
 
 
 
        if (pUsbInterface->IsInterfaceConfigured()) {
            CleanupInterfacePipesAndDelete(pUsbInterface);
        }
    }
 
    //
    // If we are selecting more then one interface and at least one of them
    // has pipes in them, allocate a select interface URB that will be used
    // after the select config to select each interface.  The select interface
    // URB will be big enough to select the largest interface in the group.
    //
    // The select interface URB is allocated before the select config so that
    // we know once the select config has completed successfully, we can be
    // guaranteed that we can select the interfaces we want and not have to
    // handle undoing the select config upon URB allocation failure.
    //
    if (m_NumInterfaces > 1 && maxNumPipes > 0) {
        size = GET_SELECT_INTERFACE_REQUEST_SIZE(maxNumPipes);
 
        pSelectUrb = (PURB) FxPoolAllocate(GetDriverGlobals(),
                                           NonPagedPool,
                                           size
                                           );
 
        if (pSelectUrb == NULL) {
            status = STATUS_INSUFFICIENT_RESOURCES;
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                "Could not allocate a select interface URB, %!STATUS!", status);
            goto Done;
        }
 
        RtlZeroMemory(pSelectUrb, size);
    }
 
    //
    // Send the select config to the usb core
    //
    WDF_REQUEST_SEND_OPTIONS_INIT(&options,
                                  WDF_REQUEST_SEND_OPTION_IGNORE_TARGET_STATE);
    WDF_REQUEST_SEND_OPTIONS_SET_TIMEOUT(&options, WDF_REL_TIMEOUT_IN_SEC(2));
 
    FxFormatUsbRequest(request.m_TrueRequest, Urb, FxUrbType, m_USBDHandle);
    status = SubmitSync(request.m_TrueRequest, &options);
 
    if (NT_SUCCESS(status)) {
        //
        // Save the config handle and store off all the pipes
        //
        m_ConfigHandle = Urb->UrbSelectConfiguration.ConfigurationHandle;
 
        //
        // Initialize the first interface
        //
        pIface = &Urb->UrbSelectConfiguration.Interface;
 
        pUsbInterface = GetInterfaceFromNumber(pIface->InterfaceNumber);
        pUsbInterface->SetNumConfiguredPipes((UCHAR)pIface->NumberOfPipes);
 
        //
        // The interface now owns the array of pipes
        //
        pUsbInterface->SetConfiguredPipes(pPipeInfo[0].Pipes);
        pPipeInfo[0].Pipes = NULL;
        pPipeInfo[0].NumPipes = 0;
 
        pUsbInterface->SetInfo(pIface);
 
        //
        // Since this could be the only interface, set the index now, so if we
        // return the number of configured interfaces, it will be valid for the
        // single interface case.
        //
        intfIndex = 1;
 
        //
        // If we have a more then one interface, we must select each of the addtional
        // interfaces after the select config because usbccgp (the generic parent
        // driver) didn't fill out all of the pipe info for IAD (interface
        // association descriptor) devices.  The first interface is filled out
        // property, it is 2->N that are left blank.
        //
        // pSelectUrb can be equal to NULL and have more then one interface if
        // all interfaces have no pipes associated with them.  In that case, we
        // still want to iterate over the remaining pipes so that we can
        // initialize our structures properly.
        //
        if (m_NumInterfaces > 1) {
            //
            // Loop over the interfaces again.
            //
            pCur = (PUCHAR) &Urb->UrbSelectConfiguration.Interface;
            pIface = (PUSBD_INTERFACE_INFORMATION) pCur;
            pEnd = ((PUCHAR) Urb) + Urb->UrbSelectConfiguration.Hdr.Length;
 
            //
            // Start at the 2nd one since the first is already selected
            //
            pCur += pIface->Length;
 
            for ( ; pCur < pEnd; pCur += pIface->Length, intfIndex++) {
#pragma prefast(suppress: __WARNING_UNUSED_POINTER_ASSIGNMENT, "pIface is used in the for loop in many places. It looks like a false positive")
                pIface = (PUSBD_INTERFACE_INFORMATION) pCur;
                ASSERT(pIface->NumberOfPipes <= maxNumPipes);
 
                pUsbInterface = GetInterfaceFromNumber(pIface->InterfaceNumber);
                ASSERT(pUsbInterface != NULL);
 
                //
                // Valid to have an interface with no pipes.  If there are no
                // pipes, GET_SELECT_INTERFACE_REQUEST_SIZE will compute value
                // too small of a size to pass validation.
                //
                if (pIface->NumberOfPipes > 0) {
 
                    pUsbInterface->FormatSelectSettingUrb(
                        pSelectUrb,
                        (USHORT) pIface->NumberOfPipes,
                        pIface->AlternateSetting
                        );
                    irp = request.m_TrueRequest->GetSubmitFxIrp();
                    irp->Reuse(STATUS_SUCCESS);
 
                    request.m_TrueRequest->ClearFieldsForReuse();
                    FxFormatUsbRequest(request.m_TrueRequest,
                                       pSelectUrb,
                                       FxUrbTypeLegacy,
                                       NULL);
 
                    status = SubmitSync(request.m_TrueRequest, &options);
                    if (!NT_SUCCESS(status)) {
                        DoTraceLevelMessage(
                            GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                            "USB core failed Select Interface URB, %!STATUS!",
                            status);
                        goto Done;
                    }
 
                    //
                    // Copy the info back into the original select config URB
                    //
 
                    RtlCopyMemory(pIface,
                                  &pSelectUrb->UrbSelectInterface.Interface,
                                  pSelectUrb->UrbSelectInterface.Interface.Length);
                }
 
                //
                // Update the pointer to point to the new pipes with the pointer
                // to the pipes stored earlier.
                //
                ASSERT(pPipeInfo[intfIndex].NumPipes == pIface->NumberOfPipes);
                pUsbInterface->SetNumConfiguredPipes((UCHAR)pIface->NumberOfPipes);
 
                //
                // The interface now owns the array of pipes
                //
                pUsbInterface->SetConfiguredPipes(pPipeInfo[intfIndex].Pipes);
                pPipeInfo[intfIndex].Pipes = NULL;
                pPipeInfo[intfIndex].NumPipes = 0;
 
                //
                // SetInfo only after a successful select config so that we can
                // copy the USBD_PIPE_INFORMATION .
                //
                pUsbInterface->SetInfo(pIface);
            }
        }
 
        if (NumConfiguredInterfaces != NULL) {
            *NumConfiguredInterfaces = intfIndex;
        }
    }
    else {
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
            "USB core failed Select Configuration, %!STATUS!", status);
    }
 
Done:
    if (pSelectUrb != NULL) {
        FxPoolFree(pSelectUrb);
        pSelectUrb = NULL;
    }
 
    if (pPipeInfo != NULL) {
        //
        // Free all arrays that may have been allocated
        //
        for (intfIndex = 0; intfIndex < m_NumInterfaces; intfIndex++) {
            //
            // We can have NumPipes == 0 and still have an allocated array, so
            // use the array != NULL as the check.
            //
            if (pPipeInfo[intfIndex].Pipes != NULL) {
                //
                // Delete any pipes that might have been created
                //
                for (iPipe = 0;  iPipe < pPipeInfo[intfIndex].NumPipes; iPipe++) {
                    if (pPipeInfo[intfIndex].Pipes[iPipe] != NULL) {
                        pPipeInfo[intfIndex].Pipes[iPipe]->DeleteFromFailedCreate();
                        pPipeInfo[intfIndex].Pipes[iPipe] = NULL;
                    }
                }
 
                //
                // Now free the array itself and clear out the count
                //
                FxPoolFree(pPipeInfo[intfIndex].Pipes);
                pPipeInfo[intfIndex].Pipes = NULL;
                pPipeInfo[intfIndex].NumPipes = 0;
            }
        }
 
        FxPoolFree(pPipeInfo);
        pPipeInfo = NULL;
    }
 
    return status;
}

Referenced by SelectConfigDescriptor(), SelectConfigInterfaces(), SelectConfigMulti(), and SelectConfigSingle().

SelectConfigAuto()

_Must_inspect_result_ NTSTATUS FxUsbDevice::SelectConfigAuto

(

__in PWDF_OBJECT_ATTRIBUTES

PipeAttributes

)

SelectConfigDescriptor()

_Must_inspect_result_ NTSTATUS FxUsbDevice::SelectConfigDescriptor	(	__in PWDF_OBJECT_ATTRIBUTES	PipeAttributes,
		__in PWDF_USB_DEVICE_SELECT_CONFIG_PARAMS	Params
	)

Definition at line 1322 of file fxusbdevice.cpp.

{
    PUSBD_INTERFACE_LIST_ENTRY pInterfaces;
    PURB urb;
    NTSTATUS status;
    ULONG i, size;
    PUSB_CONFIGURATION_DESCRIPTOR configurationDescriptor;
    PUSB_INTERFACE_DESCRIPTOR* interfaceDescriptors;
    ULONG numInterfaces;
    PFX_DRIVER_GLOBALS  pFxDriverGlobals;
 
    pFxDriverGlobals = GetDriverGlobals();
 
    configurationDescriptor = Params->Types.Descriptor.ConfigurationDescriptor;
    interfaceDescriptors = Params->Types.Descriptor.InterfaceDescriptors;
    numInterfaces = Params->Types.Descriptor.NumInterfaceDescriptors;
 
    for (i = 0; i < numInterfaces; i++) {
        if (interfaceDescriptors[i] == NULL) {
            return STATUS_INVALID_PARAMETER;
        }
    }
 
    //
    // eventually size = sizeof(USBD_INTERFACE_LIST_ENTRY) * (numInterfaces + 1)
    //
    status = RtlULongAdd(numInterfaces, 1, &size);
    if (!NT_SUCCESS(status)) {
        return status;
    }
 
    status = RtlULongMult(size, sizeof(USBD_INTERFACE_LIST_ENTRY), &size);
    if (!NT_SUCCESS(status)) {
        return status;
    }
 
    pInterfaces = (PUSBD_INTERFACE_LIST_ENTRY) FxPoolAllocate(
        pFxDriverGlobals, NonPagedPool, size);
 
    if (pInterfaces == NULL) {
        status = STATUS_INSUFFICIENT_RESOURCES;
 
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
            "Could not allocate array of USBD_INTERFACE_LIST_ENTRY, %!STATUS!",
            status);
 
        return status;
    }
 
    RtlZeroMemory(pInterfaces, size);
 
    for (i = 0; i < numInterfaces; i++) {
        pInterfaces[i].InterfaceDescriptor = interfaceDescriptors[i];
    }
 
    if (configurationDescriptor == NULL) {
        configurationDescriptor = m_ConfigDescriptor;
    }
 
    //
    // NOTE:
    //
    // Creating a config request using the caller's config descriptor does not
    // currently work if the provided config descriptor is not the same as the
    // descriptor reported by the device.   It does not work because we try to
    // validate the interface number in the URB against an existing
    // FxUsbInterface (which is based on the config descriptor described by the
    // device, not the provided one), and if that validation fails, we return
    // !NT_SUCCESS from SelectConfig().
    //
    urb = FxUsbCreateConfigRequest(GetDriverGlobals(),
                                   configurationDescriptor,
                                   pInterfaces,
                                   GetDefaultMaxTransferSize());
    if (urb == NULL) {
        status = STATUS_INSUFFICIENT_RESOURCES;
    }
    else {
        status = SelectConfig(PipesAttributes, urb, FxUrbTypeLegacy, NULL);
        FxPoolFree(urb);
        urb = NULL;
    }
 
    FxPoolFree(pInterfaces);
    pInterfaces = NULL;
 
    return status;
}

SelectConfigInterfaces()

_Must_inspect_result_ NTSTATUS FxUsbDevice::SelectConfigInterfaces	(	__in PWDF_OBJECT_ATTRIBUTES	PipesAttributes,
		__in PUSB_CONFIGURATION_DESCRIPTOR	ConfigurationDescriptor,
		__in_ecount(NumInterfaces) PUSB_INTERFACE_DESCRIPTOR *	InterfaceDescriptors,
		__in ULONG	NumInterfaces
	)

Definition at line 1929 of file fxusbdevice.cpp.

{
    PUSBD_INTERFACE_LIST_ENTRY pInterfaces;
    PURB urb;
    NTSTATUS status;
    ULONG i, size;
    PFX_DRIVER_GLOBALS  pFxDriverGlobals;
 
    pFxDriverGlobals = GetDriverGlobals();
 
    //
    // eventually size = sizeof(USBD_INTERFACE_LIST_ENTRY) * (NumInterfaces + 1)
    //
    status = RtlULongAdd(NumInterfaces, 1, &size);
    if (!NT_SUCCESS(status)) {
        return status;
    }
 
    status = RtlULongMult(size, sizeof(USBD_INTERFACE_LIST_ENTRY), &size);
    if (!NT_SUCCESS(status)) {
        return status;
    }
 
    for (i = 0; i < NumInterfaces; i++) {
        if (InterfaceDescriptors[i] == NULL) {
            return STATUS_INVALID_PARAMETER;
        }
    }
 
    pInterfaces = (PUSBD_INTERFACE_LIST_ENTRY) FxPoolAllocate(
        pFxDriverGlobals,
        NonPagedPool,
        size
        );
 
    if (pInterfaces == NULL) {
        status = STATUS_INSUFFICIENT_RESOURCES;
 
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
            "Could not allocate array of USBD_INTERFACE_LIST_ENTRY, %!STATUS!",
            status);
 
        return status;
    }
 
    RtlZeroMemory(pInterfaces, size);
 
    for (i = 0; i < NumInterfaces; i++) {
        pInterfaces[i].InterfaceDescriptor = InterfaceDescriptors[i];
    }
 
    if (ConfigurationDescriptor == NULL) {
        ConfigurationDescriptor = m_ConfigDescriptor;
    }
 
    urb = FxUsbCreateConfigRequest(GetDriverGlobals(),
                                   ConfigurationDescriptor,
                                   pInterfaces,
                                   GetDefaultMaxTransferSize());
    if (urb == NULL) {
        status = STATUS_INSUFFICIENT_RESOURCES;
    }
    else {
        status = SelectConfig(PipesAttributes, urb, FxUrbTypeLegacy, NULL);
        FxPoolFree(urb);
        urb = NULL;
    }
 
    FxPoolFree(pInterfaces);
    pInterfaces = NULL;
 
    return status;
}

SelectConfigMulti()

_Must_inspect_result_ NTSTATUS FxUsbDevice::SelectConfigMulti	(	__in PWDF_OBJECT_ATTRIBUTES	PipeAttributes,
		__in PWDF_USB_DEVICE_SELECT_CONFIG_PARAMS	Params
	)

Definition at line 901 of file fxusbdevicekm.cpp.

{
    PUSBD_INTERFACE_LIST_ENTRY pList;
    PURB urb;
    NTSTATUS status;
    ULONG size;
    UCHAR i;
    PFX_DRIVER_GLOBALS pFxDriverGlobals;
 
    pFxDriverGlobals = GetDriverGlobals();
 
    Params->Types.MultiInterface.NumberOfConfiguredInterfaces = 0;
 
    //
    // The array needs an extra element which is zero'd out to mark the end
    //
    size = sizeof(USBD_INTERFACE_LIST_ENTRY) * (m_NumInterfaces + 1);
    pList = (PUSBD_INTERFACE_LIST_ENTRY) FxPoolAllocate(
        pFxDriverGlobals,
        NonPagedPool,
        size
        );
 
    if (pList == NULL) {
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    RtlZeroMemory(pList, size);
 
    if (Params->Type == WdfUsbTargetDeviceSelectConfigTypeMultiInterface) {
        for (i = 0; i < m_NumInterfaces; i++) {
            pList[i].InterfaceDescriptor =
                m_Interfaces[i]->GetSettingDescriptor(0);
 
            if (pList[i].InterfaceDescriptor == NULL) {
                DoTraceLevelMessage(
                    GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                    "WDFUSBDEVICE %p could not retrieve AlternateSetting 0 for "
                    "bInterfaceNumber %d", GetHandle(),
                    m_Interfaces[i]->m_InterfaceNumber);
 
                status = STATUS_INVALID_PARAMETER;
                goto Done;
            }
        }
    }
    else {
        //
        // Type is WdfUsbTargetDeviceSelectConfigTypeInterfacesPairs
        //
        UCHAR interfacePairsNum = 0;
        UCHAR bitArray[UCHAR_MAX/sizeof(UCHAR)];
 
        //
        // initialize the bit array
        //
        RtlZeroMemory(bitArray, sizeof(bitArray));
        //
        // Build a list of descriptors from the Setting pairs
        // passed in by the user. There could be interfaces not
        // covered in the setting/interface pairs array passed.
        // If that is the case return STATUS_INVALID_PARAMETER
        //
        for (i = 0; i < Params->Types.MultiInterface.NumberInterfaces ; i++) {
            PWDF_USB_INTERFACE_SETTING_PAIR settingPair;
            UCHAR interfaceNumber;
            UCHAR altSettingIndex;
 
            settingPair = &Params->Types.MultiInterface.Pairs[i];
 
            status = GetInterfaceNumberFromInterface(
                settingPair->UsbInterface,
                &interfaceNumber
                );
 
            //
            //convert the interface handle to interface number
            //
            if (NT_SUCCESS(status)) {
                altSettingIndex = settingPair->SettingIndex;
 
                //
                // do the following only if the bit is not already set
                //
                if (FxBitArraySet(&bitArray[0], interfaceNumber) == FALSE) {
                    pList[interfacePairsNum].InterfaceDescriptor =
                         FxUsbParseConfigurationDescriptor(
                             m_ConfigDescriptor,
                             interfaceNumber,
                             altSettingIndex
                             );
 
                    if (pList[interfacePairsNum].InterfaceDescriptor == NULL) {
                        status = STATUS_INVALID_PARAMETER;
                        DoTraceLevelMessage(
                            GetDriverGlobals(), TRACE_LEVEL_ERROR,
                            TRACINGIOTARGET,
                            "WDFUSBDEVICE %p could not retrieve "
                            "AlternateSetting %d for "
                            "bInterfaceNumber %d, returning %!STATUS!",
                            GetHandle(),
                            altSettingIndex, interfaceNumber, status);
                        goto Done;
                    }
 
                    interfacePairsNum++;
                }
            }
            else {
                goto Done;
            }
        }
 
        //
        // Check if there are any interfaces not specified by the array. If
        // there are, then select setting 0 for them.
        //
        if (m_NumInterfaces > interfacePairsNum) {
            status = STATUS_INVALID_PARAMETER;
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                "WDFUSBDEVICE %p interface pairs set (%d) is not equal to actual "
                "# of interfaces (%d) reported by the device, %!STATUS!",
                GetObjectHandle(), interfacePairsNum, m_NumInterfaces, status);
            goto Done;
        }
    } //WdfUsbTargetDeviceSelectConfigTypeInterfacesPairs
 
    urb = FxUsbCreateConfigRequest(
        GetDriverGlobals(),
        m_ConfigDescriptor,
        pList,
        GetDefaultMaxTransferSize()
        );
 
    if (urb == NULL) {
        status = STATUS_INSUFFICIENT_RESOURCES;
    }
    else {
        status = SelectConfig(
            PipesAttributes,
            urb,
            FxUrbTypeLegacy,
            &Params->Types.MultiInterface.NumberOfConfiguredInterfaces);
 
        FxPoolFree(urb);
        urb = NULL;
    }
 
Done:
    FxPoolFree(pList);
    pList = NULL;
 
    return status;
}

SelectConfigSingle()

_Must_inspect_result_ NTSTATUS FxUsbDevice::SelectConfigSingle	(	__in PWDF_OBJECT_ATTRIBUTES	PipeAttributes,
		__in PWDF_USB_DEVICE_SELECT_CONFIG_PARAMS	Params
	)

Definition at line 809 of file fxusbdevicekm.cpp.

{
    //
    // The array needs an extra element which is zero'd out to mark the end
    //
    USBD_INTERFACE_LIST_ENTRY listEntry[2];
    PURB urb;
    NTSTATUS status;
 
    RtlZeroMemory(&Params->Types.SingleInterface,
                  sizeof(Params->Types.SingleInterface));
 
    if (m_NumInterfaces > 1) {
        status = STATUS_INVALID_PARAMETER;
 
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
            "WDFUSBDEVICE %p cannot be auto configured for a single interface "
            "since there are %d interfaces on the device, %!STATUS!",
            GetHandle(), m_NumInterfaces, status);
 
        return status;
    }
 
    RtlZeroMemory(&listEntry[0], sizeof(listEntry));
 
    //
    // Use AlternateSetting 0 by default
    //
    listEntry[0].InterfaceDescriptor = m_Interfaces[0]->GetSettingDescriptor(0);
 
    if (listEntry[0].InterfaceDescriptor == NULL) {
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
            "WDFUSBDEVICE %p could not retrieve AlternateSetting 0 for "
            "bInterfaceNumber %d", GetHandle(),
            m_Interfaces[0]->m_InterfaceNumber);
 
        return STATUS_INVALID_PARAMETER;
    }
 
    urb = FxUsbCreateConfigRequest(GetDriverGlobals(),
                                   m_ConfigDescriptor,
                                   &listEntry[0],
                                   GetDefaultMaxTransferSize());
 
    if (urb == NULL) {
        status = STATUS_INSUFFICIENT_RESOURCES;
    }
    else {
        status = SelectConfig(PipeAttributes, urb, FxUrbTypeLegacy, NULL);
 
        if (NT_SUCCESS(status)) {
            Params->Types.SingleInterface.NumberConfiguredPipes  =
                 m_Interfaces[0]->GetNumConfiguredPipes();
 
            Params->Types.SingleInterface.ConfiguredUsbInterface =
                m_Interfaces[0]->GetHandle();
        }
 
        FxPoolFree(urb);
        urb = NULL;
    }
 
    return status;
}

SelectInterface()

_Must_inspect_result_ NTSTATUS FxUsbDevice::SelectInterface	(	__in PWDF_OBJECT_ATTRIBUTES	PipesAttributes,
		__in PURB	Urb
	)

SelectInterfaceByInterface()

_Must_inspect_result_ NTSTATUS FxUsbDevice::SelectInterfaceByInterface	(	__in PWDF_OBJECT_ATTRIBUTES	PipesAttributes,
		__in PUSB_INTERFACE_DESCRIPTOR	InterfaceDescriptor
	)

SendSyncRequest()

_Must_inspect_result_ NTSTATUS FxUsbDevice::SendSyncRequest ( __in FxSyncRequest *  Request, __in ULONGLONG  Time  )

protected

Definition at line 31 of file fxusbdeviceum.cpp.

{
    NTSTATUS status;
    WDF_REQUEST_SEND_OPTIONS options;
 
    WDF_REQUEST_SEND_OPTIONS_INIT(&options, 0);
    WDF_REQUEST_SEND_OPTIONS_SET_TIMEOUT(&options, WDF_REL_TIMEOUT_IN_SEC(Time));
 
    status = SubmitSync(Request->m_TrueRequest, &options);
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                            "FxUsbDevice SubmitSync failed");
        goto Done;
    }
 
Done:
    return status;
}

SendSyncUmUrb()

_Must_inspect_result_ NTSTATUS FxUsbDevice::SendSyncUmUrb ( __inout PUMURB  Urb, __in ULONGLONG  Time, __in_opt WDFREQUEST  Request = NULL, __in_opt PWDF_REQUEST_SEND_OPTIONS  Options = NULL  )

protected

Definition at line 55 of file fxusbdeviceum.cpp.

{
    NTSTATUS status;
    WDF_REQUEST_SEND_OPTIONS options;
    FxSyncRequest request(GetDriverGlobals(), NULL, Request);
 
    status = request.Initialize();
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                            "Failed to initialize FxSyncRequest");
        return status;
    }
 
    if (NULL == Options) {
        Options = &options;
    }
 
    WDF_REQUEST_SEND_OPTIONS_INIT(Options, 0);
    WDF_REQUEST_SEND_OPTIONS_SET_TIMEOUT(Options, WDF_REL_TIMEOUT_IN_SEC(Time));
 
    status = request.m_TrueRequest->ValidateTarget(this);
    if (NT_SUCCESS(status)) {
        FxUsbUmFormatRequest(request.m_TrueRequest, &Urb->UmUrbHeader, m_pHostTargetFile);
        status = SubmitSync(request.m_TrueRequest, Options);
        if (!NT_SUCCESS(status)) {
            DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                                "FxUsbDevice SubmitSync failed");
            return status;
        }
    }
 
    return status;
}

Referenced by FxUsbInterface::MakeAndConfigurePipes(), FxUsbInterface::SelectSettingByIndex(), and FxUsbInterface::SetWinUsbHandle().

Start()

_Must_inspect_result_ NTSTATUS FxUsbDevice::Start ( VOID  )

protectedvirtual

Reimplemented from FxIoTarget.

Definition at line 534 of file fxusbdevice.cpp.

{
    NTSTATUS status;
 
    status = FxIoTarget::Start();
 
    if (NT_SUCCESS(status)) {
        FxRequestBase* pRequest;
        LIST_ENTRY head, *ple;
        ULONG i, iInterface;
        FxUsbInterface *pUsbInterface;
        KIRQL irql;
 
        InitializeListHead(&head);
 
        Lock(&irql);
 
        //
        // Iterate over all of the interfaces.  For each pipe on each interface,
        // grab all pended i/o for later submission.
        //
        for (iInterface = 0; iInterface < m_NumInterfaces; iInterface++){
 
            pUsbInterface = m_Interfaces[iInterface];
 
            for (i = 0; i < pUsbInterface->m_NumberOfConfiguredPipes; i++) {
                pUsbInterface->m_ConfiguredPipes[i]->GotoStartState(&head);
            }
        }
        Unlock(irql);
 
        //
        // Since we are going to reference the FxUsbPipe's outside of the
        // lock and the interface can go away in the meantime, add a reference
        // (multiple times perhaps) to each FxUsbPipe to make sure it sticks
        // around.
        //
        for (ple = head.Flink; ple != &head; ple = ple->Flink) {
            pRequest = FxRequestBase::_FromListEntry(ple);
            pRequest->GetTarget()->ADDREF(this);
        }
 
        //
        // Drain the list of pended requests.
        //
        while (!IsListEmpty(&head)) {
            FxIoTarget* pTarget;
 
            ple = RemoveHeadList(&head);
 
            pRequest = FxRequestBase::_FromListEntry(ple);
 
            pTarget = pRequest->GetTarget();
 
            pTarget->SubmitPendedRequest(pRequest);
 
            //
            // Release the reference taken above when accumulating pended i/o.
            //
            pTarget->RELEASE(this);
        }
    }
 
    return status;
}

Stop()

VOID FxUsbDevice::Stop ( __in WDF_IO_TARGET_SENT_IO_ACTION  Action )

protectedvirtual

Reimplemented from FxIoTarget.

Definition at line 605 of file fxusbdevice.cpp.

{
    FxUsbInterface *pUsbInterface;
    SINGLE_LIST_ENTRY head;
    ULONG iPipe, iInterface;
    KIRQL irql;
 
    head.Next = NULL;
 
    //
    // Stop all of our own I/O first
    //
    FxIoTarget::Stop(Action);
 
    //
    // if we are just canceling i/o, then we just acquire the spin lock b/c
    // we can be called at dispatch level for this action code.
    //
    if (Action != WdfIoTargetLeaveSentIoPending) {
        ASSERT(Mx::MxGetCurrentIrql() == PASSIVE_LEVEL);
 
        AcquireInterfaceIterationLock();
    }
 
    //
    // Since we don't have to synchronize on the I/O already sent, just set
    // each pipe's state to stop.
    //
    Lock(&irql);
 
    for (iInterface = 0; iInterface < m_NumInterfaces; iInterface++) {
        pUsbInterface = m_Interfaces[iInterface];
 
        if (pUsbInterface->m_ConfiguredPipes != NULL) {
            for (iPipe = 0;
                 iPipe < pUsbInterface->m_NumberOfConfiguredPipes;
                 iPipe++) {
 
                if (pUsbInterface->m_ConfiguredPipes[iPipe] != NULL) {
                    BOOLEAN wait;
 
                    wait = FALSE;
 
                    pUsbInterface->m_ConfiguredPipes[iPipe]->GotoStopState(
                        Action,
                        &head,
                        &wait,
                        TRUE
                        );
                }
            }
        }
    }
    Unlock(irql);
 
    //
    // If we are leaving sent IO pending, the io target will set the IO
    // completion event during stop even if there is still outstanding IO.
    //
 
    if (head.Next != NULL) {
        _CancelSentRequests(&head);
    }
 
    for (iInterface = 0; iInterface < m_NumInterfaces;  iInterface++) {
        pUsbInterface = m_Interfaces[iInterface];
 
        if (pUsbInterface->m_ConfiguredPipes != NULL) {
            //
            // Iterate over the pipes and clean each one up
            //
            for (iPipe = 0;
                 iPipe < pUsbInterface->m_NumberOfConfiguredPipes;
                 iPipe++) {
                //
                // Same reason as above
                //
                if (pUsbInterface->m_ConfiguredPipes[iPipe] != NULL) {
                    pUsbInterface->m_ConfiguredPipes[iPipe]->
                        WaitForSentIoToComplete();
                }
            }
        }
    }
 
    if (Action != WdfIoTargetLeaveSentIoPending) {
        ReleaseInterfaceIterationLock();
    }
}

Member Data Documentation

FxUsbInterface

friend FxUsbDevice::FxUsbInterface

Definition at line 186 of file fxusbdevice.hpp.

Referenced by CreateInterfaces().

FxUsbPipe

friend FxUsbDevice::FxUsbPipe

Definition at line 185 of file fxusbdevice.hpp.

Referenced by SelectConfig().

m_BusInterfaceContext

PVOID FxUsbDevice::m_BusInterfaceContext

protected

Definition at line 635 of file fxusbdevice.hpp.

Referenced by FxUsbDevice(), GetCurrentFrameNumber(), InitDevice(), and ~FxUsbDevice().

m_BusInterfaceDereference

PINTERFACE_DEREFERENCE FxUsbDevice::m_BusInterfaceDereference

protected

Definition at line 637 of file fxusbdevice.hpp.

Referenced by FxUsbDevice(), InitDevice(), and ~FxUsbDevice().

m_ConfigDescriptor

PUSB_CONFIGURATION_DESCRIPTOR FxUsbDevice::m_ConfigDescriptor

protected

Definition at line 629 of file fxusbdevice.hpp.

Referenced by CreateInterfaces(), FxUsbInterface::CreateSettings(), FxUsbDevice(), GetConfigDescriptor(), FxUsbInterface::GetEndpointInformation(), InitDevice(), SelectConfigDescriptor(), SelectConfigInterfaces(), SelectConfigMulti(), SelectConfigSingle(), and ~FxUsbDevice().

m_ConfigHandle

USBD_CONFIGURATION_HANDLE FxUsbDevice::m_ConfigHandle

protected

Definition at line 625 of file fxusbdevice.hpp.

Referenced by FxUsbInterface::FormatSelectSettingUrb(), FxUsbDevice(), GetConfigHandle(), and SelectConfig().

m_ControlPipe

USBD_PIPE_HANDLE FxUsbDevice::m_ControlPipe

protected

Definition at line 621 of file fxusbdevice.hpp.

Referenced by FxUsbDevice(), GetControlPipeHandle(), and InitDevice().

m_DeviceDescriptor

USB_DEVICE_DESCRIPTOR FxUsbDevice::m_DeviceDescriptor

protected

Definition at line 627 of file fxusbdevice.hpp.

Referenced by CopyDeviceDescriptor(), FxUsbDevice(), and InitDevice().

m_HcdPortCapabilities

ULONG FxUsbDevice::m_HcdPortCapabilities

protected

Definition at line 641 of file fxusbdevice.hpp.

Referenced by FxUsbDevice(), GetInformation(), and InitDevice().

m_InterfaceIterationLock

FxWaitLockInternal FxUsbDevice::m_InterfaceIterationLock

protected

Definition at line 639 of file fxusbdevice.hpp.

Referenced by _Acquires_lock_(), and _Releases_lock_().

m_Interfaces

FxUsbInterface** FxUsbDevice::m_Interfaces

protected

Definition at line 623 of file fxusbdevice.hpp.

Referenced by CancelSentIo(), CreateInterfaces(), FxUsbDevice(), GetInterfaceFromIndex(), GetInterfaceFromNumber(), PipesGotoRemoveState(), Purge(), RemoveDeletedInterface(), SelectConfigMulti(), SelectConfigSingle(), Start(), Stop(), and ~FxUsbDevice().

m_MismatchedInterfacesInConfigDescriptor

BOOLEAN FxUsbDevice::m_MismatchedInterfacesInConfigDescriptor

protected

Definition at line 649 of file fxusbdevice.hpp.

Referenced by CreateInterfaces(), FxUsbDevice(), and HasMismatchedInterfacesInConfigDescriptor().

m_NumInterfaces

UCHAR FxUsbDevice::m_NumInterfaces

protected

Definition at line 647 of file fxusbdevice.hpp.

Referenced by CancelSentIo(), CreateInterfaces(), FxUsbDevice(), GetInterfaceFromIndex(), GetInterfaceFromNumber(), GetNumInterfaces(), PipesGotoRemoveState(), Purge(), RemoveDeletedInterface(), SelectConfig(), SelectConfigMulti(), SelectConfigSingle(), Start(), Stop(), and ~FxUsbDevice().

m_OnUSBD

BOOLEAN FxUsbDevice::m_OnUSBD

protected

Definition at line 645 of file fxusbdevice.hpp.

Referenced by FxUsbDevice(), InitDevice(), and OnUSBD().

m_pHostTargetFile

IWudfFile* FxUsbDevice::m_pHostTargetFile

private

Definition at line 658 of file fxusbdevice.hpp.

Referenced by Dispose(), FxUsbPipe::FormatAbortRequest(), FxUsbPipe::FormatResetRequest(), FxUsbDevice(), and SendSyncUmUrb().

m_QueryBusTime

PUSB_BUSIFFN_QUERY_BUS_TIME FxUsbDevice::m_QueryBusTime

protected

Definition at line 633 of file fxusbdevice.hpp.

Referenced by FxUsbDevice(), GetCurrentFrameNumber(), and InitDevice().

m_Traits

ULONG FxUsbDevice::m_Traits

protected

Definition at line 643 of file fxusbdevice.hpp.

Referenced by FxUsbInterface::DetermineDefaultMaxTransferSize(), FxUsbDevice(), GetInformation(), and InitDevice().

m_UrbType

FX_URB_TYPE FxUsbDevice::m_UrbType

protected

Definition at line 651 of file fxusbdevice.hpp.

Referenced by FxUsbDevice(), GetFxUrbTypeForRequest(), GetUrbType(), and InitDevice().

m_USBDHandle

USBD_HANDLE FxUsbDevice::m_USBDHandle

protected

Definition at line 619 of file fxusbdevice.hpp.

Referenced by CreateIsochUrb(), CreateUrb(), Dispose(), FormatControlRequest(), FormatStringRequest(), FxUsbDevice(), GetUSBDHandle(), InitDevice(), QueryUsbCapability(), and SelectConfig().

m_UsbdVersionInformation

USBD_VERSION_INFORMATION FxUsbDevice::m_UsbdVersionInformation

protected

Definition at line 631 of file fxusbdevice.hpp.

Referenced by FxUsbDevice(), GetInformation(), and InitDevice().

m_WinUsbHandle

WINUSB_INTERFACE_HANDLE FxUsbDevice::m_WinUsbHandle

private

Definition at line 663 of file fxusbdevice.hpp.

Referenced by FxUsbDevice(), and FxUsbInterface::SetWinUsbHandle().

---

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

• sdk/lib/drivers/wdf/shared/inc/private/common/fxusbdevice.hpp
• sdk/lib/drivers/wdf/shared/targets/usb/fxusbdevice.cpp
• sdk/lib/drivers/wdf/shared/targets/usb/km/fxusbdevicekm.cpp
• sdk/lib/drivers/wdf/shared/targets/usb/um/fxusbdeviceum.cpp