usbdriver.~cpp

C++ Buider下控制USB设备的例程。目标板为C8051F开发板

#include "USBDriver.h"
#include "NuBar_Sys.h"

//---------------------------------------------------------------------------
#pragma hdrstop

HANDLE USBDriver::OpenOneDevice(HDEVINFO hDvcInfo, PSP_INTERFACE_DEVICE_DATA DvcInfoData, char *sDevNameBuf)
{
    HANDLE hOut = INVALID_HANDLE_VALUE;

  	ULONG  iReqLen = 0;
 	SetupDiGetInterfaceDeviceDetail(hDvcInfo, DvcInfoData, NULL, 0, &iReqLen, NULL);

  	ULONG iDevDataLen = iReqLen; //sizeof(SP_FNCLASS_DEVICE_DATA) + 512;
  	PSP_INTERFACE_DEVICE_DETAIL_DATA pDevData = (PSP_INTERFACE_DEVICE_DETAIL_DATA)malloc(iDevDataLen);

  	pDevData->cbSize = sizeof(SP_INTERFACE_DEVICE_DETAIL_DATA);
 	 if(SetupDiGetInterfaceDeviceDetail(hDvcInfo, DvcInfoData, pDevData, iDevDataLen, &iReqLen, NULL))
   	{
        strcpy(sDevNameBuf, pDevData->DevicePath);
        hOut = CreateFile(pDevData->DevicePath, GxiENERIC_READ|GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);
   	}

  	free(pDevData);
 	return hOut;
}
//---------------------------------------------------------------------------
HANDLE USBDriver::OpenUsbDevice(const GUID *pGuid, char *sDevNameBuf)
{
  	HANDLE hOut = INVALID_HANDLE_VALUE;

    // Retrieve device list for GUID that has been specified.
    HDEVINFO hDevInfo = SetupDiGetClassDevs(pGuid, NULL, NULL, (DIGCF_PRESENT|DIGCF_DEVICEINTERFACE));

    if( hDevInfo != NULL)
    {
        SP_DEVICE_INTERFACE_DATA deviceInfoData;

  	    for(int iDevIndex=0; iDevIndex < 127; iDevIndex++)
   	    {
            // Clear data structure
		    ZeroMemory(&deviceInfoData, sizeof(deviceInfoData));
		    deviceInfoData.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);

            if(SetupDiEnumDeviceInterfaces(hDevInfo, 0, pGuid, iDevIndex, &deviceInfoData))
      	    {
       	        if((hOut=OpenOneDevice(hDevInfo, &deviceInfoData, sDevNameBuf)) != INVALID_HANDLE_VALUE)
          	        break;
      	    }
     	    else if(GetLastError() == ERROR_NO_MORE_ITEMS) //No more items
        	    break;
   	    }
    }
  	SetupDiDestroyDeviceInfoList(hDevInfo);

 	return hOut;
}
//---------------------------------------------------------------------------
bool USBDriver::GetUsbDeviceFileName(const GUID *pGuid, char *sDevNameBuf)
{
  	HANDLE hDev = OpenUsbDevice(pGuid, sDevNameBuf);
  	if(hDev != INVALID_HANDLE_VALUE)
   	{
        CloseHandle(hDev);
     	return true;
   	}
 	return false;
}
//---------------------------------------------------------------------------
HANDLE USBDriver::OpenMyDevice(void)
{
  	return OpenUsbDevice(&USB_DRIVER_GUID, DeviceName);
}
//---------------------------------------------------------------------------
HANDLE USBDriver::OpenMyDevPipe(const char *PipeName)
{
  	if(GetUsbDeviceFileName(&USB_DRIVER_GUID, DeviceName))
        {
        strcat(DeviceName,"\\");
    	strcat(DeviceName,PipeName);
        return CreateFile(DeviceName, GENERIC_WRITE|GENERIC_READ, FILE_SHARE_WRITE|FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
   	}
  	return INVALID_HANDLE_VALUE;
}
//---------------------------------------------------------------------------
bool USBDriver::SendToDevice(HANDLE hUSB_Handle, char *buf, DWORD len)
{
    unsigned long return_value;

    if(hUSB_Handle == INVALID_HANDLE_VALUE)
        return false;

  	WriteFile(hUSB_Handle, buf, len, &return_value, NULL);

    return true;
}
//---------------------------------------------------------------------------
DWORD USBDriver::ReadFromDevice(HANDLE hUSB_Handle, char *buf, DWORD len)
{
    DWORD BytesRead;

    if(hUSB_Handle == INVALID_HANDLE_VALUE)
        return 0;

    WriteFile(hUSB_Handle, buf, len, &BytesRead, NULL);
    ReadFile(hUSB_Handle, buf, len, &BytesRead, NULL);

    return BytesRead;
}

//---------------------------------------------------------------------------
void USBDriver::USBDriver_Init(void)
{
    hUSB_Read = INVALID_HANDLE_VALUE;
    hUSB_Write = INVALID_HANDLE_VALUE;
}

//---------------------------------------------------------------------------
bool USBDriver::ConnectToUSBDevice(void)
{
    if(hUSB_Read != INVALID_HANDLE_VALUE) CloseHandle(hUSB_Read);
    if(hUSB_Write != INVALID_HANDLE_VALUE) CloseHandle(hUSB_Write);

    hUSB_Read = OpenMyDevPipe(USB_READPIPE);
    if(hUSB_Read == INVALID_HANDLE_VALUE)
    {
        //MessageDlg("USB device fail!! (read)\n\nReset hardware and try again", mtWarning, TMsgDlgButtons() << mbOK, 0);
        return false;
    }

    hUSB_Write = OpenMyDevPipe(USB_WRITEPIPE);
    if(hUSB_Write == INVALID_HANDLE_VALUE)
    {
        //MessageDlg("USB Device Fail!! (write)\n\nReset hardware and try again", mtWarning, TMsgDlgButtons() << mbOK, 0);
        return false;
    }
    return true;
}

//---------------------------------------------------------------------------
void USBDriver::DisconnectFromUSBDevice(void)
{
    if(hUSB_Read != INVALID_HANDLE_VALUE)
    {
        CloseHandle(hUSB_Read);
        hUSB_Read = INVALID_HANDLE_VALUE;
    }

    if(hUSB_Write != INVALID_HANDLE_VALUE)
    {
        CloseHandle(hUSB_Write);
        hUSB_Write = INVALID_HANDLE_VALUE;
    }
}


bool USBDriver::CodeUpdate(int type, char *buf, DWORD len)
{
    DWORD i, offset;
    char tx_buf[USB_BUFSIZE];
    Cmd_Hdr_T *cmd = (Cmd_Hdr_T *)&tx_buf[0];

    if(ConnectToUSBDevice() == false)
        return false;

    cmd->cmd_id = ltob_16(NUBAR_FWDOWNLOAD_ID);

    cmd->subcmd_id = ltob_16(0);
    offset = 0;
    for(i = 0; i < len/FW_DOWNLOAD_BUFSZIE; i++)
    {
        cmd->param.dnldfw.index = ltob_16(i);
        memcpy(cmd->param.dnldfw.buf, &buf[offset], FW_DOWNLOAD_BUFSZIE);
        SendToDevice(hUSB_Write, buf, USB_BUFSIZE);
        offset += FW_DOWNLOAD_BUFSZIE;
    }
    if(len%FW_DOWNLOAD_BUFSZIE)
    {
        cmd->param.dnldfw.index = ltob_16(i);
        memcpy(cmd->param.dnldfw.buf, &buf[offset], len-offset);
        SendToDevice(hUSB_Write, buf, len-offset+6);
    }

    // 挡