/*

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

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "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: 

* e32utils\trgtest\trgtesth.cpp

*

*/

#include <e32err.h>

#include <windows.h>

#include <shlwapi.h>

#include <stdio.h>

#include <time.h>

#pragma comment(lib, "shlwapi.lib")

const TUint8 SOH=0x01;

const TUint8 STX=0x02;

const TUint8 EOT=0x04;

const TUint8 ACK=0x06;

const TUint8 NAK=0x15;

const TUint8 CAN=0x18;

const TUint8 SUB=0x1A;

const TUint8 BIGC=0x43;

const TUint8 BIGG=0x47;

// Try 115200bps first since it is the most commonly supported baud rate.  Newer platforms like the

// NaviEngine support 230400bps and above.

const TUint KDefaultBaudRate = 115200;

const TUint KBaudRateSearchList[] = {KDefaultBaudRate, 230400, 460800};

#define READ_BUF_SIZE	32768

#define WRITE_BUF_SIZE	32768

#define MAX_LINE		32768

#define PACKET_SIZE		1024

#define MIN(a,b)		((a)<(b)?(a):(b))

#define OFFSET(p,off)	((void*)((char*)p+off))

#define RESET_COMM()	PurgeComm(Comm, PURGE_RXCLEAR|PURGE_TXCLEAR)

const TInt	KExitCodeOK							= 0;		// no failure

const TInt	KExitCodeUsage						= 1;		// command like usage

const TInt	KExitCodeLog						= 2;		// can't open log file

const TInt	KExitCodeImage						= 3;		// can't open image file

const TInt	KExitCodeSerial						= 4;		// can't open serial port

const TInt	KExitCodeDownload					= 5;		// download started, but failed

const TInt	KExitCodeFaulted					= 6;		// entered debug monitor abnormally

const TInt	KExitCodeHung						= 7;		// target hung

const TInt	KExitCodeDOA						= 8;		// board was in debug monitor at start

const TInt	KExitCodeUnsupportedBaudRate		= 9;		// the baud rate set by the -b parameter is not supported by the PC's COM port

const TInt	KExitCodeAssert						= 99;		// trgtest assertion failed

FILE* LogFile = NULL;

HANDLE Comm = INVALID_HANDLE_VALUE;

char ImgFileName[MAX_PATH] = "";

TInt ImgFileSize = 0;

char LineBuf[MAX_LINE+1];

void* ImgFileChunkBase = NULL;

TBool use_stdout = false;

enum EDebugMonitorOptions

{

	kDebugDumpCodeSegs = 1

};

TUint DebugMonitorOptions = kDebugDumpCodeSegs;

#define TT_ASSERT(x)	__ASSERT_ALWAYS(x, __Panic(__LINE__))

const char* GetWinErrMsg(DWORD errorCode)

	{

	static char lastErrorBuffer[512]; // not thread safe or reentrant (but shouldn't need to be)

	strcpy(lastErrorBuffer, "Unknown error");

	if(errorCode != ERROR_SUCCESS)

		{

		if(FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, errorCode, 0, lastErrorBuffer, 512, NULL) != 0)

			{

			size_t size = strlen(lastErrorBuffer);

			// Strip any trailing carriage return.

			if(StrCmpNI(lastErrorBuffer + size - 2, "\r\n", 2) == 0)

				{

				lastErrorBuffer[size - 2] = '\0';

				size -= 2;

				}

			// Strip any trailing period.

			if(lastErrorBuffer[size - 1] == '.')

				{

				lastErrorBuffer[size - 1] = '\0';

				}

			}

		}

	return lastErrorBuffer;

	}

const char* GetSymOrWinErrMsg(TInt errorCode)

	{

	static char lastErrorBuffer[512]; // not thread safe or reentrant (but shouldn't need to be)

	strcpy(lastErrorBuffer, "Unknown error");

	switch(errorCode)

		{

		case KErrNone:

			{

			// Unknown error

			}

		break;

		case KErrEof:

			{

			strcpy(lastErrorBuffer, "Unexpected end of file");

			}

		break;

		case KErrTimedOut:

			{

			strcpy(lastErrorBuffer, "Timed-out");

			}

		break;

		default:

			{

			if(errorCode > 0)

				{

				strcpy(lastErrorBuffer, GetWinErrMsg(errorCode));

				}

			}

		break;

		}

	return lastErrorBuffer;

	}

void __Panic(TInt aLine)

	{

	fprintf(stderr, "Assertion failed at line %d\n", aLine);

	exit(KExitCodeAssert);

	}

void WriteLog(const void* aBuf, TInt aLength)

	{

	if (LogFile)

		fwrite(aBuf, 1, aLength, LogFile);

	}

void WriteLogS(const char* aString)

	{

	WriteLog( aString, strlen(aString) );

	}

void TraceLog(const char* aFmt, ...)

	{

	char buf[512];

	va_list list;

	va_start(list, aFmt);

	if (!LogFile)

		return;

	sprintf(buf, "TRGTEST: ");

	vsprintf(buf, aFmt, list);

	strcat(buf, "\r\n");

	WriteLogS(buf);

	}

/*

YModem packet structure:

Byte 0 = STX

Byte 1 = sequence number (first user data packet is 1)

Byte 2 = complement of sequence number

Bytes 3-1026 = data (1K per packet)

Bytes 1027, 1028 = 16-bit CRC (big-endian)

A herald packet is sent first, with sequence number 0

The data field consists of the null-terminated file name

followed by the null-terminated file size in ASCII decimal

digits.

*/

struct SPacket

	{

	TUint8 iPTI;

	TUint8 iSeq;

	TUint8 iSeqBar;

	TUint8 iData[PACKET_SIZE];

	TUint8 iCRC1;

	TUint8 iCRC0;

	};

static const TUint16 crcTab[256] =

    {

	0x0000,0x1021,0x2042,0x3063,0x4084,0x50a5,0x60c6,0x70e7,0x8108,0x9129,0xa14a,

	0xb16b,0xc18c,0xd1ad,0xe1ce,0xf1ef,0x1231,0x0210,0x3273,0x2252,0x52b5,0x4294,

	0x72f7,0x62d6,0x9339,0x8318,0xb37b,0xa35a,0xd3bd,0xc39c,0xf3ff,0xe3de,0x2462,

	0x3443,0x0420,0x1401,0x64e6,0x74c7,0x44a4,0x5485,0xa56a,0xb54b,0x8528,0x9509,

	0xe5ee,0xf5cf,0xc5ac,0xd58d,0x3653,0x2672,0x1611,0x0630,0x76d7,0x66f6,0x5695,

	0x46b4,0xb75b,0xa77a,0x9719,0x8738,0xf7df,0xe7fe,0xd79d,0xc7bc,0x48c4,0x58e5,

	0x6886,0x78a7,0x0840,0x1861,0x2802,0x3823,0xc9cc,0xd9ed,0xe98e,0xf9af,0x8948,

	0x9969,0xa90a,0xb92b,0x5af5,0x4ad4,0x7ab7,0x6a96,0x1a71,0x0a50,0x3a33,0x2a12,

	0xdbfd,0xcbdc,0xfbbf,0xeb9e,0x9b79,0x8b58,0xbb3b,0xab1a,0x6ca6,0x7c87,0x4ce4,

	0x5cc5,0x2c22,0x3c03,0x0c60,0x1c41,0xedae,0xfd8f,0xcdec,0xddcd,0xad2a,0xbd0b,

	0x8d68,0x9d49,0x7e97,0x6eb6,0x5ed5,0x4ef4,0x3e13,0x2e32,0x1e51,0x0e70,0xff9f,

	0xefbe,0xdfdd,0xcffc,0xbf1b,0xaf3a,0x9f59,0x8f78,0x9188,0x81a9,0xb1ca,0xa1eb,

	0xd10c,0xc12d,0xf14e,0xe16f,0x1080,0x00a1,0x30c2,0x20e3,0x5004,0x4025,0x7046,

	0x6067,0x83b9,0x9398,0xa3fb,0xb3da,0xc33d,0xd31c,0xe37f,0xf35e,0x02b1,0x1290,

	0x22f3,0x32d2,0x4235,0x5214,0x6277,0x7256,0xb5ea,0xa5cb,0x95a8,0x8589,0xf56e,

	0xe54f,0xd52c,0xc50d,0x34e2,0x24c3,0x14a0,0x0481,0x7466,0x6447,0x5424,0x4405,

	0xa7db,0xb7fa,0x8799,0x97b8,0xe75f,0xf77e,0xc71d,0xd73c,0x26d3,0x36f2,0x0691,

	0x16b0,0x6657,0x7676,0x4615,0x5634,0xd94c,0xc96d,0xf90e,0xe92f,0x99c8,0x89e9,

	0xb98a,0xa9ab,0x5844,0x4865,0x7806,0x6827,0x18c0,0x08e1,0x3882,0x28a3,0xcb7d,

	0xdb5c,0xeb3f,0xfb1e,0x8bf9,0x9bd8,0xabbb,0xbb9a,0x4a75,0x5a54,0x6a37,0x7a16,

	0x0af1,0x1ad0,0x2ab3,0x3a92,0xfd2e,0xed0f,0xdd6c,0xcd4d,0xbdaa,0xad8b,0x9de8,

	0x8dc9,0x7c26,0x6c07,0x5c64,0x4c45,0x3ca2,0x2c83,0x1ce0,0x0cc1,0xef1f,0xff3e,

	0xcf5d,0xdf7c,0xaf9b,0xbfba,0x8fd9,0x9ff8,0x6e17,0x7e36,0x4e55,0x5e74,0x2e93,

	0x3eb2,0x0ed1,0x1ef0

    };

void UpdateCrc(const void* aPtr, TInt aLength, TUint16& aCrc)

//

// Perform a CCITT CRC checksum.

//

	{

	register const TUint8* pB = (const TUint8*)aPtr;

	register TUint16 crc=aCrc;

    while (aLength--)

		crc=TUint16((crc<<8)^crcTab[(crc>>8)^*pB++]);

	aCrc=crc;

	}

void ClearCommError()

	{

	DWORD err;

	COMSTAT s;

	TT_ASSERT(ClearCommError(Comm,&err,&s));

	}

void OpenCommPort(TInt aPort)

	{

	char buf[20];

	sprintf(buf, "\\\\.\\COM%d", aPort); // COM ports with indexes higher than 9 can only be referenced by prefixing the device name with "\\.\\"

	Comm = CreateFile(buf, GENERIC_READ|GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);

	if (Comm == INVALID_HANDLE_VALUE)

		{

		if(GetLastError() == ERROR_ACCESS_DENIED)

			{

			fprintf(stderr, "Can't open COM%d: Error %d (Access denied) - a terminal application has probably been left running with the port still open\n", aPort, ERROR_ACCESS_DENIED);

			}

		else

			{

			fprintf(stderr, "Can't open COM%d: Error %d (%s)\n", aPort, GetLastError(), GetWinErrMsg(GetLastError()));

			}

		exit(KExitCodeSerial);

		}

	// Raise our thread priority to avoid being starved if builds are continuing in parallel while we are communicating with the target

	// at high speeds.  TrgTest does not use serial flow control so if the buffers fill up, data will be lost.  We do not try to use the

	// real-time process priority class because it requires administrator privileges.

	SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL);

	}

TInt SetupCommPort(TInt aPort, TUint aBaudRate, TBool aIgnoreInvalidBaudRateError = false)

	{

	TInt r = KErrNone;

	const char* errFuncName = NULL;

	DCB dcb;

	dcb.DCBlength = sizeof(dcb);

	if(!GetCommState(Comm, &dcb))

		{

		r = GetLastError();

		errFuncName = "GetCommState";

		}

	else if(!SetCommMask(Comm, EV_ERR|EV_RXCHAR))

		{

		r = GetLastError();

		errFuncName = "SetCommMask";

		}

	else if(!SetupComm(Comm, READ_BUF_SIZE, WRITE_BUF_SIZE))

		{

		r = GetLastError();

		errFuncName = "SetupComm";

		}

	if(r != KErrNone)

		{

		TT_ASSERT(errFuncName);

		fprintf(stderr, "Error in SetupComm: Error %d (%s) calling %s\n", r, GetWinErrMsg(r), errFuncName);

		TraceLog("Error in SetupComm: Error %d (%s) calling %s", r, GetWinErrMsg(r), errFuncName);

		fprintf(stderr, "Trying to proceed anyway, be suspicious of any problems!\n");

		TraceLog("Trying to proceed anyway, be suspicious of any problems!");

		}

	ClearCommError();

	r = KErrNone;

	dcb.fAbortOnError = TRUE;

	dcb.BaudRate=aBaudRate;

	dcb.Parity=NOPARITY;

	dcb.fParity = FALSE;

	dcb.fErrorChar = FALSE;

	dcb.ByteSize = 8;

	dcb.StopBits=ONESTOPBIT;

	dcb.fInX  = FALSE;

	dcb.fOutX = FALSE;

	dcb.XonChar = 0;

	dcb.XoffChar = 0;

	dcb.ErrorChar = 0;

	dcb.fOutxDsrFlow = FALSE;

	dcb.fOutxCtsFlow = FALSE;

	dcb.fDsrSensitivity =  FALSE;

	dcb.fRtsControl = RTS_CONTROL_DISABLE;

	dcb.fDtrControl = DTR_CONTROL_DISABLE;

	if(!SetCommState(Comm, &dcb))

		{

		if(GetLastError() == ERROR_INVALID_PARAMETER)

			{

			r = KExitCodeUnsupportedBaudRate;

			if(aIgnoreInvalidBaudRateError)

				{

				return r;

				}

			else

				{

				fprintf(stderr, "Error in SetCommState : Error %d (%s) - a baud rate of %dbps is not supported by COM%d - try a different port\n", GetLastError(), GetWinErrMsg(GetLastError()), aBaudRate, aPort);

				TraceLog("Error in SetCommState : Error %d (%s) - a baud rate of %dbps is not supported by COM%d - try a different port", GetLastError(), GetWinErrMsg(GetLastError()), aBaudRate, aPort);

				}

			}

		else

			{

			fprintf(stderr, "Error in SetCommState : Error %d calling (%s) SetCommState\n", GetLastError(), GetWinErrMsg(GetLastError()), aBaudRate);

			TraceLog("Error in SetCommState : Error %d (%s) SetCommState", GetLastError(), GetWinErrMsg(GetLastError()), aBaudRate);

			r = KExitCodeSerial;

			}

		exit(r);

		}

	EscapeCommFunction(Comm, SETDTR);

	EscapeCommFunction(Comm, SETRTS);

	return KErrNone;

	}

void SetupTimeout(TInt aInt, TInt aTot)

	{

	COMMTIMEOUTS ct;

	GetCommTimeouts(Comm, &ct);

	ct.ReadIntervalTimeout = aInt;		// ms

	ct.ReadTotalTimeoutMultiplier = 0;

	ct.ReadTotalTimeoutConstant = aTot;	// ms

	ct.WriteTotalTimeoutConstant = 0;

	ct.WriteTotalTimeoutMultiplier = 0;

	SetCommTimeouts(Comm, &ct);

	}

TInt CommRead1(TInt aTimeout)

	{

	unsigned char c;

	DWORD n=0;

	BOOL ok;

	SetupTimeout(0, aTimeout);

	ok = ReadFile(Comm, &c, 1, &n, NULL);

	if (!ok)

		ClearCommError();

	if (ok && n)

		return c;

	return KErrTimedOut;

	}

TInt CommRead(void* aBuf, TInt aMax, TInt aTimeout)

	{

	DWORD n=0;

	BOOL ok;

	SetupTimeout(100, aTimeout);

	ok = ReadFile(Comm, aBuf, aMax, &n, NULL);

	if (!ok)

		ClearCommError();

	if (n==0)

		return KErrTimedOut;

	return n;

	}

void CommWrite(const void* aBuf, TInt aLen)

	{

	DWORD n = 0;

	BOOL ok = WriteFile(Comm, aBuf, aLen, &n, NULL);

	if (!ok)

		ClearCommError();

	}

void CommWriteC(TUint aChar)

	{

	unsigned char c = (unsigned char)aChar;

	CommWrite(&c, 1);

	}

void CommWriteS(const char* aString)

	{

	CommWrite( aString, strlen(aString) );

	}

TInt PreparePacket(SPacket& pkt, TInt aSeq, TInt& aOutBytesUploaded)

	{

	TInt r = KErrNone;

	TUint16 crc = 0;

	pkt.iPTI = STX;

	pkt.iSeq = (TUint8)(aSeq>=0 ? aSeq : 0);

	pkt.iSeqBar = (TUint8)~pkt.iSeq;

	if (aSeq>0)

		{

		TInt l;

		aOutBytesUploaded = (aSeq-1)*PACKET_SIZE;	// file position of packet

		if ( aOutBytesUploaded >= ImgFileSize )

			return KErrEof;

		l = MIN(PACKET_SIZE, ImgFileSize-aOutBytesUploaded);

		memcpy(pkt.iData, OFFSET(ImgFileChunkBase,aOutBytesUploaded), l);

		if (l<PACKET_SIZE)

			memset(pkt.iData+l, 0, PACKET_SIZE-l);

		aOutBytesUploaded = max( aOutBytesUploaded, 0L );

		}

	else

		{

		aOutBytesUploaded = 0;

		memset(pkt.iData, 0, PACKET_SIZE);

		if (aSeq==0)

			{

			const char* p = ImgFileName;

			const char* q = p + strlen(p);

			while (--q>=p && *q!='\\') {}

			sprintf( (char*)pkt.iData, "%s%c%d", q+1, 0, ImgFileSize);

			}

		}

	UpdateCrc(pkt.iData, PACKET_SIZE, crc);

	pkt.iCRC1 = (TUint8)(crc>>8);

	pkt.iCRC0 = (TUint8)crc;

	return r;

	}

TInt SendPacket(TInt& aSeq, TBool aStream, clock_t startTime)

	{

	TBool ackPacket = aSeq == -1;

	TInt c;

	SPacket pkt;

	TInt retries = 10;

	TInt tmout = (aSeq>=0) ? 2000 : 500;

	TInt bytesUploaded;

	// Prepare the next packet.

	TInt r = PreparePacket(pkt, aSeq, bytesUploaded);

	if (r==KErrNone)

		{

		// Keep trying to send the packet until it is acknowledged.

		for(;;)

			{

			RESET_COMM();

			CommWrite(&pkt, sizeof(pkt));

			if (aStream)

				break;

			c = CommRead1(tmout);

			if (c==KErrTimedOut && aSeq<0)

				{

				return KErrNone;

				}

			if (c>=0)

				{

				if (c==ACK)

					break;

				}

			if (--retries==0)

				{

				r = KErrTimedOut;

				break;

				}

			}

		// Check to see if the send operation was successful.	

		if (r == KErrNone || (r == KErrEof))

			{

			// Verify the stream type for the first packet.

			if(aSeq==0)

				{

				c = CommRead1(100);

				if (c==KErrTimedOut)

					{

					r = KErrNone;

					}

				else if (aStream && c!=BIGG)

					r = KErrTimedOut;

				else if (!aStream && c!=BIGC)

					r = KErrTimedOut;

				}

			if(r == KErrNone)

				{

				++aSeq;

				}

			}

		}

	// Print the progress info.

	if (((r == KErrNone) && ((aSeq & 7) == 0)) || (r != KErrNone) || ackPacket)

		{

		// Calculate total packet count.

		TInt totalPacketCount = (ImgFileSize / PACKET_SIZE) + 2; // one extra packet for handshake and one extra packet for acknowledgement

		TInt roundedImageFileSize = ImgFileSize;

		TInt remainderSize = ImgFileSize % PACKET_SIZE;

		if(remainderSize != 0)

			{

			totalPacketCount ++;

			roundedImageFileSize += (PACKET_SIZE - remainderSize);

			}

		// Calculate the percentage complete.