rwbulk.c

USB通讯控件,Bulk通讯方式,可以直接从USB设备中读取数据保存为文件,或者把文件发送给USB设备,用于三星2410相关开发.

/*++

  Modified RWBulk.c
  
--*/

#include "Forcelib.h"
#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 "BulkUsb.h"
#include "GUID.h"

#include "usbdi.h"

//void EB_Printf(TCHAR *fmt,...); //engine.h

//#define NOISY(_x_) EB_Printf _x_ ;

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

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

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


HANDLE
OpenOneDevice (
			   IN       HDEVINFO                    HardwareDeviceInfo,
			   IN       PSP_INTERFACE_DEVICE_DATA   DeviceInfoData,
			   IN       char *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 SetupDiEnumInterfaceDevice()
					 
					   Return Value:
					   
						 return HANDLE if the open and initialization was successfull,
						 else INVLAID_HANDLE_VALUE.
						 
						   --*/
{
    PSP_INTERFACE_DEVICE_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.
    //
    SetupDiGetInterfaceDeviceDetail (
		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);
    functionClassDeviceData->cbSize = sizeof (SP_INTERFACE_DEVICE_DETAIL_DATA);
	
    //
    // Retrieve the information from Plug and Play.
    //
    if (! SetupDiGetInterfaceDeviceDetail (
	       HardwareDeviceInfo,
		   DeviceInfoData,
		   functionClassDeviceData,
		   predictedLength,
		   &requiredLength,
		   NULL)) {
		free( functionClassDeviceData );
		return INVALID_HANDLE_VALUE;
    }
	
    strcpy( devName,functionClassDeviceData->DevicePath) ;
    //EB_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) {
		//EB_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_INTERFACE_DEVICE_DATA deviceInfoData;
	ULONG                    i;
	BOOLEAN                  done;
	PUSB_DEVICE_DESCRIPTOR   usbDeviceInst;
	PUSB_DEVICE_DESCRIPTOR   *UsbDevices = &usbDeviceInst;
	
	*UsbDevices = 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_INTERFACEDEVICE)); // 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_INTERFACE_DEVICE_DATA);
	
	i=0;
	while (!done) {
		NumberDevices *= 2;
		
		if (*UsbDevices) {
			*UsbDevices =
				realloc (*UsbDevices, (NumberDevices * sizeof (USB_DEVICE_DESCRIPTOR)));
		} 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 = 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 = OpenUsbDevice( (LPGUID)&GUID_CLASS_I82930_BULK, completeDeviceName);
	
	
    if (hDEV == INVALID_HANDLE_VALUE) {
		//EB_Printf("Failed to open (%s) = %d", completeDeviceName, GetLastError());
    } else {
		//EB_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_BULK,
		completeDeviceName) )
    {
		//NOISY(("Failed to GetUsbDeviceFileName:%d\n", GetLastError()));
		return  INVALID_HANDLE_VALUE;
    }
	
    strcat (completeDeviceName,
		"\\"
		);          
	
    strcat (completeDeviceName,
		filename
		);                  
	
    //EB_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"));
    }       
	
    return h;
}



// Begin, routines for USB configuration dump (Cmdline "rwbulk -u" )


char
*usbDescriptorTypeString(UCHAR bDescriptorType )
/*++
Routine Description:

  Called to get ascii string of USB descriptor
  
	Arguments:
	
	  PUSB_ENDPOINT_DESCRIPTOR->bDescriptorType or
	  PUSB_DEVICE_DESCRIPTOR->bDescriptorType or
	  PUSB_INTERFACE_DESCRIPTOR->bDescriptorType or
	  PUSB_STRING_DESCRIPTOR->bDescriptorType or
	  PUSB_POWER_DESCRIPTOR->bDescriptorType or
	  PUSB_CONFIGURATION_DESCRIPTOR->bDescriptorType
	  
		Return Value:
		
		  ptr to string
		  
			--*/{
			
			switch(bDescriptorType) {
	
    case USB_DEVICE_DESCRIPTOR_TYPE:
		return "USB_DEVICE_DESCRIPTOR_TYPE";
		
    case USB_CONFIGURATION_DESCRIPTOR_TYPE:
		return "USB_CONFIGURATION_DESCRIPTOR_TYPE";
		
		
    case USB_STRING_DESCRIPTOR_TYPE:
		return "USB_STRING_DESCRIPTOR_TYPE";
		
		
    case USB_INTERFACE_DESCRIPTOR_TYPE:
		return "USB_INTERFACE_DESCRIPTOR_TYPE";
		
		
    case USB_ENDPOINT_DESCRIPTOR_TYPE:
		return "USB_ENDPOINT_DESCRIPTOR_TYPE";
		
		
#ifdef USB_POWER_DESCRIPTOR_TYPE // this is the older definintion which is actually obsolete
		// workaround for temporary bug in 98ddk, older USB100.h file
    case USB_POWER_DESCRIPTOR_TYPE:
		return "USB_POWER_DESCRIPTOR_TYPE";
#endif