osrbulk.cpp

基于vc++6.0环境的cypress USB 驱动源代码

///////////////////////////////////////////////////////////////////////////////
//
//    (C) Copyright 2005 OSR Open Systems Resources, Inc.
//    Copyright (c) 1997-1998  Microsoft Corporation
//    All Rights Reserved
//
//    This sofware is supplied for instructional purposes only.
//
//    OSR Open Systems Resources, Inc. (OSR) expressly disclaims any warranty
//    for this software.  THIS SOFTWARE IS PROVIDED  "AS IS" WITHOUT WARRANTY
//    OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING, WITHOUT LIMITATION,
//    THE IMPLIED WARRANTIES OF MECHANTABILITY OR FITNESS FOR A PARTICULAR
//    PURPOSE.  THE ENTIRE RISK ARISING FROM THE USE OF THIS SOFTWARE REMAINS
//    WITH YOU.  OSR's entire liability and your exclusive remedy shall not
//    exceed the price paid for this material.  In no event shall OSR or its
//    suppliers be liable for any damages whatsoever (including, without
//    limitation, damages for loss of business profit, business interruption,
//    loss of business information, or any other pecuniary loss) arising out
//    of the use or inability to use this software, even if OSR has been
//    advised of the possibility of such damages.  Because some states/
//    jurisdictions do not allow the exclusion or limitation of liability for
//    consequential or incidental damages, the above limitation may not apply
//    to you.
//
//    OSR Open Systems Resources, Inc.
//    105 Route 101A Suite 19
//    Amherst, NH 03031  [phone] FAX: [phone]
//    email bugs to: [e-mail]
//
//
//    MODULE:
//
//        OSRBulk.CPP -- Contains string values for various
//                          constants used in the driver.
//                          Entire module for debugging
//                          output purposes onlu...
//
//    ABSTRACT:
//
//      Console test app for USBFx2LK.sys driver
//
//    AUTHOR(S):
//
//        OSR Open Systems Resources, Inc.
// 
//    REVISION:   
//
//      $Revision: 1 $ , $Date: 3/09/05 3:26p $  
//
///////////////////////////////////////////////////////////////////////////////
#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 <initguid.h>
#include <usbfx2lk_ioctl.h>

#pragma warning(push)
#pragma warning(disable : 4200)
#include <usbdi.h>
#pragma warning(pop)

#define NOISY(_x_) printf _x_ ;
#define NPERLN 8


char inPipe[32] = "";     // pipe name for bulk input pipe on our test board
char outPipe[32] = "";    // pipe name for bulk 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;
BOOL fShowSegment = FALSE;
ULONG successes = 0;
ULONG errors = 0;

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
int SegmentNumber = 0;    // #number to display in segment register

// functions


/*++
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.

--*/
HANDLE OpenOneDevice (IN       HDEVINFO                    HardwareDeviceInfo,
                      IN       PSP_DEVICE_INTERFACE_DATA   DeviceInfoData,
                      IN       char *devName)
{
    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 = (PSP_DEVICE_INTERFACE_DETAIL_DATA) new UCHAR[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)) {
            delete []functionClassDeviceData;
            return INVALID_HANDLE_VALUE;
        }

        strcpy( devName,functionClassDeviceData->DevicePath) ;
        printf( "Attempting to open %s\n", devName );

        hOut = CreateFile (
            functionClassDeviceData->DevicePath,
            GENERIC_READ | GENERIC_WRITE,
            0,
            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 );
        }
        delete []functionClassDeviceData;
        return hOut;
}


/*++
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.
--*/
HANDLE OpenUsbDevice( LPGUID  pGuid, char *outNameBuf)
{
    ULONG NumberDevices, OldNumberDevices;
    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;
    OldNumberDevices = 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.

    //
    // 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) {
        OldNumberDevices = NumberDevices;
        NumberDevices *= 2;

        if (*UsbDevices) {
            tempDevDesc = (PUSB_DEVICE_DESCRIPTOR) new UCHAR[(NumberDevices * sizeof (USB_DEVICE_DESCRIPTOR))];
            if(tempDevDesc) {
                memcpy(tempDevDesc,*UsbDevices,OldNumberDevices*sizeof (USB_DEVICE_DESCRIPTOR));
                delete []*UsbDevices;
                *UsbDevices = tempDevDesc;
                tempDevDesc = NULL;
            } else {
                delete []*UsbDevices;
                *UsbDevices = NULL;
            }
        } else {
            *UsbDevices = (PUSB_DEVICE_DESCRIPTOR) new UCHAR[(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);
    delete []*UsbDevices;
    return hOut;
}




/*++
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

--*/
BOOL GetUsbDeviceFileName( LPGUID  pGuid, char *outNameBuf)
{
    HANDLE hDev = OpenUsbDevice( pGuid, outNameBuf );
    if ( hDev != INVALID_HANDLE_VALUE )
    {
        CloseHandle( hDev );
        return TRUE;
    }
    return FALSE;

}

/*++
Routine Description:

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

Arguments:

None

Return Value:

Device handle on success else NULL

--*/
HANDLE open_dev()
{

    HANDLE hDEV = OpenUsbDevice( (LPGUID)&GUID_OSR_USBFX2LK_INTERFACE, completeDeviceName);


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

    return hDEV;
}


/*++
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

--*/
HANDLE open_file( char *filename,ULONG Flags)
{

    int success = 1;
    HANDLE h;

    if ( !GetUsbDeviceFileName(
        (LPGUID) &GUID_OSR_USBFX2LK_INTERFACE,
        completeDeviceName) )
    {
        NOISY(("Failed to GetUsbDeviceFileName err - %d\n", GetLastError()));
        return  INVALID_HANDLE_VALUE;
    }

    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,
        Flags,
        0,
        NULL,
        OPEN_EXISTING,
        FILE_FLAG_OVERLAPPED,
        NULL);

    if (h == INVALID_HANDLE_VALUE) {
        NOISY(("Failed to open (%s) = %d", completeDeviceName, GetLastError()));
        success = 0;
    } else {
        NOISY(("Opened successfully.\n"));
    }           

    return h;
}

/*++
Routine Description:

Called by main() to dump usage info to the console when
the app is called with no parms or with an invalid parm

Arguments:

None

Return Value:

None

--*/
void usage()
{
    static int i=1;

    if (i) {
        printf("Usage for Read/Write test:\n");
        printf("-t [n] where n is number of bytes to read and write\n");
        printf("-c [n] where n is number of iterations (default = 1)\n");
        printf("-v verbose -- dumps read data\n");

        printf("\nUsage for USB and Endpoint info:\n");
        printf("-u to dump USB configuration and pipe info \n");
        i = 0;
    }
}


/*++
Routine Description:

Called by main() to parse command line parms

Arguments:

argc and argv that was passed to main()

Return Value:

Sets global flags as per user function request

--*/
void parse(int argc,char *argv[] )
{
    int i;

    if ( argc < 2 ) // give usage if invoked with no parms
        usage();

    for (i=0; i<argc; i++) {
        if (argv[i][0] == '-' ||
            argv[i][0] == '/') {
                switch(argv[i][1]) {
            case 't':
            case 'T':