/*++ Copyright (c) 1996 Microsoft Corporation Module Name: device.c Abstract Resource management routines for devices and collections Author: ervinp Environment: Kernel mode only Revision History: --*/ #include "pch.h" #ifdef ALLOC_PRAGMA #pragma alloc_text(PAGE, HidpStartDevice) #pragma alloc_text(PAGE, HidpStartCollectionPDO) #pragma alloc_text(PAGE, AllocDeviceResources) #pragma alloc_text(PAGE, FreeDeviceResources) #pragma alloc_text(PAGE, AllocCollectionResources) #pragma alloc_text(PAGE, FreeCollectionResources) #pragma alloc_text(PAGE, InitializeCollection) #pragma alloc_text(PAGE, HidpCleanUpFdo) #pragma alloc_text(PAGE, HidpRemoveDevice) #pragma alloc_text(PAGE, HidpRemoveCollection) #endif /* ******************************************************************************** * AllocDeviceResources ******************************************************************************** * * */ NTSTATUS AllocDeviceResources(FDO_EXTENSION *fdoExt) { ULONG numCollections; NTSTATUS status = STATUS_SUCCESS; PAGED_CODE(); /* * This will allocate fdoExt->rawReportDescription */ status = HidpGetDeviceDescriptor(fdoExt); if (NT_SUCCESS(status)){ /* * Ask HIDPARSE to fill in the HIDP_DEVICE_DESC for this device. */ status = HidP_GetCollectionDescription( fdoExt->rawReportDescription, fdoExt->rawReportDescriptionLength, NonPagedPool, &fdoExt->deviceDesc); if (NT_SUCCESS(status)){ fdoExt->devDescInitialized = TRUE; numCollections = fdoExt->deviceDesc.CollectionDescLength; ASSERT(numCollections); fdoExt->classCollectionArray = ALLOCATEPOOL(NonPagedPool, numCollections*sizeof(HIDCLASS_COLLECTION)); if (!fdoExt->classCollectionArray){ fdoExt->classCollectionArray = BAD_POINTER; status = STATUS_INSUFFICIENT_RESOURCES; } else { RtlZeroMemory(fdoExt->classCollectionArray, numCollections*sizeof(HIDCLASS_COLLECTION)); } } } else { fdoExt->rawReportDescription = BAD_POINTER; } DBGSUCCESS(status, FALSE) return status; } /* ******************************************************************************** * FreeDeviceResources ******************************************************************************** * * */ VOID FreeDeviceResources(FDO_EXTENSION *fdoExt) { ULONG i; PAGED_CODE(); for (i = 0; i < fdoExt->deviceDesc.CollectionDescLength; i++) { FreeCollectionResources(fdoExt, fdoExt->classCollectionArray[i].CollectionNumber); } /* * Free the stuff returned by HIDPARSE's HidP_GetCollectionDescription. */ if (fdoExt->devDescInitialized){ HidP_FreeCollectionDescription(&fdoExt->deviceDesc); #if DBG fdoExt->deviceDesc.CollectionDesc = BAD_POINTER; fdoExt->deviceDesc.ReportIDs = BAD_POINTER; #endif } fdoExt->deviceDesc.CollectionDescLength = 0; /* * Free the raw report descriptor allocated during START_DEVICE by HidpGetDeviceDescriptor(). */ if (ISPTR(fdoExt->rawReportDescription)){ ExFreePool(fdoExt->rawReportDescription); } fdoExt->rawReportDescription = BAD_POINTER; if (ISPTR(fdoExt->classCollectionArray)){ ExFreePool(fdoExt->classCollectionArray); } fdoExt->classCollectionArray = BAD_POINTER; } /* ******************************************************************************** * AllocCollectionResources ******************************************************************************** * * */ NTSTATUS AllocCollectionResources(FDO_EXTENSION *fdoExt, ULONG collectionNum) { PHIDCLASS_COLLECTION collection; NTSTATUS status = STATUS_SUCCESS; PAGED_CODE(); collection = GetHidclassCollection(fdoExt, collectionNum); if (collection){ ULONG descriptorLen; descriptorLen = collection->hidCollectionInfo.DescriptorSize; if (descriptorLen){ collection->phidDescriptor = ALLOCATEPOOL(NonPagedPool, descriptorLen); if (collection->phidDescriptor){ status = HidpGetCollectionDescriptor( fdoExt, collection->CollectionNumber, collection->phidDescriptor, &descriptorLen); } else { collection->phidDescriptor = BAD_POINTER; status = STATUS_INSUFFICIENT_RESOURCES; } if (NT_SUCCESS(status)){ ULONG i = collection->CollectionIndex; ULONG inputLength; ASSERT(fdoExt->devDescInitialized); inputLength = fdoExt->deviceDesc.CollectionDesc[i].InputLength; if (inputLength){ if (collection->hidCollectionInfo.Polled){ collection->cookedInterruptReportBuf = BAD_POINTER; } else { collection->cookedInterruptReportBuf = ALLOCATEPOOL(NonPagedPool, inputLength); if (!collection->cookedInterruptReportBuf){ status = STATUS_INSUFFICIENT_RESOURCES; } } fdoExt->isOutputOnlyDevice = FALSE; } else { /* * This is an output-only device (e.g. USB monitor) */ DBGWARN(("Zero input length -> output-only device.")) collection->cookedInterruptReportBuf = BAD_POINTER; } } } else { ASSERT(descriptorLen > 0); status = STATUS_DEVICE_CONFIGURATION_ERROR; } } else { status = STATUS_DEVICE_DATA_ERROR; } DBGSUCCESS(status, TRUE) return status; } /* ******************************************************************************** * FreeCollectionResources ******************************************************************************** * * */ VOID FreeCollectionResources(FDO_EXTENSION *fdoExt, ULONG collectionNum) { PHIDCLASS_COLLECTION collection; PAGED_CODE(); collection = GetHidclassCollection(fdoExt, collectionNum); if (collection){ if (collection->hidCollectionInfo.Polled){ if (ISPTR(collection->savedPolledReportBuf)){ ExFreePool(collection->savedPolledReportBuf); } collection->savedPolledReportBuf = BAD_POINTER; } else { if (ISPTR(collection->cookedInterruptReportBuf)){ ExFreePool(collection->cookedInterruptReportBuf); } else { // this is an output-only collection } } collection->cookedInterruptReportBuf = BAD_POINTER; if (ISPTR(collection->phidDescriptor)){ ExFreePool(collection->phidDescriptor); } collection->phidDescriptor = BAD_POINTER; } else { TRAP; } } /* ******************************************************************************** * InitializeCollection ******************************************************************************** * * */ NTSTATUS InitializeCollection(FDO_EXTENSION *fdoExt, ULONG collectionIndex) { PHIDCLASS_COLLECTION collection; ULONG descriptorBufLen; NTSTATUS status = STATUS_SUCCESS; PAGED_CODE(); ASSERT(ISPTR(fdoExt->classCollectionArray)); collection = &fdoExt->classCollectionArray[collectionIndex]; RtlZeroMemory(collection, sizeof(HIDCLASS_COLLECTION)); ASSERT(fdoExt->devDescInitialized); collection->CollectionNumber = fdoExt->deviceDesc.CollectionDesc[collectionIndex].CollectionNumber; collection->CollectionIndex = collectionIndex; InitializeListHead(&collection->FileExtensionList); KeInitializeSpinLock(&collection->FileExtensionListSpinLock); KeInitializeSpinLock(&collection->powerEventSpinLock); KeInitializeSpinLock(&collection->secureReadLock); collection->secureReadMode = 0; descriptorBufLen = sizeof(HID_COLLECTION_INFORMATION); status = HidpGetCollectionInformation( fdoExt, collection->CollectionNumber, &collection->hidCollectionInfo, &descriptorBufLen); DBGSUCCESS(status, TRUE) return status; } void HidpGetRemoteWakeEnableState( PDO_EXTENSION *pdoExt ) { HANDLE hKey; NTSTATUS status; ULONG tmp; BOOLEAN wwEnableFound; hKey = NULL; wwEnableFound = FALSE; status = IoOpenDeviceRegistryKey (pdoExt->pdo, PLUGPLAY_REGKEY_DEVICE, STANDARD_RIGHTS_ALL, &hKey); if (NT_SUCCESS (status)) { UNICODE_STRING valueName; ULONG length; ULONG value; PKEY_VALUE_FULL_INFORMATION fullInfo; PAGED_CODE(); RtlInitUnicodeString (&valueName, HIDCLASS_REMOTE_WAKE_ENABLE); length = sizeof (KEY_VALUE_FULL_INFORMATION) + valueName.MaximumLength + sizeof(value); fullInfo = ExAllocatePool (PagedPool, length); if (fullInfo) { status = ZwQueryValueKey (hKey, &valueName, KeyValueFullInformation, fullInfo, length, &length); if (NT_SUCCESS (status)) { DBGASSERT (sizeof(value) == fullInfo->DataLength, ("Value data wrong length for REmote wake reg value."), TRUE); RtlCopyMemory (&value, ((PUCHAR) fullInfo) + fullInfo->DataOffset, fullInfo->DataLength); pdoExt->remoteWakeEnabled = (value ? TRUE : FALSE); } ExFreePool (fullInfo); } ZwClose (hKey); hKey = NULL; } } WMIGUIDREGINFO HidClassWmiGuidList = { &GUID_POWER_DEVICE_WAKE_ENABLE, 1, 0 // wait wake }; WMIGUIDREGINFO HidClassFdoWmiGuidList = { &GUID_POWER_DEVICE_ENABLE, 1, 0 }; /* ******************************************************************************** * HidpStartCollectionPDO ******************************************************************************** * * */ NTSTATUS HidpStartCollectionPDO(FDO_EXTENSION *fdoExt, PDO_EXTENSION *pdoExt, PIRP Irp) { NTSTATUS status = STATUS_SUCCESS; PAGED_CODE(); /* * Initialize the collection only if it's not already initialized. * This is so we don't destroy the FileExtensionList after a STOP/START. */ if (pdoExt->state == COLLECTION_STATE_UNINITIALIZED){ pdoExt->state = COLLECTION_STATE_INITIALIZED; } if (NT_SUCCESS(status)){ PHIDCLASS_COLLECTION collection = GetHidclassCollection(fdoExt, pdoExt->collectionNum); if (collection){ /* * If all collection PDOs for this device FDO are initialized, * figure out the maximum report size and finish starting the device. */ if (AnyClientPDOsInitialized(fdoExt, TRUE)){ DBGSTATE(fdoExt->state, DEVICE_STATE_START_SUCCESS, FALSE) /* * If this is a polled collection, * start the background polling loop FOR EACH COLLECTION. * Otherwise, if it's an ordinary interrupt collection, * start the ping-pong IRPs for it. */ if (collection->hidCollectionInfo.Polled){ if (HidpSetMaxReportSize(fdoExt)){ ULONG i; for (i = 0; i < fdoExt->deviceDesc.CollectionDescLength; i++){ PHIDCLASS_COLLECTION ctn; ctn = &fdoExt->classCollectionArray[i]; /* * If one of the collections is polled, they * should ALL be polled. */ ASSERT(ctn->hidCollectionInfo.Polled); ctn->PollInterval_msec = DEFAULT_POLL_INTERVAL_MSEC; /* * Allocate the buffer for saving the polled device's * last report. Allocate one more byte than the max * report size for the device in case we have to * prepend a report id byte. */ ctn->savedPolledReportBuf = ALLOCATEPOOL(NonPagedPool, fdoExt->maxReportSize+1); if (ctn->savedPolledReportBuf){ ctn->polledDataIsStale = TRUE; StartPollingLoop(fdoExt, ctn, TRUE); status = STATUS_SUCCESS; } else { ASSERT(ctn->savedPolledReportBuf); status = STATUS_INSUFFICIENT_RESOURCES; } } } } else if (fdoExt->isOutputOnlyDevice){ /* * Don't start ping-pong IRPs. */ } else { status = HidpStartAllPingPongs(fdoExt); } } if (NT_SUCCESS(status)) { pdoExt->state = COLLECTION_STATE_RUNNING; #if DBG collection->Signature = HIDCLASS_COLLECTION_SIG; #endif /* * Create the 'file-name' used by clients to open this device. */ HidpCreateSymbolicLink(pdoExt, pdoExt->collectionNum, TRUE, pdoExt->pdo); if (!pdoExt->MouseOrKeyboard && WAITWAKE_SUPPORTED(fdoExt)) { // // register for the wait wake guid as well // pdoExt->WmiLibInfo.GuidCount = sizeof (HidClassWmiGuidList) / sizeof (WMIGUIDREGINFO); ASSERT (1 == pdoExt->WmiLibInfo.GuidCount); // // See if the user has enabled remote wake for the device // PRIOR to registering with WMI. // HidpGetRemoteWakeEnableState(pdoExt); pdoExt->WmiLibInfo.GuidList = &HidClassWmiGuidList; pdoExt->WmiLibInfo.QueryWmiRegInfo = HidpQueryWmiRegInfo; pdoExt->WmiLibInfo.QueryWmiDataBlock = HidpQueryWmiDataBlock; pdoExt->WmiLibInfo.SetWmiDataBlock = HidpSetWmiDataBlock; pdoExt->WmiLibInfo.SetWmiDataItem = HidpSetWmiDataItem; pdoExt->WmiLibInfo.ExecuteWmiMethod = NULL; pdoExt->WmiLibInfo.WmiFunctionControl = NULL; IoWMIRegistrationControl(pdoExt->pdo, WMIREG_ACTION_REGISTER); if (SHOULD_SEND_WAITWAKE(pdoExt)) { HidpCreateRemoteWakeIrp(pdoExt); } } if (AllClientPDOsInitialized(fdoExt, TRUE)){ HidpStartIdleTimeout(fdoExt, TRUE); } } } else { status = STATUS_DEVICE_DATA_ERROR; } } DBGSUCCESS(status, FALSE) return status; } /* ******************************************************************************** * HidpStartDevice ******************************************************************************** * * */ NTSTATUS HidpStartDevice(PHIDCLASS_DEVICE_EXTENSION HidDeviceExtension, PIRP Irp) { FDO_EXTENSION *fdoExt; enum deviceState previousState; NTSTATUS status; ULONG i; PAGED_CODE(); ASSERT(!HidDeviceExtension->isClientPdo); fdoExt = &HidDeviceExtension->fdoExt; previousState = fdoExt->state; fdoExt->state = DEVICE_STATE_STARTING; /* * Get the power-state conversion table */ status = HidpQueryDeviceCapabilities( HidDeviceExtension->hidExt.PhysicalDeviceObject, &fdoExt->deviceCapabilities); if (NT_SUCCESS(status)){ /* * Alert the rest of the driver stack that the device is starting. */ IoCopyCurrentIrpStackLocationToNext(Irp); status = HidpCallDriverSynchronous(fdoExt->fdo, Irp); if (NT_SUCCESS(status)){ /* * If we're just resuming from STOP, * there's nothing else to do; * otherwise, need to call down the USB stack * for some info and allocate some resources. */ if (previousState == DEVICE_STATE_INITIALIZED){ status = AllocDeviceResources(fdoExt); if (NT_SUCCESS(status)){ /* * Assume this is an output-only device until we start * a collection-pdo which handles inputs. * Only set fdoExt->isOutputOnlyDevice on the first start * not on a subsequent start following a stop. */ fdoExt->isOutputOnlyDevice = TRUE; /* * Initialize WMI stuff */ fdoExt->WmiLibInfo.GuidCount = sizeof(HidClassFdoWmiGuidList) / sizeof (WMIGUIDREGINFO); fdoExt->WmiLibInfo.GuidList = &HidClassFdoWmiGuidList; fdoExt->WmiLibInfo.QueryWmiRegInfo = HidpQueryWmiRegInfo; fdoExt->WmiLibInfo.QueryWmiDataBlock = HidpQueryWmiDataBlock; fdoExt->WmiLibInfo.SetWmiDataBlock = HidpSetWmiDataBlock; fdoExt->WmiLibInfo.SetWmiDataItem = HidpSetWmiDataItem; fdoExt->WmiLibInfo.ExecuteWmiMethod = NULL; fdoExt->WmiLibInfo.WmiFunctionControl = NULL; /* * Allocate all the collection resources before allocating * the pingpong irps, so that we can set a maximum report * size. */ for (i = 0; i < fdoExt->deviceDesc.CollectionDescLength; i++) { // If one of these fails, we will clean up properly // in the remove routine, so there's no need to // bother cleaning up here. status = InitializeCollection(fdoExt, i); if (!NT_SUCCESS(status)){ break; } status = AllocCollectionResources(fdoExt, fdoExt->deviceDesc.CollectionDesc[i].CollectionNumber); if (!NT_SUCCESS(status)){ break; } } /* * We need ot allocate the pingpongs in the fdo start * routine due to race conditions introduced by selective * suspend. */ if (!fdoExt->isOutputOnlyDevice && !fdoExt->driverExt->DevicesArePolled) { status = HidpReallocPingPongIrps(fdoExt, MIN_PINGPONG_IRPS); } if (NT_SUCCESS(status)){ /* * We will have to create an array of PDOs, one for each device class. * The following call will cause NTKERN to call us back with * IRP_MN_QUERY_DEVICE_RELATIONS and initialize its collection-PDOs. */ IoInvalidateDeviceRelations(HidDeviceExtension->hidExt.PhysicalDeviceObject, BusRelations); } } } else if (previousState == DEVICE_STATE_STOPPED){ // // Any request that comes in when we are in low power will be // dealt with at that time // DBGSTATE(fdoExt->prevState, DEVICE_STATE_START_SUCCESS, TRUE) } else { TRAP; status = STATUS_DEVICE_CONFIGURATION_ERROR; } } } if (NT_SUCCESS(status)){ fdoExt->state = DEVICE_STATE_START_SUCCESS; #if WIN95_BUILD /* * Send down the WaitWake IRP. * This allows the device to wake up the system. * * Note: On Win98 there is no way for a client to * send a WaitWake IRP. Therefore we initiate * a WaitWake IRP for every device, not just * if a client sends us a WaitWake IRP, like on NT. */ /* * We could have been suspended, stopped, then started again. In * this case, we need to not send a WW irp because we already have * on pending. */ if (fdoExt->deviceCapabilities.SystemWake > PowerSystemWorking) { SubmitWaitWakeIrp(HidDeviceExtension); } #endif #if DBG { ULONG i; // Win98 doesn't have good debug extensions DBGVERBOSE(("Started fdoExt %ph with %d collections: ", fdoExt, fdoExt->deviceDesc.CollectionDescLength)) for (i = 0; i < fdoExt->deviceDesc.CollectionDescLength; i++){ DBGVERBOSE((" - collection #%d: (in=%xh,out=%xh,feature=%xh) usagePage %xh, usage %xh ", fdoExt->deviceDesc.CollectionDesc[i].CollectionNumber, fdoExt->deviceDesc.CollectionDesc[i].InputLength, fdoExt->deviceDesc.CollectionDesc[i].OutputLength, fdoExt->deviceDesc.CollectionDesc[i].FeatureLength, fdoExt->deviceDesc.CollectionDesc[i].UsagePage, fdoExt->deviceDesc.CollectionDesc[i].Usage)) } } #endif } else { fdoExt->state = DEVICE_STATE_START_FAILURE; } DBGSUCCESS(status, FALSE) return status; } VOID HidpCleanUpFdo(FDO_EXTENSION *fdoExt) { PAGED_CODE(); if (fdoExt->openCount == 0){ /* * This is the last CLOSE on an alreay-removed device. * * Free resources and the FDO name * (wPdoName that was allocated in HidpAddDevice); * */ DequeueFdoExt(fdoExt); FreeDeviceResources(fdoExt); RtlFreeUnicodeString(&fdoExt->name); IoWMIRegistrationControl(fdoExt->fdo, WMIREG_ACTION_DEREGISTER); /* * Delete the device-FDO and all collection-PDOs * Don't touch fdoExt after this. */ HidpDeleteDeviceObjects(fdoExt); } } /* ******************************************************************************** * HidpRemoveDevice ******************************************************************************** * */ NTSTATUS HidpRemoveDevice(FDO_EXTENSION *fdoExt, IN PIRP Irp) { BOOLEAN proceedWithRemove; NTSTATUS status; PIRP IdleIrp; PAGED_CODE(); /* * All collection-PDOs should have been removed by now, * but we want to verify this. * Only allow removal of this device-FDO if all the * collection-PDOs are removed * (or if they never got created in the first place). */ if (fdoExt->prevState == DEVICE_STATE_START_FAILURE){ proceedWithRemove = TRUE; } else if (fdoExt->prevState == DEVICE_STATE_STOPPED){ /* * If a device fails to initialize, it may get * STOP_DEVICE before being removed, so we want to * go ahead and remove it without calling * AllClientPDOsInitialized, which accesses some * data which may not have been initialized. * In this case we're never checking for the * case that the device was initialized successfully, * then stopped, and then removed without its * collection-PDOs being removed; but this is an * illegal case, so we'll just punt on it. */ proceedWithRemove = TRUE; } else if (AllClientPDOsInitialized(fdoExt, FALSE)){ proceedWithRemove = TRUE; } else { /* * This shouldn't happen -- all the collection-PDOs * should have been removed before the device-FDO. */ DBGERR(("State of fdo %x state is %d",fdoExt->fdo,fdoExt->state)) TRAP; proceedWithRemove = FALSE; } if (proceedWithRemove){ PHIDCLASS_DEVICE_EXTENSION HidDeviceExtension = CONTAINING_RECORD(fdoExt, HIDCLASS_DEVICE_EXTENSION, fdoExt); DBGASSERT((fdoExt->state == DEVICE_STATE_REMOVING || fdoExt->state == DEVICE_STATE_INITIALIZED || fdoExt->state == DEVICE_STATE_START_FAILURE), ("Device is in incorrect state: %x", fdoExt->state), TRUE) if (ISPTR(fdoExt->waitWakeIrp)){ IoCancelIrp(fdoExt->waitWakeIrp); fdoExt->waitWakeIrp = BAD_POINTER; } HidpCancelIdleNotification(fdoExt, TRUE); if (ISPTR(fdoExt->idleNotificationRequest)) { IoFreeIrp(fdoExt->idleNotificationRequest); fdoExt->idleNotificationRequest = BAD_POINTER; } while (IdleIrp = DequeuePowerDelayedIrp(fdoExt)) { IdleIrp->IoStatus.Status = STATUS_NO_SUCH_DEVICE; IoCompleteRequest(IdleIrp, IO_NO_INCREMENT); } DestroyPingPongs(fdoExt); /* * Note: THE ORDER OF THESE ACTIONS IS VERY CRITICAL */ Irp->IoStatus.Status = STATUS_SUCCESS; IoSkipCurrentIrpStackLocation (Irp); status = HidpCallDriver(fdoExt->fdo, Irp); fdoExt->state = DEVICE_STATE_REMOVED; DerefDriverExt(fdoExt->driverExt->MinidriverObject); fdoExt->driverExt = BAD_POINTER; /* * After Detach we can no longer send IRPS to this device * object as it will be GONE! */ IoDetachDevice(HidDeviceExtension->hidExt.NextDeviceObject); /* * If all client handles on this device have been closed, * destroy the objects and our context for it; * otherwise, we'll do this when the last client closes * their handle. * * On NT we can only get here if all our creates have been closed, so * this is unnecessary, but on Win9x, a remove can be sent with valid * opens against the stack. * * Don't touch fdoExt after this. */ HidpCleanUpFdo(fdoExt); } else { status = STATUS_DEVICE_CONFIGURATION_ERROR; } DBGSUCCESS(status, FALSE) return status; } /* ******************************************************************************** * HidpRemoveCollection ******************************************************************************** * */ VOID HidpRemoveCollection(FDO_EXTENSION *fdoExt, PDO_EXTENSION *pdoExt, IN PIRP Irp) { PAGED_CODE(); // // This pdo is no longer available as it has been removed. // It should still be returned for each Query Device Relations // IRPS to the HID bus, but it itself should respond to all // IRPS with STATUS_DELETE_PENDING. // if (pdoExt->prevState == COLLECTION_STATE_UNINITIALIZED || // for started pdos pdoExt->state == COLLECTION_STATE_UNINITIALIZED){ // For unstarted pdos pdoExt->state = COLLECTION_STATE_UNINITIALIZED; DBGVERBOSE(("HidpRemoveCollection: collection uninitialized.")) } else { ULONG ctnIndx = pdoExt->collectionIndex; PHIDCLASS_COLLECTION collection = &fdoExt->classCollectionArray[ctnIndx]; ULONG numReportIDs = fdoExt->deviceDesc.ReportIDsLength; PIRP remoteWakeIrp; if (!pdoExt->MouseOrKeyboard && WAITWAKE_SUPPORTED(fdoExt)) { // // Unregister for remote wakeup. // IoWMIRegistrationControl (pdoExt->pdo, WMIREG_ACTION_DEREGISTER); } remoteWakeIrp = (PIRP) InterlockedExchangePointer(&pdoExt->remoteWakeIrp, NULL); if (remoteWakeIrp) { IoCancelIrp(remoteWakeIrp); } pdoExt->state = COLLECTION_STATE_UNINITIALIZED; /* * Destroy this collection. * This will also abort all pending reads on this collection-PDO. */ HidpDestroyCollection(fdoExt, collection); } DBGVERBOSE(("HidpRemoveCollection: removed pdo %ph (refCount=%xh)", pdoExt->pdo, (ULONG)(*(((PUCHAR)pdoExt->pdo)-0x18)))) }