windows-xp/Source/XPSP1/NT/drivers/wdm/usb/driver/isoperf/iso.c

/***************************************************************************

Copyright (c) 1995  Microsoft Corporation

Module Name:

        iso.c

Abstract:


Environment:

        kernel mode only

Notes:

  THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY
  KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR
  PURPOSE.

  Copyright (c) 1996 Microsoft Corporation.  All Rights Reserved.


Revision History:

****************************************************************************/

#define DRIVER

#pragma warning(disable:4214) //  bitfield nonstd
#include "wdm.h"
#pragma warning(default:4214) 

#include "stdarg.h"
#include "stdio.h"

#pragma warning(disable:4200) //non std struct used
#include "usbdi.h"
#pragma warning(default:4200)

#include "usbdlib.h"
#include "usb.h"

#include "ioctl.h"
#include "isoperf.h"
#include "iso.h"

#define MAX_URBS_PER_PIPE 16 

UCHAR ucIsoInterface        = 0;

// Memory Leak detection global counters
ULONG gulBytesAllocated             = 0;
ULONG gulBytesFreed                 = 0;

NTSTATUS
ISOPERF_RefreshIsoUrb(
    PURB urb,
    USHORT packetSize,
    USBD_PIPE_HANDLE pipeHandle,
    PVOID pvDataBuffer,
    ULONG ulDataBufferLen
    )
/*++
Routine Description:
    Refreshes an Iso Usb Request Block in prep for resubmission to USB stack.
                
Arguments:
        urb         - pointer to urb to refresh
        packetsize  - max packet size for the endpoint for which this urb is intended
        pipeHandle  - Usbd pipe handle for the Urb
        pvDataBuff  - pointer to a data buffer that will contain data or will receive data
        ulDataBufLen- length of data buffer
        
Return Value:
    NT status code:
        STATUS_SUCCESS indicates Urb successfully refreshed
        Other status codes indicate error (most likely is a bad parameter passed in, which
        would result in STATUS_INVALID_PARAMETER to be returned)

--*/
{
    NTSTATUS ntStatus   = STATUS_SUCCESS;
    ULONG siz           = 0;
    ULONG i             = 0;
    ULONG numPackets    = 0;
    
    // Calculate the number of packets in this buffer
    numPackets = ulDataBufferLen/packetSize;

    // Adjust num packets by one if data buffer can accommodate it
    if (numPackets*packetSize < ulDataBufferLen) {
        numPackets++;
    }
    
    //
    // Use macro from provided by stack to figure out Urb length for given size of packets.  This is
    // necessary since Urb for iso transfers depends on the number of packets in the data buffer
    // since per-packet information is passed on the usbd interface
    //
    siz = GET_ISO_URB_SIZE(numPackets);

    // Clear out any garbage that may have gotten put in the urb by the last transfer
    RtlZeroMemory(urb, siz);

    // Now fill in the Urb
    urb->UrbIsochronousTransfer.Length               = (USHORT) siz;
    urb->UrbIsochronousTransfer.Function             = URB_FUNCTION_ISOCH_TRANSFER;
    urb->UrbIsochronousTransfer.PipeHandle           = pipeHandle;
    urb->UrbIsochronousTransfer.TransferFlags        = USBD_TRANSFER_DIRECTION_IN;
    urb->UrbIsochronousTransfer.TransferBufferMDL    = NULL;
    urb->UrbIsochronousTransfer.TransferBuffer       = pvDataBuffer;
    urb->UrbIsochronousTransfer.TransferBufferLength = numPackets * packetSize;

    ASSERT (ulDataBufferLen >= numPackets*packetSize);
    
    // This flag tells the stack to start sending/receiving right away
    urb->UrbIsochronousTransfer.TransferFlags       |= USBD_START_ISO_TRANSFER_ASAP;
    urb->UrbIsochronousTransfer.StartFrame           = 0;

    urb->UrbIsochronousTransfer.NumberOfPackets      = numPackets;
    urb->UrbIsochronousTransfer.ReservedMBZ          = 0;

    for (i=0; i< urb->UrbIsochronousTransfer.NumberOfPackets; i++) {
        urb->UrbIsochronousTransfer.IsoPacket[i].Offset
                    = i * packetSize;
    }//for

    return ntStatus;

}//ISOPERF_RefreshIsoUrb


NTSTATUS
ISOPERF_IsoInCompletion(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp,
    IN PVOID Context
    )
/*++

Routine Description:
    This is the completion routine that is called at the end of an iso Irp/Urb.  It is
    called when the Usb stack completes the Irp.

    NOTE: IoCompletion routine always runs at IRQL DISPATCH_LEVEL. 
    
Arguments:
    DeviceObject - pointer to the device object that represents this USB iso test device
                   DeviceObject is obtained from context due to old, old bug
                   in initial WDM implemenations
    Irp          - pointer to the Irp that was completed by the usb stack
    Context      - caller-supplied context that is passed in for use by this completion routine

    
Return Value:

    NT status code

--*/
{
    PIsoTxterContext                pIsoContext     = Context;
    PDEVICE_OBJECT                  myDeviceObject  = pIsoContext->DeviceObject;
    PDEVICE_EXTENSION               deviceExtension = myDeviceObject->DeviceExtension;
    pConfig_Stat_Info               pStatInfo       = deviceExtension->pConfig_Stat_Information;
    PIO_STACK_LOCATION              nextStack       = NULL;
    PURB                            urb             = pIsoContext->urb;
    PISOPERF_WORKITEM               isoperfWorkItem = NULL;
    PDEVICE_EXTENSION               MateDeviceExtension = NULL;
    ULONG                                                       unew,lnew,uold,lold;
    char *                          pcWork          = NULL; //a worker pointer
    ULONG                           i               = 0;
    char                            tempStr[32];
    
    ISO_ASSERT (pIsoContext != NULL);
    ISO_ASSERT (pStatInfo != NULL);
    ISO_ASSERT (deviceExtension != NULL);
    
    ISOPERF_KdPrint_MAXDEBUG (("In IsoInCompletionRoutine %x %x %x\n",
                                DeviceObject, Irp, Context));

                                
    // Check the USBD status code and only proceed in resubmission if the Urb was successful
    // or if the device extension flag that indicates the device is gone is FALSE
    if ( (USBD_SUCCESS(urb->UrbHeader.Status))  && ((deviceExtension->StopTransfers) == FALSE) ) {

                ISOPERF_GetUrbTimeStamp (urb, &lold, &uold);    //Get the Urb's timestamp
                
                GET_PENTIUM_CLOCK_COUNT(unew,lnew);                             //Get the time now

                pStatInfo->ulUrbDeltaClockCount = lnew-lold;    //Compute & store the delta
                
        // Check that data is incrementing from last data pattern received on this pipe
        if ((ISOPERF_IsDataGood(pIsoContext))== TRUE) {

                        // Data was good
            pStatInfo->ulSuccessfulIrps++;
            pStatInfo->ulBytesTransferredIn += pIsoContext->ulBufferLen;
            
        } else {

            // An error occured, so stop the test by setting the flag to stop the test 
            deviceExtension->bStopIsoTest = TRUE;
            deviceExtension->ulCountDownToStop = 0;

                        // Put this information in the status area for the device so the app can see it when it asks
            pStatInfo->erError = DataCompareFailed;
            pStatInfo->bStopped = 1;
         
        }//else data was bad
        
        if ( (deviceExtension->bStopIsoTest == TRUE) && (deviceExtension->ulCountDownToStop > 0) ) {

            // User has requested a stop to the Iso Test so, decrement the countdown value
            (deviceExtension->ulCountDownToStop)--;
        
        }//if user requested a stop
       
        // If device extension says to keep going on this test then continue on        
        if ((deviceExtension->ulCountDownToStop) > 0) {
        
            // Refresh this Urb before we resubmit it to the stack
            ISOPERF_RefreshIsoUrb (pIsoContext->urb,
                                   pIsoContext->PipeInfo->MaximumPacketSize,
                                   pIsoContext->PipeInfo->PipeHandle,
                                   pIsoContext->pvBuffer,
                                   pIsoContext->ulBufferLen
                                  );

            // If this iso in device has a mate, then start a thread to have it use this data buffer
            if (deviceExtension->MateDeviceObject) {

                MateDeviceExtension = deviceExtension->MateDeviceObject->DeviceExtension;

                // Check if the mate device is up and running
                if ( (MateDeviceExtension->Stopped == FALSE) && (MateDeviceExtension->StopTransfers == FALSE) ) {

                    //start a Work Item to use this buffer which will only do so when the buffer has arrived
                    isoperfWorkItem = ISOPERF_ExAllocatePool(NonPagedPool, sizeof(ISOPERF_WORKITEM),&gulBytesAllocated);

                    isoperfWorkItem->DeviceObject = deviceExtension->MateDeviceObject;
                    isoperfWorkItem->pvBuffer     = pIsoContext->pvBuffer;
                    isoperfWorkItem->ulBufferLen  = pIsoContext->ulBufferLen;
                    isoperfWorkItem->bFirstUrb    = pIsoContext->bFirstUrb;
                    isoperfWorkItem->InMaxPacket  = pIsoContext->PipeInfo->MaximumPacketSize;
                    isoperfWorkItem->ulNumberOfFrames = urb->UrbIsochronousTransfer.NumberOfPackets;

                                        // Call the OUT pipe transfer routine
                    ISOPERF_StartIsoOutTest (isoperfWorkItem);

                    // Since the firstUrb flag is used to tell the outpipe whether it's a virgin or not, 
                    // and since this Urb can be recycled through here again, we have to de-virginize the 
                    // flag so this Urb doesn't always cause the outpipe to think it's dealing with a virgin Urb.
                    if (pIsoContext->bFirstUrb == TRUE) {
                        pIsoContext->bFirstUrb = FALSE;
                    }//if this was the first Urb
                    
                }//if mate device is ok

            }//if there is a mate device in the system (that this driver runs)

            // Get the next lower driver's stack
            nextStack = IoGetNextIrpStackLocation(Irp);
            ASSERT(nextStack != NULL);

            //
            // Set up the next lower driver's stack parameters which is where that
            // driver will go to get its parameters for this internal IOCTL Irp
            //
            nextStack->Parameters.Others.Argument1  = urb;
            nextStack->MajorFunction                = IRP_MJ_INTERNAL_DEVICE_CONTROL;
            nextStack->Parameters.DeviceIoControl.IoControlCode =
                IOCTL_INTERNAL_USB_SUBMIT_URB;

            IoSetCompletionRoutine(Irp,
                    ISOPERF_IsoInCompletion,
                    pIsoContext,
                    TRUE,
                    TRUE,
                    FALSE); //INVOKE ON CANCEL

                        // Time stamp the Urb before we send it down the stack
                        ISOPERF_TimeStampUrb (urb, &unew, &lnew);
                        
            // Call the driver
            IoCallDriver (deviceExtension->StackDeviceObject,
                          Irp);
                          
            // Tell the IO Manager that we want to handle this Irp from here on...
            return (STATUS_MORE_PROCESSING_REQUIRED);

        } else {

            ISOPERF_KdPrint (("Stopped Iso test (did not resubmit Irp/Urb due to device extension flag)\n"));

        }/* else the tests should be stopped */
        
    }//if Urb status was successful

    // Otherwise, the Urb was unsuccessful
    else {
        pStatInfo->erError = UsbdErrorInCompletion;
        pStatInfo->ulUnSuccessfulIrps++;

        FIRE_OFF_CATC;

        if (!(USBD_SUCCESS(urb->UrbHeader.Status))) {
            ISOPERF_KdPrint (("Urb unsuccessful (status: %#x)\n",urb->UrbHeader.Status));

            // Dump out the status for the packets
            for (i=0; i< urb->UrbIsochronousTransfer.NumberOfPackets; i++) {
                ISOPERF_KdPrint (("Packet %d: Status: [%#X]\n",
                                    i,
                                    urb->UrbIsochronousTransfer.IsoPacket[i].Status));
                                    
                // Put the last known bad packet status code into this space in the stat area
                if (!USBD_SUCCESS(urb->UrbIsochronousTransfer.IsoPacket[i].Status)) {
                    pStatInfo->UsbdPacketStatCode = urb->UrbIsochronousTransfer.IsoPacket[i].Status;
                }//if hit a fail code                 
                sprintf (tempStr, "Data: %x",  *((PULONG)(urb->UrbIsochronousTransfer.TransferBuffer)));
                ISOPERF_KdPrint (("First data in buffer: %s\n",tempStr));
                
            }//for all the packets
                
        }else {
            ISOPERF_KdPrint (("Urb successful, but StopTransfers flag is set (%d)\n",deviceExtension->StopTransfers));
        }
        
            
    }//Urb was unsuccessful, so don't repost it and fall thru to cleanup code

    // Clean up section.  This only executes if:
    //  --Urb (bus transfer) was unsuccessful (stop the test)
    //  --Buffer didn't look right (a hiccup was detected, etc.)
    //  --User requested tests to stop
    ISOPERF_KdPrint (("Stopping Iso In Stream and Cleaning Up...U:%x|C:%x|B:%x\n", 
                                        urb,
                                        pIsoContext,
                                        pIsoContext->pvBuffer));    
                                        
    // Free up the memory created for this transfer that we are retiring
    if (urb) {
        // We can't free the Urb itself, since it has some junk before it, so we have to roll back the 
        // pointer to get to the beginning of the block that we originally allocated, and then try to free it.
        pcWork = (char*)urb;                        //get the urb
        urb = (PURB) (pcWork - (2*sizeof(ULONG)));  //the original pointer is 2 DWORDs behind the Urb
        ISOPERF_KdPrint (("Freeing urb %x\n",urb)); 
        ISOPERF_ExFreePool (urb, &gulBytesFreed);   //Free that buffer
    }//if
    
    if (pIsoContext) {

        // Free the data buffer
        if (pIsoContext->pvBuffer) {
            ISOPERF_KdPrint (("Freeing databuff %x\n",pIsoContext->pvBuffer));
            ISOPERF_ExFreePool (pIsoContext->pvBuffer, &gulBytesFreed);
        }
            
        // Free the Iso Context
        ISOPERF_KdPrint (("Freeing pIsoContext %x\n",pIsoContext));
        ISOPERF_ExFreePool (pIsoContext, &gulBytesFreed);
        
    }//if valid Iso Context

    //Decrement the number of outstanding Irps since this one is being retired
    (deviceExtension->ulNumberOfOutstandingIrps)--;
    
    // If this is the last Irp we are retiring, then the device should be marked as not busy
    if (deviceExtension->ulNumberOfOutstandingIrps == 0) {
        deviceExtension->DeviceIsBusy = FALSE;
        pStatInfo->bDeviceRunning = FALSE;
    }//if not irps left outstanding on this device

    //Free the IoStatus block that we allocated for  this Irp
    if (Irp->UserIosb) {
        ISOPERF_KdPrint (("Freeing My IoStatusBlock %x\n",Irp->UserIosb));
        ISOPERF_ExFreePool(Irp->UserIosb, &gulBytesFreed);
    } else {
        //Bad thing...no IoStatus block pointer??
        ISOPERF_KdPrint (("ERROR: Irp's IoStatus block is apparently NULL!\n"));
        TRAP();
    }//else bad iostatus pointer
    
        //Free the Irp here and return STATUS_MORE_PROCESSING_REQUIRED instead of SUCCESS
    ISOPERF_KdPrint (("Freeing Irp %x\n",Irp));
        IoFreeIrp(Irp);
        
    // Tell the IO Manager that we want to handle this Irp from here on...
    ISOPERF_KdPrint (("Returning STATUS_MORE_PROCESSING_REQUIRED from IsoInCompletion\n"));
    return (STATUS_MORE_PROCESSING_REQUIRED);

}//ISOPERF_IsoInCompletion


PURB
ISOPERF_BuildIsoRequest(
    IN PDEVICE_OBJECT DeviceObject,
    IN PUSBD_PIPE_INFORMATION pPipeInfo,
    IN BOOLEAN Read,
    IN ULONG length,
    IN ULONG ulFrameNumber,
    IN PVOID pvTransferBuffer,
    IN PMDL pMDL
    )
/*++
Routine Description:
    Allocates and initializes most of a URB.  The caller must initialize the FLAGS field 
    with any further flags they desire after this function is called.

Arguments:
    DeviceObject - pointer to the device extension for this instance of the device
    pPipeInfo    -   ptr to pipe descr for which to build the iso request (urb)
    Read         -   if TRUE, it's a read, FALSE it's a write
    length       -   length of the data buffer or MDL, used for packetizing the buffer for iso txfer
    ulframeNumber- if non-zero, use this frame number to build in the urb and don't set flags
    pvTransferBuffer -  Non-NULL: this is the TB ;  NULL: an MDL is specified
    ulTransferBufferLength -  len of buffer specified in pvTransferBuffer
    pMDL        - if an MDL is being used, this is a ptr to it
    
Return Value:
    Almost initialized iso urb.  Caller must fill in the flags after this fn is called.
    
--*/
{
    ULONG siz;
    ULONG packetSize,numPackets, i;
    PURB urb = NULL;
    PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
        char * pcWork = NULL;
    ISO_ASSERT(pPipeInfo!=NULL)

    packetSize = pPipeInfo->MaximumPacketSize;

    numPackets = length/packetSize;
    if (numPackets*packetSize < length) {
        numPackets++;
    }

    siz = GET_ISO_URB_SIZE(numPackets);

    //Add room for a URB time stamp at the beginning of the Urb by allocating more than
    //siz by 4 DWORDs.  The pentium clock count macro can then be used by the caller of 
    //this routine to fill in the clock count stamp.  We allocate an extra 2 DWORDs more than
    //we need to allow some room for stuff to put at the end of the URB in the future.
    pcWork = ISOPERF_ExAllocatePool(NonPagedPool, (siz+(4*sizeof(ULONG))), &gulBytesAllocated);

    urb = (PURB) (pcWork + (2*sizeof(ULONG)));          //Push pass the clock count area to the urb area

    if (urb) {
        RtlZeroMemory(urb, siz);

        urb->UrbIsochronousTransfer.Length =                (USHORT) siz;
        urb->UrbIsochronousTransfer.Function =              URB_FUNCTION_ISOCH_TRANSFER;
        urb->UrbIsochronousTransfer.PipeHandle =            pPipeInfo->PipeHandle;
        urb->UrbIsochronousTransfer.TransferFlags =         Read ? USBD_TRANSFER_DIRECTION_IN : 0;

        urb->UrbIsochronousTransfer.TransferBufferMDL =     pMDL;  
        urb->UrbIsochronousTransfer.TransferBuffer =        pvTransferBuffer;
        urb->UrbIsochronousTransfer.TransferBufferLength =  length;
        urb->UrbIsochronousTransfer.Function =              URB_FUNCTION_ISOCH_TRANSFER;

        if (ulFrameNumber==0) {
            //No frame number specified, just start asap
            urb->UrbIsochronousTransfer.TransferFlags |= USBD_START_ISO_TRANSFER_ASAP;
        }else{
            //use specific starting framenumber & don't set (unset) the asap flag
            urb->UrbIsochronousTransfer.StartFrame = ulFrameNumber;
            urb->UrbIsochronousTransfer.TransferFlags &= ~USBD_START_ISO_TRANSFER_ASAP;
        }//if framenumber was specified

        urb->UrbIsochronousTransfer.NumberOfPackets = numPackets;
        urb->UrbIsochronousTransfer.ReservedMBZ = 0;

                // Fill in the packet size array
        for (i=0; i< urb->UrbIsochronousTransfer.NumberOfPackets; i++) {
            urb->UrbIsochronousTransfer.IsoPacket[i].Offset
                        = i * packetSize;
        } //for

    }//if urb

    return urb;
}

    
PVOID 
ISOPERF_GetBuff (
                PDEVICE_OBJECT DeviceObject,
                ULONG          ulPipeNumber,
                ULONG          ulInterfaceNumber,
                ULONG          ulNumberOfFrames,
                PULONG         pulBufferSize
                )
/*++
ISOPERF_GetBuff

Routine Description:
    Creates a buffer as specified by input params.   If the input params specify a buffer
    that is too big to be submitted to this pipe, then this request will fail.
    
Arguments:
    DeviceObject - pointer to the device extension for this instance of the device

Return Value:
        Returns a pointer to the allocated data buffer
    
--*/
{
    PDEVICE_EXTENSION deviceExtension = NULL;
    ULONG             ulMaxPacketSize = 0;
    ULONG             ulBufferSize    = 0;
    ULONG             ulMaxTxferSize  = 0;    
    PVOID             pvBuffer        = NULL;
    
    deviceExtension = DeviceObject->DeviceExtension;
    ulMaxPacketSize = deviceExtension->Interface[ulInterfaceNumber]->Pipes[ulPipeNumber].MaximumPacketSize;
    ulMaxTxferSize  = deviceExtension->Interface[ulInterfaceNumber]->Pipes[ulPipeNumber].MaximumTransferSize;

    ulBufferSize    = *pulBufferSize = ulMaxPacketSize * ulNumberOfFrames;

    // Check if this buffer is too big to submit on this pipe (per its initial setup)
    if (ulBufferSize > ulMaxTxferSize) {
        *pulBufferSize = 0;
        return (NULL);
    } else {
        return ( ISOPERF_ExAllocatePool (NonPagedPool, ulBufferSize, &gulBytesAllocated) );
    }

}//ISOPERF_GetBuff

ULONG
ISOPERF_StartIsoInTest (
                PDEVICE_OBJECT DeviceObject,
                PIRP           pIrp
               )
/*++
ISOPERF_StartIsoInTest

Routine Description:
    Starts the Iso In Test
    
Arguments:
    DeviceObject - pointer to the device extension for this instance of the device
    pIrp         - pointer to the Irp from the Ioctl
    
Return Value:
    
--*/


{
    NTSTATUS                    ntStatus                = STATUS_INVALID_PARAMETER;
    PDEVICE_EXTENSION           deviceExtension         = NULL;
    PURB                        urb                 = NULL;
    ULONG                       ulFrameNumber           = 0;
    ULONG                       UrbNumber               = 0;
    ULONG                       NumberOfFrames          = 0;
    PUSBD_INTERFACE_INFORMATION pInterfaceInfo          = NULL;
    PUSBD_PIPE_INFORMATION      pUsbdPipeInfo           = NULL;
    PUSBD_INTERFACE_INFORMATION pMateInterfaceInfo  = NULL;
    PUSBD_PIPE_INFORMATION      pMateUsbdPipeInfo   = NULL;
    ULONG                       ulBufferSize            = 0;
    IsoTxferContext *           pIsoContext             = NULL;
    PVOID                       pvBuff                  = NULL;
    BOOLEAN                     bFirstUrb               = FALSE;
    BOOLEAN                     bHaveMate               = FALSE;
    ULONG                       Upper, Lower;
    pConfig_Stat_Info           configStatInfo          = NULL;
    ULONG                       Max_Urbs_Per_Pipe   = 0; 
    PDEVICE_OBJECT              mateDeviceObject    = NULL;
    PDEVICE_EXTENSION           mateDeviceExtension = NULL;
    pConfig_Stat_Info           mateConfigStatInfo  = NULL;
        char *                                          pcWork                      = NULL;

    ISOPERF_KdPrint (("Enter ISOPERF_StartIsoInTest (%x) (%x)\n",DeviceObject, pIrp));
    
    deviceExtension     = DeviceObject->DeviceExtension;
    pInterfaceInfo      = deviceExtension->Interface[ucIsoInterface];
    ISO_ASSERT (pInterfaceInfo!=NULL)
    
    //make sure this is an IN Iso device
    if (deviceExtension->dtTestDeviceType != Iso_In_With_Pattern) {
        ISOPERF_KdPrint (("Error: not an Iso IN device! (%d)\n",deviceExtension->dtTestDeviceType));
        TRAP();
        return (ULONG)STATUS_INVALID_PARAMETER;
    }//if it's NOT an ISO IN then bounce it back

        // Get the config info for the In Iso Device
    configStatInfo = deviceExtension->pConfig_Stat_Information;
    ASSERT (configStatInfo != NULL);

    // Check out the offset provided to make sure it's not too big
    if (configStatInfo->ulFrameOffset >= USBD_ISO_START_FRAME_RANGE) {
        ISOPERF_KdPrint (("Error: Detected a FrameOffset Larger than allowed! (%d)\n",configStatInfo->ulFrameOffset));
        TRAP();
        return (ULONG)STATUS_INVALID_PARAMETER;
    }//if bad frame offset

    if (configStatInfo) {
        Max_Urbs_Per_Pipe = configStatInfo->ulMax_Urbs_Per_Pipe;
        NumberOfFrames    = configStatInfo->ulNumberOfFrames;
    }//if configstatinfo is not null
        
        // Only set up the output device if the config info indicates a desire to do the In->Out test
        if (configStatInfo->ulDoInOutTest) {
            //If there is an OUT Iso device, and we are trying to do a IN->OUT test, then set that device object up
            ntStatus = ISOPERF_FindMateDevice (DeviceObject);

            if (ntStatus == STATUS_SUCCESS) {
                bHaveMate = TRUE;
                mateDeviceObject = deviceExtension->MateDeviceObject;
                mateDeviceExtension = mateDeviceObject->DeviceExtension;
                pMateInterfaceInfo = mateDeviceExtension->Interface[ucIsoInterface];
                mateConfigStatInfo = mateDeviceExtension->pConfig_Stat_Information;
                mateConfigStatInfo->ulFrameOffset = configStatInfo->ulFrameOffsetMate;
                
            }//if status success        

            // Reset the pipe on the mate device if it's also here
            // NOTE: we only reset the first pipe on the mate device here
            if (bHaveMate == TRUE) {
                ASSERT (pMateInterfaceInfo!=NULL);
                pMateUsbdPipeInfo = &(pMateInterfaceInfo->Pipes[0]);
                ASSERT (pMateUsbdPipeInfo != NULL);
                ISOPERF_ResetPipe(deviceExtension->MateDeviceObject,pMateUsbdPipeInfo);
            }// if mate
        } else {
                // Set the mate dev obj to NULL so completion routine knows not to use it
                deviceExtension->MateDeviceObject = NULL;
        }//if In->Out test is not being requested
        
    // Reset the first pipe on the IN device
    pUsbdPipeInfo= &(pInterfaceInfo->Pipes[0]);
    ISOPERF_ResetPipe(DeviceObject, pUsbdPipeInfo);

    // Untrigger the CATC so if we trigger it later it will go off
    RESTART_CATC;

    // Get the current frame number 
    ulFrameNumber = ISOPERF_GetCurrentFrame(DeviceObject);

    //Save away the current frame number so the app can peek at it
    configStatInfo->ulFrameNumberAtStart = ulFrameNumber;

    // See what the user wants to do wrt starting frame number by looking at the config info
    if (configStatInfo->ulFrameOffset == 0) {
        // This means start ASAP
        ulFrameNumber = 0;
    }else {
        //Add the offset that the User wants to add to this frame number (it better be less than 1024!)
        ulFrameNumber += configStatInfo->ulFrameOffset;
    } //else

    //Save away the starting frame number so the app can peek at it
    configStatInfo->ulStartingFrameNumber = ulFrameNumber;

    // Set flag to indicate first Urb
    bFirstUrb = TRUE;
    
    // Get the pipe info for the first pipe
    pUsbdPipeInfo= &(pInterfaceInfo->Pipes[0]);

    // Build all the urbs for each pipe (note we send multiple Urbs down the stack)
    for (UrbNumber=0;UrbNumber<Max_Urbs_Per_Pipe;UrbNumber++) {

        //
        // Calculate the buffer size required and get a pointer to the buffer
        // Note:  this buffer needs to be freed when the StopIsoInTest ioctl is 
        //        received.  The completion routine will free the buffer when it 
        //        sees that it is time to stop the iso in test (the pointer is grabbed
        //        from the irp).
        //
        pvBuff = ISOPERF_GetBuff (DeviceObject,
                                  0,                    // pipe number
                                  0,                    // interface number
                                  NumberOfFrames,    // Nbr of mS worth of data to post
                                  &ulBufferSize);

  
        ISO_ASSERT (pvBuff!=NULL);
 
        //
        // Create the context for this transfer out of the nonpaged pool since it survives
        // this routine and is used in the completion routine
        //
        pIsoContext = ISOPERF_ExAllocatePool (NonPagedPool, sizeof (IsoTxferContext), &gulBytesAllocated);

        //build the urb
        urb =    ISOPERF_BuildIsoRequest(DeviceObject,
                                         pUsbdPipeInfo,     //Pipe info struct
                                         TRUE,              //READ
                                         ulBufferSize,      //Data buffer size
                                         bFirstUrb ? ulFrameNumber : 0, //Frame Nbr
                                         pvBuff,            //Data buffer
                                         NULL               //no MDL used
                                        );
        if (urb) {

            // Fill in the iso context
            pIsoContext->urb           = urb;
            pIsoContext->DeviceObject  = DeviceObject;
            pIsoContext->PipeInfo      = pUsbdPipeInfo;
            pIsoContext->irp           = pIrp;
            pIsoContext->pvBuffer      = pvBuff;
            pIsoContext->ulBufferLen   = ulBufferSize;
            pIsoContext->PipeNumber    = UrbNumber;
            pIsoContext->NumPackets    = urb->UrbIsochronousTransfer.NumberOfPackets;
            pIsoContext->bFirstUrb     = bFirstUrb;
            
            ISOPERF_KdPrint_MAXDEBUG (("Urb %d pvBuff %x ulBuffSz %d NumPackts %d pIsoCont %x  Urb: %x\n",
                                        UrbNumber,pvBuff,ulBufferSize,pIsoContext->NumPackets,pIsoContext,urb));

                        // Time stamp the Urb before we send it down the stack
                        ISOPERF_TimeStampUrb(urb, &Lower, &Upper);

            //Create our own Irp for the device and call the usb stack w/ our urb/irp
            ntStatus = ISOPERF_CallUSBDEx ( DeviceObject, 
                                            urb, 
                                            FALSE,                   //Don't block
                                            ISOPERF_IsoInCompletion, //Completion routine
                                            pIsoContext,             //pvContext
                                            FALSE);                  //don't want timeout 


            // Set the busy flag if the Urb/Irp succeed
            if (NT_SUCCESS(ntStatus)) {
                deviceExtension->DeviceIsBusy = TRUE;
                //Set to some huge value; ioctl to stop the test will set this to a smaller value
                deviceExtension->ulCountDownToStop = 0xFFFF; 
                deviceExtension->bStopIsoTest = FALSE;
                deviceExtension->StopTransfers = FALSE;

                configStatInfo->erError         = NoError;
                configStatInfo->bDeviceRunning  = TRUE;
                
            } else {

                deviceExtension->DeviceIsBusy = FALSE;
                deviceExtension->bStopIsoTest = TRUE;
                deviceExtension->StopTransfers = TRUE;

                configStatInfo->erError         = ErrorInPostingUrb;
                configStatInfo->UrbStatusCode   = urb->UrbHeader.Status;
                
                if (bFirstUrb) {
                    //since this is the first Urb,  we know for sure the device isn't running
                    configStatInfo->bDeviceRunning  = FALSE;
                    configStatInfo->bStopped        = TRUE;                      
                }//if first Urb
                
            } //else FAILED calling USB stack
                
        }//if urb[UrbNumber] exists

        // Reset the flag that indicates it's the first Urb
        bFirstUrb = FALSE;
        
    }//for all the urbs per pipe (UrbNumber)


    ISOPERF_KdPrint (("Exit ISOPERF_StartIsoInTest (%x)\n",ntStatus));

    return ntStatus;
    
}//StartIsoInTest


NTSTATUS
ISOPERF_ResetPipe(
    IN PDEVICE_OBJECT DeviceObject,
    IN USBD_PIPE_INFORMATION * pPipeInfo
    )
/*++

Routine Description:
    Resets the given Pipe by calling a USBD function
    
Arguments:
    DeviceObject - pointer to dev obj for this instance of usb device
    pPipeInfo    - pointer to usbd pipe info struct
    
Return Value:

--*/
{
    NTSTATUS ntStatus;
    PURB urb;
    PDEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension;
    
    ISO_ASSERT (pPipeInfo!=NULL)
    
    urb = ISOPERF_ExAllocatePool(NonPagedPool,((sizeof(struct _URB_PIPE_REQUEST))+64), &gulBytesAllocated);

    if (urb) {

    urb->UrbHeader.Length = (USHORT) sizeof (struct _URB_PIPE_REQUEST);
    urb->UrbHeader.Function = URB_FUNCTION_RESET_PIPE;
    urb->UrbPipeRequest.PipeHandle = pPipeInfo->PipeHandle;

    ntStatus = ISOPERF_CallUSBD   ( DeviceObject,
                                    urb);

    } else {
            ntStatus = STATUS_NO_MEMORY;
    }

    ISOPERF_KdPrint (("Freeing urb in RESET_PIPE: %x\n",urb));
    
    // Free the urb we created since we blocked on this function
    if (urb) {
        ISOPERF_ExFreePool (urb, &gulBytesFreed);
    }//if urb
    
    return ntStatus;
}


ULONG
ISOPERF_GetCurrentFrame(
    IN PDEVICE_OBJECT DeviceObject
    )
/*++
ISOPERF_GetCurrentFrame

Arguments:
    DeviceExtension - pointer to the device extension for this instance 

Return Value:
        Current Frame Number
--*/
{
    NTSTATUS ntStatus;
        PURB urb;
        ULONG currentUSBFrame = 0;

    ISOPERF_KdPrint_MAXDEBUG (("In ISOPERF_GetCurrentFrame: (%x)\n",DeviceObject));
    
        urb = ISOPERF_ExAllocatePool(NonPagedPool,sizeof(struct _URB_GET_CURRENT_FRAME_NUMBER), &gulBytesAllocated);
                                                 
        if (urb) {

                urb->UrbHeader.Length = (USHORT) sizeof (struct _URB_GET_CURRENT_FRAME_NUMBER);
                urb->UrbHeader.Function = URB_FUNCTION_GET_CURRENT_FRAME_NUMBER;

                ntStatus = ISOPERF_CallUSBD   ( DeviceObject, 
                                                urb
                                                );

                if (NT_SUCCESS(ntStatus) && USBD_SUCCESS(URB_STATUS(urb))) {
                        currentUSBFrame = urb->UrbGetCurrentFrameNumber.FrameNumber;

            // Since a ZERO for the USBFrameNumber indicates an error, and if it really is zero by chance, then just bump it by one
                        if (currentUSBFrame==0) {
                            currentUSBFrame++;
                        }
            }

                ISOPERF_ExFreePool(urb, &gulBytesFreed);
                
        } else {
                ntStatus = STATUS_NO_MEMORY;            
    }           

    ISOPERF_KdPrint_MAXDEBUG (("Exit ISOPERF_GetCurrentFrame: (%x)\n",currentUSBFrame));

        return currentUSBFrame;                 
}       


NTSTATUS 
ISOPERF_StopIsoInTest (
    IN PDEVICE_OBJECT   DeviceObject,
    IN PIRP             Irp
    )
/*++
Routine Description:
        Stops the Iso IN test by setting fields in the device extension so that the completion
        routine no longer does checks and resubmits Irps to keep the iso stream running.

        This call causes no USB stack calls nor USB bus traffic.
        
Arguments:
    DeviceObject - pointer to the device extension for this instance of the device
        Irp                      - pointer to the Irp created in the Ioctl
        
Return Value:
        Always returns NT status of STATUS_SUCCESS
        
--*/
{
    PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
    ULONG Upper, Lower;

    GET_PENTIUM_CLOCK_COUNT(Upper,Lower);
    
    ISOPERF_KdPrint (("Enter StopIsoInTest\n"));
    ISOPERF_KdPrint (("Upper:Lower -- %ld : %ld\n",Upper,Lower));
    
    ISO_ASSERT (deviceExtension != NULL);

    deviceExtension->bStopIsoTest = TRUE;
    deviceExtension->ulCountDownToStop = 100;
    
    ISOPERF_KdPrint (("Stopped: %d\n",          deviceExtension->Stopped));
    ISOPERF_KdPrint (("StopTransfers: %d\n",    deviceExtension->StopTransfers));
    ISOPERF_KdPrint (("DeviceIsBusy: %d\n",     deviceExtension->DeviceIsBusy));
    ISOPERF_KdPrint (("NeedCleanup: %d\n",      deviceExtension->NeedCleanup));
    ISOPERF_KdPrint (("bStopIsoTest: %d\n",     deviceExtension->bStopIsoTest));
    ISOPERF_KdPrint (("ulNumberOfOutstandingIrps: %d\n", deviceExtension->ulNumberOfOutstandingIrps));
    ISOPERF_KdPrint (("ulCountDownToStop: %d\n", deviceExtension->ulCountDownToStop));
   
    
    ISOPERF_KdPrint (("Exit StopIsoInTest\n"));
    
    return (STATUS_SUCCESS);    
}//ISOPERF_StopIsoInTest


BOOLEAN
ISOPERF_IsDataGood(PIsoTxterContext pIsoContext
)
/*++

Routine Description:
    Checks the data in the buffer for an incrementing pattern in every "maxpacketsize" granule
    of bytes.
    
Arguments:
    pIsoContext - pointer to the Iso context that contains what this routine needs to process the buffer
    
Return Value:
    TRUE - indicates buffer looks good
    FALSE - buffer has an error
    
--*/
{
    PUCHAR pchWork, pchEnd;
    UCHAR cCurrentValue, cNextValue;
    ULONG ulMaxPacketSize;
    
    pchWork = pIsoContext->pvBuffer;
    ulMaxPacketSize = pIsoContext->PipeInfo->MaximumPacketSize;
    
    if (pchWork==NULL) {
        ISOPERF_KdPrint (("Bad pchWork in IsDataGood (%x)\n",pchWork));
        return (FALSE);
    }

    if (ulMaxPacketSize >= 1024) {
        ISOPERF_KdPrint (("Bad MaxPacketSize in IsDataGood (%x)\n",ulMaxPacketSize));
        return (FALSE);
    }
        
    pchEnd = pchWork + ((pIsoContext->ulBufferLen) - ulMaxPacketSize);

    if (pchEnd > (pchWork + ((pIsoContext->NumPackets)*(ulMaxPacketSize)))) {
        ISOPERF_KdPrint (("Buffer Problem in IsDataGood: Base: %x | End: %x | NumPackts: %d | MaxPacktSz: %d\n",
                            pchWork, pchEnd, pIsoContext->NumPackets, ulMaxPacketSize));
    }
    
    ASSERT (pchEnd <= (pchWork + ((pIsoContext->NumPackets)*ulMaxPacketSize)));

    cCurrentValue = *pchWork;

    while (pchWork < pchEnd) {

        // Get the next frame's byte value
        cNextValue = *(pchWork + ulMaxPacketSize);
        
        if (cNextValue == (cCurrentValue + 1)) {
            //Success, go on to next packet
            pchWork+=ulMaxPacketSize; 
            cCurrentValue = *pchWork;
        }else{

            // Maybe this is the rollover case, so check for it and don't fail it if it is
            if (cNextValue==0) {
                if (cCurrentValue==0xFF) {
                    //Success, go on to next packet
                    pchWork+=ulMaxPacketSize; 
                    cCurrentValue = *pchWork;
                    continue;
                }
            }
                    
            ISOPERF_KdPrint (("Fail data compare: pchWork: %x | cNextValue: %x | *pchWork: %x | Base: %x\n",
                                pchWork, cNextValue, *pchWork, pIsoContext->pvBuffer));    
            FIRE_OFF_CATC;
            RESTART_CATC;
            return (FALSE);
        }
        
    } //while
        
    return (TRUE);
    
}//ISOPERF_IsDataGood



NTSTATUS
ISOPERF_GetStats (
    IN      PDEVICE_OBJECT      DeviceObject,
    IN      PIRP                Irp,
    IN OUT  pConfig_Stat_Info   pStatInfoOut,
    IN      ULONG               ulBufferLen
    )
/*++
Routine Description:
    Copies the existing Iso traffic counter values into buffer supplied by caller.  The 
    values of the counter variables are defined in IOCTL.H in the pIsoStats structure.
    
Arguments:
    DeviceObject - pointer to the device extension for this instance of the device
        Irp                      - pointer to the Irp created in the Ioctl
    pIsoStats    - pointer to buffer where stats will go
    ulBufferLen  - len of above output buffer
    
Return Value:
        NT status of STATUS_SUCCESS means copy was successful
        NT status of STATUS_INVALID_PARAMETER means a param (usually a pointer) was bad

--*/
{

    ULONG Upper, Lower;
    pConfig_Stat_Info pStatInfo       = NULL;
    NTSTATUS          ntStatus        = STATUS_SUCCESS;
    PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;

    ISOPERF_KdPrint_MAXDEBUG (("In GetStats (%x) (%x) (%x) (%d)\n",
                       DeviceObject,Irp,pStatInfoOut,ulBufferLen));
                       
    ASSERT (deviceExtension != NULL);

    if (deviceExtension) {
        pStatInfo = deviceExtension->pConfig_Stat_Information;
    }

    ASSERT (pStatInfo!= NULL);

    GET_PENTIUM_CLOCK_COUNT(Upper,Lower);

    if ( (pStatInfoOut) && (ulBufferLen >= sizeof(Config_Stat_Info)) ) {

        // Only copy the stat info from the dev ext area if it exists
        if (pStatInfo) {
            memcpy (pStatInfoOut, pStatInfo, sizeof (Config_Stat_Info));
        }/* if dev ext's stat/config info exists */

        // Get the global mem alloc/free info
        pStatInfoOut->ulBytesAllocated = gulBytesAllocated; 
        pStatInfoOut->ulBytesFreed     = gulBytesFreed;

        // Get the current countdown value
        pStatInfoOut->ulCountDownToStop= deviceExtension->ulCountDownToStop;
        
        // Get the Pentium counter values
        pStatInfoOut->ulUpperClockCount=Upper;
        pStatInfoOut->ulLowerClockCount=Lower;

        // Get the device type
        pStatInfoOut->DeviceType = deviceExtension->dtTestDeviceType;

            Irp->IoStatus.Information       = sizeof (Config_Stat_Info);    

    } else {

        ntStatus = STATUS_INVALID_PARAMETER;
            Irp->IoStatus.Information = 0;    
            
        }/* else */

        return (ntStatus);
        
}//ISOPERF_GetStats

NTSTATUS
ISOPERF_SetDriverConfig (
    IN      PDEVICE_OBJECT      DeviceObject,
    IN      PIRP                Irp,
    IN OUT  pConfig_Stat_Info   pConfInfoIn,
    IN      ULONG               ulBufferLen
    )
/*++
Routine Description:
    Sets the driver's test parameters.  These are only checked by this driver when the 
    Iso tests are started.  So, if a user mode app tries to set these after a test has started
    they will take effect on the next "start" of the test.    

Arguments:
    DeviceObject - pointer to the device extension for this instance of the device
        Irp                      - pointer to the Irp created in the Ioctl
    pIsoStats    - pointer to buffer where config info is located
    ulBufferLen  - len of above input buffer
    
Return Value:
        NT status of STATUS_SUCCESS means setting of params was successful
        NT status of STATUS_INVALID_PARAMETER means a param (usually a pointer) was bad

--*/
{
    pConfig_Stat_Info pDriverConfigInfo       = NULL;
    NTSTATUS          ntStatus        = STATUS_SUCCESS;
    PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
    
    ASSERT (deviceExtension != NULL);

    if (deviceExtension) {
        pDriverConfigInfo = deviceExtension->pConfig_Stat_Information;
    }else{
        ntStatus = STATUS_INVALID_PARAMETER;
    }//else bad dev ext
    
    ASSERT (pDriverConfigInfo!= NULL);

    if ( (pConfInfoIn) && (ulBufferLen >= sizeof(Config_Stat_Info)) ) {

        // Only copy the stat info from the dev ext area if it exists
        if (pDriverConfigInfo) {

            //Set the config info in the driver's config/stat area
            pDriverConfigInfo->ulNumberOfFrames     = pConfInfoIn->ulNumberOfFrames;
            pDriverConfigInfo->ulMax_Urbs_Per_Pipe  = pConfInfoIn->ulMax_Urbs_Per_Pipe;
                        pDriverConfigInfo->ulDoInOutTest                = pConfInfoIn->ulDoInOutTest;
            pDriverConfigInfo->ulFrameOffset        = pConfInfoIn->ulFrameOffset;
            pDriverConfigInfo->ulFrameOffsetMate    = pConfInfoIn->ulFrameOffsetMate;
                    
            ISOPERF_KdPrint (("Setting Driver Config-Number of Frames: %d | MaxUrbsPerPipe: %d | DoInOut: %d | FrameOffset %d | MateOffset %d\n",
                              pDriverConfigInfo->ulNumberOfFrames,
                              pDriverConfigInfo->ulMax_Urbs_Per_Pipe,
                              pDriverConfigInfo->ulDoInOutTest,
                              pDriverConfigInfo->ulFrameOffset,
                              pDriverConfigInfo->ulFrameOffsetMate));
                              
        }/* if dev ext's stat/config info exists */
        else {
            ntStatus = STATUS_INVALID_PARAMETER;
        }//else bad dev extension
        
            Irp->IoStatus.Information       = 0;    

    } else {

        ntStatus = STATUS_INVALID_PARAMETER;
            Irp->IoStatus.Information = 0;    
            
        }/* else bad buffer passed in (pointer was bad, or length was not correct) */

        return (ntStatus);
        
}//ISOPERF_SetDriverConfig

NTSTATUS
ISOPERF_FindMateDevice (
    PDEVICE_OBJECT DeviceObject
    )
/*++
    Searches the linked list of device objects looking for the long lost mate device for the
    given device object.  By practicing safe device mating rituals (ie., checking that the device
    object is a known type, etc.) it then puts the mate's device object pointer into the device extension
    of the given device object.  

    If no mate is found, sadly, then this routine puts a NULL in the mate deviceobject field in the dev extension, 
    and returns a STATUS_NOT_FOUND result code

++*/
{
    NTSTATUS         ntStatus               = STATUS_SUCCESS;
    PDEVICE_EXTENSION deviceExtension       = DeviceObject->DeviceExtension;
    PDRIVER_OBJECT    driverObject          = DeviceObject->DriverObject;
    PDEVICE_OBJECT    NextDeviceObject      = DeviceObject->NextDevice;
    PDEVICE_EXTENSION NextDeviceExtension   = NULL;
    dtDeviceType      dtMateTestDeviceTypeA = Unknown_Device_Type;
    dtDeviceType      dtMateTestDeviceTypeB = Unknown_Device_Type;

    ASSERT (DeviceObject != NULL);
    ASSERT (deviceExtension!=NULL);

    if (NextDeviceObject == NULL) {
        ISOPERF_KdPrint(("FindMateDevice: No Next Device\n"));

        // NOTE: (old code)
        // WDM appears to be loading an entirely separate driver image for the same venid/prodid.  
        // This makes the approach where we look at the device chain to find the next device in the
        // chain not feasible, so as a shortterm fix we'll put the Device Object for a Output Iso device
        // in a global variable (which does seem to persist across dd loads) and we'll see if that is a 
        // mate.  kjaff 12/24/96
        if (gMyOutputDevice!=NULL) {
            ISOPERF_KdPrint(("There is a global device us to check...(%x)\n",gMyOutputDevice));
            NextDeviceObject = gMyOutputDevice;
            NextDeviceExtension = NextDeviceObject->DeviceExtension;
        } else {        
            ISOPERF_KdPrint (("No global device found either...exiting...\n"));
            return STATUS_NOT_FOUND;
        }//else no global either

    }else{
        NextDeviceExtension = NextDeviceObject->DeviceExtension;
        ISOPERF_KdPrint(("Found a NextDevice: %x\n",NextDeviceObject));
    }//else there is a next device
    
    // The Mate for the device is dependent on the device type
    switch (deviceExtension->dtTestDeviceType) {
        case Iso_In_With_Pattern:
            //This dev can have 2 mate types
            ISOPERF_KdPrint (("Looking for a mate for Iso_In_With_Pattern %d\n",deviceExtension->dtTestDeviceType));
            dtMateTestDeviceTypeA = Iso_Out_With_Interrupt_Feedback;
            dtMateTestDeviceTypeB = Iso_Out_Without_Feedback;
            break;

        case Iso_Out_With_Interrupt_Feedback:
            break;
            
        case Iso_Out_Without_Feedback:
            break;

        case Unknown_Device_Type:
            break;

        default:
            break;
    }//switch on device type

    ntStatus = STATUS_NOT_FOUND; //assume we haven't found the mate
    
    while (NextDeviceObject != NULL) {

        NextDeviceExtension = NextDeviceObject->DeviceExtension;
        
        // Is this the mate?
        if ( (NextDeviceExtension->dtTestDeviceType == dtMateTestDeviceTypeA) ||
             (NextDeviceExtension->dtTestDeviceType == dtMateTestDeviceTypeB) ) {

             ISOPERF_KdPrint (("Found a mate for Dev %X : %X\n",DeviceObject, NextDeviceObject));
             
             //Found a mate, so fill in this dev object into the given dev obj's ext
             deviceExtension->MateDeviceObject = NextDeviceObject;
             ntStatus = STATUS_SUCCESS;
             break; //drop out of the while

        } else {

            ISOPERF_KdPrint (("%x is not a mate for Dev %X (type:%d\n",
                                NextDeviceObject,
                                DeviceObject,
                                NextDeviceExtension->dtTestDeviceType));

            // Get the next device object
            NextDeviceObject = NextDeviceObject->NextDevice;
            
        }//else go on to next device object
        
    }//while next dev obj

    ISOPERF_KdPrint (("FindMateDevice exiting...\n"));
    
    return ntStatus;
    
}//ISOPERF_FindMateDevice


VOID 
ISOPERF_StartIsoOutTest (
   IN PISOPERF_WORKITEM IsoperfWorkItem
   )
/*++

    Queues an Irp to the USB stack on the given device object.

  Inputs:
        IsoperfWorkItem - This routine is designed to be fired offf either directly or via a Work Item.  The
                                          work item structure only allows for one parameter to be passed to the work item
                                          routine, hence this single workitem parameter.

   Return Value:
        None
        
++*/
{
    PDEVICE_OBJECT              deviceObject    = NULL;
    PDEVICE_EXTENSION           deviceExtension = NULL;
    PUSBD_INTERFACE_INFORMATION pInterfaceInfo  = NULL;
    PUSBD_PIPE_INFORMATION      pUsbdPipeInfo   = NULL;
    pConfig_Stat_Info           configStatInfo  = NULL;
    PVOID                       pvBuff          = NULL;
    PURB                        urb             = NULL;
    ULONG                       ulBufferSize    = 0;
    NTSTATUS                    ntStatus        = STATUS_SUCCESS;
    IsoTxferContext *           pIsoContext     = NULL;
    ULONG                       ulFrameNumber   = 0;
    ULONG                       NumberOfFrames  = 0;
    ULONG                       i               = 0;
    
    deviceObject        = IsoperfWorkItem->DeviceObject;
    pvBuff              = IsoperfWorkItem->pvBuffer;
    ulBufferSize        = IsoperfWorkItem->ulBufferLen;

    deviceExtension     = deviceObject->DeviceExtension;
    pInterfaceInfo      = deviceExtension->Interface[ucIsoInterface];
    configStatInfo              = deviceExtension->pConfig_Stat_Information;

    ASSERT (pInterfaceInfo!=NULL);
    ASSERT (configStatInfo != NULL);
    ASSERT (deviceObject != NULL);
    
    if ( (configStatInfo==NULL) || (pInterfaceInfo==NULL) || (deviceObject==NULL) ) {
        ISOPERF_KdPrint (("Bad Parameter Received: configInf: %x | InterfInfo: %x | DevObj: %x\n",
                           configStatInfo, pInterfaceInfo, deviceObject));
        TRAP();
        return;
    }//if any params are bad

    // Check out the offset provided to make sure it's not too big
    if (configStatInfo->ulFrameOffset >= USBD_ISO_START_FRAME_RANGE) {
        ISOPERF_KdPrint (("ISOOUT: Error-Detected a FrameOffset Larger than allowed! (%d)\n",configStatInfo->ulFrameOffset));
        TRAP();
        return;
    }//if bad frame offset

    if (IsoperfWorkItem->bFirstUrb) {

        // We have to match the endpoint maxpacket sizes for this to work (we can't assume that this is the
        // case since the Out device sometimes seems to have a larger maxpacket than the In device
        // DESIGNDESIGN This may be OK if we later on want to do some rate-matching emulation here.
        if ( (deviceExtension->Interface[0]->Pipes[0].MaximumPacketSize) >= IsoperfWorkItem->InMaxPacket ) {
            deviceExtension->Interface[0]->Pipes[0].MaximumPacketSize = IsoperfWorkItem->InMaxPacket;
        } else {
            //if the OUT device's maxpacket is smaller than the IN device's this seems incorrect so do nothing
            return;
        }//else the endpoint sizes seem out of whack

//#if 0
        // Since this is the first Urb, we need the frame number, so get it
        ulFrameNumber = ISOPERF_GetCurrentFrame(deviceObject);

        ISOPERF_KdPrint (("StartISOOut got Frame Number: %x | Offset: %d\n",ulFrameNumber,configStatInfo->ulFrameOffset));

        if (ulFrameNumber==0) {
            ISOPERF_KdPrint (("Got Bad Frame Number (%x) ...exiting...\n",ulFrameNumber));
            deviceExtension->StopTransfers = TRUE; //set flag so further transfers stop
            return;
        }//if bad frame #
        
        //Save away the current frame number so the app can peek at it
        configStatInfo->ulFrameNumberAtStart = ulFrameNumber;

        // See what the user wants to do wrt starting frame number by looking at the config info
        if (configStatInfo->ulFrameOffset == 0) {
            // This means start ASAP
            ulFrameNumber = 0;
        }else {
            //Add the offset that the User wants to add to this frame number (it better be less than 1024!)
            ulFrameNumber += configStatInfo->ulFrameOffset;
        } //else

        //Save away the starting frame number so the app can peek at it
        configStatInfo->ulStartingFrameNumber = ulFrameNumber;

        ISOPERF_KdPrint (("StartISOOut using Frame Number: %x\n",ulFrameNumber));

//#endif

    }//if this is the first Urb
    else 
    {
        ISOPERF_KdPrint (("StartISOOut _NOT_ the First URB!\n"));
    }//else not first Urb


    // Get the pipe info for the first pipe
    pUsbdPipeInfo= &(pInterfaceInfo->Pipes[0]);
        ASSERT(pUsbdPipeInfo != NULL);
        
    if (deviceExtension->StopTransfers != TRUE) {

                //We get the Urbs to submit and the Nbr of frames from the workitem because we want to
                //make sure this is the same as the setting for the In device (this is filled in by InComplRoutine)
        NumberOfFrames    = IsoperfWorkItem->ulNumberOfFrames;

                ASSERT (NumberOfFrames > 0);

            //We get our own buffer for now...in the future this will be passed in if we decide to reuse the
        //input device's buffer
        pvBuff = ISOPERF_GetBuff (deviceObject,
                                  0,//pipe number
                                  0,//interfacenumber
                                  NumberOfFrames,
                                  &ulBufferSize
                                 );
                                  
        if (pvBuff==NULL){
            return;
        }else{ 
                        //Copy the input buffer into our output buffer (they should be the same size)
                        ASSERT (IsoperfWorkItem->ulBufferLen == ulBufferSize);
            RtlCopyMemory (pvBuff, IsoperfWorkItem->pvBuffer, ulBufferSize);  
        }//if pvbuff
        //...to here

        //build the urb
        urb =    ISOPERF_BuildIsoRequest(deviceObject,
                                         pUsbdPipeInfo,     //Pipe info struct
                                         FALSE,             //WRITE
                                         ulBufferSize,      //Data buffer size
                                         IsoperfWorkItem->bFirstUrb ? ulFrameNumber : 0,
                                         pvBuff,            //Data buffer
                                         NULL               //no MDL used
                                        );
        ISOPERF_KdPrint_MAXDEBUG (("OUT Urb: %x\n",urb));
        
        pIsoContext = ISOPERF_ExAllocatePool (NonPagedPool, sizeof (IsoTxferContext), &gulBytesAllocated);

        // Fill in the iso context
        pIsoContext->urb           = urb;
        pIsoContext->DeviceObject  = deviceObject;
        pIsoContext->PipeInfo      = pUsbdPipeInfo;
        pIsoContext->pvBuffer      = pvBuff;  //NOTE: set this to NULL if you're using the IN device's buffer
        pIsoContext->ulBufferLen   = ulBufferSize;
        pIsoContext->PipeNumber    = 0;
        pIsoContext->NumPackets    = urb->UrbIsochronousTransfer.NumberOfPackets;
        pIsoContext->bFirstUrb     = IsoperfWorkItem->bFirstUrb;
        
        //Create our own Irp for the device and call the usb stack w/ our urb/irp
        ntStatus = ISOPERF_CallUSBDEx ( deviceObject, 
                                        urb, 
                                        FALSE,                   //Don't block
                                        ISOPERF_IsoOutCompletion,//Completion routine
                                        pIsoContext,             //pvContext
                                        FALSE);                  //don't want timeout 

        if (NT_SUCCESS(ntStatus)) {

            deviceExtension->DeviceIsBusy   = TRUE;
            deviceExtension->bStopIsoTest   = FALSE;
            deviceExtension->StopTransfers  = FALSE;
            configStatInfo->erError         = NoError;
            configStatInfo->bDeviceRunning  = 1;

        } else {

            // An error occurred, so stop things and report it thru config/stat info
            deviceExtension->DeviceIsBusy   = FALSE;
            deviceExtension->bStopIsoTest   = TRUE;
            deviceExtension->StopTransfers  = TRUE;
            configStatInfo->erError         = ErrorInPostingUrb;
            configStatInfo->bDeviceRunning  = 0;

            // If the URB status code got filled in then extract the info returned
            if (!(USBD_SUCCESS(urb->UrbHeader.Status))) {
                ISOPERF_KdPrint (("StartIsoOut -- Urb unsuccessful (status: %#x)\n",urb->UrbHeader.Status));

                configStatInfo->UrbStatusCode = urb->UrbHeader.Status;
                
                // Dump out the status for the packets
                for (i=0; i< urb->UrbIsochronousTransfer.NumberOfPackets; i++) {
                    ISOPERF_KdPrint (("Packet %d: Status: [%#X]\n",
                                        i,
                                        urb->UrbIsochronousTransfer.IsoPacket[i].Status));
                                        
                    // Put the last known bad packet status code into this space in the stat area
                    if (!USBD_SUCCESS(urb->UrbIsochronousTransfer.IsoPacket[i].Status)) {
                        configStatInfo->UsbdPacketStatCode = urb->UrbIsochronousTransfer.IsoPacket[i].Status;
                    }//if hit a fail code                 
                    
                }//for all the packets
            }// if bad Urb status code

        }//else there was an error

    }else{
        ISOPERF_KdPrint_MAXDEBUG (("IsoOut not submitting Urbs because StopTransfers is asserted!\n"));
    }//else we are being asked to stoptransfers
    
    //Free the work item junk
    ISOPERF_ExFreePool (IsoperfWorkItem, &gulBytesFreed);

    ISOPERF_KdPrint_MAXDEBUG (("Exit StartIsoOut\n"));

    return;
    
}//ISOPERF_StartIsoOutTest


NTSTATUS
ISOPERF_IsoOutCompletion(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp,
    IN PVOID Context
    )
/*++
    This is the completion routine for the Iso OUT transfer
    
  Inputs:
        Device Object - the device object 
        Irp                       - The Irp we posted that is being completed
        Context           - pointer to our defined context which has our DeviceObject since it comes back as NULL here
                            DeviceObject is obtained from context due to old, old bug
                            in initial WDM implemenations

   Return Value:
        ntStatus
        
++*/
{
    PIsoTxterContext                pIsoContext;
    PDEVICE_OBJECT                  myDeviceObject;
    PDEVICE_EXTENSION               deviceExtension;
    PURB                            urb;
    pConfig_Stat_Info               pStatInfo;
    char *                          pcWork          = NULL; //a worker pointer
    ULONG                           i               = 0;    
    
    ISOPERF_KdPrint_MAXDEBUG (("In IsoOUTCompletion\n"));
    
    TRAP();

    pIsoContext     = Context;
    myDeviceObject  = pIsoContext->DeviceObject;
    deviceExtension = myDeviceObject->DeviceExtension;
    urb             = pIsoContext->urb;
    pStatInfo       = deviceExtension->pConfig_Stat_Information;
    
    // Check the USBD status code and only proceed in resubmission if the Urb was successful
    // or if the device extension flag that indicates the device is gone is FALSE
    if (!(USBD_SUCCESS(urb->UrbHeader.Status))) {
        ISOPERF_KdPrint (("IsoOUT Urb %x unsuccessful (status: %x)\n",urb,(urb->UrbHeader.Status)));

        // Don't let it go on w/ the tests
        deviceExtension->StopTransfers = TRUE;

        // Fill in stat info
        if (pStatInfo) {
            pStatInfo->erError = UsbdErrorInCompletion;
            pStatInfo->bStopped = 1;
            pStatInfo->UrbStatusCode = urb->UrbHeader.Status;
            
        }//if pStatInfo        

        // Dump out the status for the packets
        for (i=0; i< urb->UrbIsochronousTransfer.NumberOfPackets; i++) {
            ISOPERF_KdPrint (("Packet %d: Status: [%#X]\n",
                                i,
                                urb->UrbIsochronousTransfer.IsoPacket[i].Status));
                                
            // Put the last known bad packet status code into this space in the stat area
            if (!USBD_SUCCESS(urb->UrbIsochronousTransfer.IsoPacket[i].Status)) {

                pStatInfo->UsbdPacketStatCode = urb->UrbIsochronousTransfer.IsoPacket[i].Status;

            }//if hit a fail code                 
            
        }//for all the packets

    }//if failure detected

    // Free up the URB memory created for this transfer that we are retiring
    if (urb) {

        
        // We can't free the Urb itself, since it has some junk before it, so we have to roll back the 
        // pointer to get to the beginning of the block that we originally allocated, and then try to free it.
        pcWork = (char*)urb;                        //get the urb
        urb = (PURB) (pcWork - (2*sizeof(ULONG)));  //the original pointer is 2 DWORDs behind the Urb

        ISOPERF_KdPrint_MAXDEBUG (("Freeing Urb: %x\n",urb));
        ISOPERF_ExFreePool (urb, &gulBytesFreed);
        
    }//if
    
    if (pIsoContext) {

        // Free the data buffer
        // NOTE: This only can be done if we own this data buffer.  If the same data buffer that
        //       the IN device is using is being used here, then we don't want to free this buffer.
        //       The presence of a pointer to the data buffer will tell us that
        if (pIsoContext->pvBuffer) {
            ISOPERF_KdPrint_MAXDEBUG (("Freeing pvBuffer: %x\n",pIsoContext->pvBuffer));
            ISOPERF_ExFreePool(pIsoContext->pvBuffer, &gulBytesFreed);
        }//if pvbuffer
        
        // Free the Iso Context
        ISOPERF_KdPrint_MAXDEBUG (("Freeing pIsoContext: %x\n",pIsoContext));
        ISOPERF_ExFreePool (pIsoContext, &gulBytesFreed);

    }//if valid Iso Context

    //Free the IoStatus block
    if (Irp->UserIosb) {
        ISOPERF_KdPrint_MAXDEBUG (("Freeing My IoStatus Block: %x\n",Irp->UserIosb));
        ISOPERF_ExFreePool(Irp->UserIosb, &gulBytesFreed);
    } else {
        //Bad thing...no IoStatus block pointer??
        ISOPERF_KdPrint (("ERROR: Irp's IoStatus block is apparently NULL!\n"));
        TRAP();
    }//else bad iostatus pointer

        // Free the Irp we created
    ISOPERF_KdPrint (("Freeing Irp %x\n",Irp));
    IoFreeIrp(Irp);

    ISOPERF_KdPrint_MAXDEBUG (("Exit IsoOUTCompletion\n"));
   
    return (STATUS_MORE_PROCESSING_REQUIRED); //Leave the Irp alone, IOS, since we're the top level driver
    
}//ISOPERF_IsoOutCompletion


NTSTATUS
ISOPERF_TimeStampUrb (  PVOID urb,
                                PULONG pulLower,
                                PULONG pulUpper
)
/*++

        Routine Description:
                Puts a Pentium Clock count time stamp 2 DWORDS before the given pointer (usually a urb,
                hence the name of the function).

                This function can also be used to simply get the Pentium clock count, although there 
                is already a Macro to do that.
                
        Inputs:
                PVOID urb       - pointer to a chunk of memory that ususally contains a Urb
                PULONG puLower - pointer to a ULONG that gets the current upper CPU clock count (eax)
                PULONG puUpper - same as lower, but the upper ULONG value (edx)

        Return Value:
                ntStatus indiciating success/fail

--*/
{
        char * pcWork;
        ULONG u,l;

        GET_PENTIUM_CLOCK_COUNT (u,l);
        
        // Time stamp the Urb before we send it down the stack
        pcWork  = (char*) (urb);

        //Backup 2 DWORDS
        pcWork  -= (2*sizeof(ULONG));

        //First DWORD is the Upper value (edx)
    *((PULONG)pcWork) = u;

    //Goto next DWORD
    pcWork += sizeof(ULONG);

    //Second DWORD is the Lower value (eax)
    *((PULONG)pcWork) = l;

        // Copy the values to the caller's supplied area
        *pulUpper = u;
        *pulLower = l;
        
    return STATUS_SUCCESS;
    
}

NTSTATUS
ISOPERF_GetUrbTimeStamp (       PVOID urb,
                                                        PULONG pulLower,
                                                        PULONG pulUpper
)
/* ++
        Routine Description:
                Gets the Pentium Clock count time stamp 2 DWORDS before the given pointer (usually a urb,
                hence the name of the function).

        Inputs:
                PVOID urb       - pointer to a chunk of memory that ususally contains a Urb
                PULONG puLower - pointer to a ULONG that gets the upper CPU clock count from the timestamp area(eax)
                PULONG puUpper - same as lower, but the upper ULONG value (edx)

        Return Value:
                ntStatus indiciating success/fail
--*/
{

        char * pcWork;

        //Get the Urb's pointer
        pcWork  =  (char *) urb;                        

        //The first DW before the Urb is the lower DW of the clk cnt...
        pcWork  -= (sizeof(ULONG));     

        //...when the Urb was posted to the Usb stack
        *pulLower       =  *((ULONG*)pcWork);   

        //NOTE: we don't care about the upper value right now...
        *pulUpper   = 0;
        
        return STATUS_SUCCESS;
        
}//ISOPERF_GetUrbTimeStamp