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

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

驱动编程

开发平台：

Visual C++

isostrm.c：源码内容
  1. /*++
  3. Copyright (c) 2000  Microsoft Corporation
  5. Module Name:
  7.     isostrm.c
  9. Abstract:
  11.     This file has routines for stream transfers.
  12.     Stream transfers are initiated and stopped using
  13.     the IOCTLs exposed by this driver.
  14.     The stream transfer information is contained in 
  15.     ISOUSB_STREAM_OBJECT structure which is securely
  16.     placed in the FileObject. The ISOUSB_STREAM_OBJECT 
  17.     structure has links to ISOUSB_TRANSFER_OBJECT 
  18.     (each TRANSFER_OBJECT corresponds to the number of 
  19.     irp/urb pair circulating).
  20.     So if the user-mode app simply crashes or aborts or 
  21.     does not terminate, we can cleanly abort the stream
  22.     transfers.
  24. Environment:
  26.     Kernel mode
  28. Notes:
  30.     Copyright (c) 2000 Microsoft Corporation.  
  31.     All Rights Reserved.
  33. --*/
  35. #include "isousb.h"
  36. #include "isopnp.h"
  37. #include "isopwr.h"
  38. #include "isodev.h"
  39. #include "isousr.h"
  40. #include "isowmi.h"
  41. #include "isorwr.h"
  42. #include "isostrm.h"
  44. NTSTATUS
  45. IsoUsb_StartIsoStream(
  46.     IN PDEVICE_OBJECT DeviceObject,
  47.     IN PIRP           Irp
  48.     )
  49. /*++
  50.  
  51. Routine Description:
  53.     This routine create a single stream object and
  54.     invokes StartTransfer for ISOUSB_MAX_IRP number of 
  55.     times.
  57. Arguments:
  59.     DeviceObject - pointer to device object
  60.     Irp - I/O request packet
  62. Return Value:
  64.     NT status value
  66. --*/
  67. {
  68.     ULONG                  i;
  69.     ULONG                  info;
  70.     ULONG                  inputBufferLength;
  71.     ULONG                  outputBufferLength;
  72.     NTSTATUS               ntStatus;
  73.     PFILE_OBJECT           fileObject;
  74.     PDEVICE_EXTENSION      deviceExtension;
  75.     PIO_STACK_LOCATION     irpStack;
  76.     PISOUSB_STREAM_OBJECT  streamObject;
  77.     PUSBD_PIPE_INFORMATION pipeInformation;
  79.     info = 0;
  80.     irpStack = IoGetCurrentIrpStackLocation(Irp);
  81.     fileObject = irpStack->FileObject;
  82.     streamObject = NULL;
  83.     pipeInformation = NULL;
  84.     deviceExtension = DeviceObject->DeviceExtension;
  85.     inputBufferLength = irpStack->Parameters.DeviceIoControl.InputBufferLength;
  86.     outputBufferLength = irpStack->Parameters.DeviceIoControl.OutputBufferLength;
  88.     IsoUsb_DbgPrint(3, ("IsoUsb_StartIsoStream - beginsn"));
  90.     streamObject = ExAllocatePool(NonPagedPool, 
  91.                                   sizeof(struct _ISOUSB_STREAM_OBJECT));
  93.     if(streamObject == NULL) {
  95.         IsoUsb_DbgPrint(1, ("failed to alloc mem for streamObjectn"));
  97.         ntStatus = STATUS_INSUFFICIENT_RESOURCES;
  98.         goto IsoUsb_StartIsoStream_Exit;
  99.     }
  101.     RtlZeroMemory(streamObject, sizeof(ISOUSB_STREAM_OBJECT));
  103.     //
  104.     // The Isoch IN pipe for the board is the 5th pipe
  105.     //
  106.     pipeInformation = &(deviceExtension->UsbInterface->Pipes[ISOCH_IN_PIPE_INDEX]);
  108.     // reset the pipe
  109.     //
  110.     IsoUsb_ResetPipe(DeviceObject, pipeInformation);
  111.     
  112.     streamObject->DeviceObject = DeviceObject;
  113.     streamObject->PipeInformation = pipeInformation;
  115.     KeInitializeEvent(&streamObject->NoPendingIrpEvent,
  116.                       NotificationEvent,
  117.                       FALSE);
  119.     for(i = 0; i < ISOUSB_MAX_IRP; i++) {
  121.         ntStatus = IsoUsb_StartTransfer(DeviceObject,
  122.                                         streamObject,
  123.                                         i);
  125.         if(!NT_SUCCESS(ntStatus)) {
  126.          
  127.             //
  128.             // we continue sending transfer object irps..
  129.             //
  130.             
  131.             IsoUsb_DbgPrint(1, ("IsoUsb_StartTransfer [%d] - failedn", i));
  133.             if(ntStatus == STATUS_INSUFFICIENT_RESOURCES) {
  134.                 
  135.                 ASSERT(streamObject->TransferObjectList[i] == NULL);
  136.             }
  137.         }
  138.     }
  140.     if(fileObject && fileObject->FsContext) {
  141.         
  142.         if(streamObject->PendingIrps) {
  144.             ((PFILE_OBJECT_CONTENT)fileObject->FsContext)->StreamInformation 
  145.                                                                 = streamObject;
  146.         }
  147.         else {
  149.             IsoUsb_DbgPrint(1, ("no transfer object irp sent..abort..n"));
  150.             ExFreePool(streamObject);
  151.             ((PFILE_OBJECT_CONTENT)fileObject->FsContext)->StreamInformation = NULL;
  152.         }
  153.     }
  155. IsoUsb_StartIsoStream_Exit:
  157.     Irp->IoStatus.Information = info;
  158.     Irp->IoStatus.Status = ntStatus;
  160.     IoCompleteRequest(Irp, IO_NO_INCREMENT);
  162.     IsoUsb_DbgPrint(3, ("IsoUsb_StartIsoStream::"));
  163.     IsoUsb_IoDecrement(deviceExtension);
  165.     IsoUsb_DbgPrint(3, ("IsoUsb_StartIsoStream - endsn"));
  167.     return ntStatus;
  168. }
  170. NTSTATUS
  171. IsoUsb_StartTransfer(
  172.     IN PDEVICE_OBJECT        DeviceObject,
  173.     IN PISOUSB_STREAM_OBJECT StreamObject,
  174.     IN ULONG                 Index
  175.     )
  176. /*++
  177.  
  178. Routine Description:
  180.     This routine creates a transfer object for each irp/urb pair.
  181.     After initializing the pair, it sends the irp down the stack.
  183. Arguments:
  185.     DeviceObject - pointer to device object.
  186.     StreamObject - pointer to stream object
  187.     Index - index into the transfer object table in stream object
  189. Return Value:
  191.     NT status value
  193. --*/
  194. {
  195.     PIRP                    irp;
  196.     CCHAR                   stackSize;
  197.     ULONG                   packetSize;
  198.     ULONG                   maxXferSize;
  199.     ULONG                   numPackets;
  200.     NTSTATUS                ntStatus;
  201.     PDEVICE_EXTENSION       deviceExtension;
  202.     PIO_STACK_LOCATION      nextStack;
  203.     PISOUSB_TRANSFER_OBJECT transferObject;
  205.     deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
  206.     maxXferSize = StreamObject->PipeInformation->MaximumTransferSize;
  207.     packetSize = StreamObject->PipeInformation->MaximumPacketSize;
  208.     numPackets = maxXferSize / packetSize;
  210.     IsoUsb_DbgPrint(3, ("IsoUsb_StartTransfer - beginsn"));
  212.     transferObject = ExAllocatePool(NonPagedPool,
  213.                                     sizeof(struct _ISOUSB_TRANSFER_OBJECT));
  215.     if(transferObject == NULL) {
  217.         IsoUsb_DbgPrint(1, ("failed to alloc mem for transferObjectn"));
  219.         return STATUS_INSUFFICIENT_RESOURCES;
  220.     }
  222.     RtlZeroMemory(transferObject,
  223.                   sizeof(struct _ISOUSB_TRANSFER_OBJECT));
  226.     transferObject->StreamObject = StreamObject;
  227.     
  228.     stackSize = (CCHAR) (deviceExtension->TopOfStackDeviceObject->StackSize + 1);
  230.     irp = IoAllocateIrp(stackSize, FALSE);
  232.     if(irp == NULL) {
  234.         IsoUsb_DbgPrint(1, ("failed to alloc mem for irpn"));
  236.         ExFreePool(transferObject);
  237.         return STATUS_INSUFFICIENT_RESOURCES;
  238.     }
  240.     transferObject->Irp = irp;
  242.     transferObject->DataBuffer = ExAllocatePool(NonPagedPool,
  243.                                                 maxXferSize);
  245.     if(transferObject->DataBuffer == NULL) {
  247.         IsoUsb_DbgPrint(1, ("failed to alloc mem for DataBuffern"));
  249.         ExFreePool(transferObject);
  250.         IoFreeIrp(irp);
  251.         return STATUS_INSUFFICIENT_RESOURCES;
  252.     }
  254.     transferObject->Urb = ExAllocatePool(NonPagedPool,
  255.                                          GET_ISO_URB_SIZE(numPackets));
  257.     if(transferObject->Urb == NULL) {
  259.         IsoUsb_DbgPrint(1, ("failed to alloc mem for Urbn"));
  261.         ExFreePool(transferObject->DataBuffer);
  262.         IoFreeIrp(irp);
  263.         ExFreePool(transferObject);
  264.         return STATUS_INSUFFICIENT_RESOURCES;
  265.     }
  267.     IsoUsb_InitializeStreamUrb(DeviceObject, transferObject);
  269.     StreamObject->TransferObjectList[Index] = transferObject;
  270.     InterlockedIncrement(&StreamObject->PendingIrps);
  272.     nextStack = IoGetNextIrpStackLocation(irp);
  274.     nextStack->Parameters.Others.Argument1 = transferObject->Urb;
  275.     nextStack->Parameters.DeviceIoControl.IoControlCode = 
  276.                                    IOCTL_INTERNAL_USB_SUBMIT_URB;
  277.     nextStack->MajorFunction = IRP_MJ_INTERNAL_DEVICE_CONTROL;
  279.     IoSetCompletionRoutine(irp, 
  280.                            IsoUsb_IsoIrp_Complete,
  281.                            transferObject,
  282.                            TRUE,
  283.                            TRUE,
  284.                            TRUE);
  286.     IsoUsb_DbgPrint(3, ("IsoUsb_StartTransfer::"));
  287.     IsoUsb_IoIncrement(deviceExtension);
  289.     ntStatus = IoCallDriver(deviceExtension->TopOfStackDeviceObject,
  290.                             irp);
  292.     if(NT_SUCCESS(ntStatus)) {
  294.         ntStatus = STATUS_SUCCESS;
  295.     }
  297.     IsoUsb_DbgPrint(3, ("IsoUsb_StartTransfer - endsn"));
  299.     return ntStatus;
  300. }
  303. NTSTATUS
  304. IsoUsb_InitializeStreamUrb(
  305.     IN PDEVICE_OBJECT          DeviceObject,
  306.     IN PISOUSB_TRANSFER_OBJECT TransferObject
  307.     )
  308. /*++
  309.  
  310. Routine Description:
  312.     This routine initializes the irp/urb pair in the transfer object.
  314. Arguments:
  316.     DeviceObject - pointer to device object
  317.     TransferObject - pointer to transfer object
  319. Return Value:
  321.     NT status value
  323. --*/
  324. {
  325.     PURB                  urb;
  326.     ULONG                 i;
  327.     ULONG                 siz;
  328.     ULONG                 packetSize;
  329.     ULONG                 numPackets;
  330.     ULONG                 maxXferSize;
  331.     PISOUSB_STREAM_OBJECT streamObject;
  333.     urb = TransferObject->Urb;
  334.     streamObject = TransferObject->StreamObject;
  335.     maxXferSize = streamObject->PipeInformation->MaximumTransferSize;
  336.     packetSize = streamObject->PipeInformation->MaximumPacketSize;
  337.     numPackets = maxXferSize / packetSize;
  339.     IsoUsb_DbgPrint(3, ("IsoUsb_InitializeStreamUrb - beginsn"));
  341.     if(numPackets > 255) {
  343.         numPackets = 255;
  344.         maxXferSize = packetSize * numPackets;
  345.     }
  347.     siz = GET_ISO_URB_SIZE(numPackets);
  349.     RtlZeroMemory(urb, siz);
  351.     urb->UrbIsochronousTransfer.Hdr.Length = (USHORT) siz;
  352.     urb->UrbIsochronousTransfer.Hdr.Function = URB_FUNCTION_ISOCH_TRANSFER;
  353.     urb->UrbIsochronousTransfer.PipeHandle =
  354.                                 streamObject->PipeInformation->PipeHandle;
  356.     urb->UrbIsochronousTransfer.TransferFlags = USBD_TRANSFER_DIRECTION_IN;
  358.     urb->UrbIsochronousTransfer.TransferBufferMDL = NULL;
  359.     urb->UrbIsochronousTransfer.TransferBuffer = TransferObject->DataBuffer;
  360.     urb->UrbIsochronousTransfer.TransferBufferLength = numPackets * packetSize;
  362.     urb->UrbIsochronousTransfer.TransferFlags |= USBD_START_ISO_TRANSFER_ASAP;
  364.     urb->UrbIsochronousTransfer.NumberOfPackets = numPackets;
  365.     urb->UrbIsochronousTransfer.UrbLink = NULL;
  367.     for(i=0; i<urb->UrbIsochronousTransfer.NumberOfPackets; i++) {
  369.         urb->UrbIsochronousTransfer.IsoPacket[i].Offset = i * packetSize;
  371.         //
  372.         // For input operation, length is set to whatever the device supplies.
  373.         //
  374.         urb->UrbIsochronousTransfer.IsoPacket[i].Length = 0;
  375.     }
  377.     IsoUsb_DbgPrint(3, ("IsoUsb_InitializeStreamUrb - endsn"));
  379.     return STATUS_SUCCESS;
  380. }
  382. NTSTATUS
  383. IsoUsb_IsoIrp_Complete(
  384.     IN PDEVICE_OBJECT DeviceObject,
  385.     IN PIRP           Irp,
  386.     IN PVOID          Context
  387.     )
  388. /*++
  389.  
  390. Routine Description:
  392.     This is the completion routine of the irp in the irp/urb pair
  393.     passed down the stack for stream transfers.
  395.     If the transfer was cancelled or the device yanked out, then we
  396.     release resources, dump the statistics and return 
  397.     STATUS_MORE_PROCESSING_REQUIRED, so that the cleanup module can
  398.     free the irp.
  400.     otherwise, we reinitialize the transfers and continue recirculaiton 
  401.     of the irps.
  403. Arguments:
  405.     DeviceObject - pointer to device object below us.
  406.     Irp - I/O completion routine.
  407.     Context - context passed to the completion routine
  409. Return Value:
  411. --*/
  412. {
  413.     NTSTATUS                ntStatus;
  414.     PDEVICE_OBJECT          deviceObject;
  415.     PDEVICE_EXTENSION       deviceExtension;
  416.     PIO_STACK_LOCATION      nextStack;
  417.     PISOUSB_STREAM_OBJECT   streamObject;
  418.     PISOUSB_TRANSFER_OBJECT transferObject;
  420.     transferObject = (PISOUSB_TRANSFER_OBJECT) Context;
  421.     streamObject = transferObject->StreamObject;
  422.     deviceObject = streamObject->DeviceObject;
  423.     deviceExtension = (PDEVICE_EXTENSION) deviceObject->DeviceExtension;
  425.     IsoUsb_DbgPrint(3, ("IsoUsb_IsoIrp_Complete - beginsn"));
  427.     ntStatus = IsoUsb_ProcessTransfer(transferObject);
  429.     if((ntStatus == STATUS_CANCELLED) ||
  430.        (ntStatus == STATUS_DEVICE_NOT_CONNECTED)) {
  431.     
  432.         IsoUsb_DbgPrint(3, ("Isoch irp cancelled/device removedn"));
  434.         //
  435.         // this is the last irp to complete with this erroneous value
  436.         // signal an event and return STATUS_MORE_PROCESSING_REQUIRED
  437.         //
  438.         if(InterlockedDecrement(&streamObject->PendingIrps) == 0) {
  440.             KeSetEvent(&streamObject->NoPendingIrpEvent,
  441.                        1,
  442.                        FALSE);
  444.             IsoUsb_DbgPrint(3, ("-----------------------------n"));
  445.         }
  447.         IsoUsb_DbgPrint(3, ("IsoUsb_IsoIrp_Complete::"));
  448.         IsoUsb_IoDecrement(deviceExtension);
  450.         transferObject->Irp = NULL;
  451.         IoFreeIrp(Irp);
  453.         return STATUS_MORE_PROCESSING_REQUIRED;
  454.     }
  456.     //
  457.     // otherwise circulate the irps.
  458.     //
  460.     IsoUsb_InitializeStreamUrb(deviceObject, transferObject);
  462.     nextStack = IoGetNextIrpStackLocation(Irp);
  463.     nextStack->Parameters.Others.Argument1 = transferObject->Urb;
  464.     nextStack->Parameters.DeviceIoControl.IoControlCode = 
  465.                                                 IOCTL_INTERNAL_USB_SUBMIT_URB;
  466.     nextStack->MajorFunction = IRP_MJ_INTERNAL_DEVICE_CONTROL;
  468.     IoSetCompletionRoutine(Irp,
  469.                            IsoUsb_IsoIrp_Complete,
  470.                            transferObject,
  471.                            TRUE,
  472.                            TRUE,
  473.                            TRUE);
  475.     transferObject->TimesRecycled++;
  477.     ntStatus = IoCallDriver(deviceExtension->TopOfStackDeviceObject,
  478.                             Irp);
  480.     IsoUsb_DbgPrint(3, ("IsoUsb_IsoIrp_Complete - endsn"));
  481.     IsoUsb_DbgPrint(3, ("-----------------------------n"));
  483.     return STATUS_MORE_PROCESSING_REQUIRED;
  484. }
  487. NTSTATUS
  488. IsoUsb_ProcessTransfer(
  489.     IN PISOUSB_TRANSFER_OBJECT TransferObject
  490.     )
  491. /*++
  492.  
  493. Routine Description:
  495.     This routine is invoked from the completion routine to check the status
  496.     of the irp, urb and the isochronous packets.
  498.     updates statistics
  500. Arguments:
  502.     TranferObject - pointer to transfer object for the irp/urb pair which completed.
  504. Return Value:
  506.     NT status value
  508. --*/
  509. {
  510.     PIRP        irp;
  511.     PURB        urb;
  512.     ULONG       i;
  513.     NTSTATUS    ntStatus;
  514.     USBD_STATUS usbdStatus;
  516.     irp = TransferObject->Irp;
  517.     urb = TransferObject->Urb;
  518.     ntStatus = irp->IoStatus.Status;
  520.     IsoUsb_DbgPrint(3, ("IsoUsb_ProcessTransfer - beginsn"));
  522.     if(!NT_SUCCESS(ntStatus)) {
  524.         IsoUsb_DbgPrint(3, ("Isoch irp failed with status = %Xn", ntStatus));
  525.     }
  527.     usbdStatus = urb->UrbHeader.Status;
  529.     if(!USBD_SUCCESS(usbdStatus)) {
  531.         IsoUsb_DbgPrint(3, ("urb failed with status = %Xn", usbdStatus));
  532.     }
  534.     //
  535.     // check each of the urb packets
  536.     //
  537.     for(i = 0; i < urb->UrbIsochronousTransfer.NumberOfPackets; i++) {
  539.         TransferObject->TotalPacketsProcessed++;
  541.         usbdStatus = urb->UrbIsochronousTransfer.IsoPacket[i].Status;
  543.         if(!USBD_SUCCESS(usbdStatus)) {
  545. //            IsoUsb_DbgPrint(3, ("Iso packet %d failed with status = %Xn", i, usbdStatus));
  546.             
  547.             TransferObject->ErrorPacketCount++;
  548.         }
  549.         else {
  550.             
  551.             TransferObject->TotalBytesProcessed += urb->UrbIsochronousTransfer.IsoPacket[i].Length;
  552.         }
  553.     }
  555.     IsoUsb_DbgPrint(3, ("IsoUsb_ProcessTransfer - endsn"));
  557.     return ntStatus;
  558. }
  560. NTSTATUS
  561. IsoUsb_StopIsoStream(
  562.     IN PDEVICE_OBJECT        DeviceObject,
  563.     IN PISOUSB_STREAM_OBJECT StreamObject,
  564.     IN PIRP                  Irp
  565.     )
  566. /*++
  567.  
  568. Routine Description:
  570.     This routine is invoked from the IOCTL to stop the stream transfers.
  572. Arguments:
  574.     DeviceObject - pointer to device object
  575.     StreamObject - pointer to stream object
  576.     Irp - pointer to Irp
  578. Return Value:
  580.     NT status value
  582. --*/
  583. {
  584.     ULONG              i;
  585.     KIRQL              oldIrql;
  586.     PDEVICE_EXTENSION  deviceExtension;
  587.     PIO_STACK_LOCATION irpStack;
  589.     //
  590.     // initialize vars
  591.     //
  592.     irpStack = IoGetCurrentIrpStackLocation(Irp);
  593.     deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
  595.     IsoUsb_DbgPrint(3, ("IsoUsb_StopIsoStream - beginsn"));
  597.     if((StreamObject == NULL) ||
  598.        (StreamObject->DeviceObject != DeviceObject)) {
  600.         IsoUsb_DbgPrint(1, ("invalid streamObjectn"));
  601.         return STATUS_INVALID_PARAMETER;
  602.     }
  604.     IsoUsb_StreamObjectCleanup(StreamObject, deviceExtension);
  606.     IsoUsb_DbgPrint(3, ("IsoUsb_StopIsoStream - endsn"));
  608.     return STATUS_SUCCESS;
  609. }
  611. NTSTATUS
  612. IsoUsb_StreamObjectCleanup(
  613.     IN PISOUSB_STREAM_OBJECT StreamObject,
  614.     IN PDEVICE_EXTENSION     DeviceExtension
  615.     )
  616. /*++
  617.  
  618. Routine Description:
  620.     This routine is invoked either when the user-mode app passes an IOCTL to
  621.     abort stream transfers or when the the cleanup dispatch routine is run.
  622.     It is guaranteed to run only once for every stream transfer.
  624. Arguments:
  626.     StreamObject - StreamObject corresponding to stream transfer which
  627.     needs to be aborted.
  629.     DeviceExtension - pointer to device extension
  631. Return Value:
  633.     NT status value
  635. --*/
  636. {
  637.     ULONG                   i;
  638.     ULONG                   timesRecycled;
  639.     ULONG                   totalPacketsProcessed;
  640.     ULONG                   totalBytesProcessed;
  641.     ULONG                   errorPacketCount;
  642.     PISOUSB_TRANSFER_OBJECT xferObject;
  644.     //
  645.     // initialize the variables
  646.     //
  647.     timesRecycled = 0;
  648.     totalPacketsProcessed = 0;
  649.     totalBytesProcessed = 0;
  650.     errorPacketCount = 0;
  652.     //
  653.     // cancel transferobject irps/urb pair
  654.     // safe to touch these irps because the 
  655.     // completion routine always returns 
  656.     // STATUS_MORE_PRCESSING_REQUIRED
  657.     // 
  658.     //
  659.     for(i = 0; i < ISOUSB_MAX_IRP; i++) {
  661.         if(StreamObject->TransferObjectList[i] &&
  662.            StreamObject->TransferObjectList[i]->Irp) {
  663.         
  664.             IoCancelIrp(StreamObject->TransferObjectList[i]->Irp);
  665.         }
  666.     }
  668.     //
  669.     // wait for the transfer objects irps to complete.
  670.     //
  671.     KeWaitForSingleObject(&StreamObject->NoPendingIrpEvent,
  672.                           Executive,
  673.                           KernelMode,
  674.                           FALSE,
  675.                           NULL);
  677.     //
  678.     // dump the statistics
  679.     //
  680.     for(i = 0; i < ISOUSB_MAX_IRP; i++) {
  682.         xferObject = StreamObject->TransferObjectList[i];
  684.         if(xferObject) {
  686.             timesRecycled += xferObject->TimesRecycled;
  687.             totalPacketsProcessed += xferObject->TotalPacketsProcessed;
  688.             totalBytesProcessed += xferObject->TotalBytesProcessed;
  689.             errorPacketCount += xferObject->ErrorPacketCount;
  690.         }
  691.     }
  693.     IsoUsb_DbgPrint(3, ("TimesRecycled = %dn", timesRecycled));
  694.     IsoUsb_DbgPrint(3, ("TotalPacketsProcessed = %dn", totalPacketsProcessed));
  695.     IsoUsb_DbgPrint(3, ("TotalBytesProcessed = %dn", totalBytesProcessed));
  696.     IsoUsb_DbgPrint(3, ("ErrorPacketCount = %dn", errorPacketCount));
  699.     //
  700.     // free all the buffers, urbs and transfer objects 
  701.     // associated with stream object
  702.     //
  703.     for(i = 0; i < ISOUSB_MAX_IRP; i++) {
  704.         
  705.         xferObject = StreamObject->TransferObjectList[i];
  707.         if(xferObject) { 
  708.             
  709.             if(xferObject->Urb) {
  711.                 ExFreePool(xferObject->Urb);
  712.                 xferObject->Urb = NULL;
  713.             }
  715.             if(xferObject->DataBuffer) {
  716.     
  717.                 ExFreePool(xferObject->DataBuffer);
  718.                 xferObject->DataBuffer = NULL;
  719.             }
  721.             ExFreePool(xferObject);
  722.             StreamObject->TransferObjectList[i] = NULL;
  723.         }
  724.     }
  726.     ExFreePool(StreamObject);
  728. //    IsoUsb_ResetParentPort(DeviceObject);
  730.     return STATUS_SUCCESS;
  731. }