// Copyright (c) 1998-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\device\t_dceutl.cpp

// 

//

#include <e32base.h>

#include <e32base_private.h>

#include <e32test.h>

#include <e32cons.h>

#include <e32svr.h>

#include <e32hal.h>

#include <d32comm.h>

#include <e32uid.h>

#include <hal.h>

const TInt KDisplayTitleY=0;

const TInt KDisplayMainY=2;

const TInt KDisplayTextY=17;

const TInt KUnit0=0;

const TInt KUnit1=1;

const TInt KTestPatternSize=250;

enum TPanic {ECreatingConsole,ELoadingPDD,ELoadingLDD,ECreatingRComm,EOpeningPort,ESettingPort,ECircBuf,EStraySignal};

#if defined (__WINS__)

#define PDD_NAME _L("ECDRV.PDD")

#define LDD_NAME _L("ECOMM.LDD")

#else

#define PDD_NAME _L("EUARTn")

#define LDD_NAME _L("ECOMM")

#endif

class RComm : public RBusDevComm

	{

public:

	TInt WriteS(const TDesC8& aDes);

	};

CConsoleBase *TheConsole;

RComm *TheSerialPort;

TCommConfig TheConfigBuf;

TCommConfigV01& TheConfig=TheConfigBuf();

TBool TheDtrState;

TBool TheRtsState;

TBuf8<KTestPatternSize> TheTestBuf;

LOCAL_C void Panic(TPanic aPanic)

//

// Panic

//

	{

	if (TheSerialPort)

		TheSerialPort->Close();

	delete TheSerialPort;

	delete TheConsole;

	User::Panic(_L("T_DCEUTL"),aPanic);

	}

LOCAL_C TPtrC BaudrateText(TBps aBaudrate)

	{

	switch(aBaudrate)

		{

		case EBps50: 		return(_L("50"));

		case EBps75: 		return(_L("75"));

		case EBps110: 		return(_L("110"));

		case EBps134: 		return(_L("134"));

		case EBps150: 		return(_L("150"));

		case EBps300: 		return(_L("300"));

		case EBps600: 		return(_L("600"));

		case EBps1200: 		return(_L("1200"));

		case EBps1800: 		return(_L("1800"));

		case EBps2000: 		return(_L("2000"));

		case EBps2400: 		return(_L("2400"));

		case EBps3600: 		return(_L("3600"));

		case EBps4800: 		return(_L("4800"));

		case EBps7200: 		return(_L("7200"));

		case EBps9600: 		return(_L("9600"));

		case EBps19200: 	return(_L("19200"));

		case EBps38400: 	return(_L("38400"));

		case EBps57600: 	return(_L("57600"));

		case EBps115200: 	return(_L("115200"));

		case EBps230400: 	return(_L("230400"));

		case EBps460800:	return(_L("460800"));

		case EBps576000:	return(_L("576000"));

		case EBps1152000: 	return(_L("1152000"));

		case EBps4000000: 	return(_L("4000000"));

		case EBpsSpecial: 	return(_L("Special"));

		default: 			return(_L("Unknown"));

		}

	}

LOCAL_C TPtrC DtrText(TBool aDtrState)

	{

	if (aDtrState)

		return(_L("ASSERTED"));

	else

		return(_L("NEGATED"));

	}

LOCAL_C TPtrC RtsText(TBool aRtsState)

	{

	if (aRtsState)

		return(_L("ASSERTED"));

	else

		return(_L("NEGATED"));

	}

TInt RComm::WriteS(const TDesC8& aDes)

//

// Syncronous write

//

	{

	TRequestStatus s;

	Write(s,aDes,aDes.Length());

	User::WaitForRequest(s);

	return(s.Int());

	}

LOCAL_C void CenteredPrintf(TInt aLine,TRefByValue<const TDesC> aFmt,...)

//

// Print centrally on specified line

//

	{

	VA_LIST list;

	VA_START(list,aFmt);

	TBuf<0x100> aBuf;

	aBuf.AppendFormatList(aFmt,list);

	TInt xPos = ((TheConsole->ScreenSize().iWidth)-aBuf.Length())/2;

	if (xPos<0)

		xPos=0;

	TheConsole->SetPos(0,aLine);

	TheConsole->ClearToEndOfLine();

	TheConsole->SetPos(xPos,aLine);

	TheConsole->Write(aBuf);

	}

LOCAL_C void Heading(TRefByValue<const TDesC> aFmt,...)

//

// Print a title

//

	{

	VA_LIST list;

	VA_START(list,aFmt);

	TBuf<0x100> aBuf;

	aBuf.AppendFormatList(aFmt,list);

	CenteredPrintf(KDisplayTitleY,aBuf);

	}

LOCAL_C void Instructions(TBool topLine,TRefByValue<const TDesC> aFmt,...)

//

// Print instructions (dont use top line with hex display).

//

	{

	VA_LIST list;

	VA_START(list,aFmt);

	TBuf<0x100> aBuf;

	aBuf.AppendFormatList(aFmt,list);

	CenteredPrintf((topLine)?KDisplayTextY-1:KDisplayTextY,aBuf);

	}

LOCAL_C void StripeMem(TDes8& aBuf,TUint aStartChar,TUint anEndChar)

//

// Mark a buffer with repeating byte pattern

//

	{

	if (aStartChar==anEndChar)

		{

		aBuf.Fill(aStartChar);

		return;

		}

	TUint character=aStartChar;

	for (TInt i=0;i<aBuf.Length();i++)

		{

		aBuf[i]=(TText8)character;

		if(++character>anEndChar)

			character=aStartChar;

		}

	}

#define COLUMN_HEADER _L("            RxBuf            |          Expected       ")

LOCAL_C void DumpDescriptors(TDes8 &aLeft,TDes8 &aRight)

//

//

//

	{

	TBuf<80> b;

	CenteredPrintf(KDisplayMainY+2,_L("Compare failed:"));

	TInt minLen=Min(aLeft.Length(),aRight.Length());

	CenteredPrintf(KDisplayMainY+3,COLUMN_HEADER);

	TInt i=0;

	TInt j=0;

	TInt pos=KDisplayMainY+4;

	while (i<=minLen)

		{

		b.Format(_L("%02x: "),i);

		for (j=0;j<8;j++)

			{

			if ((i+j)<minLen)

				{

				TInt v=aLeft[i+j];

				b.AppendFormat(_L("%02x "),v);

				}

			else

				b.Append(_L("   "));

			}

		b.Append(_L(" | "));

		for (j=0;j<8;j++)

			{

			if ((i+j)<minLen)

				{

				TInt v=aRight[i+j];

				b.AppendFormat(_L("%02x "),v);

				}

			else

				b.Append(_L("   "));

			}

		CenteredPrintf(pos++,b);

		i+=8;

		if ((i%64)==0)

			{

			pos=KDisplayMainY+4;

			TheConsole->Getch();

			}

		}

	}

LOCAL_C TInt ChangeBaudrate()

//

// Change baudrate

//

	{

	CenteredPrintf(KDisplayMainY,_L("Select Baudrate:-"));

	CenteredPrintf(KDisplayMainY+1,_L("A - 4800  "));

	CenteredPrintf(KDisplayMainY+2,_L("B - 9600  "));

	CenteredPrintf(KDisplayMainY+3,_L("C - 19200 "));

	CenteredPrintf(KDisplayMainY+4,_L("D - 38400 "));

	CenteredPrintf(KDisplayMainY+5,_L("E - 57600 "));

	CenteredPrintf(KDisplayMainY+6,_L("F - 115200"));

	TChar c;

	do

		{

		c=(TUint)TheConsole->Getch();

		c.UpperCase();

		}

	while(c<'A' && c>'F');

	switch (c)

		{

		case 'A': TheConfig.iRate=EBps4800; break;

		case 'B': TheConfig.iRate=EBps9600; break;

		case 'C': TheConfig.iRate=EBps19200; break;

		case 'D': TheConfig.iRate=EBps38400; break;

		case 'E': TheConfig.iRate=EBps57600; break;

		case 'F': TheConfig.iRate=EBps115200; break;

		case 0x1b: return(KErrNone);

		}

	TInt r=TheSerialPort->SetConfig(TheConfigBuf);

	if (r!=KErrNone)

		{

		CenteredPrintf(KDisplayMainY+9,_L("Error (%d) changing baudrate"),r);

		TheConsole->Getch();

		}

	return(KErrNone);

	}

LOCAL_C TInt SendHayesCommand()

//

// Send short hayes command

//

	{

	TInt r=TheSerialPort->WriteS(_L8("AT&f\r"));

	if (r!=KErrNone)

		{

		CenteredPrintf(KDisplayMainY+1,_L("Error (%d) sending data"),r);

		TheConsole->Getch();

		}

	return(KErrNone);

	}

LOCAL_C TInt SendLongHayesCommand()

//

// Send Long hayes command

//

	{

	TInt r=TheSerialPort->WriteS(_L8("AT&f&f&f&f&f&f&f\r"));

	if (r!=KErrNone)

		{

		CenteredPrintf(KDisplayMainY+1,_L("Error (%d) sending data"),r);

		TheConsole->Getch();

		}

	return(KErrNone);

	}

const TInt KBufSize=0x100;

LOCAL_C TInt Loopback()

//

// Loopback data from Rx to Tx

//

	{

	CenteredPrintf(KDisplayMainY,_L("Loopback mode"));

	CenteredPrintf(KDisplayMainY+5,_L("Hit a key abort"));

	TheSerialPort->ResetBuffers();

	CCirBuffer* cbufPtr=new CCirBuffer;

	__ASSERT_ALWAYS(cbufPtr!=NULL,Panic(ECircBuf));

	TRAPD(r,cbufPtr->SetLengthL(KBufSize));

	__ASSERT_ALWAYS(r==KErrNone,Panic(ECircBuf));

	TRequestStatus kStat,rStat,tStat = 0;

	TBool TxActive=EFalse;

	TInt TxCount=0;

	TUint8 txChar;

	TPtr8 txPtr(&txChar,1);

	TUint8 rxChar;

	TPtr8 rxPtr(&rxChar,1);

	TheSerialPort->Read(rStat,rxPtr,1);

	TheConsole->Read(kStat);

	FOREVER

		{

		User::WaitForAnyRequest();

		if (rStat!=KRequestPending)

			{

			if (rStat.Int()!=KErrNone)

				{ // Rx error

				CenteredPrintf(KDisplayMainY+5,_L("Rx error(%d)"),rStat.Int());

				TheConsole->ReadCancel();

				User::WaitForRequest(kStat);

				goto LoopEnd;

				}

			cbufPtr->Put((TInt)rxChar);

			TheSerialPort->Read(rStat,rxPtr,1);

			if (!TxActive)

				{

				txChar=(TUint8)cbufPtr->Get();

				TheSerialPort->Write(tStat,txPtr,1);

				TxActive=ETrue;

				}

			}

		else if (TxActive && tStat!=KRequestPending)

			{

			if (tStat.Int()!=KErrNone)

				{ // Tx error

				CenteredPrintf(KDisplayMainY+5,_L("Tx error(%d)"),tStat.Int());

				TheSerialPort->ReadCancel();

				User::WaitForRequest(rStat);

				TheConsole->ReadCancel();

				User::WaitForRequest(kStat);

				TxActive=EFalse;

				goto LoopEnd;

				}

			TxCount++;

			TInt t=cbufPtr->Get();

			if (t==KErrGeneral)

				TxActive=EFalse;

			else

				{

				txChar=(TUint8)t;

				TheSerialPort->Write(tStat,txPtr,1);

				}

			}

		else if (kStat!=KRequestPending)

			{

			CenteredPrintf(KDisplayMainY+5,_L("Tx count (%d) - Hit another key"),TxCount);

			TheSerialPort->ReadCancel();

			User::WaitForRequest(rStat);

LoopEnd:

			if (TxActive)

				{

				TheSerialPort->WriteCancel();

				User::WaitForRequest(tStat);

				}

			delete cbufPtr;

			TheConsole->Getch();

			break;

			}

		else

			Panic(EStraySignal);

		}

	return(KErrNone);

	}

LOCAL_C TInt ToggleDtr()

//

// Toggle state of DTR signal

//

	{

	if (TheDtrState)

		{

		TheSerialPort->SetSignals(0,KSignalDTR); // Negate DTR

		TheDtrState=EFalse;

		}

	else

		{

		TheSerialPort->SetSignals(KSignalDTR,0); // Assert DTR

		TheDtrState=ETrue;

		}

	return(KErrNone);

	}

LOCAL_C TInt ToggleRts()

//

// Toggle state of RTS signal

//

	{

	if (TheRtsState)

		{

		TheSerialPort->SetSignals(0,KSignalRTS); // Negate RTS

		TheRtsState=EFalse;

		}

	else

		{

		TheSerialPort->SetSignals(KSignalRTS,0); // Assert RTS

		TheRtsState=ETrue;

		}

	return(KErrNone);

	}

LOCAL_C TInt SendXoff()

//

// Send XOFF

//

	{

	TInt r=TheSerialPort->WriteS(_L8("\x13"));

	if (r!=KErrNone)

		{

		CenteredPrintf(KDisplayMainY+1,_L("Error (%d) sending XOFF"),r);

		TheConsole->Getch();

		}

	return(KErrNone);

	}

LOCAL_C TInt ReceiveBlock()

//

// Receive a block

//

	{

	CenteredPrintf(KDisplayMainY,_L("Waiting to recieve a block. Hit a key to abort"));

	TheSerialPort->ResetBuffers();

	TRequestStatus kStat,rStat;

	TBuf8<KTestPatternSize> rdBuf(KTestPatternSize);

	TheSerialPort->Read(rStat,rdBuf);

	TheConsole->Read(kStat);

	User::WaitForRequest(kStat,rStat);

	if (rStat!=KRequestPending)

		{

		TheConsole->ReadCancel();

		User::WaitForRequest(kStat);

		if (rStat.Int()!=KErrNone)

			{

			CenteredPrintf(KDisplayMainY+5,_L("Rx error(%d)"),rStat.Int());

			TheConsole->Getch();

			}

		else if (rdBuf.Compare(TheTestBuf)!=0)

			DumpDescriptors(rdBuf,TheTestBuf);

		else

			{

			CenteredPrintf(KDisplayMainY+5,_L("Success"));

			TheConsole->Getch();

			}

		}

	else

		{

		TheSerialPort->ReadCancel();

		User::WaitForRequest(rStat);

		}

	return(KErrNone);

	}

LOCAL_C TInt TransmitBlock()

//

// Transmit a block

//

	{

	TInt r;

	CenteredPrintf(KDisplayMainY,_L("Hit a key to transmit a block"));

	while ((TUint)TheConsole->Getch()!=0x1b)

		{

		r=TheSerialPort->WriteS(TheTestBuf);

		if (r!=KErrNone)

			{

			CenteredPrintf(KDisplayMainY+1,_L("Error (%d) transmitting block"),r);

			TheConsole->Getch();

			}

		}

	return(KErrNone);

	}

LOCAL_C TInt SendXon()

//

// Send XON

//

	{

	TInt r=TheSerialPort->WriteS(_L8("\x11"));

	if (r!=KErrNone)

		{

		CenteredPrintf(KDisplayMainY+1,_L("Error (%d) sending XON"),r);

		TheConsole->Getch();

		}

	return(KErrNone);