// Copyright (c) 2001-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// e32test\usb\t_usb_win\src\t_usb_wintests.cpp

// Win32 USB test program performs I/O with a device running the

// Symbian OS test program T_USB_DEVICE, using the generic USB device driver USBIO.

// === Includes ===

// 

//

#include "stdafx.h"

#include <process.h>    /* _beginthread, _endthread */

#include <sys/timeb.h>

#include "usbio.h"											// USBIO Dev Kit

#include "usbiopipe.h"										// ditto

#include "t_usb_win.h"

#include "t_usb_winDlg.h"

#include "global.h"

#include "UsbcvControl.h"

#ifdef _DEBUG

#define new DEBUG_NEW

#undef THIS_FILE

static char THIS_FILE[] = __FILE__;

#endif

extern BOOL EjectVolume(char driveLetter);

extern BOOL WaitDriveReady (char driveLetter);

extern DWORD PerlScript(char * scriptName);

// === Global Vars ===

extern char gScriptFileName[];

extern char gManufacturerName[];

extern char gProductName[];

extern char gSerialNumber[];

extern char gLogfileName[];

extern BOOL gVerboseMode;

extern BOOL gKeepOpen;

extern BOOL gAbort;

extern int gTransferMode;

extern CT_usb_winDlg* gMainWindow;

extern FILE *logStream;

extern int gReadWriteTimeOut;

// Our own private GUID (also used in the .inf file as 'DriverUserInterfaceGuid')

// {55606403-E62D-4707-9F56-40D48C6736D0}

GUID gUsbioID =

	{0x55606403, 0xe62d, 0x4707, {0x9f, 0x56, 0x40, 0xd4, 0x8c, 0x67, 0x36, 0xd0}};

// Another provate GUID used in the AtenSwitch.inf file  

// {A6942415-49EE-4ef2-9CE8-D33E888EF133}

const GUID gSwitchID =

	{0xA6942415, 0x49EE, 0x4ef2, {0x9C, 0xE8, 0xD3, 0x3E, 0x88, 0x8E, 0xF1, 0x33}};

// Handle for USB device list

static HDEVINFO gDevList = NULL;

// USBIO supported device

CUsbIo gUsbDev;

static int gDevNumber = -1;

static UCHAR gEndpointMap [MAX_INTERFACES] [MAX_SETTINGS] [MAX_ENDPOINTS];

static WORD gPacketSizeMap [MAX_INTERFACES] [MAX_SETTINGS] [MAX_ENDPOINTS];

static UCHAR gAlternateSettings [MAX_INTERFACES];

static bool gIsoEndpoint [MAX_INTERFACES] [MAX_SETTINGS] [MAX_ENDPOINTS];

static USHORT vendorId = 0;

static USHORT productId = 0;

static USHORT productIdMS = 0;

// endpoints

// Read/write buffer

static const DWORD KMaxTransferSize = 1024*1024;

static const DWORD KPreambleLength = 8;

static bool gFinishAllTests = false;

static HANDLE gThreadStartedEvent; 

static HANDLE gThreadEndedEvents[MAX_THREADS]; 

static HANDLE gThreadWaitEvents[MAX_THREADS]; 

HANDLE gDeviceConnectEvent; 

HANDLE gDeviceDisconnectEvent;

static __int64 gDeviceIdleCount = -1;

static struct _timeb gHostTime;

enum

	{

	EXml,

	ELoop,

	ECompare,

	EReceiveOnly,

	ETransmitOnly,

	EFileReceive,

	EFileTransmit,

	EComment,

	EConnect,

	EDisconnect,

	EWait,

	EFail,

	ESwitch,

	EWaitConnect,

	EWaitDisconnect,

	EDo,

	ERepeat,

	EUsbcv,

	EMassStorage,

	EEject,

	EPerl,

	EWaitDrive,

	};

enum Ep0Requests

	{

	EStop = 0x1,

	EVersion = 0x10,

	ETestParam = 0x20,

	ETestResult = 0x30,

	ETestFail = 0x40,

	ETestConnect = 0x50,

	ETestDisconnect = 0x60,

	ETestMassStorage = 0x70,

	ETestIdleCounter = 0x80,

	};

struct TestParamHost

	{

	WORD displayRate;

	DWORD outRate;

	DWORD inRate;

	BYTE index;

	bool signalNextSettingThread;

	};

typedef struct TestParamHost TestParamHostType;

struct TestParam

	{

	DWORD minSize;

	DWORD maxSize;

	DWORD packetNumber;

	BYTE interfaceNumber;

	BYTE alternateSetting;

	BYTE outPipe;

	BYTE inPipe;

	WORD repeat;

	WORD settingRepeat;

	BYTE beforeIndex;

	BYTE afterIndex;

	TestParamHostType host;

	TestParam ();

	};

typedef struct TestParam TestParamType;

typedef TestParamType* TestParamPtr;

// The version of T_USB we require (at least)

static const DWORD KTusbVersionMajor = 1;

static const DWORD KTusbVersionMinor = 0;

static const DWORD KTusbVersionMicro = 1;

static const DWORD KHostLogFileSize = 64*1024;

#define ERR_SCRIPT_NAME		0xF0000001L

// use a timeout for a WaitConnect to activate a scan for hardware changes

#define CONNECT_RESCAN_TIMEOUT	300000

#define RESCAN_APPNAME "C:\\Program Files\\devcon\\i386\\devcon.exe"

#define RESCAN_CMDLINE " rescan"

/////////////////////////////////////////////////////////////////////////////

// global functions

//

// print to output window

//

// Note:

// This is a global function that is called from any thread context.

// It is not possible to call MFC objects from a thread context that is

// created by using non-MFC means.

// So we use SendMessage to access the OutputWindow.

//

void PrintOut(BOOL screenFlag, BOOL logFlag, BOOL timeFlag, const char *format, ...)

{

	if (screenFlag)

	{

		const int buffersize = 512;

		va_list argptr;

		char buffer[buffersize];

		// print to buffer

		va_start(argptr,format);

		_vsnprintf(buffer,buffersize-1,format,argptr);

		buffer[buffersize-1] = 0;

		// with a time stamp and carriage return linefeed 

		if (timeFlag)

		{

			SYSTEMTIME localTime;

			GetLocalTime(&localTime);

			unsigned int len = strlen(buffer);

			GetDateFormat(LOCALE_USER_DEFAULT,0,&localTime,"dd MMM yyyy",&buffer[len],buffersize-len);

			len = strlen(buffer);

			GetTimeFormat(LOCALE_USER_DEFAULT,0,&localTime," H:mm:ss"NL,&buffer[len],buffersize-len);

		}

		// send buffer to output window (synchronous behavior for buffer protection)

		gMainWindow->SendMessage(WM_USER_PRINTOUT,0,(LPARAM)buffer); \

		if (logStream && logFlag)

			fputs(buffer,logStream);

		va_end(argptr);

	}

}

static void Delay(int milliseconds)

	{

	PRINT_IF_VERBOSE "* Short wait... ");

	Sleep(milliseconds);

	PRINT_IF_VERBOSE "done"NL);

	}

TestParam::TestParam()

	{

	minSize = 10;

	maxSize = 100;

	packetNumber = 0;

	interfaceNumber = 0;

	alternateSetting = 0;

	outPipe = 2;

	inPipe = 1;

	repeat = 0;

	settingRepeat = 0;

	beforeIndex = 0;

	host.displayRate = 100;

	host.outRate = 0;

	host.inRate = 0;

	host.index = 0;

	host.signalNextSettingThread = FALSE;

	}

//

// Process a line from the test script file

// returns the test type and sets up the test parameter structure

//

static int ParseTestLine(char* aLine,TestParamPtr aParam, USBIO_CLASS_OR_VENDOR_REQUEST* aRequest)

	{

	int testType = EComment;

	struct testKey

		{

		int testId;

		char testString[20];

		};

	typedef struct testKey testKeyType;

	size_t tokenLength = 0;

	testKeyType testKeyTable[] =

		{

		EXml,"Xml",

		ELoop,"Loop",

		ECompare,"Compare",

		EReceiveOnly,"Stream",

		EFileReceive,"File",

		EConnect,"Connect",

		EDisconnect,"Disconnect",

		EWait,"Wait",

		EFail,"Fail",

		ESwitch,"Switch",

		EWaitConnect,"WaitConnect",

		EWaitDisconnect, "WaitDisconnect",

		ERepeat, "Repeat",

		EDo, "Do",

		EUsbcv, "Usbcv",

		EMassStorage, "MStore",

		EEject, "Eject",

		EPerl, "Perl",

		EWaitDrive, "WaitDrive",

		};

	size_t  numKeys = sizeof( testKeyTable ) / sizeof( testKeyType );

	char delim[]   = " ,\t\n";

	char stringDelim[]   = "\"";

	char * token = strtok(aLine,delim);

	if (token == NULL)

		{

		return testType;

		}

	tokenLength = strlen(token);

	memset (aParam,0,sizeof(TestParamType));

	// default display rate 

	aParam->host.displayRate = 100;

	for (int i = 0; i < (int)numKeys; i++)

		{

		if (strnicmp (token,testKeyTable[i].testString,tokenLength) == 0)

			{

			testType = testKeyTable[i].testId;

			break;

			}

		}

	int paramCount = 0;

	// now set up test type in request setup packet

	switch (testType)

		{

	case EXml:

		aRequest->Value = 'X';

		paramCount = 2;

		break;

	case ELoop:

		aRequest->Value = 'L';

		break;

	case ECompare:

		aRequest->Value = 'C';

		break;

	case EReceiveOnly:

		aRequest->Value = 'S';

		paramCount = 1;

		break;

	case EFileReceive:

		aRequest->Value = 'F';

		paramCount = 1;

		break;

	case EComment:

		return testType;

		break;

	case EConnect:

		aRequest->Value = 'R';

		break;

	case EDisconnect:

		aRequest->Value = 'D';

		break;

	case EWait:

		aParam->minSize = INFINITE;

		break;

	case EWaitConnect:

		aParam->minSize = INFINITE;

		break;

	case EWaitDisconnect:

		aParam->minSize = INFINITE;

		break;

	case EFail:

	case ESwitch:

	case EDo:

	case ERepeat:

	case EUsbcv:

	case EMassStorage:

	case EEject:

	case EPerl:

	case EWaitDrive:

		break;

		}

	if (testType == EPerl)

		{

		// a space at the beginning of the line

		aLine[0] = ' ';

		strcpy(&aLine[1],&aLine[tokenLength+1]);

		// strip off carriage return or line feed

		if (iscntrl(aLine[strlen(aLine)-1]))

			{

			aLine[strlen(aLine)-1] = '\0';

			if (iscntrl(aLine[strlen(aLine)-1]))

				aLine[strlen(aLine)-1] = '\0';

			}

		return testType;

		}

	token = strtok(NULL,delim);

	if (testType == EEject || testType == EWaitDrive)

		{

		strcpy(aLine,token);

		return testType;

		}

	if (testType == EFileReceive)

		{

		// The first parameter is the drive letter on the device to use

		if (token != NULL)

			aParam->minSize = token[0];

		else

			aParam->minSize = 'D';

		token = strtok(NULL,delim);

		}

	while (token != NULL)

		{

		unsigned long ulParam = strtoul (token,NULL,0);

		switch (paramCount)

			{

		case 0 :

			aParam->minSize = (DWORD)ulParam;

			break;

		case 1 :

			aParam->maxSize = (DWORD)ulParam;

			break;

		case 2 :

			aParam->packetNumber = (DWORD)ulParam;

			break;

		case 3 :

			aParam->interfaceNumber = (BYTE)ulParam;

			break;

		case 4:

			aParam->alternateSetting = (BYTE)ulParam;

			// skip outpipe for Xml IN

			if (testType == EXml)

				{

				paramCount++;

				}

			break;

		case 5:

			aParam->outPipe = (BYTE)ulParam;

			break;

		case 6 :

			aParam->inPipe = (BYTE)ulParam;

			if (aParam->inPipe > 31)

				{

				if (testType == EReceiveOnly)

					testType = ETransmitOnly;

				if (testType == EFileReceive)

					testType = EFileTransmit;

				}

			break;

		case 7 :

			aParam->repeat = (WORD)ulParam;

			break;

		case 8 :

			aParam->host.displayRate = (WORD)ulParam;

			break;

		case 9 :

			aParam->settingRepeat = (WORD)ulParam;

			break;

		case 10 :

			aParam->beforeIndex = (BYTE)ulParam;

			break;

		case 11 :

			aParam->afterIndex = (BYTE)ulParam;

			break;

		case 12 :

			aParam->host.outRate = (DWORD)ulParam;

			break;

		case 13 :

			aParam->host.inRate = (DWORD)ulParam;

			break;

			}

		paramCount++;

		token = strtok(NULL,delim);

		}

	return testType;

	}

static void ShowErrorText (DWORD errCode)

	{

	char textBuf[80];

	CUsbIo::ErrorText(textBuf,80,errCode);

	PRINT_ALWAYS "%s"NL,textBuf); 

	gAbort = true;

	}

static DWORD OpenUsbDevice()

	{

	DWORD dwRC;

	USB_DEVICE_DESCRIPTOR DevDesc;

	// buffer used to store string descriptor

	unsigned char StrDescBuffer[sizeof(USB_STRING_DESCRIPTOR)+512];

	// pointer to USB string descriptor

	USB_STRING_DESCRIPTOR* StrDesc;

	DWORD StrDescSize;