/*++

Copyright (c) 1997-2004  Microsoft Corporation

Module Name:

    RwIso.c

Abstract:

    Console test app for IsoUsb.sys driver

Environment:

    user 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) 1997-2004 Microsoft Corporation.  All Rights Reserved.


Revision History:

    11/17/97: created

--*/

#include <windows.h>

#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <time.h>

#include "devioctl.h"

#include <setupapi.h>
#include <basetyps.h>

#include "IsoUsr.h"

#include "usbdi.h"

#define NOISY(_x_) printf _x_ ;

char inPipe[32]  = "PIPE04";    // pipe name for iso input pipe on our test board
char outPipe[32] = "PIPE05";    // pipe name for iso output pipe on our test board
char completeDeviceName[256] = "";  //generated from the GUID registered by the driver itself

BOOL fDumpUsbConfig = FALSE;    // flags set in response to console command line switches
BOOL fDumpReadData  = FALSE;
BOOL fRead          = FALSE;
BOOL fWrite         = FALSE;

PVOID gpStreamObj;
char gbuf[256];


BOOL    SelectAltInterface = FALSE;
UCHAR   AltInterface;
UCHAR   AltSetting;


BOOL fIsoStreamStarted = FALSE;
HANDLE ghStreamDev = NULL;
int gMS = 10000; // default to 10 secs stream test

int gDebugLevel = 1;      // higher == more verbose, default is 1, 0 turns off all

ULONG IterationCount = 1; // count of iterations of the test we are to perform
int WriteLen = 0;         // #bytes to write
int ReadLen = 0;          // #bytes to read

void StartIsoStream( void );

void StopIsoStream( void );

void Usage();

BOOL Parse ( int argc, char *argv[] );

// functions


HANDLE
OpenOneDevice (
    IN HDEVINFO                     HardwareDeviceInfo,
    IN PSP_DEVICE_INTERFACE_DATA    DeviceInfoData,
    IN PCHAR                        devName
    )
/*++
Routine Description:

    Given the HardwareDeviceInfo, representing a handle to the plug and
    play information, and deviceInfoData, representing a specific usb device,
    open that device and fill in all the relevant information in the given
    USB_DEVICE_DESCRIPTOR structure.

Arguments:

    HardwareDeviceInfo:  handle to info obtained from Pnp mgr via SetupDiGetClassDevs()
    DeviceInfoData:      ptr to info obtained via SetupDiEnumDeviceInterfaces()

Return Value:

    return HANDLE if the open and initialization was successfull,
    else INVLAID_HANDLE_VALUE.

--*/
{
    PSP_DEVICE_INTERFACE_DETAIL_DATA    functionClassDeviceData = NULL;
    ULONG                               predictedLength = 0;
    ULONG                               requiredLength = 0;
    HANDLE                              hOut = INVALID_HANDLE_VALUE;

    //
    // allocate a function class device data structure to receive the
    // goods about this particular device.
    //
    SetupDiGetDeviceInterfaceDetail(
        HardwareDeviceInfo,
        DeviceInfoData,
        NULL,   // probing so no output buffer yet
        0,      // probing so output buffer length of zero
        &requiredLength,
        NULL);  // not interested in the specific dev-node


    predictedLength = requiredLength;
    // sizeof (SP_FNCLASS_DEVICE_DATA) + 512;

    functionClassDeviceData = malloc (predictedLength);

    if (NULL == functionClassDeviceData)
    {
        return INVALID_HANDLE_VALUE;
    }

    functionClassDeviceData->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA);

    //
    // Retrieve the information from Plug and Play.
    //
    if (!SetupDiGetDeviceInterfaceDetail(HardwareDeviceInfo,
                                         DeviceInfoData,
                                         functionClassDeviceData,
                                         predictedLength,
                                         &requiredLength,
                                         NULL))
    {
        free(functionClassDeviceData);

        return INVALID_HANDLE_VALUE;
    }

    strcpy(devName, functionClassDeviceData->DevicePath);

    printf("Attempting to open %s\n", devName);

    hOut = CreateFile(
               functionClassDeviceData->DevicePath,
               GENERIC_READ | GENERIC_WRITE,
               FILE_SHARE_READ | FILE_SHARE_WRITE,
               NULL,            // No SECURITY_ATTRIBUTES structure
               OPEN_EXISTING,   // No special create flags
               0,               // No special attributes
               NULL);           // No template file

    if (INVALID_HANDLE_VALUE == hOut)
    {
        printf("FAILED to open %s\n", devName);
    }

    free(functionClassDeviceData);

    return hOut;
}


HANDLE
OpenUsbDevice( LPGUID  pGuid, char *outNameBuf)
/*++
Routine Description:

    Do the required PnP things in order to find the next available
    proper device in the system at this time.

Arguments:

    pGuid:      ptr to GUID registered by the driver itself
    outNameBuf: the generated name for this device

Return Value:

    return HANDLE if the open and initialization was successful,
    else INVLAID_HANDLE_VALUE.
--*/
{
   ULONG                    NumberDevices;
   HANDLE                   hOut = INVALID_HANDLE_VALUE;
   HDEVINFO                 hardwareDeviceInfo;
   SP_DEVICE_INTERFACE_DATA deviceInfoData;
   ULONG                    i;
   BOOLEAN                  done;
   PUSB_DEVICE_DESCRIPTOR   usbDeviceInst;
   PUSB_DEVICE_DESCRIPTOR   *UsbDevices = &usbDeviceInst;
   PUSB_DEVICE_DESCRIPTOR   tempDevDesc;

   *UsbDevices = NULL;
   tempDevDesc = NULL;
   NumberDevices = 0;

   //
   // Open a handle to the plug and play dev node.
   // SetupDiGetClassDevs() returns a device information set that contains info on all
   // installed devices of a specified class.
   //
   hardwareDeviceInfo = SetupDiGetClassDevs(
                            pGuid,
                            NULL,   // Define no enumerator (global)
                            NULL,   // Define no
                            (DIGCF_PRESENT | // Only Devices present
                             DIGCF_DEVICEINTERFACE)); // Function class devices.

   if (hardwareDeviceInfo == INVALID_HANDLE_VALUE)
   {
       return INVALID_HANDLE_VALUE;
   }

   //
   // Take a wild guess at the number of devices we have;
   // Be prepared to realloc and retry if there are more than we guessed
   //
   NumberDevices = 4;
   done = FALSE;
   deviceInfoData.cbSize = sizeof (SP_DEVICE_INTERFACE_DATA);

   i=0;

   while (!done)
   {
       NumberDevices *= 2;

       if (*UsbDevices)
       {
           tempDevDesc = realloc(*UsbDevices,
                                 (NumberDevices * sizeof (USB_DEVICE_DESCRIPTOR)));

            if (tempDevDesc)
            {
                *UsbDevices = tempDevDesc;
                tempDevDesc = NULL;
            }
            else
            {
                free(*UsbDevices);
                *UsbDevices = NULL;
            }
       }
       else
       {
           *UsbDevices = calloc(NumberDevices,
                                sizeof (USB_DEVICE_DESCRIPTOR));
       }

       if (NULL == *UsbDevices)
       {
           // SetupDiDestroyDeviceInfoList destroys a device information set
           // and frees all associated memory.
           //
           SetupDiDestroyDeviceInfoList(hardwareDeviceInfo);

           return INVALID_HANDLE_VALUE;
       }

       usbDeviceInst = *UsbDevices + i;

       for (; i < NumberDevices; i++)
       {
           // SetupDiEnumDeviceInterfaces() returns information about
           // device interfaces exposed by one or more devices. Each call
           // returns information about one interface; the routine can be
           // called repeatedly to get information about several
           // interfaces exposed by one or more devices.
           //
           if (SetupDiEnumDeviceInterfaces(hardwareDeviceInfo,
                                           0, // We don't care about specific PDOs
                                           pGuid,
                                           i,
                                           &deviceInfoData))
           {
               hOut = OpenOneDevice(hardwareDeviceInfo,
                                    &deviceInfoData,
                                    outNameBuf);

               if (hOut != INVALID_HANDLE_VALUE)
               {
                   done = TRUE;
                   break;
               }
           }
           else
           {
               if (ERROR_NO_MORE_ITEMS == GetLastError())
               {
                   done = TRUE;
                   break;
               }
           }
       }
   }

   NumberDevices = i;

   // SetupDiDestroyDeviceInfoList() destroys a device information set
   // and frees all associated memory.
   //
   SetupDiDestroyDeviceInfoList (hardwareDeviceInfo);

   free (*UsbDevices);

   return hOut;
}




BOOL
GetUsbDeviceFileName( LPGUID  pGuid, char *outNameBuf)
/*++
Routine Description:

    Given a ptr to a driver-registered GUID, give us a string with the
    device name that can be used in a CreateFile() call.

    Actually briefly opens and closes the device and sets outBuf if
    successfull; returns FALSE if not

Arguments:

    pGuid:      ptr to GUID registered by the driver itself
    outNameBuf: the generated zero-terminated name for this device

Return Value:

    TRUE on success else FALSE

--*/
{
    HANDLE  hDev;

    hDev = OpenUsbDevice(pGuid, outNameBuf);

    if (hDev != INVALID_HANDLE_VALUE)
    {
        CloseHandle( hDev );

        return TRUE;
    }

    return FALSE;
}

HANDLE
open_dev()
/*++
Routine Description:

    Called by dumpUsbConfig() to open an instance of our device

Arguments:

    None

Return Value:

    Device handle on success else NULL

--*/
{
    HANDLE  hDEV;

    hDEV = OpenUsbDevice((LPGUID)&GUID_CLASS_I82930_ISO,
                         completeDeviceName);

    if (hDEV == INVALID_HANDLE_VALUE)
    {
        printf("Failed to open (%s) = %d", completeDeviceName, GetLastError());
    }
    else
    {
        printf("DeviceName = (%s)\n", completeDeviceName);
    }

    return hDEV;
}


HANDLE
open_file( char *filename)
/*++
Routine Description:

    Called by main() to open an instance of our device after obtaining its name

Arguments:

    None

Return Value:

    Device handle on success else NULL

--*/
{
    int     success = 1;
    HANDLE  h;

    if (!GetUsbDeviceFileName((LPGUID)&GUID_CLASS_I82930_ISO,
                              completeDeviceName))
    {
        NOISY(("Failed to GetUsbDeviceFileName - err = %d\n", GetLastError()));

        return INVALID_HANDLE_VALUE;
    }

    strcat(completeDeviceName, "\\");

    if ((strlen(completeDeviceName) + strlen(filename)) > 255)
    {
        NOISY(("Failed to open handle - possibly long filename\n"));

        return INVALID_HANDLE_VALUE;
    }

    strcat(completeDeviceName, filename);

    printf("completeDeviceName = (%s)\n", completeDeviceName);

    h = CreateFile(completeDeviceName,
                   GENERIC_WRITE | GENERIC_READ,
                   FILE_SHARE_WRITE | FILE_SHARE_READ,
                   NULL,
                   OPEN_EXISTING,
                   0,
                   NULL);

    if (h == INVALID_HANDLE_VALUE)
    {
        NOISY(("Failed to open (%s) = %d", completeDeviceName, GetLastError()));

        success = 0;
    }
    else
    {
        NOISY(("Opened successfully.\n"));
    }