#include <fxusbinterface.hpp>

Inheritance diagram for FxUsbInterface:

Collaboration diagram for FxUsbInterface:

[legend]

Public Member Functions
	FxUsbInterface (_In_ PFX_DRIVER_GLOBALS FxDriverGlobals, _In_ FxUsbDevice *UsbDevice, _In_ PUSB_INTERFACE_DESCRIPTOR InterfaceDescriptor)

VOID	SetInfo (__in PUSBD_INTERFACE_INFORMATION Interface)

VOID	CleanUpAndDelete (__in BOOLEAN ClearDestroyCallback)

_Must_inspect_result_ NTSTATUS	SelectSetting (__in PWDF_OBJECT_ATTRIBUTES PipesAttributes, __in PURB Urb)

UCHAR	GetNumConfiguredPipes (VOID)

UCHAR	GetInterfaceNumber (VOID)

UCHAR	GetNumSettings (VOID)

UCHAR	GetNumEndpoints (__in UCHAR SettingIndex)

VOID	GetEndpointInformation (__in UCHAR SettingIndex, __in UCHAR PipeIndex, __in PWDF_USB_PIPE_INFORMATION PipeInfo)

VOID	GetDescriptor (__in PUSB_INTERFACE_DESCRIPTOR UsbInterfaceDescriptor, __in UCHAR SettingIndex)

UCHAR	GetConfiguredSettingIndex (VOID)

WDFUSBPIPE	GetConfiguredPipe (__in UCHAR PipeIndex, __out_opt PWDF_USB_PIPE_INFORMATION PipeInfo)

_Must_inspect_result_ NTSTATUS	CreateSettings (VOID)

VOID	SetNumConfiguredPipes (__in UCHAR NumberOfPipes)

VOID	SetConfiguredPipes (__in FxUsbPipe **ppPipes)

BOOLEAN	IsInterfaceConfigured (VOID)

_Must_inspect_result_ NTSTATUS	SelectSettingByDescriptor (__in PWDF_OBJECT_ATTRIBUTES PipesAttributes, __in PUSB_INTERFACE_DESCRIPTOR InterfaceDescriptor)

_Must_inspect_result_ NTSTATUS	SelectSettingByIndex (__in PWDF_OBJECT_ATTRIBUTES PipesAttributes, __in UCHAR SettingIndex)

VOID	CopyEndpointFieldsFromDescriptor (__in PWDF_USB_PIPE_INFORMATION PipeInfo, __in PUSB_ENDPOINT_DESCRIPTOR EndpointDesc, __in UCHAR SettingIndex)

ULONG	DetermineDefaultMaxTransferSize (VOID)

WDFUSBINTERFACE	GetHandle (VOID)

PUSB_INTERFACE_DESCRIPTOR	GetSettingDescriptor (__in UCHAR Setting)

NTSTATUS	CheckAndSelectSettingByIndex (__in UCHAR SettingIndex)

NTSTATUS	UpdatePipeAttributes (__in PWDF_OBJECT_ATTRIBUTES PipesAttributes)

NTSTATUS	SetWinUsbHandle (_In_ UCHAR FrameworkInterfaceIndex)

NTSTATUS	MakeAndConfigurePipes (__in PWDF_OBJECT_ATTRIBUTES PipesAttributes, __in UCHAR NumPipes)

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	FxUsbDevice

friend	FxUsbPipe

Protected Member Functions
	~FxUsbInterface (VOID)

VOID	RemoveDeletedPipe (__in FxUsbPipe *Pipe)

VOID	FormatSelectSettingUrb (__in_bcount(GET_SELECT_INTERFACE_REQUEST_SIZE(NumEndpoints)) PURB Urb, __in USHORT NumEndpoints, __in UCHAR SettingNumber)

	__field_ecount (m_NumSettings) FxUsbInterfaceSetting *m_Settings

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

FxObjectDebugExtension *	GetDebugExtension (VOID)

BOOLEAN	IsDebug (VOID)

VOID	AllocateTagTracker (__in WDFTYPE Type)

virtual VOID	SelfDestruct (VOID)

PVOID __inline	GetObjectHandleUnchecked (VOID)

VOID __inline	DestroyChildren (VOID)

VOID	DeleteEarlyDisposedObject (VOID)

Protected Attributes
FxUsbDevice *	m_UsbDevice

FxUsbPipe **	m_ConfiguredPipes

UCHAR	m_NumSettings

UCHAR	m_NumberOfConfiguredPipes

UCHAR	m_InterfaceNumber

UCHAR	m_CurAlternateSetting

UCHAR	m_Class

UCHAR	m_SubClass

UCHAR	m_Protocol

Protected Attributes inherited from FxObject
union {
CfxDeviceBase * m_DeviceBase

CfxDevice * m_Device

};

Private Attributes
WINUSB_INTERFACE_HANDLE	m_WinUsbHandle

Additional Inherited Members
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 Protected Member Functions inherited from FxObject
static PVOID	_GetBase (__in FxObject *Object)

Detailed Description

Definition at line 32 of file fxusbinterface.hpp.

Constructor & Destructor Documentation

◆ FxUsbInterface()

FxUsbInterface::FxUsbInterface	(	_In_ PFX_DRIVER_GLOBALS	FxDriverGlobals,
		_In_ FxUsbDevice *	UsbDevice,
		_In_ PUSB_INTERFACE_DESCRIPTOR	InterfaceDescriptor
	)

Definition at line 29 of file fxusbinterface.cpp.

      :
    FxNonPagedObject(FX_TYPE_USB_INTERFACE ,sizeof(FxUsbInterface), FxDriverGlobals),
    m_UsbDevice(UsbDevice)
{
    m_UsbDevice->ADDREF(this);
 
    m_InterfaceNumber = InterfaceDescriptor->bInterfaceNumber;
    m_Protocol = InterfaceDescriptor->bInterfaceProtocol;
    m_Class = InterfaceDescriptor->bInterfaceClass;
    m_SubClass = InterfaceDescriptor->bInterfaceSubClass;
 
    m_CurAlternateSetting = 0;
    m_NumSettings = 0;
    m_NumberOfConfiguredPipes = 0;
    m_ConfiguredPipes = NULL;
    m_Settings = NULL;
 
    MarkNoDeleteDDI(ObjectDoNotLock);
}

◆ ~FxUsbInterface()

FxUsbInterface::~FxUsbInterface ( VOID )

protected

Definition at line 53 of file fxusbinterface.cpp.

{
    ULONG i;
 
    m_UsbDevice->RemoveDeletedInterface(this);
 
    for (i = 0; i < m_NumberOfConfiguredPipes; i++) {
        ASSERT(m_ConfiguredPipes[i] == NULL);
    }
 
    if (m_ConfiguredPipes != NULL) {
        FxPoolFree(m_ConfiguredPipes);
        m_ConfiguredPipes = NULL;
    }
 
    m_NumberOfConfiguredPipes = 0;
 
    if (m_Settings != NULL) {
        FxPoolFree(m_Settings);
        m_Settings = NULL;
    }
 
    //
    // Release the reference taken in the constructor
    //
    m_UsbDevice->RELEASE(this);
}

Member Function Documentation

◆ __field_ecount()

FxUsbInterface::__field_ecount ( m_NumSettings )

protected

◆ CheckAndSelectSettingByIndex()

_Must_inspect_result_ NTSTATUS FxUsbInterface::CheckAndSelectSettingByIndex ( __in UCHAR SettingIndex )

Definition at line 557 of file fxusbinterface.cpp.

{
     if (GetConfiguredSettingIndex() != SettingIndex) {
         return SelectSettingByIndex(NULL,
                                     SettingIndex);
     }
     else {
         return STATUS_SUCCESS;
     }
}

◆ CleanUpAndDelete()

VOID FxUsbInterface::CleanUpAndDelete ( __in BOOLEAN ClearDestroyCallback )

Definition at line 82 of file fxusbinterface.cpp.

{
    FxUsbPipe** pPipes;
    ULONG numPipes;
    KIRQL irql;
    ULONG i;
 
    //
    // Capture the values, clear them out of the object and then clean them up
    // outside of the lock.
    //
    m_UsbDevice->Lock(&irql);
 
    pPipes = m_ConfiguredPipes;
    numPipes = m_NumberOfConfiguredPipes;
 
    m_ConfiguredPipes = NULL;
    m_NumberOfConfiguredPipes = 0;
 
    m_UsbDevice->Unlock(irql);
 
    if (pPipes != NULL) {
        for (i = 0; i < numPipes; i++) {
            if (pPipes[i] != NULL) {
                if (Failure) {
                    //
                    // FxIoTarget::Remove will be called in FxIoTarget::Dispose()
                    //
                    pPipes[i]->DeleteFromFailedCreate();
                }
                else {
                    pPipes[i]->DeleteObject();
                }
            }
            else {
                //
                // No more pointers to delete, break out of the loop
                //
                break;
            }
        }
 
        FxPoolFree(pPipes);
        pPipes = NULL;
    }
}

Referenced by FxUsbDevice::PipesGotoRemoveState().

◆ CopyEndpointFieldsFromDescriptor()

VOID FxUsbInterface::CopyEndpointFieldsFromDescriptor	(	__in PWDF_USB_PIPE_INFORMATION	PipeInfo,
		__in PUSB_ENDPOINT_DESCRIPTOR	EndpointDesc,
		__in UCHAR	SettingIndex
	)

Definition at line 977 of file fxusbinterface.cpp.

{
    PipeInfo->MaximumPacketSize  = EndpointDesc->wMaxPacketSize;
    PipeInfo->EndpointAddress  = EndpointDesc->bEndpointAddress;
    PipeInfo->Interval  = EndpointDesc->bInterval;
 
    //
    // Extract the lower 2 bits which contain the EP type
    //
    PipeInfo->PipeType  = FxUsbPipe::_UsbdPipeTypeToWdf(
        (USBD_PIPE_TYPE) (EndpointDesc->bmAttributes & 0x03)
        );
 
    //
    // Filling in a default value since the EndpointDescriptor doesn't contain it
    //
    if (PipeInfo->PipeType == WdfUsbPipeTypeControl) {
        PipeInfo->MaximumTransferSize = FxUsbPipeControlMaxTransferSize;
    }
    else {
        PipeInfo->MaximumTransferSize  = DetermineDefaultMaxTransferSize();
    }
 
    PipeInfo->SettingIndex  = SettingIndex;
}

Referenced by GetEndpointInformation().

◆ CreateSettings()

_Must_inspect_result_ NTSTATUS FxUsbInterface::CreateSettings ( VOID )

Definition at line 199 of file fxusbinterface.cpp.

{
    PUSB_INTERFACE_DESCRIPTOR  pDescriptor;
    ULONG size;
    UCHAR i;
 
    //
    // No need to validate the size of the interface descriptor since FxUsbDevice::CreateInterfaces
    // has already done so
    //
    pDescriptor = (PUSB_INTERFACE_DESCRIPTOR) FxUsbFindDescriptorType(
        m_UsbDevice->m_ConfigDescriptor,
        m_UsbDevice->m_ConfigDescriptor->wTotalLength,
        m_UsbDevice->m_ConfigDescriptor,
        USB_INTERFACE_DESCRIPTOR_TYPE
        );
 
    //
    // Calculate the number of settings for this interface
    //
    while (pDescriptor != NULL) {
        if (m_InterfaceNumber == pDescriptor->bInterfaceNumber) {
           m_NumSettings++;
        }
        pDescriptor = (PUSB_INTERFACE_DESCRIPTOR) FxUsbFindDescriptorType(
            m_UsbDevice->m_ConfigDescriptor,
            m_UsbDevice->m_ConfigDescriptor->wTotalLength,
            WDF_PTR_ADD_OFFSET(pDescriptor, pDescriptor->bLength),
            USB_INTERFACE_DESCRIPTOR_TYPE
            );
    }
    size =  sizeof(FxUsbInterfaceSetting) * m_NumSettings;
    m_Settings = (FxUsbInterfaceSetting *) FxPoolAllocate(
        GetDriverGlobals(), NonPagedPool, size);
 
    if (m_Settings == NULL) {
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
            "Could not allocate memory for %d settings for bInterfaceNumber %d "
            "(Protocol %d, Class %d, SubClass %d), %!STATUS!",
            m_NumSettings, m_InterfaceNumber, m_Protocol, m_Class, m_SubClass,
            STATUS_INSUFFICIENT_RESOURCES);
 
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    RtlZeroMemory(m_Settings, size);
 
    //
    // Add all the settings for this interface
    //
    pDescriptor = (PUSB_INTERFACE_DESCRIPTOR) FxUsbFindDescriptorType(
        m_UsbDevice->m_ConfigDescriptor,
        m_UsbDevice->m_ConfigDescriptor->wTotalLength,
        m_UsbDevice->m_ConfigDescriptor,
        USB_INTERFACE_DESCRIPTOR_TYPE
        );
 
    while (pDescriptor != NULL) {
        if (m_InterfaceNumber == pDescriptor->bInterfaceNumber) {
            if (pDescriptor->bAlternateSetting < m_NumSettings) {
                m_Settings[pDescriptor->bAlternateSetting].InterfaceDescriptor = pDescriptor;
            }
            else {
                DoTraceLevelMessage(
                    GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                    "Interface Number %d does not have contiguous alternate settings,"
                    "expected %d settings, found alt setting %d, %!STATUS!",
                    pDescriptor->bInterfaceNumber, m_NumSettings,
                    pDescriptor->bAlternateSetting, STATUS_INVALID_DEVICE_REQUEST);
 
                return STATUS_INVALID_DEVICE_REQUEST;
            }
        }
 
        pDescriptor = (PUSB_INTERFACE_DESCRIPTOR) FxUsbFindDescriptorType(
            m_UsbDevice->m_ConfigDescriptor,
            m_UsbDevice->m_ConfigDescriptor->wTotalLength,
            WDF_PTR_ADD_OFFSET(pDescriptor, pDescriptor->bLength),
            USB_INTERFACE_DESCRIPTOR_TYPE
            );
    }
 
    for (i = 0; i < m_NumSettings; i++) {
 
        if (m_Settings[i].InterfaceDescriptor == NULL) {
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                "Interface Number %d does not have contiguous alternate settings,"
                "expected consecutive %d settings, but alt setting %d missing "
                "%!STATUS!", m_InterfaceNumber, m_NumSettings, i,
                STATUS_INVALID_DEVICE_REQUEST);
 
            return STATUS_INVALID_DEVICE_REQUEST;
        }
 
        //
        // Only validate the endpoints if the interface reports it has some. We don't
        // want to validate EP descriptors that may be after the interface descriptor
        // that are never used because bNumEndpoints doesn't indicate they are present.
        //
        if (m_Settings[i].InterfaceDescriptor->bNumEndpoints > 0) {
            PVOID pRelativeEnd;
            NTSTATUS status;
 
            //
            // Validate that each endpoint descriptor is the correct size for this alt setting.
            // We will use the next inteface descriptor as the end, and if this is the last
            // interface descriptor, use the end of the config descriptor as our end.
            //
            pRelativeEnd = FxUsbFindDescriptorType(
                m_UsbDevice->m_ConfigDescriptor,
                m_UsbDevice->m_ConfigDescriptor->wTotalLength,
                m_Settings[i].InterfaceDescriptor,
                USB_INTERFACE_DESCRIPTOR_TYPE
                );
 
            if (pRelativeEnd == NULL) {
                //
                // This is the last alt setting in the config descriptor, use the end of the
                // config descriptor as our end
                //
                pRelativeEnd = WDF_PTR_ADD_OFFSET(m_UsbDevice->m_ConfigDescriptor,
                    m_UsbDevice->m_ConfigDescriptor->wTotalLength);
            }
 
            //
            // Limit the number of endpoints validated to bNumEndpoints. In theory
            // there could be EP descriptors after N EP descriptors that are never
            // used, thus we don't want to risk valdiating them and failing them
            // (ie an app compat concern, in a perfect world we would validate them)
            //
            status = FxUsbValidateDescriptorType(
                GetDriverGlobals(),
                m_UsbDevice->m_ConfigDescriptor,
                m_Settings[i].InterfaceDescriptor,
                pRelativeEnd,
                USB_ENDPOINT_DESCRIPTOR_TYPE,
                sizeof(USB_ENDPOINT_DESCRIPTOR),
                FxUsbValidateDescriptorOpAtLeast,
                m_Settings[i].InterfaceDescriptor->bNumEndpoints
                );
 
            if (!NT_SUCCESS(status)) {
                DoTraceLevelMessage(
                    GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                    "Interface Number %d does not have a valid endpoint descriptor,"
                    "%!STATUS!", m_InterfaceNumber, status);
 
                return status;
            }
        }
    }
 
    return STATUS_SUCCESS;
}

◆ DetermineDefaultMaxTransferSize()

ULONG FxUsbInterface::DetermineDefaultMaxTransferSize ( VOID )

Definition at line 952 of file fxusbinterface.cpp.

{
    if (m_UsbDevice->m_Traits & WDF_USB_DEVICE_TRAIT_AT_HIGH_SPEED) {
        return FxUsbPipeHighSpeedMaxTransferSize;
    }
    else {
        return FxUsbPipeLowSpeedMaxTransferSize;
    }
}

Referenced by CopyEndpointFieldsFromDescriptor().

◆ FormatSelectSettingUrb()

VOID FxUsbInterface::FormatSelectSettingUrb	(	__in_bcount(GET_SELECT_INTERFACE_REQUEST_SIZE(NumEndpoints)) PURB	Urb,
		__in USHORT	NumEndpoints,
		__in UCHAR	SettingNumber
	)

protected

Definition at line 786 of file fxusbinterface.cpp.

{
    ULONG defaultMaxTransferSize;
    USHORT size;
    UCHAR i;
 
    size = GET_SELECT_INTERFACE_REQUEST_SIZE(NumEndpoints);
 
    RtlZeroMemory(Urb, size);
 
    //
    // Setup the URB, format the request, and send it
    //
    UsbBuildSelectInterfaceRequest(Urb,
                                   size,
                                   m_UsbDevice->m_ConfigHandle,
                                   m_InterfaceNumber,
                                   SettingNumber);
 
    defaultMaxTransferSize = m_UsbDevice->GetDefaultMaxTransferSize();
 
    Urb->UrbSelectInterface.Interface.Length =
        GET_USBD_INTERFACE_SIZE(NumEndpoints);
 
    Urb->UrbSelectInterface.Interface.NumberOfPipes = NumEndpoints;
 
    for (i = 0; i < NumEndpoints; i++) {
 
        //
        // Make sure that the Interface Length conveys the exact number of EP's
        //
        ASSERT(
            &Urb->UrbSelectInterface.Interface.Pipes[i] <
            WDF_PTR_ADD_OFFSET(&Urb->UrbSelectInterface.Interface,
                               Urb->UrbSelectInterface.Interface.Length)
            );
 
        Urb->UrbSelectInterface.Interface.Pipes[i].PipeFlags = 0x0;
        Urb->UrbSelectInterface.Interface.Pipes[i].MaximumTransferSize =
            defaultMaxTransferSize;
    }
}

Referenced by FxUsbDevice::SelectConfig(), SelectSettingByDescriptor(), and SelectSettingByIndex().

◆ GetConfiguredPipe()

WDFUSBPIPE FxUsbInterface::GetConfiguredPipe	(	__in UCHAR	PipeIndex,
		__out_opt PWDF_USB_PIPE_INFORMATION	PipeInfo
	)

Definition at line 1024 of file fxusbinterface.cpp.

{
    if (PipeIndex >= m_NumberOfConfiguredPipes) {
        return NULL;
    }
    else {
        if (PipeInfo != NULL) {
            m_ConfiguredPipes[PipeIndex]->GetInformation(PipeInfo);
        }
 
        return m_ConfiguredPipes[PipeIndex]->GetHandle();
    }
}

◆ GetConfiguredSettingIndex()

UCHAR FxUsbInterface::GetConfiguredSettingIndex ( VOID )

Definition at line 1087 of file fxusbinterface.cpp.

{
    if (IsInterfaceConfigured()) {
        return m_CurAlternateSetting;
    }
    else {
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
            "WDFUSBINTERFACE %p not configured, cannot retrieve configured "
            "setting index", GetHandle());
 
        FxVerifierDbgBreakPoint(GetDriverGlobals());
 
        return 0;
    }
}

Referenced by FxUsbPipe::GetInformation().

◆ GetDescriptor()

VOID FxUsbInterface::GetDescriptor	(	__in PUSB_INTERFACE_DESCRIPTOR	UsbInterfaceDescriptor,
		__in UCHAR	SettingIndex
	)

Definition at line 1056 of file fxusbinterface.cpp.

{
    if (SettingIndex >= m_NumSettings) {
        RtlZeroMemory(UsbInterfaceDescriptor,
                      sizeof(*UsbInterfaceDescriptor));
    }
    else {
        RtlCopyMemory(UsbInterfaceDescriptor,
                      m_Settings[SettingIndex].InterfaceDescriptor,
                      sizeof(*UsbInterfaceDescriptor));
    }
}

◆ GetEndpointInformation()

VOID FxUsbInterface::GetEndpointInformation	(	__in UCHAR	SettingIndex,
		__in UCHAR	PipeIndex,
		__in PWDF_USB_PIPE_INFORMATION	PipeInfo
	)

Definition at line 855 of file fxusbinterface.cpp.

{
    PUCHAR pEnd, pCur;
    PUSB_INTERFACE_DESCRIPTOR pInterfaceDesc;
    PUSB_ENDPOINT_DESCRIPTOR pEndpointDesc;
    UCHAR curEndpointIndex;
    BOOLEAN endPointFound;
 
    pInterfaceDesc = NULL;
    curEndpointIndex = 0;
    endPointFound = FALSE;
    UNREFERENCED_PARAMETER(endPointFound);
 
    //
    // Extract the interface descriptor for the alternate setting for the interface
    //
    pInterfaceDesc = GetSettingDescriptor(SettingIndex);
 
    if (pInterfaceDesc == NULL) {
        return;
    }
 
    pEnd = (PUCHAR) WDF_PTR_ADD_OFFSET(
        m_UsbDevice->m_ConfigDescriptor,
        m_UsbDevice->m_ConfigDescriptor->wTotalLength
        );
 
    //
    // Start from the descriptor after current one
    //
    pCur = (PUCHAR) WDF_PTR_ADD_OFFSET(pInterfaceDesc, pInterfaceDesc->bLength);
 
    //
    // Iterate through the list of EP descriptors following the interface descriptor
    // we just found and get the endpoint descriptor which matches the endpoint
    // index or we hit another interface descriptor
    //
    // We have already validated that the descriptor headers are well formed and within
    // the config descriptor bounds
    //
    while (pCur < pEnd) {
        PUSB_COMMON_DESCRIPTOR pCommonDesc = (PUSB_COMMON_DESCRIPTOR) pCur;
 
        //
        // If we hit the next interface no way we can find the EndPoint
        //
        if (pCommonDesc->bDescriptorType == USB_INTERFACE_DESCRIPTOR_TYPE) {
            break;
        }
 
        if (pCommonDesc->bDescriptorType == USB_ENDPOINT_DESCRIPTOR_TYPE) {
            //
            // Size of pEndpointDesc has been validated by CreateSettings() and
            // is within the config descriptor
            //
            pEndpointDesc = (PUSB_ENDPOINT_DESCRIPTOR) pCommonDesc;
 
            if (EndpointIndex == curEndpointIndex) {
                CopyEndpointFieldsFromDescriptor(PipeInfo,
                                                 pEndpointDesc,
                                                 SettingIndex);
                break;
            }
 
            curEndpointIndex++;
        }
 
        //
        // Advance past this descriptor
        //
        pCur +=  pCommonDesc->bLength;
    }
}

◆ GetHandle()

WDFUSBINTERFACE FxUsbInterface::GetHandle ( VOID )

inline

Definition at line 173 of file fxusbinterface.hpp.

    {
         return (WDFUSBINTERFACE) GetObjectHandle();
    }

Referenced by if(), and FxUsbDevice::SelectConfigSingle().

◆ GetInterfaceNumber()

UCHAR FxUsbInterface::GetInterfaceNumber ( VOID )

inline

Definition at line 70 of file fxusbinterface.hpp.

    {
        return m_InterfaceNumber;
    }

Referenced by FxUsbDevice::GetInterfaceNumberFromInterface().

◆ GetNumConfiguredPipes()

UCHAR FxUsbInterface::GetNumConfiguredPipes ( VOID )

inline

Definition at line 62 of file fxusbinterface.hpp.

    {
        return m_NumberOfConfiguredPipes;
    }

Referenced by FxUsbDevice::SelectConfigSingle().

◆ GetNumEndpoints()

UCHAR FxUsbInterface::GetNumEndpoints ( __in UCHAR SettingIndex )

Definition at line 1120 of file fxusbinterface.cpp.

{
    if (SettingIndex >= m_NumSettings) {
        return 0;
    }
    else {
        return m_Settings[SettingIndex].InterfaceDescriptor->bNumEndpoints;
    }
}

◆ GetNumSettings()

UCHAR FxUsbInterface::GetNumSettings ( VOID )

inline

Definition at line 78 of file fxusbinterface.hpp.

    {
        return m_NumSettings;
    }

Referenced by switch().

◆ GetSettingDescriptor()

PUSB_INTERFACE_DESCRIPTOR FxUsbInterface::GetSettingDescriptor ( __in UCHAR Setting )

Definition at line 1145 of file fxusbinterface.cpp.

{
    UCHAR i;
 
    for (i = 0; i < m_NumSettings; i++) {
        if (m_Settings[i].InterfaceDescriptor->bAlternateSetting == Setting) {
            return m_Settings[i].InterfaceDescriptor;
        }
    }
 
    return NULL;
}

Referenced by GetEndpointInformation(), FxUsbDevice::SelectConfigMulti(), and FxUsbDevice::SelectConfigSingle().

◆ IsInterfaceConfigured()

BOOLEAN FxUsbInterface::IsInterfaceConfigured ( VOID )

inline

Definition at line 139 of file fxusbinterface.hpp.

    {
        return m_ConfiguredPipes != NULL ? TRUE : FALSE;
    }

Referenced by GetConfiguredSettingIndex(), MakeAndConfigurePipes(), FxUsbDevice::SelectConfig(), SelectSetting(), SelectSettingByDescriptor(), and SelectSettingByIndex().

◆ MakeAndConfigurePipes()

NTSTATUS FxUsbInterface::MakeAndConfigurePipes	(	__in PWDF_OBJECT_ATTRIBUTES	PipesAttributes,
		__in UCHAR	NumPipes
	)

Definition at line 85 of file fxusbinterfaceum.cpp.

{
    NTSTATUS status = STATUS_SUCCESS;
    UCHAR iPipe;
    FxUsbPipe* pPipe;
    FxUsbPipe** ppPipes;
    //
    // Zero pipes are a valid configuration, this simplifies the code below.
    //
    ULONG size = (NumPipes == 0 ? 1 : NumPipes) * sizeof(FxUsbPipe*);
    UMURB urb;
 
    ppPipes = (FxUsbPipe**)FxPoolAllocate(GetDriverGlobals(), NonPagedPool, size);
    if (ppPipes == NULL) {
        status = STATUS_INSUFFICIENT_RESOURCES;
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
            "Unable to allocate memory %!STATUS!", status);
        goto Done;
    }
 
    RtlZeroMemory(ppPipes, size);
 
    for (iPipe = 0; iPipe < NumPipes; iPipe++) {
        ppPipes[iPipe] = new (GetDriverGlobals(), PipesAttributes)
            FxUsbPipe(GetDriverGlobals(), m_UsbDevice);
 
        if (ppPipes[iPipe] == NULL) {
            status = STATUS_INSUFFICIENT_RESOURCES;
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                "Unable to allocate memory for the pipes %!STATUS!", status);
            goto Done;
        }
 
        pPipe = ppPipes[iPipe];
 
        status = pPipe->Init(m_UsbDevice->m_Device);
        if (!NT_SUCCESS(status)) {
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                "Init pipe failed  %!STATUS!", status);
            goto Done;
        }
 
        status = pPipe->Commit(PipesAttributes, NULL, this);
        if (!NT_SUCCESS(status)) {
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                "Commit pipe failed  %!STATUS!", status);
            goto Done;
        }
    }
 
    if (IsInterfaceConfigured()) {
        //
        // Delete the old pipes
        //
        m_UsbDevice->CleanupInterfacePipesAndDelete(this);
    }
 
    SetNumConfiguredPipes(NumPipes);
    SetConfiguredPipes(ppPipes);
 
    for (iPipe = 0; iPipe < m_NumberOfConfiguredPipes ; iPipe++) {
        RtlZeroMemory(&urb, sizeof(UMURB));
 
        urb.UmUrbQueryPipe.Hdr.InterfaceHandle = m_WinUsbHandle;
        urb.UmUrbQueryPipe.Hdr.Function = UMURB_FUNCTION_QUERY_PIPE;
        urb.UmUrbQueryPipe.Hdr.Length = sizeof(_UMURB_QUERY_PIPE);
 
        urb.UmUrbQueryPipe.AlternateSetting = m_CurAlternateSetting;
        urb.UmUrbQueryPipe.PipeID = iPipe;
 
        status = m_UsbDevice->SendSyncUmUrb(&urb, 2);
 
        if (!NT_SUCCESS(status)) {
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                "Send UMURB_FUNCTION_QUERY_PIPE failed  %!STATUS!", status);
            goto Done;
        }
 
        m_ConfiguredPipes[iPipe]->InitPipe(&urb.UmUrbQueryPipe.PipeInformation,
                                           m_InterfaceNumber,
                                           this);
    }
 
Done:
    if (!NT_SUCCESS(status)) {
        if (ppPipes != NULL) {
            ASSERT(ppPipes != m_ConfiguredPipes);
 
            for (iPipe = 0; iPipe < NumPipes; iPipe++) {
                if (ppPipes[iPipe] != NULL) {
                    ppPipes[iPipe]->DeleteFromFailedCreate();
                }
            }
 
            FxPoolFree(ppPipes);
            ppPipes = NULL;
        }
    }
 
    return status;
}

Referenced by SelectSettingByIndex().

◆ RemoveDeletedPipe()

VOID FxUsbInterface::RemoveDeletedPipe ( __in FxUsbPipe * Pipe )

protected

Definition at line 148 of file fxusbinterface.cpp.

{
    ULONG i;
 
    if (m_ConfiguredPipes == NULL) {
        return;
    }
 
    for (i = 0; i < m_NumberOfConfiguredPipes; i++) {
        if (m_ConfiguredPipes[i] == Pipe) {
            m_ConfiguredPipes[i] = NULL;
            return;
        }
    }
}

Referenced by FxUsbPipe::~FxUsbPipe().

◆ SelectSetting()

_Must_inspect_result_ NTSTATUS FxUsbInterface::SelectSetting	(	__in PWDF_OBJECT_ATTRIBUTES	PipesAttributes,
		__in PURB	Urb
	)

Definition at line 585 of file fxusbinterface.cpp.

{
    FxSyncRequest request(GetDriverGlobals(), NULL);
    LIST_ENTRY pendHead;
    FxUsbPipe* pPipe;
    NTSTATUS status;
    UCHAR iPipe, numPipes;
    WDF_REQUEST_SEND_OPTIONS options;
    FxUsbPipe ** ppPipes;
    ULONG size;
 
    //
    // 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;
    }
 
    //
    // Subtract the size of the embedded pipe.
    //
    const ULONG interfaceStructSize = sizeof(Urb->UrbSelectInterface.Interface) -
                                      sizeof(USBD_PIPE_INFORMATION);
 
    //
    // This check will happen twice for SelectSettingByInterface/Descriptor.
    //
    // We could just do it here, but the above two functions will unnecessarily
    // have to build an URB.
    //
    if (IsInterfaceConfigured() &&
        m_CurAlternateSetting ==
                          Urb->UrbSelectInterface.Interface.AlternateSetting) {
        //
        // don't do anything
        //
        return STATUS_SUCCESS;
    }
 
    InitializeListHead(&pendHead);
    numPipes = 0;
    ppPipes = NULL;
 
    if (Urb->UrbSelectInterface.Hdr.Length < interfaceStructSize) {
        status = STATUS_INVALID_PARAMETER;
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
            "Urb header length 0x%x is less than expected 0x%x"
            "%!STATUS!", Urb->UrbSelectInterface.Hdr.Length, interfaceStructSize,status
            );
        return status;
    }
 
    status = request.m_TrueRequest->ValidateTarget(m_UsbDevice);
    if (!NT_SUCCESS(status)) {
        goto Done;
    }
 
    //
    // Urb->UrbSelectInterface.Interface.NumberOfPipes is set when the URB
    // completes.  So, we must compute the number of pipes being requested based
    // on the size of the structure and its Length (as set by the caller).
    // To calculate the number of pipes we need to account for the
    // embedded pipe in the structure.
    //
    numPipes = (UCHAR) ((Urb->UrbSelectInterface.Interface.Length -
                         interfaceStructSize) /
                       sizeof(USBD_PIPE_INFORMATION)
                       );
 
    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*);
    }
 
    //
    // If the interface is already configured don't do anything with the old
    // settings till we allocate new.
    //
    ppPipes = (FxUsbPipe **) FxPoolAllocate(GetDriverGlobals(), NonPagedPool, size);
 
    if (ppPipes == NULL) {
        status = STATUS_INSUFFICIENT_RESOURCES;
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
            "Unable to allocate memory %!STATUS!"
            , status);
        goto Done;
    }
 
    RtlZeroMemory(ppPipes, size);
 
    for (iPipe = 0; iPipe < numPipes; iPipe++) {
        ppPipes[iPipe] = new (GetDriverGlobals(), PipesAttributes)
            FxUsbPipe(GetDriverGlobals(),m_UsbDevice);
 
        if (ppPipes[iPipe] == NULL) {
            status = STATUS_INSUFFICIENT_RESOURCES;
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                "Unable to allocate memory for the pipes %!STATUS!", status);
            goto Done;
        }
 
        pPipe = ppPipes[iPipe];
 
        status = pPipe->Init(m_UsbDevice->m_Device);
        if (!NT_SUCCESS(status)) {
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                "Init pipe failed  %!STATUS!", status);
            goto Done;
        }
 
        status = pPipe->Commit(PipesAttributes, NULL, this);
 
        if (!NT_SUCCESS(status)) {
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                "Commit pipe failed  %!STATUS!", status);
            goto Done;
        }
    }
 
    if (IsInterfaceConfigured()) {
        //
        // Delete the old pipes
        //
        m_UsbDevice->CleanupInterfacePipesAndDelete(this);
    }
 
 
    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, FxUrbTypeLegacy, NULL);
    status = m_UsbDevice->SubmitSync(request.m_TrueRequest, &options, NULL);
 
    //
    // If select interface URB fails we are at the point of no return and we
    // will end up with no configured pipes.
    //
    if (NT_SUCCESS(status)) {
        SetNumConfiguredPipes(numPipes);
        SetConfiguredPipes(ppPipes);
        SetInfo(&Urb->UrbSelectInterface.Interface);
    }
 
Done:
    if (!NT_SUCCESS(status)) {
        if (ppPipes != NULL) {
            ASSERT(ppPipes != m_ConfiguredPipes);
 
            for (iPipe = 0; iPipe < numPipes; iPipe++) {
                if (ppPipes[iPipe] != NULL) {
                    ppPipes[iPipe]->DeleteFromFailedCreate();
                }
            }
 
            FxPoolFree(ppPipes);
            ppPipes = NULL;
        }
    }
 
    return status;
}

Referenced by SelectSettingByDescriptor(), SelectSettingByIndex(), and switch().

◆ SelectSettingByDescriptor()

_Must_inspect_result_ NTSTATUS FxUsbInterface::SelectSettingByDescriptor	(	__in PWDF_OBJECT_ATTRIBUTES	PipesAttributes,
		__in PUSB_INTERFACE_DESCRIPTOR	InterfaceDescriptor
	)

Definition at line 490 of file fxusbinterface.cpp.

{
    PURB urb;
    NTSTATUS status;
    USHORT size;
 
    if (IsInterfaceConfigured() &&
        (m_CurAlternateSetting == InterfaceDescriptor->bAlternateSetting)) {
        //
        // Don't do anything
        //
        return STATUS_SUCCESS;
    }
 
    if (InterfaceDescriptor->bInterfaceNumber != m_InterfaceNumber) {
        status = STATUS_INVALID_PARAMETER;
 
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
            "WDFUSBINTERFACE %p has interface num %d, select setting by "
            "descriptor specified interface num %d, %!STATUS!",
            GetHandle(), m_InterfaceNumber,
            InterfaceDescriptor->bInterfaceNumber, status
            );
 
        return status;
    }
 
    size = GET_SELECT_INTERFACE_REQUEST_SIZE(InterfaceDescriptor->bNumEndpoints);
 
    urb = (PURB) FxPoolAllocate(GetDriverGlobals(), NonPagedPool, size);
 
    if (urb == NULL) {
        status = STATUS_INSUFFICIENT_RESOURCES;
    }
    else {
        FormatSelectSettingUrb(
            urb,
            InterfaceDescriptor->bNumEndpoints,
            InterfaceDescriptor->bAlternateSetting
            );
 
        status = SelectSetting(PipesAttributes, urb);
 
        FxPoolFree(urb);
    }
 
    return status;
}

Referenced by switch().

◆ SelectSettingByIndex()

_Must_inspect_result_ NTSTATUS FxUsbInterface::SelectSettingByIndex	(	__in PWDF_OBJECT_ATTRIBUTES	PipesAttributes,
		__in UCHAR	SettingIndex
	)

Definition at line 374 of file fxusbinterface.cpp.

{
#if (FX_CORE_MODE == FX_CORE_KERNEL_MODE)
    PURB urb;
#elif (FX_CORE_MODE == FX_CORE_USER_MODE)
    UMURB urb;
    PUSB_INTERFACE_DESCRIPTOR interfaceDesc;
#endif
    FxUsbInterfaceSetting entry;
    UCHAR numEP;
    NTSTATUS status;
    USHORT size;
 
    status = STATUS_SUCCESS;
 
    //
    // We should have at least 1 setting on the interface
    //
    ASSERT(m_NumSettings != 0);
 
    //
    // If m_NumberOfConfiguredPipes == 0 then it also tells us that
    // the interface wasn't configured.  So it can keep track of configuredness
    // of the interface. Could there be a case when the selected setting has 0
    // EP's.  Due to the above case we use m_InterfaceConfigured.
    //
    if (IsInterfaceConfigured() && m_CurAlternateSetting == SettingIndex) {
        return STATUS_SUCCESS;
    }
 
    //
    // Check for an invalid alternate setting
    //
    if (SettingIndex >= m_NumSettings){
        return STATUS_INVALID_PARAMETER;
    }
 
    RtlCopyMemory(&entry, &m_Settings[SettingIndex], sizeof(entry));
 
    //
    // Create the configured pipes
    //
    numEP = entry.InterfaceDescriptor->bNumEndpoints;
 
    size = GET_SELECT_INTERFACE_REQUEST_SIZE(numEP);
 
#if (FX_CORE_MODE == FX_CORE_KERNEL_MODE)
    urb = (PURB) FxPoolAllocate(GetDriverGlobals(), NonPagedPool, size);
 
    if (urb == NULL) {
        status = STATUS_INSUFFICIENT_RESOURCES;
    }
    else {
        FormatSelectSettingUrb(urb, numEP, SettingIndex);
 
        status = SelectSetting(PipesAttributes, urb);
 
        FxPoolFree(urb);
        urb = NULL;
    }
#elif (FX_CORE_MODE == FX_CORE_USER_MODE)
    RtlZeroMemory(&urb, sizeof(UMURB));
 
    urb.UmUrbSelectInterface.Hdr.InterfaceHandle = m_WinUsbHandle;
    urb.UmUrbSelectInterface.Hdr.Function = UMURB_FUNCTION_SELECT_INTERFACE;
    urb.UmUrbSelectInterface.Hdr.Length = sizeof(_UMURB_SELECT_INTERFACE);
 
    urb.UmUrbSelectInterface.AlternateSetting = SettingIndex;
 
    status = m_UsbDevice->SendSyncUmUrb(&urb, 2);
 
    if (NT_SUCCESS(status)) {
        RtlZeroMemory(&urb, sizeof(UMURB));
 
        urb.UmUrbInterfaceInformation.Hdr.InterfaceHandle = m_WinUsbHandle;
        urb.UmUrbInterfaceInformation.Hdr.Function = UMURB_FUNCTION_GET_DESCRIPTOR_FROM_INTERFACE;
        urb.UmUrbInterfaceInformation.Hdr.Length = sizeof(_UMURB_INTERFACE_INFORMATION);
 
        urb.UmUrbInterfaceInformation.AlternateSetting = SettingIndex;
 
        status = m_UsbDevice->SendSyncUmUrb(&urb, 2);
 
        if (NT_SUCCESS(status)) {
            interfaceDesc = &urb.UmUrbInterfaceInformation.UsbInterfaceDescriptor;
 
            m_Settings[SettingIndex].InterfaceDescriptorAlloc = *interfaceDesc;
 
            m_CurAlternateSetting = SettingIndex;
 
            MakeAndConfigurePipes(PipesAttributes, interfaceDesc->bNumEndpoints);
        }
    }
#endif
 
    return status;
}

Referenced by CheckAndSelectSettingByIndex(), and switch().

◆ SetConfiguredPipes()

VOID FxUsbInterface::SetConfiguredPipes ( __in FxUsbPipe ** ppPipes )

inline

Definition at line 131 of file fxusbinterface.hpp.

    {
        m_ConfiguredPipes = ppPipes;
    }

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

◆ SetInfo()

VOID FxUsbInterface::SetInfo ( __in PUSBD_INTERFACE_INFORMATION Interface )

Definition at line 167 of file fxusbinterface.cpp.

{
    UCHAR i;
 
    ASSERT(m_InterfaceNumber == InterfaceInfo->InterfaceNumber);
 
    m_CurAlternateSetting = InterfaceInfo->AlternateSetting;
 
    for (i = 0; i < m_NumberOfConfiguredPipes ; i++) {
        m_ConfiguredPipes[i]->InitPipe(&InterfaceInfo->Pipes[i],
                                       InterfaceInfo->InterfaceNumber,
                                       this);
    }
}

Referenced by FxUsbDevice::SelectConfig(), and SelectSetting().

◆ SetNumConfiguredPipes()

VOID FxUsbInterface::SetNumConfiguredPipes ( __in UCHAR NumberOfPipes )

inline

Definition at line 123 of file fxusbinterface.hpp.

    {
        m_NumberOfConfiguredPipes = NumberOfPipes;
    }

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

◆ SetWinUsbHandle()

NTSTATUS FxUsbInterface::SetWinUsbHandle ( _In_ UCHAR FrameworkInterfaceIndex )

Definition at line 28 of file fxusbinterfaceum.cpp.

{
    NTSTATUS status = STATUS_SUCCESS;
    UMURB urb;
 
    if (m_InterfaceNumber != FrameworkInterfaceIndex) {
        DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_INFORMATION, TRACINGIOTARGET,
                            "Composite device detected: Converting absolute interface "
                            "index %d to relative interface index %d", m_InterfaceNumber,
                            FrameworkInterfaceIndex);
    }
 
    if (FrameworkInterfaceIndex == 0) {
        m_WinUsbHandle = m_UsbDevice->m_WinUsbHandle;
    }
    else {
        RtlZeroMemory(&urb, sizeof(UMURB));
 
        urb.UmUrbGetAssociatedInterface.Hdr.InterfaceHandle = m_UsbDevice->m_WinUsbHandle;
        urb.UmUrbGetAssociatedInterface.Hdr.Function = UMURB_FUNCTION_GET_ASSOCIATED_INTERFACE;
        urb.UmUrbGetAssociatedInterface.Hdr.Length = sizeof(_UMURB_GET_ASSOCIATED_INTERFACE);
 
        //
        // If this is using the WinUSB dispatcher, this will ultimately call
        // WinUsb_GetAssociatedInterface which expects a 0-based index but starts
        // counting from index 1. To get the handle for interface n, we pass n-1
        // and WinUSB will return the handle for (n-1)+1.
        //
        // The NativeUSB dispatcher ultimately calls WdfUsbTargetDeviceGetInterface.
        // Unlike WinUSB.sys, this starts counting from index zero. The NativeUSB
        // dispatcher expects this framework quirk and adjusts accordingly. See
        // WudfNativeUsbDispatcher.cpp for more information.
        //
        // The actual interface number may differ from the interface index in
        // composite devices. In all cases, the interface index (starting from zero)
        // must be used.
        //
        urb.UmUrbGetAssociatedInterface.InterfaceIndex = FrameworkInterfaceIndex - 1;
 
        status = m_UsbDevice->SendSyncUmUrb(&urb, 5);
 
        if (NT_SUCCESS(status)) {
            m_WinUsbHandle = urb.UmUrbGetAssociatedInterface.InterfaceHandle;
        }
        else {
            DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                                "Failed to retrieve WinUsb interface handle");
            m_WinUsbHandle = NULL;
        }
    }
 
    return status;
}

◆ UpdatePipeAttributes()

NTSTATUS FxUsbInterface::UpdatePipeAttributes ( __in PWDF_OBJECT_ATTRIBUTES PipesAttributes )

Definition at line 196 of file fxusbinterfaceum.cpp.

{
    NTSTATUS status = STATUS_SUCCESS;
    UCHAR iPipe;
    FxUsbPipe** ppPipes;
    UCHAR numberOfPipes;
 
    numberOfPipes = m_NumberOfConfiguredPipes;
    ppPipes = m_ConfiguredPipes;
 
    for (iPipe = 0; iPipe < numberOfPipes; iPipe++) {
        status = FxObjectAllocateContext(ppPipes[iPipe],
                                         PipesAttributes,
                                         TRUE,
                                         NULL);
        if (!NT_SUCCESS(status)) {
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                "UpdatePipeAttributes failed  %!STATUS!", status);
            break;
        }
    }
 
    //
    // Pipe attributes are updated as part of select
    // config and it is ok for the client driver to configure
    // twice with the same attributes. In a similar scenario,
    // KMDF will return STATUS_SUCCESS, so we should do the
    // same for UMDF for consistency
    //
    if (status == STATUS_OBJECT_NAME_EXISTS) {
        status = STATUS_SUCCESS;
    }
 
    return status;
}

Member Data Documentation

◆ FxUsbDevice

friend FxUsbInterface::FxUsbDevice

Definition at line 34 of file fxusbinterface.hpp.

◆ FxUsbPipe

friend FxUsbInterface::FxUsbPipe

Definition at line 35 of file fxusbinterface.hpp.

Referenced by MakeAndConfigurePipes(), and SelectSetting().

◆ m_Class

UCHAR FxUsbInterface::m_Class

protected

Definition at line 255 of file fxusbinterface.hpp.

Referenced by CreateSettings(), and FxUsbInterface().

◆ m_ConfiguredPipes

FxUsbPipe** FxUsbInterface::m_ConfiguredPipes

protected

Definition at line 233 of file fxusbinterface.hpp.

Referenced by FxUsbDevice::CancelSentIo(), CleanUpAndDelete(), FxUsbInterface(), GetConfiguredPipe(), IsInterfaceConfigured(), MakeAndConfigurePipes(), FxUsbDevice::PipesGotoRemoveState(), FxUsbDevice::Purge(), RemoveDeletedPipe(), SelectSetting(), SetConfiguredPipes(), SetInfo(), FxUsbDevice::Start(), FxUsbDevice::Stop(), UpdatePipeAttributes(), and ~FxUsbInterface().

◆ m_CurAlternateSetting

UCHAR FxUsbInterface::m_CurAlternateSetting

protected

Definition at line 254 of file fxusbinterface.hpp.

Referenced by FxUsbInterface(), GetConfiguredSettingIndex(), MakeAndConfigurePipes(), SelectSetting(), SelectSettingByDescriptor(), SelectSettingByIndex(), and SetInfo().

◆ m_InterfaceNumber

UCHAR FxUsbInterface::m_InterfaceNumber

protected

Definition at line 253 of file fxusbinterface.hpp.

Referenced by CreateSettings(), FormatSelectSettingUrb(), FxUsbInterface(), GetInterfaceNumber(), MakeAndConfigurePipes(), SelectSettingByDescriptor(), SetInfo(), and SetWinUsbHandle().

◆ m_NumberOfConfiguredPipes

UCHAR FxUsbInterface::m_NumberOfConfiguredPipes

protected

Definition at line 248 of file fxusbinterface.hpp.

Referenced by FxUsbDevice::CancelSentIo(), CleanUpAndDelete(), FxUsbInterface(), GetConfiguredPipe(), GetNumConfiguredPipes(), MakeAndConfigurePipes(), FxUsbDevice::PipesGotoRemoveState(), FxUsbDevice::Purge(), RemoveDeletedPipe(), SetInfo(), SetNumConfiguredPipes(), FxUsbDevice::Start(), FxUsbDevice::Stop(), UpdatePipeAttributes(), and ~FxUsbInterface().

◆ m_NumSettings

UCHAR FxUsbInterface::m_NumSettings

protected

Definition at line 243 of file fxusbinterface.hpp.

Referenced by CreateSettings(), FxUsbInterface(), GetDescriptor(), GetNumEndpoints(), GetNumSettings(), GetSettingDescriptor(), and SelectSettingByIndex().

◆ m_Protocol

UCHAR FxUsbInterface::m_Protocol

protected

Definition at line 257 of file fxusbinterface.hpp.

Referenced by CreateSettings(), and FxUsbInterface().

◆ m_SubClass

UCHAR FxUsbInterface::m_SubClass

protected

Definition at line 256 of file fxusbinterface.hpp.

Referenced by CreateSettings(), and FxUsbInterface().

◆ m_UsbDevice

FxUsbDevice* FxUsbInterface::m_UsbDevice

protected

Definition at line 228 of file fxusbinterface.hpp.

Referenced by CleanUpAndDelete(), CreateSettings(), DetermineDefaultMaxTransferSize(), FormatSelectSettingUrb(), FxUsbInterface(), GetEndpointInformation(), MakeAndConfigurePipes(), SelectSetting(), SelectSettingByIndex(), SetWinUsbHandle(), and ~FxUsbInterface().

◆ m_WinUsbHandle

WINUSB_INTERFACE_HANDLE FxUsbInterface::m_WinUsbHandle

private

Definition at line 264 of file fxusbinterface.hpp.

Referenced by FxUsbPipe::FormatAbortRequest(), FxUsbPipe::FormatResetRequest(), MakeAndConfigurePipes(), SelectSettingByIndex(), and SetWinUsbHandle().

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

sdk/lib/drivers/wdf/shared/inc/private/common/fxusbinterface.hpp
sdk/lib/drivers/wdf/shared/targets/usb/fxusbinterface.cpp
sdk/lib/drivers/wdf/shared/targets/usb/um/fxusbinterfaceum.cpp

Public Member Functions

Public Attributes

Protected Member Functions

Protected Attributes

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ FxUsbInterface()

◆ ~FxUsbInterface()

Member Function Documentation

◆ __field_ecount()

◆ CheckAndSelectSettingByIndex()

◆ CleanUpAndDelete()

◆ CopyEndpointFieldsFromDescriptor()

◆ CreateSettings()

◆ DetermineDefaultMaxTransferSize()

◆ FormatSelectSettingUrb()

◆ GetConfiguredPipe()

◆ GetConfiguredSettingIndex()

◆ GetDescriptor()

◆ GetEndpointInformation()

◆ GetHandle()

◆ GetInterfaceNumber()

◆ GetNumConfiguredPipes()

◆ GetNumEndpoints()

◆ GetNumSettings()

◆ GetSettingDescriptor()

◆ IsInterfaceConfigured()

◆ MakeAndConfigurePipes()

◆ RemoveDeletedPipe()

◆ SelectSetting()

◆ SelectSettingByDescriptor()

◆ SelectSettingByIndex()

◆ SetConfiguredPipes()

◆ SetInfo()

◆ SetNumConfiguredPipes()

◆ SetWinUsbHandle()

◆ UpdatePipeAttributes()

Member Data Documentation

◆ FxUsbDevice

◆ FxUsbPipe

◆ m_Class

◆ m_ConfiguredPipes

◆ m_CurAlternateSetting

◆ m_InterfaceNumber

◆ m_NumberOfConfiguredPipes

◆ m_NumSettings

◆ m_Protocol

◆ m_SubClass

◆ m_UsbDevice

◆ m_WinUsbHandle