三星串口调试工具dnw0.50A极其源码(vc6.0)

/*++ Modified RWBulk.c --*/ #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 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; 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());