Something went wrong. Try again.
Reactos
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481/*++
Copyright (c) Microsoft Corporation
Module Name:
FxUsbDevice.cpp
Abstract:
Author:
Environment:
kernel mode only
Revision History:
--*/
extern "C" {#include <initguid.h>}
#include "fxusbpch.hpp"
extern "C" {#if defined(EVENT_TRACING)#include "FxUsbDevice.tmh"#endif
#define RtlSizeTToULong RtlULongPtrToULong}
#if (FX_CORE_MODE == FX_CORE_KERNEL_MODE)#define UCHAR_MAX (0xff)#endif
FxUsbDeviceControlContext::FxUsbDeviceControlContext( __in FX_URB_TYPE FxUrbType ) : FxUsbRequestContext(FX_RCT_USB_CONTROL_REQUEST){ m_PartialMdl = NULL; m_UnlockPages = FALSE; m_USBDHandle = NULL;
if (FxUrbType == FxUrbTypeLegacy) { m_Urb = &m_UrbLegacy; } else { m_Urb = NULL; }}
FxUsbDeviceControlContext::~FxUsbDeviceControlContext( VOID ){ if (m_Urb && (m_Urb != &m_UrbLegacy)) { USBD_UrbFree(m_USBDHandle, (PURB)m_Urb); } m_Urb = NULL; m_USBDHandle = NULL;}
__checkReturnNTSTATUSFxUsbDeviceControlContext::AllocateUrb( __in USBD_HANDLE USBDHandle ){ NTSTATUS status;
ASSERT(USBDHandle != NULL); ASSERT(m_Urb == NULL);
status = USBD_UrbAllocate(USBDHandle, (PURB*)&m_Urb);
if (!NT_SUCCESS(status)) { goto Done; }
m_USBDHandle = USBDHandle;
Done: return status;}
VOIDFxUsbDeviceControlContext::Dispose( VOID ){ if (m_Urb && (m_Urb != &m_UrbLegacy)){ USBD_UrbFree(m_USBDHandle, (PURB) m_Urb); m_Urb = NULL; m_USBDHandle = NULL; }}
VOIDFxUsbDeviceControlContext::CopyParameters( __in FxRequestBase* Request ){#if (FX_CORE_MODE == FX_CORE_KERNEL_MODE) m_CompletionParams.IoStatus.Information = m_Urb->TransferBufferLength; m_UsbParameters.Parameters.DeviceControlTransfer.Length = m_Urb->TransferBufferLength;#elif (FX_CORE_MODE == FX_CORE_USER_MODE) m_CompletionParams.IoStatus.Information = m_UmUrb.UmUrbControlTransfer.TransferBufferLength; m_UsbParameters.Parameters.DeviceControlTransfer.Length = m_UmUrb.UmUrbControlTransfer.TransferBufferLength;#endif FxUsbRequestContext::CopyParameters(Request); // __super call}
VOIDFxUsbDeviceControlContext::ReleaseAndRestore( __in FxRequestBase* Request ){ // // Check now because Init will NULL out the field // if (m_PartialMdl != NULL) { if (m_UnlockPages) { Mx::MxUnlockPages(m_PartialMdl); m_UnlockPages = FALSE; }
#if (FX_CORE_MODE == FX_CORE_KERNEL_MODE) FxMdlFree(Request->GetDriverGlobals(), m_PartialMdl);#endif m_PartialMdl = NULL; }
FxUsbRequestContext::ReleaseAndRestore(Request); // __super call}
USBD_STATUSFxUsbDeviceControlContext::GetUsbdStatus( VOID ){ return m_Urb->Hdr.Status;}
FxUsbDeviceStringContext::FxUsbDeviceStringContext( __in FX_URB_TYPE FxUrbType ) : FxUsbRequestContext(FX_RCT_USB_STRING_REQUEST){ m_USBDHandle = NULL; m_StringDescriptor = NULL; m_StringDescriptorLength = 0; RtlZeroMemory(&m_UrbLegacy, sizeof(m_UrbLegacy));
if (FxUrbType == FxUrbTypeLegacy) { m_Urb = &m_UrbLegacy; m_Urb->Hdr.Function = URB_FUNCTION_GET_DESCRIPTOR_FROM_DEVICE; m_Urb->Hdr.Length = sizeof(*m_Urb); m_Urb->DescriptorType = USB_STRING_DESCRIPTOR_TYPE; } else { m_Urb = NULL; }}
FxUsbDeviceStringContext::~FxUsbDeviceStringContext( VOID ){ if (m_StringDescriptor != NULL) { FxPoolFree(m_StringDescriptor); m_StringDescriptor = NULL; }
if (m_Urb && (m_Urb != &m_UrbLegacy)){ USBD_UrbFree(m_USBDHandle, (PURB) m_Urb); } m_Urb = NULL; m_USBDHandle = NULL;}
__checkReturnNTSTATUSFxUsbDeviceStringContext::AllocateUrb( __in USBD_HANDLE USBDHandle ){ NTSTATUS status;
ASSERT(USBDHandle != NULL); ASSERT(m_Urb == NULL);
status = USBD_UrbAllocate(USBDHandle, (PURB*)&m_Urb);
if (!NT_SUCCESS(status)) { goto Done; }
m_USBDHandle = USBDHandle;
m_Urb->Hdr.Function = URB_FUNCTION_GET_DESCRIPTOR_FROM_DEVICE; m_Urb->Hdr.Length = sizeof(*m_Urb); m_Urb->DescriptorType = USB_STRING_DESCRIPTOR_TYPE;
Done: return status;}
VOIDFxUsbDeviceStringContext::Dispose( VOID ){ if (m_Urb && (m_Urb != &m_UrbLegacy)){ USBD_UrbFree(m_USBDHandle, (PURB) m_Urb); m_Urb = NULL; m_USBDHandle = NULL; }
}
VOIDFxUsbDeviceStringContext::CopyParameters( __in FxRequestBase* Request ){ // // Make sure we got an even number of bytes and that we got a header // if ((m_StringDescriptor->bLength & 0x1) || m_StringDescriptor->bLength < sizeof(USB_COMMON_DESCRIPTOR)) { m_CompletionParams.IoStatus.Status = STATUS_DEVICE_DATA_ERROR; } else if (NT_SUCCESS(Request->GetSubmitFxIrp()->GetStatus())) { // // No matter what, indicate the required size to the caller // m_UsbParameters.Parameters.DeviceString.RequiredSize = m_StringDescriptor->bLength - sizeof(USB_COMMON_DESCRIPTOR);
if (m_UsbParameters.Parameters.DeviceString.RequiredSize > m_RequestMemory->GetBufferSize()) { // // Too much string to fit into the buffer supplied by the client. // Morph the status into a warning. Copy as much as we can. // m_CompletionParams.IoStatus.Status = STATUS_BUFFER_OVERFLOW; RtlCopyMemory(m_RequestMemory->GetBuffer(), &m_StringDescriptor->bString[0], m_RequestMemory->GetBufferSize()); } else { // // Everything fits, copy it over // m_CompletionParams.IoStatus.Information = m_UsbParameters.Parameters.DeviceString.RequiredSize;
RtlCopyMemory(m_RequestMemory->GetBuffer(), &m_StringDescriptor->bString[0], m_UsbParameters.Parameters.DeviceString.RequiredSize); } }
FxUsbRequestContext::CopyParameters(Request); // __super call}
VOIDFxUsbDeviceStringContext::SetUrbInfo( __in UCHAR StringIndex, __in USHORT LangID ){ SetUsbType(WdfUsbRequestTypeDeviceString);
ASSERT(m_StringDescriptor != NULL && m_StringDescriptorLength != 0);
#if (FX_CORE_MODE == FX_CORE_KERNEL_MODE) m_Urb->TransferBuffer = m_StringDescriptor; m_Urb->TransferBufferLength = m_StringDescriptorLength;
m_Urb->Index = StringIndex; m_Urb->LanguageId = LangID;#elif (FX_CORE_MODE == FX_CORE_USER_MODE) m_UmUrb.UmUrbDescriptorRequest.Buffer = m_StringDescriptor; m_UmUrb.UmUrbDescriptorRequest.BufferLength = m_StringDescriptorLength;
m_UmUrb.UmUrbDescriptorRequest.Index = StringIndex; m_UmUrb.UmUrbDescriptorRequest.LanguageID = LangID;#endif}
USBD_STATUSFxUsbDeviceStringContext::GetUsbdStatus( VOID ){ return m_Urb->Hdr.Status;}
_Must_inspect_result_NTSTATUSFxUsbDeviceStringContext::AllocateDescriptor( __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in size_t BufferSize ){ PUSB_STRING_DESCRIPTOR pDescriptor; size_t length; NTSTATUS status;
if (BufferSize <= m_StringDescriptorLength) { return STATUS_SUCCESS; }
length = sizeof(USB_STRING_DESCRIPTOR) - sizeof(pDescriptor->bString[0]) + BufferSize;
pDescriptor = (PUSB_STRING_DESCRIPTOR) FxPoolAllocate( FxDriverGlobals, NonPagedPool, length);
if (pDescriptor == NULL) { return STATUS_INSUFFICIENT_RESOURCES; }
if (m_StringDescriptor != NULL) { FxPoolFree(m_StringDescriptor); }
RtlZeroMemory(pDescriptor, length);
m_StringDescriptor = pDescriptor;
status = RtlSizeTToULong(length, &m_StringDescriptorLength);
return status;}
FxUsbUrb::FxUsbUrb( __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in USBD_HANDLE USBDHandle, __in_bcount(BufferSize) PVOID Buffer, __in size_t BufferSize ) : FxMemoryBufferPreallocated(FxDriverGlobals, sizeof(*this), Buffer, BufferSize), m_USBDHandle(USBDHandle){ MarkDisposeOverride();}
FxUsbUrb::~FxUsbUrb(){}
BOOLEANFxUsbUrb::Dispose( VOID ){ ASSERT(m_USBDHandle != NULL); ASSERT(m_pBuffer != NULL); USBD_UrbFree(m_USBDHandle, (PURB)m_pBuffer); m_pBuffer = NULL; m_USBDHandle = NULL;
return FxMemoryBufferPreallocated::Dispose(); // __super call}
FxUsbDevice::FxUsbDevice( __in PFX_DRIVER_GLOBALS FxDriverGlobals ) : 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);}
BOOLEANFxUsbDevice::Dispose( VOID ){#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}
FxUsbDevice::~FxUsbDevice(){ 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;}
VOIDFxUsbDevice::RemoveDeletedInterface( __in FxUsbInterface* Interface ){ UCHAR i;
if (m_Interfaces == NULL) { return; }
for (i = 0; i < m_NumInterfaces; i++) { if (m_Interfaces[i] == Interface) { m_Interfaces[i] = NULL; return; } }}
VOIDFxUsbDevice::GetInformation( __out PWDF_USB_DEVICE_INFORMATION Information ){ Information->Traits = m_Traits; Information->HcdPortCapabilities = m_HcdPortCapabilities;
RtlCopyMemory(&Information->UsbdVersionInformation, &m_UsbdVersionInformation, sizeof(m_UsbdVersionInformation));}
ULONGFxUsbDevice::GetDefaultMaxTransferSize( VOID )/*++
Routine Description: Determines the default max transfer size based on the usb host controller and OS we are running on. What it boils down to is that on XP and later the usb core ignores the default max transfer size, but it does use the value on Windows 2000. To make life fun, there is only one definition of USBD_DEFAULT_MAXIMUM_TRANSFER_SIZE whose value changes depending on header versioning. Since we are versioned for the latest OS, we do not pick up the Win2k value by using the #define, rather we have to use the value that we *would* have picked up if we were header versioned for Win2k.
NOTE: we could be on win2k with a usbport serviced stack. in this case, usbport doesn't care about max transfer sizes
Arguments: None
Return Value: usb core and OS appropriate default max transfer size.
--*/{ // // 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;}
_Must_inspect_result_NTSTATUSFxUsbDevice::Start( VOID ){ 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;}
#define STOP_TAG (PVOID) 'pots'
VOIDFxUsbDevice::Stop( __in WDF_IO_TARGET_SENT_IO_ACTION Action ){ 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(); }}
VOIDFxUsbDevice::Purge( __in WDF_IO_TARGET_PURGE_IO_ACTION Action ){ 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(); }}
VOIDFxUsbDevice::_CleanupPipesRequests( __in PLIST_ENTRY PendHead, __in PSINGLE_LIST_ENTRY SentHead ){ while (!IsListEmpty(PendHead)) { PLIST_ENTRY ple; FxRequestBase* pRequest;
ple = RemoveHeadList(PendHead);
InitializeListHead(ple);
pRequest = FxRequestBase::_FromListEntry(ple); pRequest->GetTarget()->CompletePendedRequest(pRequest); }
_CancelSentRequests(SentHead);}
VOIDFxUsbDevice::PipesGotoRemoveState( __in BOOLEAN ForceRemovePipes ){ 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();}
_Must_inspect_result_NTSTATUSFxUsbDevice::CreateInterfaces( VOID ){ 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;}
_Must_inspect_result_NTSTATUSFxUsbDevice::GetPortStatus( __out PULONG PortStatus ){ 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;}
BOOLEANFxUsbDevice::IsEnabled( VOID ){ 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;}
_Must_inspect_result_NTSTATUSFxUsbDevice::IsConnected( VOID ){#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}
_Must_inspect_result_NTSTATUSFxUsbDevice::CyclePort( VOID ){ 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;}
_Must_inspect_result_NTSTATUSFxUsbDevice::FormatCycleRequest( __in FxRequestBase* Request ){ FxRequestBuffer emptyBuffer;
return FormatIoctlRequest(Request, IOCTL_INTERNAL_USB_CYCLE_PORT, TRUE, &emptyBuffer, &emptyBuffer);}
_Must_inspect_result_NTSTATUSFxUsbDevice::GetConfigDescriptor( __out PVOID ConfigDescriptor, __inout PUSHORT ConfigDescriptorLength ){ 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;}
_Must_inspect_result_NTSTATUSFxUsbDevice::SelectConfigDescriptor( __in PWDF_OBJECT_ATTRIBUTES PipesAttributes, __in PWDF_USB_DEVICE_SELECT_CONFIG_PARAMS Params ){ 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;}
struct FxInterfacePipeInformation { // // Array of pipes // FxUsbPipe** Pipes;
// // Number of entries in Pipes // ULONG NumPipes;};
_Must_inspect_result_NTSTATUSFxUsbDevice::SelectConfig( __in PWDF_OBJECT_ATTRIBUTES PipesAttributes, __in PURB Urb, __in FX_URB_TYPE FxUrbType, __out_opt PUCHAR NumConfiguredInterfaces )/*++
Routine Description: Selects the configuration as described by the parameter Urb. If there is a previous active configuration, the WDFUSBPIPEs for it are stopped and destroyed before the new configuration is selected
Arguments: PipesAttributes - object attributes to apply to each created WDFUSBPIPE
Urb - the URB describing the configuration to select
Return Value: NTSTATUS
--*/{ 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;}
_Must_inspect_result_NTSTATUSFxUsbDevice::Deconfig( VOID ){ 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;}
_Must_inspect_result_NTSTATUSFxUsbDevice::SelectConfigInterfaces( __in PWDF_OBJECT_ATTRIBUTES PipesAttributes, __in PUSB_CONFIGURATION_DESCRIPTOR ConfigurationDescriptor, __in_ecount(NumInterfaces) PUSB_INTERFACE_DESCRIPTOR* InterfaceDescriptors, __in ULONG NumInterfaces ){ 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;}
FxUsbInterface *FxUsbDevice::GetInterfaceFromIndex( __in UCHAR InterfaceIndex ){ if (InterfaceIndex < m_NumInterfaces){ return m_Interfaces[InterfaceIndex]; }
return NULL;}
_Must_inspect_result_NTSTATUSFxUsbDevice::GetInterfaceNumberFromInterface( __in WDFUSBINTERFACE UsbInterface, __out PUCHAR InterfaceNumber ){ FxUsbInterface * pUsbInterface;
FxObjectHandleGetPtr(GetDriverGlobals(), UsbInterface, FX_TYPE_USB_INTERFACE , (PVOID*) &pUsbInterface);
*InterfaceNumber = pUsbInterface->GetInterfaceNumber();
return STATUS_SUCCESS;}
FxUsbInterface *FxUsbDevice::GetInterfaceFromNumber( __in UCHAR InterfaceNumber ){ ULONG i;
for (i = 0; i < m_NumInterfaces; i++) { if (m_Interfaces[i]->GetInterfaceNumber() == InterfaceNumber) { return m_Interfaces[i]; } }
return NULL;}
VOIDFxUsbDevice::CleanupInterfacePipesAndDelete( __in FxUsbInterface * UsbInterface ){ 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();}
VOIDFxUsbDevice::CancelSentIo( VOID ){ 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}
__checkReturnNTSTATUSFxUsbDevice::CreateUrb( __in_opt PWDF_OBJECT_ATTRIBUTES Attributes, __out WDFMEMORY* UrbMemory, __deref_opt_out_bcount(sizeof(URB)) PURB* Urb ){ 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;}
__checkReturnNTSTATUSFxUsbDevice::CreateIsochUrb( __in_opt PWDF_OBJECT_ATTRIBUTES Attributes, __in ULONG NumberOfIsochPackets, __out WDFMEMORY* UrbMemory, __deref_opt_out_bcount(GET_ISOCH_URB_SIZE(NumberOfIsochPackets)) PURB* Urb ){ 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;}
BOOLEANFxUsbDevice::IsObjectDisposedOnRemove( __in FxObject* Object )/*++
Routine Description: This routine determines if the Object being passed is guranteed to be disposed on a Pnp remove operation.
The object will be disposed on Pnp remove operation if it is a somewhere in the child tree of the FxDevice assocaited with this FxUsbDevice object, or in the child tree of an Io Allocated Request.
Arguments:
Object - The Object being checked
Return Value:
TRUE if the Object is guranteed to be disposed on a pnp remove operation FALSE otherwise.
--*/{ 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;}
FX_URB_TYPEFxUsbDevice::GetFxUrbTypeForRequest( __in FxRequestBase* Request )/*++
Routine Description: This routine essentially determines whether this routine can use a urb allocated by the USBD_xxxUrbAllocate APIs
The USBD_xxxUrbAllocate APIs are only used for those requests that could be disposed at the time the client driver devnode is being removed.
If we cannot make that gurantee about that request, FxUrbTypeLegacy is returned and the USBD_xxxUrbAllocate api's must not be used to allocate an Urb.
Else FxUrbTypeUsbdAllocated is returned.
Arguments:
Request - FxRequest
Return Value:
FxUrbTypeUsbdAllocated, or FxUrbTypeLegacy
--*/{ if (m_UrbType == FxUrbTypeLegacy) { return FxUrbTypeLegacy; }
if (Request->IsAllocatedFromIo()) { return FxUrbTypeUsbdAllocated; }
if (IsObjectDisposedOnRemove((FxObject*) Request)) { return FxUrbTypeUsbdAllocated; }
return FxUrbTypeLegacy;}