Something went wrong. Try again.
Reactos
Something went wrong. Try again.
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172/*++
Copyright (c) Microsoft Corporation
Module Name:
FxUsbInterface.cpp
Abstract:
Author:
Environment:
Both kernel and user mode
Revision History:
--*/
#include "fxusbpch.hpp"
extern "C" {#if defined(EVENT_TRACING)#include "FxUsbInterface.tmh"#endif}
FxUsbInterface::FxUsbInterface( __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in FxUsbDevice* UsbDevice, __in PUSB_INTERFACE_DESCRIPTOR InterfaceDescriptor ) : 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(){ 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);}
VOIDFxUsbInterface::CleanUpAndDelete( __in BOOLEAN Failure )/*++
Routine Description: Deletes the pipes contained on the interface.
Arguments: Failure - if TRUE, the pipes were never exposed to the client, so any attributes are cleared before deletion (via DeleteFromFailedCreate)
Assumes: FxUsbDevice::InterfaceIterationLock is held by the caller
Return Value: None
--*/{ 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; }}
VOIDFxUsbInterface::RemoveDeletedPipe( __in FxUsbPipe* Pipe ){ ULONG i;
if (m_ConfiguredPipes == NULL) { return; }
for (i = 0; i < m_NumberOfConfiguredPipes; i++) { if (m_ConfiguredPipes[i] == Pipe) { m_ConfiguredPipes[i] = NULL; return; } }}
VOIDFxUsbInterface::SetInfo( __in PUSBD_INTERFACE_INFORMATION InterfaceInfo )/*++
Routine Description: Captures the alternate from the interface information into this structure and then assigns info to all the created pipes.
Arguments: InterfaceInfo - info to capture
Return Value: None
--*/{ 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); }}
_Must_inspect_result_NTSTATUSFxUsbInterface::CreateSettings( VOID )/*++
Routine Description: 1) Find the max number of settings for the interface 2) Allocate an array for the settings 3) Create a setting object for each setting and initialize
Arguments: None
Return Value: NTSTATUS
--*/{ 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;}
_Must_inspect_result_NTSTATUSFxUsbInterface::SelectSettingByIndex( __in PWDF_OBJECT_ATTRIBUTES PipesAttributes, __in UCHAR SettingIndex )/*++
Routine Description: Setlects a setting by alternate setting index.
Arguments: PipesAttributes - optional attributes to apply to each of the created pipes
SettingIndex - alternate setting index to use
Return Value: NTSTATUS
--*/{#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;}
_Must_inspect_result_NTSTATUSFxUsbInterface::SelectSettingByDescriptor( __in PWDF_OBJECT_ATTRIBUTES PipesAttributes, __in PUSB_INTERFACE_DESCRIPTOR InterfaceDescriptor )/*++
Routine Description: Selects an alternate setting by using a USB interface descriptor
Arguments: PipesAttributes - optional attributes to apply to each of the created pipes
Return Value: NTSTATUS
--*/{ 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;}
_Must_inspect_result_NTSTATUSFxUsbInterface::CheckAndSelectSettingByIndex( __in UCHAR SettingIndex )/*++
Routine Description: Checks if the give SettingIndex is the current alternate setting and if not, selects that setting
Arguments: SettingIndex - Alternate setting
Return Value: NTSTATUS
--*/{ if (GetConfiguredSettingIndex() != SettingIndex) { return SelectSettingByIndex(NULL, SettingIndex); } else { return STATUS_SUCCESS; }}
_Must_inspect_result_NTSTATUSFxUsbInterface::SelectSetting( __in PWDF_OBJECT_ATTRIBUTES PipesAttributes, __in PURB Urb )/*++
Routine Description: Worker function which all top level SelectSetting DDIs call into. This will 1) preallocate all required objects so that we can return failure before we make any undoable changes to the device's state 2) send the select interface URB to the device 3) initialize all created objects
Arguments: PipesAttributes - optional attributes to apply to all created pipes
Urb - Urb to send to the device
Return Value: NTSTATUS
--*/{ 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;}
VOIDFxUsbInterface::FormatSelectSettingUrb( __in_bcount(GET_SELECT_INTERFACE_REQUEST_SIZE(NumEndpoints)) PURB Urb, __in USHORT NumEndpoints, __in UCHAR SettingNumber )/*++
Routine Description: Format a URB for selecting an interface's new setting. Note this will setup the URB header and all pipes' information in the URB's array of pipe infos.
This function exists as a method of FxUsbDevice instead of FxUsbInterface because in the case of a select config where we manually select setting 0 on interfaces 2...N we don't have an FxUsbInterface pointer
Arguments: Urb - the URB to format. It is assumed the caller allocated a large enough URB to contain NumEndpoints
NumEndpoints - number of endpoints in the new setting
InterfaceNum - interface number for the interface
SettingNumber - setting number on the interface
--*/{ 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; }}
VOIDFxUsbInterface::GetEndpointInformation( __in UCHAR SettingIndex, __in UCHAR EndpointIndex, __in PWDF_USB_PIPE_INFORMATION PipeInfo )/*++
Routine Description: The layout of the config descriptor is such that each interface+setting pair is followed by the endpoints for that interface+setting pair. Keep track of the index.
Arguments: SettingIndex - alternate setting to get info for
EndpointIndex - index into the number endpoints for this interface+setting
PipeInfo - Info to return
Return Value: None
--*/{ 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; }}
ULONGFxUsbInterface::DetermineDefaultMaxTransferSize( VOID )/*++
Routine Description: Returns the maximum transfer size of an endpoint
Arguments: None
Return Value: max transfer size
--*/{ if (m_UsbDevice->m_Traits & WDF_USB_DEVICE_TRAIT_AT_HIGH_SPEED) { return FxUsbPipeHighSpeedMaxTransferSize; } else { return FxUsbPipeLowSpeedMaxTransferSize; }}
VOIDFxUsbInterface::CopyEndpointFieldsFromDescriptor( __in PWDF_USB_PIPE_INFORMATION PipeInfo, __in PUSB_ENDPOINT_DESCRIPTOR EndpointDesc, __in UCHAR SettingIndex )/*++
Routine Description: Copy informatoin out of the usb endpoint descriptor into this object
Arguments: PipeInfo - information to return
EndpointDesc - descriptor to copy from
SettingIndex - alternate setting this information is for
Return Value: None
--*/{ 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;}
WDFUSBPIPEFxUsbInterface::GetConfiguredPipe( __in UCHAR PipeIndex, __out_opt PWDF_USB_PIPE_INFORMATION PipeInfo )/*++
Routine Description: Return the WDFUSBPIPE for the given index
Arguments: PipeIndex - index into the number of configured pipes for the interface
PipeInfo - optional information to return about the returned pipe
Return Value: valid WDFUSBPIPE handle or NULL on error
--*/{ if (PipeIndex >= m_NumberOfConfiguredPipes) { return NULL; } else { if (PipeInfo != NULL) { m_ConfiguredPipes[PipeIndex]->GetInformation(PipeInfo); }
return m_ConfiguredPipes[PipeIndex]->GetHandle(); }}
VOIDFxUsbInterface::GetDescriptor( __in PUSB_INTERFACE_DESCRIPTOR UsbInterfaceDescriptor, __in UCHAR SettingIndex )/*++
Routine Description: Copies the descriptor back to the caller
Arguments: UsbInterfaceDescriptor - descriptor pointer to fill in
SettingIndex - alternate setting that the caller is interested in
Return Value: None
--*/{ if (SettingIndex >= m_NumSettings) { RtlZeroMemory(UsbInterfaceDescriptor, sizeof(*UsbInterfaceDescriptor)); } else { RtlCopyMemory(UsbInterfaceDescriptor, m_Settings[SettingIndex].InterfaceDescriptor, sizeof(*UsbInterfaceDescriptor)); }}
UCHARFxUsbInterface::GetConfiguredSettingIndex( VOID )/*++
Routine Description: Returns the currently configured setting index for the interface
Arguments: None
Return Value: Currently configured Index
--*/
{ 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; }}
UCHARFxUsbInterface::GetNumEndpoints( __in UCHAR SettingIndex )/*++
Routine Description: Returns the number of endpoints on a given alternate interface
Arguments: SettingIndex - index of the alternate setting
Return Value: Number of endpoints or 0 on error
--*/{ if (SettingIndex >= m_NumSettings) { return 0; } else { return m_Settings[SettingIndex].InterfaceDescriptor->bNumEndpoints; }}
PUSB_INTERFACE_DESCRIPTORFxUsbInterface::GetSettingDescriptor( __in UCHAR Setting )/*++
Routine Description: Returns the device's interface descriptor for the given alternate setting
Arguments: Setting - AlternateSetting desired
Return Value: USB interface descriptor or NULL on failure
--*/{ UCHAR i;
for (i = 0; i < m_NumSettings; i++) { if (m_Settings[i].InterfaceDescriptor->bAlternateSetting == Setting) { return m_Settings[i].InterfaceDescriptor; } }
return NULL;}