/*----------------------------------------------------------------------------
 *  Copyright (c) 2001 by National Semiconductor Corporation
 *  National Semiconductor Corporation
 *  2900 Semiconductor Drive
 *  Santa Clara, California 95051
 *
 *  All rights reserved
 *
 *<<<-------------------------------------------------------------------------
 * File Contents:
 *	USBDriver.cpp - this class handles USB driver interface. It calls API functions of WinDriver
 *					as defined by Jungo.
 *					The class impements Singleton design pattern, i.e there is one 
 *					single object of this class in the application, acessed by all the tests.
 *
 *  Project: USB Demo Application
 *  Author : Yan Nosovitsky
 *  Date   : Dec 2001
 *----------------------------------------------------------------------->>>*/

#include "stdafx.h"
#include <conio.h>
#include <stdio.h>
#include "USBDriver.h"

USBDriver* USBDriver::curUSBDriver = NULL;

USBDriver::USBDriver()
{
  HANDLE hWD;

  DWORD  configNum = 0, dwInterface = 0, dwAlternate = 0;
  WD_USB_SCAN_DEVICES usbScan;

  errorCode = NO_USB_ERROR;
  driverHandle = NULL;

  //RegisterWinDriver();

  
  if (!USB_Get_WD_handle(&hWD))
	  return;

  BZERO(usbScan);

  usbScan.searchId.dwVendorId = DRIVER_DEFAULT_VENDOR_ID;
  usbScan.searchId.dwProductId = DRIVER_DEFAULT_PRODUCT_ID;
    

  WD_UsbScanDevice(hWD, &usbScan);
  if (!usbScan.dwDevices)
  {
        errorCode = NO_USB_DEVICE_FOUND;
        WD_Close(hWD);
        return ;
  }

  uniqueId = usbScan.uniqueId[0];
  deviceGeneralInfo = usbScan.deviceGeneralInfo[0];

  configNum = DRIVER_DEFAULT_CONFIG;
  dwInterface = DRIVER_DEFAULT_INTERFACE;
  dwAlternate = DRIVER_DEFAULT_ALTERNATE;

  if (!OpenUSBDriver(uniqueId, configNum, dwInterface, dwAlternate))
  {
        WD_Close(hWD);
        return ;
  }

  WD_Close(hWD);

  numOfUSBUsers = 0;
  bulkOutTestRun = FALSE;
  intTestRun = FALSE;
}

USBDriver::~USBDriver()
{
	CloseUSBDriver();
}

bool USBDriver::OpenUSBDriver(DWORD uniqueId, DWORD configIndex, DWORD dwInterface, DWORD dwAlternate)
{
   
    WD_VERSION ver;
    WD_USB_DEVICE_REGISTER devReg;

	driverHandle = (DRIVER_HANDLE) malloc (sizeof (DRIVER_STRUCT));

    driverHandle->hDevice = 0;
    driverHandle->hWD = WD_Open();

    // check whether the handle is valid & the version is OK
    if (driverHandle->hWD==INVALID_HANDLE_VALUE)
    {
		errorCode = FAIL_OPEN_WINDRIVER;
        return FALSE;
    }

    BZERO(ver);
    WD_Version(driverHandle->hWD, &ver);
    if (ver.dwVer<WD_VER)
    {
		errorCode = INCORRECT_WINDRIVER_VER;
        WD_Close(driverHandle->hWD);
        return FALSE;
    }

    BZERO(devReg);
    devReg.uniqueId = uniqueId;
    devReg.dwConfigurationIndex = configIndex;
    devReg.dwInterfaceNum = dwInterface;
    devReg.dwInterfaceAlternate = dwAlternate;
    WD_UsbDeviceRegister(driverHandle->hWD, &devReg);
    if (!devReg.hDevice)
    {
		errorCode = FAIL_OPEN_USB_DEVICE;
        WD_Close(driverHandle->hWD);
        return FALSE;
    }
    driverHandle->hDevice = devReg.hDevice;
    driverHandle->deviceInfo = devReg.Device;


    return TRUE;
}

void USBDriver::CloseUSBDriver()
{
    WD_USB_DEVICE_REGISTER devReg;

    BZERO(devReg);
	if (driverHandle)
	{
		devReg.hDevice = driverHandle->hDevice;
		WD_UsbDeviceUnregister(driverHandle->hWD, &devReg);

		// close WinDriver
		WD_Close(driverHandle->hWD);
		free (driverHandle);
		driverHandle = NULL;
	}
}

bool USBDriver::USB_Get_WD_handle(HANDLE *phWD)
{
    WD_VERSION ver;

	*phWD = INVALID_HANDLE_VALUE;
    *phWD = WD_Open();

    // Check whether handle is valid and version OK
    if (*phWD==INVALID_HANDLE_VALUE) 
    {
		errorCode = FAIL_OPEN_WINDRIVER;
        return FALSE;
    }

    BZERO(ver);
    WD_Version(*phWD, &ver);
    if (ver.dwVer<WD_VER) 
    {
        errorCode = INCORRECT_WINDRIVER_VER;
        WD_Close (*phWD);
        *phWD = INVALID_HANDLE_VALUE;
        return FALSE;
    }

    return TRUE;
}

USBDriver* USBDriver::GetUSBDriver()
{
	if (curUSBDriver == NULL) /* first call */
		curUSBDriver = new USBDriver();
	else
	{
		if (curUSBDriver->errorCode)
		{
			delete curUSBDriver;
			curUSBDriver = new USBDriver();
		}
	}
	return curUSBDriver;
}

void USBDriver::ChangeConfig(int configNum)
{
}

void USBDriver::ChangeInterface(int interfaceNum)
{
}
	
bool USBDriver::CheckPipe(USB_PIPE_TYPE pipeType, int pipeNum, WD_USB_PIPE_INFO *pipeInfo)
{
	if (driverHandle->deviceInfo.Pipe[pipeNum].type == pipeType)
	{
		*pipeInfo = driverHandle->deviceInfo.Pipe[pipeNum];
		return TRUE;
	}
	return FALSE;
}

int USBDriver::WorkWithPipe(int pipeAddress, BYTE *buffer, int size, BOOL isRead)
{
    WD_USB_TRANSFER transfer;

    BZERO(transfer);
    transfer.dwPipe = pipeAddress;
    transfer.dwBytes = size;
    transfer.fRead = isRead;
    transfer.pBuffer = buffer;
    transfer.hDevice = driverHandle->hDevice;
	if (size < 100000)
		 /* default timeout */
		transfer.dwTimeout = 300000;
	else
		transfer.dwTimeout = 300000*(size/100000);
    WD_UsbTransfer(driverHandle->hWD, &transfer);

    if (transfer.fOK)
        return transfer.dwBytesTransfered;
	errorCode = DEVICE_WAS_DISCONNECTED;
    return 0xffffffff;
}
	
int USBDriver::WorkWithZeroPipe( BYTE setupPacket[8], BYTE *buffer, int size, BOOL isRead)
{
	WD_USB_TRANSFER transfer;
    int i;

    BZERO(transfer);
    transfer.dwPipe = 0x00;
    transfer.dwBytes = size;
    transfer.fRead = isRead;
    for (i=0; i<8; i++)
        transfer.SetupPacket[i] = setupPacket[i];
    transfer.pBuffer = buffer;
    transfer.hDevice = driverHandle->hDevice;
    transfer.dwTimeout = 300000;
    WD_UsbTransfer(driverHandle->hWD, &transfer);

    if (transfer.fOK)
        return transfer.dwBytesTransfered;
	errorCode = DEVICE_WAS_DISCONNECTED;
    return 0xffffffff;

}

void USBDriver::StopTransferPipe(int pipeAddress)
{
	WD_USB_TRANSFER transfer;

    BZERO(transfer);
    transfer.dwPipe = pipeAddress;
    transfer.dwOptions = USB_TRANSFER_HALT;
    transfer.hDevice = driverHandle->hDevice;
    WD_UsbTransfer(driverHandle->hWD, &transfer);
}

void USBDriver::ResetPipe(int pipeAddress)
{
}

CString USBDriver::GetErrorDescriptor()
{
	CString error;

	switch (errorCode)
	{
	case NO_USB_ERROR :
		break;
	case NO_USB_DEVICE_FOUND:
		error.Format(_T("Cannot find USB Device."));
		break;
	case FAIL_OPEN_WINDRIVER:
		error.Format(_T("Cannot open WinDriver."));
		break;
	case INCORRECT_WINDRIVER_VER:
		error.Format(_T("Incorrect WinDriver version."));
		break;
	case FAIL_OPEN_USB_DEVICE:
		error.Format(_T("Cannot open USB driver."));
		break;
	case DEVICE_WAS_DISCONNECTED:
		error.Format(_T("USB Device was disconnected."));
	}
	return error;
}

void USBDriver::RegisterWinDriver()
{
    HANDLE hWD;
    WD_LICENSE lic;  

	hWD = WD_Open();
    if (hWD!=INVALID_HANDLE_VALUE)
    {
            // replace the following string with your license string
			// strcpy(lic.cLicense, "12345678.license.sting"");
            WD_License(hWD, &lic);
            WD_Close(hWD);
    }
}