开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 驱动编程 > 查看源码
isopnp.c
资源名称：isousb.rar　[点击查看]
上传用户：leituo004
上传日期：2014-11-03
资源大小：159k
文件大小：73k
源码类别：

驱动编程

开发平台：

Visual C++

isopnp.c：源码内容
  1. /*++
  3. Copyright (c) 2000  Microsoft Corporation
  5. Module Name:
  7.     isopnp.c
  9. Abstract:
  11.     Isoch USB device driver for Intel 82930 USB test board
  12.     Plug and Play module
  14. Environment:
  16.     Kernel mode
  18. Notes:
  20.     Copyright (c) 2000 Microsoft Corporation.  
  21.     All Rights Reserved.
  23. --*/
  25. #include "isousb.h"
  26. #include "isopnp.h"
  27. #include "isopwr.h"
  28. #include "isodev.h"
  29. #include "isowmi.h"
  30. #include "isousr.h"
  31. #include "isorwr.h"
  32. #include "isostrm.h"
  34. NTSTATUS
  35. IsoUsb_DispatchPnP(
  36.     IN PDEVICE_OBJECT DeviceObject,
  37.     IN PIRP           Irp
  38.     )
  39. /*++
  40.  
  41. Routine Description:
  43.     The plug and play dispatch routines.
  44.     Most of these requests the driver will completely ignore.
  45.     In all cases it must pass on the IRP to the lower driver.
  47. Arguments:
  49.     DeviceObject - pointer to a device object.
  51.     Irp - pointer to an I/O Request Packet.
  53. Return Value:
  55.     NT status code
  57. --*/
  58. {
  59.     PIO_STACK_LOCATION irpStack;
  60.     PDEVICE_EXTENSION  deviceExtension;
  61.     KEVENT             startDeviceEvent;
  62.     NTSTATUS           ntStatus;
  64.     //
  65.     // initialize variables
  66.     //
  68.     irpStack = IoGetCurrentIrpStackLocation(Irp);
  69.     deviceExtension = DeviceObject->DeviceExtension;
  71.     //
  72.     // since the device is removed, fail the Irp.
  73.     //
  75.     if(Removed == deviceExtension->DeviceState) {
  77.         ntStatus = STATUS_DELETE_PENDING;
  79.         Irp->IoStatus.Status = ntStatus;
  80.         Irp->IoStatus.Information = 0;
  82.         IoCompleteRequest(Irp, IO_NO_INCREMENT);
  84.         return ntStatus;
  85.     }
  87.     IsoUsb_DbgPrint(3, ("///////////////////////////////////////////n"));
  88.     IsoUsb_DbgPrint(3, ("IsoUsb_DispatchPnP::"));
  89.     IsoUsb_IoIncrement(deviceExtension);
  91.     if(irpStack->MinorFunction == IRP_MN_START_DEVICE) {
  93.         ASSERT(deviceExtension->IdleReqPend == 0);
  94.     }
  95.     else {
  97.         if(deviceExtension->SSEnable) {
  98.             
  99.             CancelSelectSuspend(deviceExtension);
  100.         }
  101.     }
  103.     IsoUsb_DbgPrint(2, (PnPMinorFunctionString(irpStack->MinorFunction)));
  105.     switch(irpStack->MinorFunction) {
  107.     case IRP_MN_START_DEVICE:
  109.         ntStatus = HandleStartDevice(DeviceObject, Irp);
  111.         break;
  113.     case IRP_MN_QUERY_STOP_DEVICE:
  115.         //
  116.         // if we cannot stop the device, we fail the query stop irp
  117.         //
  118.         ntStatus = CanStopDevice(DeviceObject, Irp);
  120.         if(NT_SUCCESS(ntStatus)) {
  122.             ntStatus = HandleQueryStopDevice(DeviceObject, Irp);
  124.             return ntStatus;
  125.         }
  126.         break;
  128.     case IRP_MN_CANCEL_STOP_DEVICE:
  130.         ntStatus = HandleCancelStopDevice(DeviceObject, Irp);
  132.         break;
  133.      
  134.     case IRP_MN_STOP_DEVICE:
  136.         ntStatus = HandleStopDevice(DeviceObject, Irp);
  138.         IsoUsb_DbgPrint(3, ("IsoUsb_DispatchPnP::IRP_MN_STOP_DEVICE::"));
  139.         IsoUsb_IoDecrement(deviceExtension);
  141.         return ntStatus;
  143.     case IRP_MN_QUERY_REMOVE_DEVICE:
  145.         //
  146.         // if we cannot remove the device, we fail the query remove irp
  147.         //
  148.         ntStatus = CanRemoveDevice(DeviceObject, Irp);
  150.         if(NT_SUCCESS(ntStatus)) {
  151.         
  152.             ntStatus = HandleQueryRemoveDevice(DeviceObject, Irp);
  154.             return ntStatus;
  155.         }
  156.         break;
  158.     case IRP_MN_CANCEL_REMOVE_DEVICE:
  160.         ntStatus = HandleCancelRemoveDevice(DeviceObject, Irp);
  162.         break;
  164.     case IRP_MN_SURPRISE_REMOVAL:
  166.         ntStatus = HandleSurpriseRemoval(DeviceObject, Irp);
  168.         IsoUsb_DbgPrint(3, ("IsoUsb_DispatchPnP::IRP_MN_SURPRISE_REMOVAL::"));
  169.         IsoUsb_IoDecrement(deviceExtension);
  171.         return ntStatus;
  173.     case IRP_MN_REMOVE_DEVICE:
  175.         ntStatus = HandleRemoveDevice(DeviceObject, Irp);
  177.         return ntStatus;
  179.     case IRP_MN_QUERY_CAPABILITIES:
  181.         ntStatus = HandleQueryCapabilities(DeviceObject, Irp);
  183.         break;
  185.     default:
  187.         IoSkipCurrentIrpStackLocation(Irp);
  189.         ntStatus = IoCallDriver(deviceExtension->TopOfStackDeviceObject, Irp);
  191.         IsoUsb_DbgPrint(3, ("IsoUsb_DispatchPnP::default::"));
  192.         IsoUsb_IoDecrement(deviceExtension);
  194.         return ntStatus;
  196.     } // switch
  198. //
  199. // complete request 
  200. //
  202.     Irp->IoStatus.Status = ntStatus;
  203.     Irp->IoStatus.Information = 0;
  205.     IoCompleteRequest(Irp, IO_NO_INCREMENT);
  207. //
  208. // decrement count
  209. //
  210.     IsoUsb_DbgPrint(3, ("IsoUsb_DispatchPnP::"));
  211.     IsoUsb_IoDecrement(deviceExtension);
  213.     return ntStatus;
  214. }
  216. NTSTATUS
  217. HandleStartDevice(
  218.     IN PDEVICE_OBJECT DeviceObject,
  219.     IN PIRP              Irp
  220.     )
  221. /*++
  222.  
  223. Routine Description:
  225.     This is the dispatch routine for IRP_MN_START_DEVICE
  227. Arguments:
  229.     DeviceObject - pointer to a device object.
  231.     Irp - I/O request packet
  233. Return Value:
  235.     NT status value
  237. --*/
  238. {
  239.     KIRQL             oldIrql;
  240.     KEVENT            startDeviceEvent;
  241.     NTSTATUS          ntStatus;
  242.     PDEVICE_EXTENSION deviceExtension;
  243.     LARGE_INTEGER     dueTime;
  245.     IsoUsb_DbgPrint(3, ("HandleStartDevice - beginsn"));
  247.     //
  248.     // initialize variables
  249.     //
  250.     deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
  251.     deviceExtension->UsbConfigurationDescriptor = NULL;
  252.     deviceExtension->UsbInterface = NULL;
  254.     //
  255.     // We cannot touch the device (send it any non pnp irps) until a
  256.     // start device has been passed down to the lower drivers.
  257.     // first pass the Irp down
  258.     //
  260.     KeInitializeEvent(&startDeviceEvent, NotificationEvent, FALSE);
  262.     IoCopyCurrentIrpStackLocationToNext(Irp);
  264.     IoSetCompletionRoutine(Irp, 
  265.                            (PIO_COMPLETION_ROUTINE)IrpCompletionRoutine, 
  266.                            (PVOID)&startDeviceEvent, 
  267.                            TRUE, 
  268.                            TRUE, 
  269.                            TRUE);
  271.     ntStatus = IoCallDriver(deviceExtension->TopOfStackDeviceObject, Irp);
  273.     if(ntStatus == STATUS_PENDING) {
  275.         KeWaitForSingleObject(&startDeviceEvent, 
  276.                               Executive, 
  277.                               KernelMode, 
  278.                               FALSE, 
  279.                               NULL);
  281.         ntStatus = Irp->IoStatus.Status;
  282.     }
  284.     if(!NT_SUCCESS(ntStatus)) {
  286.         IsoUsb_DbgPrint(1, ("Lower drivers failed this Irpn"));
  287.         return ntStatus;
  288.     }
  290.     //
  291.     // Read the device descriptor, configuration descriptor 
  292.     // and select the interface descriptors
  293.     //
  295.     ntStatus = ReadandSelectDescriptors(DeviceObject);
  297.     if(!NT_SUCCESS(ntStatus)) {
  299.         IsoUsb_DbgPrint(1, ("ReadandSelectDescriptors failedn"));
  300.         return ntStatus;
  301.     }
  303.     //
  304.     // enable the symbolic links for system components to open
  305.     // handles to the device
  306.     //
  308.     ntStatus = IoSetDeviceInterfaceState(&deviceExtension->InterfaceName, 
  309.                                          TRUE);
  311.     if(!NT_SUCCESS(ntStatus)) {
  313.         IsoUsb_DbgPrint(1, ("IoSetDeviceInterfaceState:enable:failedn"));
  314.         return ntStatus;
  315.     }
  317.     KeAcquireSpinLock(&deviceExtension->DevStateLock, &oldIrql);
  319.     SET_NEW_PNP_STATE(deviceExtension, Working);
  320.     deviceExtension->QueueState = AllowRequests;
  322.     KeReleaseSpinLock(&deviceExtension->DevStateLock, oldIrql);
  324.     //
  325.     // initialize wait wake outstanding flag to false.
  326.     // and issue a wait wake.
  327.     
  328.     deviceExtension->FlagWWOutstanding = 0;
  329.     deviceExtension->FlagWWCancel = 0;
  330.     deviceExtension->WaitWakeIrp = NULL;
  332.     if(deviceExtension->WaitWakeEnable) {
  334.         IssueWaitWake(deviceExtension);
  335.     }
  337.     ProcessQueuedRequests(deviceExtension);
  339.     if(WinXpOrBetter == deviceExtension->WdmVersion) {
  341.         deviceExtension->SSEnable = deviceExtension->SSRegistryEnable;
  343.         //
  344.         // set timer for selective suspend requests.
  345.         //
  347.         if(deviceExtension->SSEnable) {
  349.             dueTime.QuadPart = -10000 * IDLE_INTERVAL;               // 5000 ms
  351.             KeSetTimerEx(&deviceExtension->Timer, 
  352.                          dueTime,
  353.                          IDLE_INTERVAL,                              // 5000 ms
  354.                          &deviceExtension->DeferredProcCall);
  356.             deviceExtension->FreeIdleIrpCount = 0;
  357.         }
  358.     }
  360.     if((Win2kOrBetter == deviceExtension->WdmVersion) ||
  361.        (WinXpOrBetter == deviceExtension->WdmVersion)) {
  363.         deviceExtension->IsDeviceHighSpeed = 0;
  364.         GetBusInterfaceVersion(DeviceObject);
  365.     }
  367.     IsoUsb_DbgPrint(3, ("HandleStartDevice - endsn"));
  369.     return ntStatus;
  370. }
  373. NTSTATUS
  374. ReadandSelectDescriptors(
  375.     IN PDEVICE_OBJECT DeviceObject
  376.     )
  377. /*++
  378.  
  379. Routine Description:
  381.     This routine configures the USB device.
  382.     In this routines we get the device descriptor, 
  383.     the configuration descriptor and select the
  384.     configuration descriptor.
  386. Arguments:
  388.     DeviceObject - pointer to a device object
  390. Return Value:
  392.     NTSTATUS - NT status value.
  394. --*/
  395. {
  396.     PURB                   urb;
  397.     ULONG                  siz;
  398.     NTSTATUS               ntStatus;
  399.     PUSB_DEVICE_DESCRIPTOR deviceDescriptor;
  400.     
  401.     //
  402.     // initialize variables
  403.     //
  405.     urb = NULL;
  406.     deviceDescriptor = NULL;
  408.     //
  409.     // 1. Read the device descriptor
  410.     //
  412.     urb = ExAllocatePool(NonPagedPool, 
  413.                          sizeof(struct _URB_CONTROL_DESCRIPTOR_REQUEST));
  415.     if(urb) {
  417.         siz = sizeof(USB_DEVICE_DESCRIPTOR);
  418.         deviceDescriptor = ExAllocatePool(NonPagedPool, siz);
  420.         if(deviceDescriptor) {
  422.             UsbBuildGetDescriptorRequest(
  423.                     urb, 
  424.                     (USHORT) sizeof(struct _URB_CONTROL_DESCRIPTOR_REQUEST),
  425.                     USB_DEVICE_DESCRIPTOR_TYPE, 
  426.                     0, 
  427.                     0, 
  428.                     deviceDescriptor, 
  429.                     NULL, 
  430.                     siz, 
  431.                     NULL);
  433.             ntStatus = CallUSBD(DeviceObject, urb);
  435.             if(NT_SUCCESS(ntStatus)) {
  437.                 ASSERT(deviceDescriptor->bNumConfigurations);
  438.                 ntStatus = ConfigureDevice(DeviceObject);    
  439.             }
  440.                             
  441.             ExFreePool(urb);                
  442.             ExFreePool(deviceDescriptor);
  443.         }
  444.         else {
  446.             IsoUsb_DbgPrint(1, ("Failed to allocate memory for deviceDescriptor"));
  448.             ExFreePool(urb);
  449.             ntStatus = STATUS_INSUFFICIENT_RESOURCES;
  450.         }
  451.     }
  452.     else {
  454.         IsoUsb_DbgPrint(1, ("Failed to allocate memory for urb"));
  456.         ntStatus = STATUS_INSUFFICIENT_RESOURCES;
  457.     }
  459.     return ntStatus;
  460. }
  462. NTSTATUS
  463. ConfigureDevice(
  464.     IN PDEVICE_OBJECT DeviceObject
  465.     )
  466. /*++
  467.  
  468. Routine Description:
  470.     This helper routine reads the configuration descriptor
  471.     for the device in couple of steps.
  473. Arguments:
  475.     DeviceObject - pointer to a device object
  477. Return Value:
  479.     NTSTATUS - NT status value
  481. --*/
  482. {
  483.     PURB                          urb;
  484.     ULONG                         siz;
  485.     NTSTATUS                      ntStatus;
  486.     PDEVICE_EXTENSION             deviceExtension;
  487.     PUSB_CONFIGURATION_DESCRIPTOR configurationDescriptor;
  491.     //
  492.     // initialize the variables
  493.     //
  495.     urb = NULL;
  496.     configurationDescriptor = NULL;
  497.     deviceExtension = DeviceObject->DeviceExtension;
  499.     //
  500.     // Read the first configuration descriptor
  501.     // This requires two steps:
  502.     // 1. Read the fixed sized configuration desciptor (CD)
  503.     // 2. Read the CD with all embedded interface and endpoint descriptors
  504.     //
  506.     urb = ExAllocatePool(NonPagedPool, 
  507.                          sizeof(struct _URB_CONTROL_DESCRIPTOR_REQUEST));
  509.     if(urb) {
  511.         siz = sizeof(USB_CONFIGURATION_DESCRIPTOR);
  512.         configurationDescriptor = ExAllocatePool(NonPagedPool, siz);
  514.         if(configurationDescriptor) {
  516.             UsbBuildGetDescriptorRequest(
  517.                     urb, 
  518.                     (USHORT) sizeof(struct _URB_CONTROL_DESCRIPTOR_REQUEST),
  519.                     USB_CONFIGURATION_DESCRIPTOR_TYPE, 
  520.                     0, 
  521.                     0, 
  522.                     configurationDescriptor,
  523.                     NULL, 
  524.                     sizeof(USB_CONFIGURATION_DESCRIPTOR), 
  525.                     NULL);
  527.             ntStatus = CallUSBD(DeviceObject, urb);
  529.             if(!NT_SUCCESS(ntStatus)) {
  531.                 IsoUsb_DbgPrint(1, ("UsbBuildGetDescriptorRequest failedn"));
  532.                 goto ConfigureDevice_Exit;
  533.             }
  534.         }
  535.         else {
  537.             IsoUsb_DbgPrint(1, ("Failed to allocate mem for config Descriptorn"));
  539.             ntStatus = STATUS_INSUFFICIENT_RESOURCES;
  540.             goto ConfigureDevice_Exit;
  541.         }
  543.         siz = configurationDescriptor->wTotalLength;
  545.         ExFreePool(configurationDescriptor);
  547.         configurationDescriptor = ExAllocatePool(NonPagedPool, siz);
  549.         if(configurationDescriptor) {
  551.             UsbBuildGetDescriptorRequest(
  552.                     urb, 
  553.                     (USHORT)sizeof(struct _URB_CONTROL_DESCRIPTOR_REQUEST),
  554.                     USB_CONFIGURATION_DESCRIPTOR_TYPE,
  555.                     0, 
  556.                     0, 
  557.                     configurationDescriptor, 
  558.                     NULL, 
  559.                     siz, 
  560.                     NULL);
  562.             ntStatus = CallUSBD(DeviceObject, urb);
  564.             if(!NT_SUCCESS(ntStatus)) {
  566.                 IsoUsb_DbgPrint(1,("Failed to read configuration descriptor"));
  567.                 goto ConfigureDevice_Exit;
  568.             }
  569.         }
  570.         else {
  572.             IsoUsb_DbgPrint(1, ("Failed to alloc mem for config Descriptorn"));
  573.             ntStatus = STATUS_INSUFFICIENT_RESOURCES;
  574.             goto ConfigureDevice_Exit;
  575.         }
  576.     }
  577.     else {
  579.         IsoUsb_DbgPrint(1, ("Failed to allocate memory for urbn"));
  580.         ntStatus = STATUS_INSUFFICIENT_RESOURCES;
  581.         goto ConfigureDevice_Exit;
  582.     }
  584.     if(configurationDescriptor) {
  586.         //
  587.         // save a copy of configurationDescriptor in deviceExtension
  588.         // remember to free it later.
  589.         //
  590.         deviceExtension->UsbConfigurationDescriptor = configurationDescriptor;
  592.         if(configurationDescriptor->bmAttributes & REMOTE_WAKEUP_MASK)
  593.         {
  594.             //
  595.             // this configuration supports remote wakeup
  596.             //
  597.             deviceExtension->WaitWakeEnable = 1;
  598.         }
  599.         else
  600.         {
  601.             deviceExtension->WaitWakeEnable = 0;
  602.         }
  604.         ntStatus = SelectInterfaces(DeviceObject, configurationDescriptor);
  605.     }
  606.     else {
  608.         deviceExtension->UsbConfigurationDescriptor = NULL;
  609.     }
  611. ConfigureDevice_Exit:
  613.     if(urb) {
  615.         ExFreePool(urb);
  616.     }
  618.     return ntStatus;
  619. }
  621. NTSTATUS
  622. SelectInterfaces(
  623.     IN PDEVICE_OBJECT                DeviceObject,
  624.     IN PUSB_CONFIGURATION_DESCRIPTOR ConfigurationDescriptor
  625.     )
  626. /*++
  627.  
  628. Routine Description:
  630.     This helper routine selects the configuration
  632. Arguments:
  634.     DeviceObject - pointer to device object
  635.     ConfigurationDescriptor - pointer to the configuration
  636.     descriptor for the device
  638. Return Value:
  640.     NT status value
  642. --*/
  643. {
  644.     LONG                        numberOfInterfaces, 
  645.                                 interfaceNumber, 
  646.                                 interfaceindex;
  647.     ULONG                       i;
  648.     PURB                        urb;
  649.     PUCHAR                      pInf;
  650.     NTSTATUS                    ntStatus;
  651.     PDEVICE_EXTENSION           deviceExtension;
  652.     PUSB_INTERFACE_DESCRIPTOR   interfaceDescriptor;
  653.     PUSBD_INTERFACE_LIST_ENTRY  interfaceList, 
  654.                                 tmp;
  655.     PUSBD_INTERFACE_INFORMATION Interface;
  657.     //
  658.     // initialize the variables
  659.     //
  661.     urb = NULL;
  662.     Interface = NULL;
  663.     interfaceDescriptor = NULL;
  664.     deviceExtension = DeviceObject->DeviceExtension;
  665.     numberOfInterfaces = ConfigurationDescriptor->bNumInterfaces;
  666.     interfaceindex = interfaceNumber = 0;
  668.     //
  669.     // Parse the configuration descriptor for the interface;
  670.     //
  672.     tmp = interfaceList =
  673.         ExAllocatePool(
  674.                NonPagedPool, 
  675.                sizeof(USBD_INTERFACE_LIST_ENTRY) * (numberOfInterfaces + 1));
  677.     if(!tmp) {
  679.         IsoUsb_DbgPrint(1, ("Failed to allocate mem for interfaceListn"));
  680.         return STATUS_INSUFFICIENT_RESOURCES;
  681.     }
  684.     while(interfaceNumber < numberOfInterfaces) {
  686.         interfaceDescriptor = USBD_ParseConfigurationDescriptorEx(
  687.                                             ConfigurationDescriptor, 
  688.                                             ConfigurationDescriptor,
  689.                                             interfaceindex,
  690.                                             0, -1, -1, -1);
  692.         if(interfaceDescriptor) {
  694.             interfaceList->InterfaceDescriptor = interfaceDescriptor;
  695.             interfaceList->Interface = NULL;
  696.             interfaceList++;
  697.             interfaceNumber++;
  698.         }
  700.         interfaceindex++;
  701.     }
  703.     interfaceList->InterfaceDescriptor = NULL;
  704.     interfaceList->Interface = NULL;
  705.     urb = USBD_CreateConfigurationRequestEx(ConfigurationDescriptor, tmp);
  707.     if(urb) {
  709.         Interface = &urb->UrbSelectConfiguration.Interface;
  711.         for(i=0; i<Interface->NumberOfPipes; i++) {
  713.             //
  714.             // perform pipe initialization here
  715.             // set the transfer size and any pipe flags we use
  716.             // USBD sets the rest of the Interface struct members
  717.             //
  719.             Interface->Pipes[i].MaximumTransferSize = 
  720.                                 USBD_DEFAULT_MAXIMUM_TRANSFER_SIZE;
  721.         }
  723.         ntStatus = CallUSBD(DeviceObject, urb);
  725.         if(NT_SUCCESS(ntStatus)) {
  727.             //
  728.             // save a copy of interface information in the device extension.
  729.             //
  730.             deviceExtension->UsbInterface = ExAllocatePool(NonPagedPool,
  731.                                                            Interface->Length);
  733.             if(deviceExtension->UsbInterface) {
  734.                 
  735.                 RtlCopyMemory(deviceExtension->UsbInterface,
  736.                               Interface,
  737.                               Interface->Length);
  738.             }
  739.             else {
  741.                 ntStatus = STATUS_INSUFFICIENT_RESOURCES;
  742.                 IsoUsb_DbgPrint(1, ("memory alloc for UsbInterface failedn"));
  743.             }
  745.             //
  746.             // Dump the interface to the debugger
  747.             //
  749.             Interface = &urb->UrbSelectConfiguration.Interface;
  751.             IsoUsb_DbgPrint(3, ("---------n"));
  752.             IsoUsb_DbgPrint(3, ("NumberOfPipes 0x%xn", 
  753.                                  Interface->NumberOfPipes));
  754.             IsoUsb_DbgPrint(3, ("Length 0x%xn", 
  755.                                  Interface->Length));
  756.             IsoUsb_DbgPrint(3, ("Alt Setting 0x%xn", 
  757.                                  Interface->AlternateSetting));
  758.             IsoUsb_DbgPrint(3, ("Interface Number 0x%xn", 
  759.                                  Interface->InterfaceNumber));
  760.             IsoUsb_DbgPrint(3, ("Class, subclass, protocol 0x%x 0x%x 0x%xn",
  761.                                  Interface->Class,
  762.                                  Interface->SubClass,
  763.                                  Interface->Protocol));
  765.             for(i=0; i<Interface->NumberOfPipes; i++) {
  767.                 IsoUsb_DbgPrint(3, ("---------n"));
  768.                 IsoUsb_DbgPrint(3, ("PipeType 0x%xn", 
  769.                                      Interface->Pipes[i].PipeType));
  770.                 IsoUsb_DbgPrint(3, ("EndpointAddress 0x%xn", 
  771.                                      Interface->Pipes[i].EndpointAddress));
  772.                 IsoUsb_DbgPrint(3, ("MaxPacketSize 0x%xn", 
  773.                                     Interface->Pipes[i].MaximumPacketSize));
  774.                 IsoUsb_DbgPrint(3, ("Interval 0x%xn", 
  775.                                      Interface->Pipes[i].Interval));
  776.                 IsoUsb_DbgPrint(3, ("Handle 0x%xn", 
  777.                                      Interface->Pipes[i].PipeHandle));
  778.                 IsoUsb_DbgPrint(3, ("MaximumTransferSize 0x%xn", 
  779.                                     Interface->Pipes[i].MaximumTransferSize));
  780.             }
  782.             IsoUsb_DbgPrint(3, ("---------n"));
  783.         }
  784.         else {
  786.             IsoUsb_DbgPrint(1, ("Failed to select an interfacen"));
  787.         }
  788.     }
  789.     else {
  790.         
  791.         IsoUsb_DbgPrint(1, ("USBD_CreateConfigurationRequestEx failedn"));
  792.         ntStatus = STATUS_INSUFFICIENT_RESOURCES;
  793.     }
  795.     if(tmp) {
  797.         ExFreePool(tmp);
  798.     }
  800.     if(urb) {
  802.         ExFreePool(urb);
  803.     }
  805.     return ntStatus;
  806. }
  809. NTSTATUS
  810. DeconfigureDevice(
  811.     IN PDEVICE_OBJECT DeviceObject
  812.     )
  813. /*++
  814.  
  815. Routine Description:
  817.     This routine is invoked when the device is removed or stopped.
  818.     This routine de-configures the usb device.
  820. Arguments:
  822.     DeviceObject - pointer to device object
  824. Return Value:
  826.     NT status value
  828. --*/
  829. {
  830.     PURB     urb;
  831.     ULONG    siz;
  832.     NTSTATUS ntStatus;
  833.     
  834.     //
  835.     // initialize variables
  836.     //
  838.     siz = sizeof(struct _URB_SELECT_CONFIGURATION);
  839.     urb = ExAllocatePool(NonPagedPool, siz);
  841.     if(urb) {
  843.         UsbBuildSelectConfigurationRequest(urb, (USHORT)siz, NULL);
  845.         ntStatus = CallUSBD(DeviceObject, urb);
  847.         if(!NT_SUCCESS(ntStatus)) {
  849.             IsoUsb_DbgPrint(3, ("Failed to deconfigure devicen"));
  850.         }
  852.         ExFreePool(urb);
  853.     }
  854.     else {
  856.         IsoUsb_DbgPrint(1, ("Failed to allocate urbn"));
  857.         ntStatus = STATUS_INSUFFICIENT_RESOURCES;
  858.     }
  860.     return ntStatus;
  861. }
  863. NTSTATUS
  864. CallUSBD(
  865.     IN PDEVICE_OBJECT DeviceObject,
  866.     IN PURB           Urb
  867.     )
  868. /*++
  869.  
  870. Routine Description:
  872.     This routine synchronously submits an urb down the stack.
  874. Arguments:
  876.     DeviceObject - pointer to device object
  877.     Urb - USB request block
  879. Return Value:
  881.     NT status value
  883. --*/
  884. {
  885.     PIRP               irp;
  886.     KEVENT             event;
  887.     NTSTATUS           ntStatus;
  888.     IO_STATUS_BLOCK    ioStatus;
  889.     PIO_STACK_LOCATION nextStack;
  890.     PDEVICE_EXTENSION  deviceExtension;
  892.     //
  893.     // initialize the variables
  894.     //
  896.     irp = NULL;
  897.     deviceExtension = DeviceObject->DeviceExtension;
  898.     
  899.     KeInitializeEvent(&event, NotificationEvent, FALSE);
  901.     irp = IoBuildDeviceIoControlRequest(IOCTL_INTERNAL_USB_SUBMIT_URB, 
  902.                                         deviceExtension->TopOfStackDeviceObject,
  903.                                         NULL, 
  904.                                         0, 
  905.                                         NULL, 
  906.                                         0, 
  907.                                         TRUE, 
  908.                                         &event, 
  909.                                         &ioStatus);
  911.     if(!irp) {
  913.         IsoUsb_DbgPrint(1, ("IoBuildDeviceIoControlRequest failedn"));
  914.         return STATUS_INSUFFICIENT_RESOURCES;
  915.     }
  917.     nextStack = IoGetNextIrpStackLocation(irp);
  918.     ASSERT(nextStack != NULL);
  919.     nextStack->Parameters.Others.Argument1 = Urb;
  921.     IsoUsb_DbgPrint(3, ("CallUSBD::"));
  922.     IsoUsb_IoIncrement(deviceExtension);
  924.     ntStatus = IoCallDriver(deviceExtension->TopOfStackDeviceObject, irp);
  926.     if(ntStatus == STATUS_PENDING) {
  928.         KeWaitForSingleObject(&event, 
  929.                               Executive, 
  930.                               KernelMode, 
  931.                               FALSE, 
  932.                               NULL);
  934.         ntStatus = ioStatus.Status;
  935.     }
  936.     
  937.     IsoUsb_DbgPrint(3, ("CallUSBD::"));
  938.     IsoUsb_IoDecrement(deviceExtension);
  939.     return ntStatus;
  940. }
  942. NTSTATUS
  943. HandleQueryStopDevice(
  944.     IN PDEVICE_OBJECT DeviceObject,
  945.     IN PIRP           Irp
  946.     )
  947. /*++
  948.  
  949. Routine Description:
  951.     This routine services the Irps of minor type IRP_MN_QUERY_STOP_DEVICE
  953. Arguments:
  955.     DeviceObject - pointer to device object
  956.     Irp - I/O request packet sent by the pnp manager.
  958. Return Value:
  960.     NT status value
  962. --*/
  963. {
  964.     KIRQL             oldIrql;
  965.     NTSTATUS          ntStatus;
  966.     PDEVICE_EXTENSION deviceExtension;
  968.     IsoUsb_DbgPrint(3, ("HandleQueryStopDevice - beginsn"));
  970.     //
  971.     // initialize variables
  972.     //
  974.     deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
  976.     //
  977.     // If we can stop the device, we need to set the QueueState to 
  978.     // HoldRequests so further requests will be queued.
  979.     //
  981.     KeAcquireSpinLock(&deviceExtension->DevStateLock, &oldIrql);
  982.     
  983.     SET_NEW_PNP_STATE(deviceExtension, PendingStop);
  984.     deviceExtension->QueueState = HoldRequests;
  985.     
  986.     KeReleaseSpinLock(&deviceExtension->DevStateLock, oldIrql);
  988.     //
  989.     // wait for the existing ones to be finished.
  990.     // first, decrement this operation
  991.     //
  993.     IsoUsb_DbgPrint(3, ("HandleQueryStopDevice::"));
  994.     IsoUsb_IoDecrement(deviceExtension);
  996.     KeWaitForSingleObject(&deviceExtension->StopEvent, 
  997.                           Executive, 
  998.                           KernelMode, 
  999.                           FALSE, 
  1000.                           NULL);
  1002.     Irp->IoStatus.Status = STATUS_SUCCESS;
  1003.     Irp->IoStatus.Information = 0;
  1005.     IoSkipCurrentIrpStackLocation(Irp);
  1007.     ntStatus = IoCallDriver(deviceExtension->TopOfStackDeviceObject, Irp);
  1009.     IsoUsb_DbgPrint(3, ("HandleQueryStopDevice - endsn"));
  1011.     return ntStatus;
  1012. }
  1014. NTSTATUS
  1015. HandleCancelStopDevice(
  1016.     IN PDEVICE_OBJECT DeviceObject,
  1017.     IN PIRP           Irp
  1018.     )
  1019. /*++
  1020.  
  1021. Routine Description:
  1023.     This routine services Irp of minor type IRP_MN_CANCEL_STOP_DEVICE
  1025. Arguments:
  1027.     DeviceObject - pointer to device object
  1028.     Irp - I/O request packet sent by the pnp manager.
  1030. Return Value:
  1032.     NT value
  1034. --*/
  1035. {
  1036.     KIRQL             oldIrql;    
  1037.     KEVENT            event;
  1038.     NTSTATUS          ntStatus;
  1039.     PDEVICE_EXTENSION deviceExtension;
  1041.     IsoUsb_DbgPrint(3, ("HandleCancelStopDevice - beginsn"));
  1043.     deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
  1045.     //
  1046.     // Send this IRP down and wait for it to come back.
  1047.     // Set the QueueState flag to AllowRequests, 
  1048.     // and process all the previously queued up IRPs.
  1049.     //
  1050.     // First check to see whether you have received cancel-stop
  1051.     // without first receiving a query-stop. This could happen if someone
  1052.     // above us fails a query-stop and passes down the subsequent
  1053.     // cancel-stop.
  1054.     //
  1056.     if(PendingStop == deviceExtension->DeviceState) {
  1058.         KeInitializeEvent(&event, NotificationEvent, FALSE);
  1060.         IoCopyCurrentIrpStackLocationToNext(Irp);
  1061.         IoSetCompletionRoutine(Irp, 
  1062.                                (PIO_COMPLETION_ROUTINE)IrpCompletionRoutine, 
  1063.                                (PVOID)&event, 
  1064.                                TRUE, 
  1065.                                TRUE, 
  1066.                                TRUE);
  1068.         ntStatus = IoCallDriver(deviceExtension->TopOfStackDeviceObject, Irp);
  1070.         if(ntStatus == STATUS_PENDING) {
  1072.             KeWaitForSingleObject(&event, 
  1073.                                   Executive, 
  1074.                                   KernelMode, 
  1075.                                   FALSE, 
  1076.                                   NULL);
  1077.             ntStatus = Irp->IoStatus.Status;
  1078.         }
  1080.         if(NT_SUCCESS(ntStatus)) {
  1082.             KeAcquireSpinLock(&deviceExtension->DevStateLock, &oldIrql);
  1084.             RESTORE_PREVIOUS_PNP_STATE(deviceExtension);
  1085.             deviceExtension->QueueState = AllowRequests;
  1086.             ASSERT(deviceExtension->DeviceState == Working);
  1088.             KeReleaseSpinLock(&deviceExtension->DevStateLock, oldIrql);
  1090.             ProcessQueuedRequests(deviceExtension);
  1091.         }
  1093.     }
  1094.     else {
  1096.         // spurious Irp
  1097.         ntStatus = STATUS_SUCCESS;
  1098.     }
  1100.     IsoUsb_DbgPrint(3, ("HandleCancelStopDevice - endsn"));
  1102.     return ntStatus;
  1103. }
  1105. NTSTATUS
  1106. HandleStopDevice(
  1107.     IN PDEVICE_OBJECT DeviceObject,
  1108.     IN PIRP           Irp
  1109.     )
  1110. /*++
  1111.  
  1112. Routine Description:
  1114.     This routine services Irp of minor type IRP_MN_STOP_DEVICE
  1116. Arguments:
  1118.     DeviceObject - pointer to device object
  1119.     Irp - I/O request packet sent by the pnp manager.
  1121. Return Value:
  1123.     NT status value
  1125. --*/
  1126. {
  1127.     KIRQL             oldIrql;
  1128.     NTSTATUS          ntStatus;
  1129.     PDEVICE_EXTENSION deviceExtension;
  1131.     IsoUsb_DbgPrint(3, ("HandleStopDevice - beginsn"));
  1133.     //
  1134.     // initialize variables
  1135.     //
  1137.     deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
  1139.     if(WinXpOrBetter == deviceExtension->WdmVersion) {
  1141.         if(deviceExtension->SSEnable) {
  1142.             //
  1143.             // Cancel the timer so that the DPCs are no longer fired.
  1144.             // we do not need DPCs because the device is stopping.
  1145.             // The timers are re-initialized while handling the start
  1146.             // device irp.
  1147.             //
  1148.             KeCancelTimer(&deviceExtension->Timer);
  1149.             //
  1150.             // after the device is stopped, it can be surprise removed.
  1151.             // we set this to 0, so that we do not attempt to cancel
  1152.             // the timer while handling surprise remove or remove irps.
  1153.             // when we get the start device request, this flag will be
  1154.             // reinitialized.
  1155.             //
  1156.             deviceExtension->SSEnable = 0;
  1158.             //
  1159.             // make sure that if a DPC was fired before we called cancel timer,
  1160.             // then the DPC and work-time have run to their completion
  1161.             //
  1162.             KeWaitForSingleObject(&deviceExtension->NoDpcWorkItemPendingEvent, 
  1163.                                   Executive, 
  1164.                                   KernelMode, 
  1165.                                   FALSE, 
  1166.                                   NULL);
  1167.             //
  1168.             // make sure that the selective suspend request has been completed.
  1169.             //
  1170.             KeWaitForSingleObject(&deviceExtension->NoIdleReqPendEvent, 
  1171.                                   Executive, 
  1172.                                   KernelMode, 
  1173.                                   FALSE, 
  1174.                                   NULL);
  1175.         }
  1176.     }
  1177.     
  1178.     //
  1179.     // after the stop Irp is sent to the lower driver object, 
  1180.     // the driver must not send any more Irps down that touch 
  1181.     // the device until another Start has occurred.
  1182.     //
  1184.     if(deviceExtension->WaitWakeEnable) {
  1185.         
  1186.         CancelWaitWake(deviceExtension);
  1187.     }
  1189.     KeAcquireSpinLock(&deviceExtension->DevStateLock, &oldIrql);
  1191.     SET_NEW_PNP_STATE(deviceExtension, Stopped);
  1192.     
  1193.     KeReleaseSpinLock(&deviceExtension->DevStateLock, oldIrql);
  1195.     //
  1196.     // This is the right place to actually give up all the resources used
  1197.     // This might include calls to IoDisconnectInterrupt, MmUnmapIoSpace, 
  1198.     // etc.
  1199.     //
  1201.     ReleaseMemory(DeviceObject);
  1202.     
  1203.     ntStatus = DeconfigureDevice(DeviceObject);
  1205.     Irp->IoStatus.Status = ntStatus;
  1206.     Irp->IoStatus.Information = 0;
  1207.     
  1208.     IoSkipCurrentIrpStackLocation(Irp);
  1209.     ntStatus = IoCallDriver(deviceExtension->TopOfStackDeviceObject, Irp);
  1211.     IsoUsb_DbgPrint(3, ("HandleStopDevice - endsn"));
  1212.     
  1213.     return ntStatus;
  1214. }
  1216. NTSTATUS
  1217. HandleQueryRemoveDevice(
  1218.     IN PDEVICE_OBJECT DeviceObject,
  1219.     IN PIRP           Irp
  1220.     )
  1221. /*++
  1222.  
  1223. Routine Description:
  1225.     This routine services Irp of minor type IRP_MN_QUERY_REMOVE_DEVICE
  1227. Arguments:
  1229.     DeviceObject - pointer to device object
  1230.     Irp - I/O request packet sent by the pnp manager.
  1232. Return Value:
  1234.     NT status value
  1236. --*/
  1237. {
  1238.     KIRQL             oldIrql;
  1239.     NTSTATUS          ntStatus;
  1240.     PDEVICE_EXTENSION deviceExtension;
  1242.     IsoUsb_DbgPrint(3, ("HandleQueryRemoveDevice - beginsn"));
  1244.     //
  1245.     // initialize variables
  1246.     //
  1248.     deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
  1250.     //
  1251.     // If we can allow removal of the device, we should set the QueueState
  1252.     // to HoldRequests so further requests will be queued. This is required
  1253.     // so that we can process queued up requests in cancel-remove just in 
  1254.     // case somebody else in the stack fails the query-remove. 
  1255.     // 
  1257.     KeAcquireSpinLock(&deviceExtension->DevStateLock, &oldIrql);
  1259.     deviceExtension->QueueState = HoldRequests;
  1260.     SET_NEW_PNP_STATE(deviceExtension, PendingRemove);
  1262.     KeReleaseSpinLock(&deviceExtension->DevStateLock, oldIrql);
  1264.     IsoUsb_DbgPrint(3, ("HandleQueryRemoveDevice::"));
  1265.     IsoUsb_IoDecrement(deviceExtension);
  1267.     //
  1268.     // wait for all the requests to be completed
  1269.     //
  1271.     KeWaitForSingleObject(&deviceExtension->StopEvent, 
  1272.                           Executive,
  1273.                           KernelMode, 
  1274.                           FALSE, 
  1275.                           NULL);
  1277.     Irp->IoStatus.Status = STATUS_SUCCESS;
  1278.     Irp->IoStatus.Information = 0;
  1280.     IoSkipCurrentIrpStackLocation(Irp);
  1281.     ntStatus = IoCallDriver(deviceExtension->TopOfStackDeviceObject, Irp);
  1283.     IsoUsb_DbgPrint(3, ("HandleQueryRemoveDevice - endsn"));
  1285.     return ntStatus;
  1286. }
  1288. NTSTATUS
  1289. HandleCancelRemoveDevice(
  1290.     IN PDEVICE_OBJECT DeviceObject,
  1291.     IN PIRP           Irp
  1292.     )
  1293. /*++
  1294.  
  1295. Routine Description:
  1297.     This routine services Irp of minor type IRP_MN_CANCEL_REMOVE_DEVICE
  1299. Arguments:
  1301.     DeviceObject - pointer to device object
  1302.     Irp - I/O request packet sent by the pnp manager.
  1304. Return Value:
  1306.     NT status value
  1308. --*/
  1309. {
  1310.     KIRQL             oldIrql;
  1311.     KEVENT            event;
  1312.     NTSTATUS          ntStatus;
  1313.     PDEVICE_EXTENSION deviceExtension;
  1315.     IsoUsb_DbgPrint(3, ("HandleCancelRemoveDevice - beginsn"));
  1317.     //
  1318.     // initialize variables
  1319.     //
  1321.     deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
  1323.     //
  1324.     // We need to reset the QueueState flag to ProcessRequest, 
  1325.     // since the device resume its normal activities.
  1326.     //
  1328.     //
  1329.     // First check to see whether you have received cancel-remove
  1330.     // without first receiving a query-remove. This could happen if 
  1331.     // someone above us fails a query-remove and passes down the 
  1332.     // subsequent cancel-remove.
  1333.     //
  1335.     if(PendingRemove == deviceExtension->DeviceState) {
  1337.         KeInitializeEvent(&event, NotificationEvent, FALSE);
  1339.         IoCopyCurrentIrpStackLocationToNext(Irp);
  1340.         IoSetCompletionRoutine(Irp, 
  1341.                                (PIO_COMPLETION_ROUTINE)IrpCompletionRoutine, 
  1342.                                (PVOID)&event, 
  1343.                                TRUE, 
  1344.                                TRUE, 
  1345.                                TRUE);
  1346.         ntStatus = IoCallDriver(deviceExtension->TopOfStackDeviceObject, Irp);
  1348.         if(ntStatus == STATUS_PENDING) {
  1350.             KeWaitForSingleObject(&event, 
  1351.                                   Executive, 
  1352.                                   KernelMode, 
  1353.                                   FALSE, 
  1354.                                   NULL);
  1356.             ntStatus = Irp->IoStatus.Status;
  1357.         }
  1359.         if(NT_SUCCESS(ntStatus)) {
  1361.             KeAcquireSpinLock(&deviceExtension->DevStateLock, &oldIrql);
  1363.             deviceExtension->QueueState = AllowRequests;
  1364.             RESTORE_PREVIOUS_PNP_STATE(deviceExtension);
  1366.             KeReleaseSpinLock(&deviceExtension->DevStateLock, oldIrql);
  1367.             //
  1368.             // process the queued requests that arrive between 
  1369.             // QUERY_REMOVE and CANCEL_REMOVE
  1370.             //
  1371.             
  1372.             ProcessQueuedRequests(deviceExtension);
  1373.             
  1374.         }
  1375.     }
  1376.     else {
  1378.         // 
  1379.         // spurious cancel-remove
  1380.         //
  1381.         ntStatus = STATUS_SUCCESS;
  1382.     }
  1384.     IsoUsb_DbgPrint(3, ("HandleCancelRemoveDevice - endsn"));
  1386.     return ntStatus;
  1387. }
  1389. NTSTATUS
  1390. HandleSurpriseRemoval(
  1391.     IN PDEVICE_OBJECT DeviceObject,
  1392.     IN PIRP           Irp
  1393.     )
  1394. /*++
  1395.  
  1396. Routine Description:
  1398.     This routine services Irp of minor type IRP_MN_SURPRISE_REMOVAL
  1400. Arguments:
  1402.     DeviceObject - pointer to device object
  1403.     Irp - I/O request packet sent by the pnp manager.
  1405. Return Value:
  1407.     NT status value
  1409. --*/
  1410. {
  1411.     KIRQL             oldIrql;
  1412.     NTSTATUS          ntStatus;
  1413.     PDEVICE_EXTENSION deviceExtension;
  1415.     IsoUsb_DbgPrint(3, ("HandleSurpriseRemoval - beginsn"));
  1417.     //
  1418.     // initialize variables
  1419.     //
  1421.     deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
  1423.     //
  1424.     // 1. fail pending requests
  1425.     // 2. return device and memory resources
  1426.     // 3. disable interfaces
  1427.     //
  1429.     if(deviceExtension->WaitWakeEnable) {
  1430.         
  1431.         CancelWaitWake(deviceExtension);
  1432.     }
  1434.     if(WinXpOrBetter == deviceExtension->WdmVersion) {
  1436.         if(deviceExtension->SSEnable) {
  1437.             
  1438.             KeCancelTimer(&deviceExtension->Timer);
  1440.             deviceExtension->SSEnable = 0;
  1441.             //
  1442.             // make sure that if a DPC was fired before we called cancel timer,
  1443.             // then the DPC and work-time have run to their completion
  1444.             //
  1445.             KeWaitForSingleObject(&deviceExtension->NoDpcWorkItemPendingEvent, 
  1446.                                   Executive, 
  1447.                                   KernelMode, 
  1448.                                   FALSE, 
  1449.                                   NULL);
  1450.             //
  1451.             // make sure that the selective suspend request has been completed.
  1452.             //
  1453.             KeWaitForSingleObject(&deviceExtension->NoIdleReqPendEvent, 
  1454.                                   Executive, 
  1455.                                   KernelMode, 
  1456.                                   FALSE, 
  1457.                                   NULL);
  1458.         }
  1459.     }
  1461.     KeAcquireSpinLock(&deviceExtension->DevStateLock, &oldIrql);
  1463.     deviceExtension->QueueState = FailRequests;
  1464.     SET_NEW_PNP_STATE(deviceExtension, SurpriseRemoved);
  1466.     KeReleaseSpinLock(&deviceExtension->DevStateLock, oldIrql);
  1468.     ProcessQueuedRequests(deviceExtension);
  1470.     ntStatus = IoSetDeviceInterfaceState(&deviceExtension->InterfaceName, 
  1471.                                          FALSE);
  1473.     if(!NT_SUCCESS(ntStatus)) {
  1475.         IsoUsb_DbgPrint(1, ("IoSetDeviceInterfaceState::disable:failedn"));
  1476.     }
  1478.     IsoUsb_AbortPipes(DeviceObject);
  1480.     Irp->IoStatus.Status = STATUS_SUCCESS;
  1481.     Irp->IoStatus.Information = 0;
  1483.     IoSkipCurrentIrpStackLocation(Irp);
  1484.     ntStatus = IoCallDriver(deviceExtension->TopOfStackDeviceObject, Irp);
  1486.     IsoUsb_DbgPrint(3, ("HandleSurpriseRemoval - endsn"));
  1488.     return ntStatus;
  1489. }
  1491. NTSTATUS
  1492. HandleRemoveDevice(
  1493.     IN PDEVICE_OBJECT DeviceObject,
  1494.     IN PIRP           Irp
  1495.     )
  1496. /*++
  1497.  
  1498. Routine Description:
  1500.     This routine services Irp of minor type IRP_MN_REMOVE_DEVICE
  1502. Arguments:
  1504.     DeviceObject - pointer to device object
  1505.     Irp - I/O request packet sent by the pnp manager.
  1507. Return Value:
  1509.     NT status value
  1511. --*/
  1512. {
  1513.     KIRQL             oldIrql;
  1514.     KEVENT            event;
  1515.     ULONG             requestCount;
  1516.     NTSTATUS          ntStatus;
  1517.     PDEVICE_EXTENSION deviceExtension;
  1519.     IsoUsb_DbgPrint(3, ("HandleRemoveDevice - beginsn"));
  1521.     //
  1522.     // initialize variables
  1523.     //
  1525.     deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
  1527.     //
  1528.     // The Plug & Play system has dictated the removal of this device.  We
  1529.     // have no choice but to detach and delete the device object.
  1530.     // (If we wanted to express an interest in preventing this removal,
  1531.     // we should have failed the query remove IRP).
  1532.     //
  1534.     if(SurpriseRemoved != deviceExtension->DeviceState) {
  1536.         //
  1537.         // we are here after QUERY_REMOVE
  1538.         //
  1540.         KeAcquireSpinLock(&deviceExtension->DevStateLock, &oldIrql);
  1542.         deviceExtension->QueueState = FailRequests;
  1543.         
  1544.         KeReleaseSpinLock(&deviceExtension->DevStateLock, oldIrql);
  1546.         if(deviceExtension->WaitWakeEnable) {
  1547.         
  1548.             CancelWaitWake(deviceExtension);
  1549.         }
  1551.         if(WinXpOrBetter == deviceExtension->WdmVersion) {
  1553.             if(deviceExtension->SSEnable) {
  1554.                 //
  1555.                 // Cancel the timer so that the DPCs are no longer fired.
  1556.                 // we do not need DPCs because the device has been removed
  1557.                 //
  1558.                 KeCancelTimer(&deviceExtension->Timer);
  1560.                 deviceExtension->SSEnable = 0;
  1562.                 //
  1563.                 // make sure that if a DPC was fired before we called cancel timer,
  1564.                 // then the DPC and work-time have run to their completion
  1565.                 //
  1566.                 KeWaitForSingleObject(&deviceExtension->NoDpcWorkItemPendingEvent, 
  1567.                                       Executive, 
  1568.                                       KernelMode, 
  1569.                                       FALSE, 
  1570.                                       NULL);
  1572.                 //
  1573.                 // make sure that the selective suspend request has been completed.
  1574.                 //
  1575.                 KeWaitForSingleObject(&deviceExtension->NoIdleReqPendEvent, 
  1576.                                       Executive, 
  1577.                                       KernelMode, 
  1578.                                       FALSE, 
  1579.                                       NULL);
  1580.             }
  1581.         }
  1583.         ProcessQueuedRequests(deviceExtension);
  1585.         ntStatus = IoSetDeviceInterfaceState(&deviceExtension->InterfaceName, 
  1586.                                              FALSE);
  1588.         if(!NT_SUCCESS(ntStatus)) {
  1590.             IsoUsb_DbgPrint(1, ("IoSetDeviceInterfaceState::disable:failedn"));
  1591.         }
  1593.         IsoUsb_AbortPipes(DeviceObject);
  1596.     }
  1598.     KeAcquireSpinLock(&deviceExtension->DevStateLock, &oldIrql);
  1600.     SET_NEW_PNP_STATE(deviceExtension, Removed);
  1601.     
  1602.     KeReleaseSpinLock(&deviceExtension->DevStateLock, oldIrql);
  1603.     
  1604.     IsoUsb_WmiDeRegistration(deviceExtension);
  1606.     //
  1607.     // need 2 decrements
  1608.     //
  1610.     IsoUsb_DbgPrint(3, ("HandleRemoveDevice::"));
  1611.     requestCount = IsoUsb_IoDecrement(deviceExtension);
  1613.     ASSERT(requestCount > 0);
  1615.     IsoUsb_DbgPrint(3, ("HandleRemoveDevice::"));
  1616.     requestCount = IsoUsb_IoDecrement(deviceExtension);
  1618.     KeWaitForSingleObject(&deviceExtension->RemoveEvent, 
  1619.                           Executive, 
  1620.                           KernelMode, 
  1621.                           FALSE, 
  1622.                           NULL);
  1624.     ReleaseMemory(DeviceObject);
  1626.     //
  1627.     // We need to send the remove down the stack before we detach,
  1628.     // but we don't need to wait for the completion of this operation
  1629.     // (and to register a completion routine).
  1630.     //
  1632.     Irp->IoStatus.Status = STATUS_SUCCESS;
  1633.     Irp->IoStatus.Information = 0;
  1635.     IoSkipCurrentIrpStackLocation(Irp);
  1636.     ntStatus = IoCallDriver(deviceExtension->TopOfStackDeviceObject, Irp);
  1637.     //
  1638.     // Detach the FDO from the device stack
  1639.     //
  1640.     IoDetachDevice(deviceExtension->TopOfStackDeviceObject);
  1641.     IoDeleteDevice(DeviceObject);
  1643.     IsoUsb_DbgPrint(3, ("HandleRemoveDevice - endsn"));
  1645.     return ntStatus;
  1646. }
  1648. NTSTATUS
  1649. HandleQueryCapabilities(
  1650.     IN PDEVICE_OBJECT DeviceObject,
  1651.     IN PIRP           Irp
  1652.     )
  1653. /*++
  1654.  
  1655. Routine Description:
  1657.     This routine services Irp of minor type IRP_MN_QUERY_CAPABILITIES
  1659. Arguments:
  1661.     DeviceObject - pointer to device object
  1662.     Irp - I/O request packet sent by the pnp manager.
  1664. Return Value:
  1666.     NT status value  
  1668. --*/
  1669. {
  1670.     ULONG                i;
  1671.     KEVENT               event;
  1672.     NTSTATUS             ntStatus;
  1673.     PDEVICE_EXTENSION    deviceExtension;
  1674.     PDEVICE_CAPABILITIES pdc;
  1675.     PIO_STACK_LOCATION   irpStack;
  1677.     IsoUsb_DbgPrint(3, ("HandleQueryCapabilities - beginsn"));
  1679.     //
  1680.     // initialize variables
  1681.     //
  1683.     irpStack = IoGetCurrentIrpStackLocation(Irp);
  1684.     deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
  1685.     pdc = irpStack->Parameters.DeviceCapabilities.Capabilities;
  1687.     //
  1688.     // We will provide here an example of an IRP that is processed
  1689.     // both on its way down and on its way up: there might be no need for
  1690.     // a function driver process this Irp (the bus driver will do that).
  1691.     // The driver will wait for the lower drivers (the bus driver among 
  1692.     // them) to process this IRP, then it processes it again.
  1693.     //
  1695.     if(pdc->Version < 1 || pdc->Size < sizeof(DEVICE_CAPABILITIES)) {
  1696.         
  1697.         IsoUsb_DbgPrint(1, ("HandleQueryCapabilities::request failedn"));
  1698.         ntStatus = STATUS_UNSUCCESSFUL;
  1699.         return ntStatus;
  1700.     }
  1702.     //
  1703.     // Set some values in deviceCapabilities here...
  1704.     //
  1705.     //.............................................
  1706.     //
  1707.     //
  1708.     // Prepare to pass the IRP down
  1709.     //
  1711.     //
  1712.     // Add in the SurpriseRemovalOK bit before passing it down.
  1713.     //
  1714.     pdc->SurpriseRemovalOK = TRUE;
  1715.     Irp->IoStatus.Status = STATUS_SUCCESS;
  1717.     KeInitializeEvent(&event, NotificationEvent, FALSE);
  1718.         
  1719.     IoCopyCurrentIrpStackLocationToNext(Irp);
  1720.     IoSetCompletionRoutine(Irp, 
  1721.                            (PIO_COMPLETION_ROUTINE)IrpCompletionRoutine, 
  1722.                            (PVOID)&event, 
  1723.                            TRUE, 
  1724.                            TRUE, 
  1725.                            TRUE);
  1726.     ntStatus = IoCallDriver(deviceExtension->TopOfStackDeviceObject, Irp);
  1728.     if(ntStatus == STATUS_PENDING) {
  1730.         KeWaitForSingleObject(&event, 
  1731.                               Executive, 
  1732.                               KernelMode, 
  1733.                               FALSE, 
  1734.                               NULL);
  1735.         ntStatus = Irp->IoStatus.Status;
  1736.     }
  1738.     //
  1739.     // initialize PowerDownLevel to disabled
  1740.     //
  1742.     deviceExtension->PowerDownLevel = PowerDeviceUnspecified;
  1744.     if(NT_SUCCESS(ntStatus)) {
  1746.         deviceExtension->DeviceCapabilities = *pdc;
  1747.        
  1748.         for(i = PowerSystemSleeping1; i <= PowerSystemSleeping3; i++) {
  1750.             if(deviceExtension->DeviceCapabilities.DeviceState[i] < 
  1751.                                                             PowerDeviceD3) {
  1753.                 deviceExtension->PowerDownLevel = 
  1754.                     deviceExtension->DeviceCapabilities.DeviceState[i];
  1755.             }
  1756.         }
  1758.         //
  1759.         // since its safe to surprise-remove this device, we shall
  1760.         // set the SurpriseRemoveOK flag to supress any dialog to 
  1761.         // user.
  1762.         //
  1764.         pdc->SurpriseRemovalOK = 1;
  1765.     }
  1767.     if(deviceExtension->PowerDownLevel == PowerDeviceUnspecified ||
  1768.        deviceExtension->PowerDownLevel <= PowerDeviceD0) {
  1769.     
  1770.         deviceExtension->PowerDownLevel = PowerDeviceD2;
  1771.     }
  1773.     IsoUsb_DbgPrint(3, ("HandleQueryCapabilities - endsn"));
  1775.     return ntStatus;
  1776. }
  1779. VOID
  1780. DpcRoutine(
  1781.     IN PKDPC Dpc,
  1782.     IN PVOID DeferredContext,
  1783.     IN PVOID SystemArgument1,
  1784.     IN PVOID SystemArgument2
  1785.     )
  1786. /*++
  1787.  
  1788. Routine Description:
  1790.     DPC routine triggered by the timer to check the idle state
  1791.     of the device and submit an idle request for the device.
  1793. Arguments:
  1795.     DeferredContext - context for the dpc routine.
  1796.                       DeviceObject in our case.
  1798. Return Value:
  1800.     None
  1802. --*/
  1803. {
  1804.     NTSTATUS          ntStatus;
  1805.     PDEVICE_OBJECT    deviceObject;
  1806.     PDEVICE_EXTENSION deviceExtension;
  1807.     PIO_WORKITEM      item;
  1809.     IsoUsb_DbgPrint(3, ("DpcRoutine - beginsn"));
  1811.     deviceObject = (PDEVICE_OBJECT)DeferredContext;
  1812.     deviceExtension = (PDEVICE_EXTENSION)deviceObject->DeviceExtension;
  1814.     //
  1815.     // Clear this event since a DPC has been fired!
  1816.     //
  1817.     KeClearEvent(&deviceExtension->NoDpcWorkItemPendingEvent);
  1819.     if(CanDeviceSuspend(deviceExtension)) {
  1821.         IsoUsb_DbgPrint(3, ("Device is Idlen"));
  1823.         item = IoAllocateWorkItem(deviceObject);
  1825.         if(item) {
  1827.             IoQueueWorkItem(item, 
  1828.                             IdleRequestWorkerRoutine,
  1829.                             DelayedWorkQueue, 
  1830.                             item);
  1832.             ntStatus = STATUS_PENDING;
  1834.         }
  1835.         else {
  1836.         
  1837.             IsoUsb_DbgPrint(3, ("Cannot alloc memory for work itemn"));
  1838.             
  1839.             ntStatus = STATUS_INSUFFICIENT_RESOURCES;
  1841.             //
  1842.             // signal the NoDpcWorkItemPendingEvent.
  1843.             //
  1844.             KeSetEvent(&deviceExtension->NoDpcWorkItemPendingEvent,
  1845.                        IO_NO_INCREMENT,
  1846.                        FALSE);
  1847.         }
  1848.     }
  1849.     else {
  1850.         
  1851.         IsoUsb_DbgPrint(3, ("Idle event not signaledn"));
  1853.         //
  1854.         // signal the NoDpcWorkItemPendingEvent.
  1855.         //
  1856.         KeSetEvent(&deviceExtension->NoDpcWorkItemPendingEvent,
  1857.                    IO_NO_INCREMENT,
  1858.                    FALSE);
  1859.     }
  1861.     IsoUsb_DbgPrint(3, ("DpcRoutine - endsn"));
  1862. }    
  1865. VOID
  1866. IdleRequestWorkerRoutine(
  1867.     IN PDEVICE_OBJECT DeviceObject,
  1868.     IN PVOID          Context
  1869.     )
  1870. /*++
  1871.  
  1872. Routine Description:
  1874.     This is the work item fired from the DPC.
  1875.     This workitem checks the idle state of the device
  1876.     and submits an idle request.
  1878. Arguments:
  1880.     DeviceObject - pointer to device object
  1881.     Context - context for the work item.
  1883. Return Value:
  1885.     None
  1887. --*/
  1888. {
  1889.     PIRP                   irp;
  1890.     NTSTATUS               ntStatus;
  1891.     PDEVICE_EXTENSION      deviceExtension;
  1892.     PIO_WORKITEM           workItem;
  1894.     IsoUsb_DbgPrint(3, ("IdleRequestWorkerRoutine - beginsn"));
  1896.     //
  1897.     // initialize variables
  1898.     //
  1899.     deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
  1900.     workItem = (PIO_WORKITEM) Context;
  1902.     if(CanDeviceSuspend(deviceExtension)) {
  1904.         IsoUsb_DbgPrint(3, ("Device is idlen"));
  1906.         ntStatus = SubmitIdleRequestIrp(deviceExtension);
  1908.         if(!NT_SUCCESS(ntStatus)) {
  1910.             IsoUsb_DbgPrint(1, ("SubmitIdleRequestIrp failedn"));
  1911.         }
  1912.     }
  1913.     else {
  1915.         IsoUsb_DbgPrint(3, ("Device is not idlen"));
  1916.     }
  1918.     IoFreeWorkItem(workItem);
  1920.     //
  1921.     // signal the NoDpcWorkItemPendingEvent.
  1922.     //
  1923.     KeSetEvent(&deviceExtension->NoDpcWorkItemPendingEvent,
  1924.                IO_NO_INCREMENT,
  1925.                FALSE);
  1927.     IsoUsb_DbgPrint(3, ("IdleRequestsWorkerRoutine - endsn"));
  1928. }
  1931. VOID
  1932. ProcessQueuedRequests(
  1933.     IN OUT PDEVICE_EXTENSION DeviceExtension
  1934.     )
  1935. /*++
  1936.  
  1937. Routine Description:
  1939.     Remove and process the entries in the queue. If this routine is called
  1940.     when processing IRP_MN_CANCEL_STOP_DEVICE, IRP_MN_CANCEL_REMOVE_DEVICE
  1941.     or IRP_MN_START_DEVICE, the requests are passed to the next lower driver.
  1942.     If the routine is called when IRP_MN_REMOVE_DEVICE is received, the IRPs
  1943.     are complete with STATUS_DELETE_PENDING
  1945. Arguments:
  1947.     DeviceExtension - pointer to device extension
  1949. Return Value:
  1951.     None
  1953. --*/
  1954. {
  1955.     KIRQL       oldIrql;
  1956.     PIRP        nextIrp,
  1957.                 cancelledIrp;
  1958.     PVOID       cancelRoutine;
  1959.     LIST_ENTRY  cancelledIrpList;
  1960.     PLIST_ENTRY listEntry;
  1962.     IsoUsb_DbgPrint(3, ("ProcessQueuedRequests - beginsn"));
  1964.     //
  1965.     // initialize variables
  1966.     //
  1968.     cancelRoutine = NULL;
  1969.     InitializeListHead(&cancelledIrpList);
  1971.     //
  1972.     // 1.  dequeue the entries in the queue
  1973.     // 2.  reset the cancel routine
  1974.     // 3.  process them
  1975.     // 3a. if the device is active, send them down
  1976.     // 3b. else complete with STATUS_DELETE_PENDING
  1977.     //
  1979.     while(1) {
  1981.         KeAcquireSpinLock(&DeviceExtension->QueueLock, &oldIrql);
  1983.         if(IsListEmpty(&DeviceExtension->NewRequestsQueue)) {
  1985.             KeReleaseSpinLock(&DeviceExtension->QueueLock, oldIrql);
  1986.             break;
  1987.         }
  1988.     
  1989.         //
  1990.         // Remove a request from the queue
  1991.         //
  1993.         listEntry = RemoveHeadList(&DeviceExtension->NewRequestsQueue);
  1994.         nextIrp = CONTAINING_RECORD(listEntry, IRP, Tail.Overlay.ListEntry);
  1996.         //
  1997.         // set the cancel routine to NULL
  1998.         //
  2000.         cancelRoutine = IoSetCancelRoutine(nextIrp, NULL);
  2002.         //
  2003.         // check if its already cancelled
  2004.         //
  2006.         if(nextIrp->Cancel) {
  2007.             if(cancelRoutine) {
  2009.                 //
  2010.                 // the cancel routine for this IRP hasnt been called yet
  2011.                 // so queue the IRP in the cancelledIrp list and complete
  2012.                 // after releasing the lock
  2013.                 //
  2014.                 
  2015.                 InsertTailList(&cancelledIrpList, listEntry);
  2016.             }
  2017.             else {
  2019.                 //
  2020.                 // the cancel routine has run
  2021.                 // it must be waiting to hold the queue lock
  2022.                 // so initialize the IRPs listEntry
  2023.                 //
  2025.                 InitializeListHead(listEntry);
  2026.             }
  2028.             KeReleaseSpinLock(&DeviceExtension->QueueLock, oldIrql);
  2029.         }
  2030.         else {
  2032.             KeReleaseSpinLock(&DeviceExtension->QueueLock, oldIrql);
  2034.             if(FailRequests == DeviceExtension->QueueState) {
  2036.                 nextIrp->IoStatus.Information = 0;
  2037.                 nextIrp->IoStatus.Status = STATUS_DELETE_PENDING;
  2038.                 IoCompleteRequest(nextIrp, IO_NO_INCREMENT);
  2039.             }
  2040.             else {
  2042.                 PIO_STACK_LOCATION irpStack;
  2044.                 IsoUsb_DbgPrint(3, ("ProcessQueuedRequests::"));
  2045.                 IsoUsb_IoIncrement(DeviceExtension);
  2047.                 IoSkipCurrentIrpStackLocation(nextIrp);
  2048.                 IoCallDriver(DeviceExtension->TopOfStackDeviceObject, nextIrp);
  2049.                
  2050.                 IsoUsb_DbgPrint(3, ("ProcessQueuedRequests::"));
  2051.                 IsoUsb_IoDecrement(DeviceExtension);
  2052.             }
  2053.         }
  2054.     } // while loop
  2056.     //
  2057.     // walk through the cancelledIrp list and cancel them
  2058.     //
  2060.     while(!IsListEmpty(&cancelledIrpList)) {
  2062.         PLIST_ENTRY listEntry = RemoveHeadList(&cancelledIrpList);
  2063.         
  2064.         cancelledIrp = CONTAINING_RECORD(listEntry, IRP, Tail.Overlay.ListEntry);
  2066.         cancelledIrp->IoStatus.Status = STATUS_CANCELLED;
  2067.         cancelledIrp->IoStatus.Information = 0;
  2069.         IoCompleteRequest(cancelledIrp, IO_NO_INCREMENT);
  2070.     }
  2072.     IsoUsb_DbgPrint(3, ("ProcessQueuedRequests - endsn"));
  2074.     return;
  2075. }
  2077. VOID
  2078. GetBusInterfaceVersion(
  2079.     IN PDEVICE_OBJECT DeviceObject
  2080.     )
  2081. /*++
  2082.  
  2083. Routine Description:
  2085.     This routine queries the bus interface version
  2087. Arguments:
  2089.     DeviceExtension
  2091. Return Value:
  2093.     VOID
  2095. --*/
  2096. {
  2097.     PIRP                       irp;
  2098.     KEVENT                     event;
  2099.     NTSTATUS                   ntStatus;
  2100.     PDEVICE_EXTENSION          deviceExtension;
  2101.     PIO_STACK_LOCATION         nextStack;
  2102.     USB_BUS_INTERFACE_USBDI_V1 busInterfaceVer1;
  2104.     //
  2105.     // initialize vars
  2106.     //
  2107.     deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
  2109.     IsoUsb_DbgPrint(3, ("GetBusInterfaceVersion - beginsn"));
  2111.     irp = IoAllocateIrp(deviceExtension->TopOfStackDeviceObject->StackSize,
  2112.                         FALSE);
  2114.     if(NULL == irp) {
  2116.         IsoUsb_DbgPrint(1, ("Failed to alloc irp in GetBusInterfaceVersionn"));
  2117.         return;
  2118.     }
  2120.     //
  2121.     // All pnp Irp's need the status field initialized to
  2122.     // STATUS_NOT_SUPPORTED
  2123.     //
  2124.     irp->IoStatus.Status = STATUS_NOT_SUPPORTED;
  2126.     KeInitializeEvent(&event, NotificationEvent, FALSE);
  2128.     IoSetCompletionRoutine(irp,
  2129.                            (PIO_COMPLETION_ROUTINE) IrpCompletionRoutine,
  2130.                            &event,
  2131.                            TRUE,
  2132.                            TRUE,
  2133.                            TRUE);
  2135.     nextStack = IoGetNextIrpStackLocation(irp);
  2136.     ASSERT(nextStack);
  2137.     nextStack->MajorFunction = IRP_MJ_PNP;
  2138.     nextStack->MinorFunction = IRP_MN_QUERY_INTERFACE;
  2140.     //
  2141.     // Allocate memory for an interface of type
  2142.     // USB_BUS_INTERFACE_USBDI_V0 and have the IRP point to it:
  2143.     //
  2144.     nextStack->Parameters.QueryInterface.Interface = 
  2145.                                 (PINTERFACE) &busInterfaceVer1;
  2147.     //
  2148.     // Assign the InterfaceSpecificData member of the IRP to be NULL
  2149.     //
  2150.     nextStack->Parameters.QueryInterface.InterfaceSpecificData = NULL;
  2152.     //
  2153.     // Set the interface type to the appropriate GUID
  2154.     //
  2155.     nextStack->Parameters.QueryInterface.InterfaceType = 
  2156.                                         &USB_BUS_INTERFACE_USBDI_GUID;
  2158.     //
  2159.     // Set the size and version of interface in the IRP
  2160.     // Currently, there is only one valid version of 
  2161.     // this interface available to clients.
  2162.     //
  2163.     nextStack->Parameters.QueryInterface.Size = 
  2164.                                     sizeof(USB_BUS_INTERFACE_USBDI_V1);
  2166.     nextStack->Parameters.QueryInterface.Version = USB_BUSIF_USBDI_VERSION_1;
  2167.     
  2168.     IsoUsb_IoIncrement(deviceExtension);
  2170.     ntStatus = IoCallDriver(DeviceObject,
  2171.                             irp);
  2173.     if(STATUS_PENDING == ntStatus) {
  2175.         KeWaitForSingleObject(&event,
  2176.                               Executive,
  2177.                               KernelMode,
  2178.                               FALSE,
  2179.                               NULL);
  2181.         ntStatus = irp->IoStatus.Status;
  2182.     }
  2184.     if(NT_SUCCESS(ntStatus)) {
  2186.         deviceExtension->IsDeviceHighSpeed = 
  2187.                 busInterfaceVer1.IsDeviceHighSpeed(
  2188.                                        busInterfaceVer1.BusContext);
  2190.         IsoUsb_DbgPrint(1, ("IsDeviceHighSpeed = %xn", 
  2191.                             deviceExtension->IsDeviceHighSpeed));
  2192.     }
  2194.     IoFreeIrp(irp);
  2196.     IsoUsb_DbgPrint(3, ("GetBusInterfaceVersion::"));
  2197.     IsoUsb_IoDecrement(deviceExtension);
  2199.     IsoUsb_DbgPrint(3, ("GetBusInterfaceVersion - endsn"));
  2200. }
  2202. NTSTATUS
  2203. IrpCompletionRoutine(
  2204.     IN PDEVICE_OBJECT DeviceObject,
  2205.     IN PIRP           Irp,
  2206.     IN PVOID          Context
  2207.     )
  2208. /*++
  2209.  
  2210. Routine Description:
  2212.     This routine is a completion routine.
  2213.     In this routine we set an event.
  2215.     Since the completion routine returns 
  2216.     STATUS_MORE_PROCESSING_REQUIRED, the Irps,
  2217.     which set this routine as the completion routine,
  2218.     should be marked pending.
  2220. Arguments:
  2222.     DeviceObject - pointer to device object
  2223.     Irp - I/O request packet
  2224.     Context - 
  2226. Return Value:
  2228.     NT status value
  2230. --*/
  2231. {
  2232.     PKEVENT event = Context;
  2234.     KeSetEvent(event, 0, FALSE);
  2236.     return STATUS_MORE_PROCESSING_REQUIRED;
  2237. }
  2240. NTSTATUS
  2241. IsoUsb_GetRegistryDword(
  2242.     IN     PWCHAR RegPath,
  2243.     IN     PWCHAR ValueName,
  2244.     IN OUT PULONG Value
  2245.     )
  2246. /*++
  2247.  
  2248. Routine Description:
  2250.     This routine reads the specified reqistry value.
  2252. Arguments:
  2254.     RegPath - registry path
  2255.     ValueName - property to be fetched from the registry
  2256.     Value - corresponding value read from the registry.
  2258. Return Value:
  2260.     NT status value
  2262. --*/
  2263. {
  2264.     ULONG                    defaultData;
  2265.     WCHAR                    buffer[MAXIMUM_FILENAME_LENGTH];
  2266.     NTSTATUS                 ntStatus;
  2267.     UNICODE_STRING           regPath;
  2268.     RTL_QUERY_REGISTRY_TABLE paramTable[2];
  2270.     IsoUsb_DbgPrint(3, ("IsoUsb_GetRegistryDword - beginsn"));
  2272.     regPath.Length = 0;
  2273.     regPath.MaximumLength = MAXIMUM_FILENAME_LENGTH * sizeof(WCHAR);
  2274.     regPath.Buffer = buffer;
  2276.     RtlZeroMemory(regPath.Buffer, regPath.MaximumLength);
  2277.     RtlMoveMemory(regPath.Buffer,
  2278.                   RegPath,
  2279.                   wcslen(RegPath) * sizeof(WCHAR));
  2281.     RtlZeroMemory(paramTable, sizeof(paramTable));
  2283.     paramTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT;
  2284.     paramTable[0].Name = ValueName;
  2285.     paramTable[0].EntryContext = Value;
  2286.     paramTable[0].DefaultType = REG_DWORD;
  2287.     paramTable[0].DefaultData = &defaultData;
  2288.     paramTable[0].DefaultLength = sizeof(ULONG);
  2290.     ntStatus = RtlQueryRegistryValues(RTL_REGISTRY_ABSOLUTE |
  2291.                                       RTL_REGISTRY_OPTIONAL,
  2292.                                       regPath.Buffer,
  2293.                                       paramTable,
  2294.                                       NULL,
  2295.                                       NULL);
  2297.     if(NT_SUCCESS(ntStatus)) {
  2299.         IsoUsb_DbgPrint(3, ("success Value = %Xn", *Value));
  2300.         return STATUS_SUCCESS;
  2301.     }
  2302.     else {
  2304.         *Value = 0;
  2305.         return STATUS_UNSUCCESSFUL;
  2306.     }
  2307. }
  2309. NTSTATUS
  2310. IsoUsb_AbortPipes(
  2311.     IN PDEVICE_OBJECT DeviceObject
  2312.     )
  2313. /*++
  2314.  
  2315. Routine Description:
  2317.     This routine sends an irp/urb pair with
  2318.     URB_FUNCTION_ABORT_PIPE request down the stack
  2320. Arguments:
  2322.     DeviceObject - pointer to device object
  2324. Return Value:
  2326.     NT status value
  2328. --*/
  2329. {
  2330.     PURB                        urb;
  2331.     ULONG                       i;
  2332.     NTSTATUS                    ntStatus;
  2333.     PDEVICE_EXTENSION           deviceExtension;
  2334.     PUSBD_PIPE_INFORMATION      pipeInformation;
  2335.     PUSBD_INTERFACE_INFORMATION interfaceInfo;
  2337.     //
  2338.     // initialize variables
  2339.     //
  2340.     deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
  2341.     interfaceInfo = deviceExtension->UsbInterface;
  2342.     
  2343.     IsoUsb_DbgPrint(3, ("IsoUsb_AbortPipes - beginsn"));
  2344.     
  2345.     if(interfaceInfo == NULL) {
  2347.         return STATUS_SUCCESS;
  2348.     }
  2350.     for(i = 0; i < interfaceInfo->NumberOfPipes; i++) {
  2352.         urb = ExAllocatePool(NonPagedPool,
  2353.                              sizeof(struct _URB_PIPE_REQUEST));
  2355.         if(urb) {
  2357.             urb->UrbHeader.Length = sizeof(struct _URB_PIPE_REQUEST);
  2358.             urb->UrbHeader.Function = URB_FUNCTION_ABORT_PIPE;
  2359.             urb->UrbPipeRequest.PipeHandle = 
  2360.                             interfaceInfo->Pipes[i].PipeHandle;
  2362.             ntStatus = CallUSBD(DeviceObject, urb);
  2364.             ExFreePool(urb);
  2365.         }
  2366.         else {
  2368.             IsoUsb_DbgPrint(1, ("Failed to alloc memory for urb for input pipen"));
  2370.             ntStatus = STATUS_INSUFFICIENT_RESOURCES;
  2371.             return ntStatus;
  2372.         }
  2373.     }
  2375.     IsoUsb_DbgPrint(3, ("IsoUsb_AbortPipes - endsn"));
  2377.     return STATUS_SUCCESS;
  2378. }
  2380. NTSTATUS
  2381. IsoUsb_DispatchClean(
  2382.     IN PDEVICE_OBJECT DeviceObject,
  2383.     IN PIRP           Irp
  2384.     )
  2385. /*++
  2386.  
  2387. Routine Description:
  2389.     Dispatch routine for IRP_MJ_CLEANUP
  2391. Arguments:
  2393.     DeviceObject - pointer to device object
  2394.     Irp - I/O request packet sent by the pnp manager
  2396. Return Value:
  2398.     NT status value
  2400. --*/
  2401. {
  2402.     PDEVICE_EXTENSION     deviceExtension;
  2403.     KIRQL                 oldIrql;
  2404.     LIST_ENTRY            cleanupList;
  2405.     PLIST_ENTRY           thisEntry, 
  2406.                           nextEntry, 
  2407.                           listHead;
  2408.     PIRP                  pendingIrp;
  2409.     PIO_STACK_LOCATION    pendingIrpStack, 
  2410.                           irpStack;
  2411.     NTSTATUS              ntStatus;
  2412.     PFILE_OBJECT          fileObject;
  2413.     PFILE_OBJECT_CONTENT  fileObjectContent;
  2414.     PISOUSB_STREAM_OBJECT tempStreamObject;
  2416.     //
  2417.     // initialize variables
  2418.     //
  2419.     deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
  2420.     irpStack = IoGetCurrentIrpStackLocation(Irp);
  2421.     fileObject = irpStack->FileObject;
  2423.     IsoUsb_DbgPrint(3, ("IsoUsb_DispatchClean::"));
  2424.     IsoUsb_IoIncrement(deviceExtension);
  2426.     //
  2427.     // check if any stream objects need to be cleaned
  2428.     //
  2430.     if(fileObject && fileObject->FsContext) {
  2432.         fileObjectContent = (PFILE_OBJECT_CONTENT)
  2433.                             fileObject->FsContext;
  2435.         if(fileObjectContent->StreamInformation) {
  2437.             tempStreamObject = (PISOUSB_STREAM_OBJECT)
  2438.                                InterlockedExchangePointer(
  2439.                                     &fileObjectContent->StreamInformation,
  2440.                                     NULL);
  2441.         
  2442.             if(tempStreamObject && 
  2443.                (tempStreamObject->DeviceObject == DeviceObject)) {
  2444.         
  2445.                 IsoUsb_DbgPrint(3, ("clean dispatch routine"
  2446.                                     " found a stream object matchn"));
  2447.                 IsoUsb_StreamObjectCleanup(tempStreamObject, deviceExtension);
  2448.             }
  2449.         }
  2450.     }
  2452.     InitializeListHead(&cleanupList);
  2454.     //
  2455.     // acquire queue lock
  2456.     //
  2457.     KeAcquireSpinLock(&deviceExtension->QueueLock, &oldIrql);
  2459.     //
  2460.     // remove all Irp's that belong to input Irp's fileobject
  2461.     //
  2463.     listHead = &deviceExtension->NewRequestsQueue;
  2465.     for(thisEntry = listHead->Flink, nextEntry = thisEntry->Flink;
  2466.        thisEntry != listHead;
  2467.        thisEntry = nextEntry, nextEntry = thisEntry->Flink) {
  2469.         pendingIrp = CONTAINING_RECORD(thisEntry, IRP, Tail.Overlay.ListEntry);
  2471.         pendingIrpStack = IoGetCurrentIrpStackLocation(pendingIrp);
  2473.         if(irpStack->FileObject == pendingIrpStack->FileObject) {
  2475.             RemoveEntryList(thisEntry);
  2477.             //
  2478.             // set the cancel routine to NULL
  2479.             //
  2480.             if(NULL == IoSetCancelRoutine(pendingIrp, NULL)) {
  2482.                 InitializeListHead(thisEntry);
  2483.             }
  2484.             else {
  2486.                 InsertTailList(&cleanupList, thisEntry);
  2487.             }
  2488.         }
  2489.     }
  2491.     //
  2492.     // Release the spin lock
  2493.     //
  2495.     KeReleaseSpinLock(&deviceExtension->QueueLock, oldIrql);
  2497.     //
  2498.     // walk thru the cleanup list and cancel all the Irps
  2499.     //
  2501.     while(!IsListEmpty(&cleanupList)) {
  2503.         //
  2504.         // complete the Irp
  2505.         //
  2506.         thisEntry = RemoveHeadList(&cleanupList);
  2508.         pendingIrp = CONTAINING_RECORD(thisEntry, IRP, Tail.Overlay.ListEntry);
  2510.         pendingIrp->IoStatus.Information = 0;
  2511.         pendingIrp->IoStatus.Status = STATUS_CANCELLED;
  2513.         IoCompleteRequest(pendingIrp, IO_NO_INCREMENT);
  2514.     }
  2516.     Irp->IoStatus.Information = 0;
  2517.     Irp->IoStatus.Status = STATUS_SUCCESS;
  2519.     IoCompleteRequest(Irp, IO_NO_INCREMENT);
  2521.     IsoUsb_DbgPrint(3, ("IsoUsb_DispatchClean::"));
  2522.     IsoUsb_IoDecrement(deviceExtension);
  2524.     return STATUS_SUCCESS;
  2525. }
  2527. BOOLEAN
  2528. CanDeviceSuspend(
  2529.     IN PDEVICE_EXTENSION DeviceExtension
  2530.     )
  2531. /*++
  2532.  
  2533. Routine Description:
  2535.     This is the routine where we check if the device
  2536.     can selectively suspend. 
  2538. Arguments:
  2540.     DeviceExtension - pointer to device extension
  2542. Return Value:
  2544.     TRUE - if the device can suspend
  2545.     FALSE - otherwise.
  2547. --*/
  2548. {
  2549.     IsoUsb_DbgPrint(3, ("CanDeviceSuspendn"));
  2551.     if((DeviceExtension->OpenHandleCount == 0) &&
  2552.         (DeviceExtension->OutStandingIO == 1)) {
  2553.         
  2554.         return TRUE;
  2555.     }
  2556.     else {
  2558.         return FALSE;
  2559.     }
  2560. }
  2562. LONG
  2563. IsoUsb_IoIncrement(
  2564.     IN OUT PDEVICE_EXTENSION DeviceExtension
  2565.     )
  2566. /*++
  2567.  
  2568. Routine Description:
  2570.     This routine bumps up the I/O count.
  2571.     This routine is typically invoked when any of the
  2572.     dispatch routines handle new irps for the driver.
  2574. Arguments:
  2576.     DeviceExtension - pointer to device extension
  2578. Return Value:
  2580.     new value
  2582. --*/
  2583. {
  2584.     LONG  result = 0;
  2585.     KIRQL oldIrql;
  2587.     KeAcquireSpinLock(&DeviceExtension->IOCountLock, &oldIrql);
  2589.     result = InterlockedIncrement(&DeviceExtension->OutStandingIO);
  2591.     //
  2592.     // when OutStandingIO bumps from 1 to 2, clear the StopEvent
  2593.     //
  2595.     if(result == 2) {
  2597.         KeClearEvent(&DeviceExtension->StopEvent);
  2598.     }
  2600.     KeReleaseSpinLock(&DeviceExtension->IOCountLock, oldIrql);
  2602.     IsoUsb_DbgPrint(3, ("IsoUsb_IoIncrement::%dn", result));
  2604.     return result;
  2605. }
  2607. LONG
  2608. IsoUsb_IoDecrement(
  2609.     IN OUT PDEVICE_EXTENSION DeviceExtension
  2610.     )
  2611. /*++
  2612.  
  2613. Routine Description:
  2615.     This routine decrements the outstanding I/O count
  2616.     This is typically invoked after the dispatch routine
  2617.     has finished processing the irp.
  2619. Arguments:
  2621.     DeviceExtension - pointer to device extension
  2623. Return Value:
  2625.     new value
  2627. --*/
  2628. {
  2629.     LONG  result = 0;
  2630.     KIRQL oldIrql;
  2632.     KeAcquireSpinLock(&DeviceExtension->IOCountLock, &oldIrql);
  2634.     result = InterlockedDecrement(&DeviceExtension->OutStandingIO);
  2636.     if(result == 1) {
  2638.         KeSetEvent(&DeviceExtension->StopEvent, IO_NO_INCREMENT, FALSE);
  2639.     }
  2641.     if(result == 0) {
  2643.         ASSERT(Removed == DeviceExtension->DeviceState);
  2645.         KeSetEvent(&DeviceExtension->RemoveEvent, IO_NO_INCREMENT, FALSE);
  2646.     }
  2648.     KeReleaseSpinLock(&DeviceExtension->IOCountLock, oldIrql);
  2650.     IsoUsb_DbgPrint(3, ("IsoUsb_IoDecrement::%dn", result));
  2652.     return result;
  2653. }
  2655. NTSTATUS
  2656. CanStopDevice(
  2657.     IN PDEVICE_OBJECT DeviceObject,
  2658.     IN PIRP           Irp
  2659.     )
  2660. /*++
  2661.  
  2662. Routine Description:
  2664.     This routine determines whether the device can be safely stopped. In our 
  2665.     particular case, we'll assume we can always stop the device.
  2666.     A device might fail the request if it doesn't have a queue for the
  2667.     requests it might come or if it was notified that it is in the paging
  2668.     path. 
  2669.   
  2670. Arguments:
  2672.     DeviceObject - pointer to the device object.
  2673.     
  2674.     Irp - pointer to the current IRP.
  2676. Return Value:
  2678.     STATUS_SUCCESS if the device can be safely stopped, an appropriate 
  2679.     NT Status if not.
  2681. --*/
  2682. {
  2683.    //
  2684.    // We assume we can stop the device
  2685.    //
  2687.    UNREFERENCED_PARAMETER(DeviceObject);
  2688.    UNREFERENCED_PARAMETER(Irp);
  2690.    return STATUS_SUCCESS;
  2691. }
  2693. NTSTATUS
  2694. CanRemoveDevice(
  2695.     IN PDEVICE_OBJECT DeviceObject,
  2696.     IN PIRP           Irp
  2697.     )
  2698. /*++
  2699.  
  2700. Routine Description:
  2702.     This routine determines whether the device can be safely removed. In our 
  2703.     particular case, we'll assume we can always remove the device.
  2704.     A device shouldn't be removed if, for example, it has open handles or
  2705.     removing the device could result in losing data (plus the reasons 
  2706.     mentioned at CanStopDevice). The PnP manager on Windows 2000 fails 
  2707.     on its own any attempt to remove, if there any open handles to the device. 
  2708.     However on Win9x, the driver must keep count of open handles and fail 
  2709.     query_remove if there are any open handles.
  2711. Arguments:
  2713.     DeviceObject - pointer to the device object.
  2714.     
  2715.     Irp - pointer to the current IRP.
  2716.     
  2717. Return Value:
  2719.     STATUS_SUCCESS if the device can be safely removed, an appropriate 
  2720.     NT Status if not.
  2722. --*/
  2723. {
  2724.    //
  2725.    // We assume we can remove the device
  2726.    //
  2728.    UNREFERENCED_PARAMETER(DeviceObject);
  2729.    UNREFERENCED_PARAMETER(Irp);
  2731.    return STATUS_SUCCESS;
  2732. }
  2734. NTSTATUS
  2735. ReleaseMemory(
  2736.     IN PDEVICE_OBJECT DeviceObject
  2737.     )
  2738. /*++
  2739.  
  2740. Routine Description:
  2742.     This routine returns all the memory allocations acquired during
  2743.     device startup. 
  2744.     
  2745. Arguments:
  2747.     DeviceObject - pointer to the device object.
  2748.         
  2749.     
  2750. Return Value:
  2752.     STATUS_SUCCESS if the device can be safely removed, an appropriate 
  2753.     NT Status if not.
  2755. --*/
  2756. {
  2757.     //
  2758.     // Disconnect from the interrupt and unmap any I/O ports
  2759.     //
  2760.     
  2761.     PDEVICE_EXTENSION deviceExtension;
  2763.     deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
  2765.     if(deviceExtension->UsbConfigurationDescriptor) {
  2767.         ExFreePool(deviceExtension->UsbConfigurationDescriptor);
  2768.         deviceExtension->UsbConfigurationDescriptor = NULL;
  2769.     }
  2771.     if(deviceExtension->UsbInterface) {
  2772.         
  2773.         ExFreePool(deviceExtension->UsbInterface);
  2774.         deviceExtension->UsbInterface = NULL;
  2775.     }
  2777.     return STATUS_SUCCESS;
  2778. }
  2780. PCHAR
  2781. PnPMinorFunctionString (
  2782.     UCHAR MinorFunction
  2783.     )
  2784. /*++
  2785.  
  2786. Routine Description:
  2788. Arguments:
  2790. Return Value:
  2792. --*/
  2793. {
  2794.     switch (MinorFunction) {
  2796.         case IRP_MN_START_DEVICE:
  2797.             return "IRP_MN_START_DEVICEn";
  2799.         case IRP_MN_QUERY_REMOVE_DEVICE:
  2800.             return "IRP_MN_QUERY_REMOVE_DEVICEn";
  2802.         case IRP_MN_REMOVE_DEVICE:
  2803.             return "IRP_MN_REMOVE_DEVICEn";
  2805.         case IRP_MN_CANCEL_REMOVE_DEVICE:
  2806.             return "IRP_MN_CANCEL_REMOVE_DEVICEn";
  2808.         case IRP_MN_STOP_DEVICE:
  2809.             return "IRP_MN_STOP_DEVICEn";
  2811.         case IRP_MN_QUERY_STOP_DEVICE:
  2812.             return "IRP_MN_QUERY_STOP_DEVICEn";
  2814.         case IRP_MN_CANCEL_STOP_DEVICE:
  2815.             return "IRP_MN_CANCEL_STOP_DEVICEn";
  2817.         case IRP_MN_QUERY_DEVICE_RELATIONS:
  2818.             return "IRP_MN_QUERY_DEVICE_RELATIONSn";
  2820.         case IRP_MN_QUERY_INTERFACE:
  2821.             return "IRP_MN_QUERY_INTERFACEn";
  2823.         case IRP_MN_QUERY_CAPABILITIES:
  2824.             return "IRP_MN_QUERY_CAPABILITIESn";
  2826.         case IRP_MN_QUERY_RESOURCES:
  2827.             return "IRP_MN_QUERY_RESOURCESn";
  2829.         case IRP_MN_QUERY_RESOURCE_REQUIREMENTS:
  2830.             return "IRP_MN_QUERY_RESOURCE_REQUIREMENTSn";
  2832.         case IRP_MN_QUERY_DEVICE_TEXT:
  2833.             return "IRP_MN_QUERY_DEVICE_TEXTn";
  2835.         case IRP_MN_FILTER_RESOURCE_REQUIREMENTS:
  2836.             return "IRP_MN_FILTER_RESOURCE_REQUIREMENTSn";
  2838.         case IRP_MN_READ_CONFIG:
  2839.             return "IRP_MN_READ_CONFIGn";
  2841.         case IRP_MN_WRITE_CONFIG:
  2842.             return "IRP_MN_WRITE_CONFIGn";
  2844.         case IRP_MN_EJECT:
  2845.             return "IRP_MN_EJECTn";
  2847.         case IRP_MN_SET_LOCK:
  2848.             return "IRP_MN_SET_LOCKn";
  2850.         case IRP_MN_QUERY_ID:
  2851.             return "IRP_MN_QUERY_IDn";
  2853.         case IRP_MN_QUERY_PNP_DEVICE_STATE:
  2854.             return "IRP_MN_QUERY_PNP_DEVICE_STATEn";
  2856.         case IRP_MN_QUERY_BUS_INFORMATION:
  2857.             return "IRP_MN_QUERY_BUS_INFORMATIONn";
  2859.         case IRP_MN_DEVICE_USAGE_NOTIFICATION:
  2860.             return "IRP_MN_DEVICE_USAGE_NOTIFICATIONn";
  2862.         case IRP_MN_SURPRISE_REMOVAL:
  2863.             return "IRP_MN_SURPRISE_REMOVALn";
  2865.         default:
  2866.             return "IRP_MN_?????n";
  2867.     }
  2868. }