// Copyright (c) 1995-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_serial.cpp

// 

//

//#define _DEBUG_DEVCOMM

#define __E32TEST_EXTENSION__

#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>

#include "d_lddturnaroundtimertest.h"

#include <u32hal.h>

//#define DRIVER_TRACE_ON // disables or adjusts timeout for tests affected by LDD trace

// Enable aggressive paging policy if required

#if 0

#define WDP_ENABLED // affects some tests

#define FLUSH_WDP_CACHE UserSvr::HalFunction(EHalGroupVM,EVMHalFlushCache,0,0)

#else

#define FLUSH_WDP_CACHE

#endif

#if defined (__WINS__)

#define PDD_NAME _L("ECDRV.PDD")

#define LDD_NAME _L("ECOMM.LDD")

#else

#define PDD_NAME _L("EUART")

#define LDD_NAME _L("ECOMM")

#endif

const char KSpinner[]={'|','/','-','\\',};

#include "../power/async.h"

#define CHECK(r,v)	{if ((r)!=(v)) {test.Printf(_L("Line %d Expected %d Got %d\n"),__LINE__,(v),(r)); test(0);}}

// constant expressions for elements in an array, and 1st address past the end

#define ELEMENTS(A) (sizeof(A)/sizeof(A[0]))

#define LIMIT(A) (A + ELEMENTS(A))

// Our own comms object with synchronous writes

class RComm : public RBusDevComm

	{

public:

	TInt WriteS(const TDesC8& aDes);

	TInt WriteS(const TDesC8& aDes,TInt aLength);

	// Override the read functions to flush the paging cache

	inline void Read(TRequestStatus &aStatus,TDes8 &aDes)

		{

		FLUSH_WDP_CACHE;

		RBusDevComm::Read(aStatus, aDes);

		}

	inline void Read(TRequestStatus &aStatus,TDes8 &aDes,TInt aLength)

		{

		FLUSH_WDP_CACHE;

		RBusDevComm::Read(aStatus, aDes, aLength);

		}

	inline void ReadOneOrMore(TRequestStatus &aStatus,TDes8 &aDes)

		{

		FLUSH_WDP_CACHE;

		RBusDevComm::ReadOneOrMore(aStatus, aDes);

		}

	};

LOCAL_D RTest test(_L("T_SERIAL"));

RComm* theSerialPorts[2];

TCommCaps2 theCaps1Buf;

TCommCapsV02& theCaps1=theCaps1Buf();

TCommCaps2 theCaps2Buf;

TCommCapsV02& theCaps2=theCaps2Buf();

TInt PortA;

TInt PortB;

const TInt KWriteSize=250;

const TInt KXonNumReads=0x10;

const TInt KXonReadSize=0x400;

class TSpeedAndName

	{

public:

	TUint iMask;

	TBps iSpeed;

	const TText* iName;

	};

class TSpeedAndNameV2

	{

public:

	TUint iMask;

	TBps iSpeed;

	const TText* iName;

	TUint iBps;

	};

const TSpeedAndName KSpeeds[]=

	{

//	{KCapsBps50,EBps50,_S("50")},

//	{KCapsBps75,EBps75,_S("75")},

//	{KCapsBps110,EBps110,_S("110")},

//	{KCapsBps134,EBps134,_S("134")},

//	{KCapsBps150,EBps150,_S("150")},

//	{KCapsBps300,EBps300,_S("300")},

//	{KCapsBps600,EBps600,_S("600")},

//	{KCapsBps1200,EBps1200,_S("1200")},

//	{KCapsBps1800,EBps1800,_S("1800")},

//	{KCapsBps2000,EBps2000,_S("2000")},

//	{KCapsBps2400,EBps2400,_S("2400")},

//	{KCapsBps3600,EBps3600,_S("3600")},

//	{KCapsBps4800,EBps4800,_S("4800")},

//	{KCapsBps7200,EBps7200,_S("7200")},

	{KCapsBps9600,EBps9600,_S("9600")},

	{KCapsBps19200,EBps19200,_S("19200")},

//	{KCapsBps38400,EBps38400,_S("38400")},

	{KCapsBps57600,EBps57600,_S("57600")},

	{KCapsBps115200,EBps115200,_S("115200")},

	};

// These speeds are used to test break handling

const TSpeedAndNameV2 KBreakSpeeds[]=

	{

//	{KCapsBps50,EBps50,_S("50"),50},

//	{KCapsBps75,EBps75,_S("75"),75},

//	{KCapsBps110,EBps110,_S("110"),110},

//	{KCapsBps134,EBps134,_S("134"),134},

//	{KCapsBps150,EBps150,_S("150"),150},

	{KCapsBps300,EBps300,_S("300"),300},

//	{KCapsBps600,EBps600,_S("600"),600},

	{KCapsBps1200,EBps1200,_S("1200"),1200},

//	{KCapsBps1800,EBps1800,_S("1800"),1800},

//	{KCapsBps2000,EBps2000,_S("2000"),2000},

//	{KCapsBps2400,EBps2400,_S("2400"),2400},

//	{KCapsBps3600,EBps3600,_S("3600"),3600},

	{KCapsBps4800,EBps4800,_S("4800"),4800},

//	{KCapsBps7200,EBps7200,_S("7200"),7200},

//	{KCapsBps9600,EBps9600,_S("9600"),9600},

//	{KCapsBps19200,EBps19200,_S("19200"),19200},

//	{KCapsBps38400,EBps38400,_S("38400"),38400},

	{KCapsBps57600,EBps57600,_S("57600"),57600},

	{KCapsBps115200,EBps115200,_S("115200"),115200},

	};

// Multiplying factors to give Min turnaround times in microseconds between Rx and Tx

#if defined (__WINS__)

const TUint KTurnaroundTimes[] =

{

	150,

	120,

	90,

	60

};

#else

const TUint KTurnaroundTimes[] =

{

#ifdef DRIVER_TRACE_ON

	150,

	120,

	90,

	60

#else

	15,

	12,

	9,

	6

#endif

};

#endif

class TFrameAndName

	{

public:

	TDataBits iData;

	TStopBits iStop;

	TParity iParity;

	const TText* iName;

	};

const TFrameAndName KFrameTypes[]=

	{

	{EData8,EStop1,EParityNone,_S("8,N,1")},

	{EData8,EStop1,EParityEven,_S("8,E,1")},

	{EData8,EStop1,EParityOdd,_S("8,O,1")},

	{EData8,EStop2,EParityNone,_S("8,N,2")},

	{EData8,EStop2,EParityEven,_S("8,E,2")},

	{EData8,EStop2,EParityOdd,_S("8,O,2")},

	{EData7,EStop2,EParityNone,_S("7,N,2")},

	{EData7,EStop2,EParityEven,_S("7,E,2")},

	{EData7,EStop2,EParityOdd,_S("7,O,2")},

	{EData7,EStop1,EParityNone,_S("7,N,1")},

	{EData7,EStop1,EParityEven,_S("7,E,1")},

	{EData7,EStop1,EParityOdd,_S("7,O,1")},

//	{EData6,EStop2,EParityNone,_S("6,N,2")},

//	{EData6,EStop2,EParityEven,_S("6,E,2")},

//	{EData6,EStop2,EParityOdd,_S("6,O,2")},

//	{EData6,EStop1,EParityNone,_S("6,N,1")},

//	{EData6,EStop1,EParityEven,_S("6,E,1")},

//	{EData6,EStop1,EParityOdd,_S("6,O,1")},

//	{EData5,EStop1,EParityNone,_S("5,N,1")},

//	{EData5,EStop1,EParityEven,_S("5,E,1")},

//	{EData5,EStop1,EParityOdd,_S("5,O,1")},

	};

class THandShakeAndName

	{

public:

	TUint iHandshake;

	const TText* iName;

	};

THandShakeAndName KHandshakes[]=

	{

//	{KConfigObeyDSR,_S("DSR/DTR")},		// most cables don't actually support this

	{KConfigObeyCTS,_S("CTS/RTS")},

// 	{KConfigObeyDCD,_S("DCD")},

	};

enum TSerialTestFault

	{

	EBadArg,

	};

_LIT(KLddFileName, "D_LDDTURNAROUNDTIMERTEST.LDD");

RLddTest1 ldd;

#ifdef _DEBUG_DEVCOMM

void CommDebug(RBusDevComm& aComm)

	{

	TCommDebugInfoPckg infopckg;

	TCommDebugInfo& info = infopckg();

	aComm.DebugInfo(infopckg);

	test.Printf(_L("  LDD State        :    TX         RX    \r\n"));

	test.Printf(_L("  Busy             : %10d %10d\r\n"), info.iTxBusy, info.iRxBusy);

	test.Printf(_L("  Held             : %10d %10d\r\n"), info.iTxHeld, info.iRxHeld);

	test.Printf(_L("  Length           : %10d %10d\r\n"), info.iTxLength, info.iRxLength);

	test.Printf(_L("  Offset           : %10d %10d\r\n"), info.iTxOffset, info.iRxOffset);

	test.Printf(_L("  Int Count        : %10d %10d\r\n"), info.iTxIntCount, info.iRxIntCount);

	test.Printf(_L("  Err Count        : %10d %10d\r\n"), info.iTxErrCount, info.iRxErrCount);

	test.Printf(_L("  Buf Count        : %10d %10d\r\n"), info.iTxBufCount, info.iRxBufCount);

	test.Printf(_L("  Fill/Drain       : %10d %10d\r\n"), info.iFillingTxBuf, info.iFillingTxBuf);

	test.Printf(_L("  XON              : %10d %10d\r\n"), info.iTxXon, info.iRxXon);

	test.Printf(_L("  XOFF             : %10d %10d\r\n"), info.iTxXoff, info.iRxXoff);

	test.Printf(_L("  Chars            : %10d %10d\r\n"), info.iTxChars, info.iRxChars);

//	test.Printf(_L("  DFC Pending      : %10d %10d\r\n"), info.iTxDfcPend, info.iTxDfcPend);

//	test.Printf(_L("  DFC Run/Count    : %10d %10d\r\n"), info.iRunningDfc, info.iDfcCount);

//	test.Printf(_L("  DFC Req/Do/Drain : %10d %10d %10d\r\n"), info.iDfcReqSeq, info.iDfcHandlerSeq, info.iDoDrainSeq);

	}

#else

void CommDebug(RBusDevComm& /*aComm*/)

	{

	test.Printf(_L("Debug Dump not available\r\n"));

	}

#endif

TInt RComm::WriteS(const TDesC8& aDes)

//

// Syncronous write

//

	{

	return(WriteS(aDes,aDes.Length()));

	}

TInt RComm::WriteS(const TDesC8& aDes,TInt aLength)

//

// Syncronous write

//

	{

	TRequestStatus s;

	// Force there to be paging events

	FLUSH_WDP_CACHE;

	//

	Write(s,aDes,aLength);

	User::WaitForRequest(s);

	return(s.Int());

	}

void Panic(TSerialTestFault const& aFault)

//

// Panic the test code

//

	{

	User::Panic(_L("Comm Test"),aFault);

	}

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

//

// Mark a buffer with repeating byte pattern

//

	{

	__ASSERT_ALWAYS(aStartChar<=anEndChar,Panic(EBadArg));

	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("                 InBuf         |         outbuf\n\r")

bool CompareDescriptors(TDes8 &aLeft,TDes8 &aRight)

//

// Compare a couple of descriptors and dump them if they don't match

//

	{

	TInt lLen=aLeft.Length();

	TInt rLen=aRight.Length();

	TInt minLen=Min(lLen,rLen);

	aRight.SetLength(minLen);

	aLeft.SetLength(minLen);

	bool r = (aLeft.Compare(aRight)==0);

	if (!r)

		{

		RDebug::Print(_L("Compare failed - dumping descriptors\n\r"));

		TInt len=aLeft.Length();

		RDebug::Print(COLUMN_HEADER);

		TBuf8<0x100> buf;

		for (TInt i=0;i<=len/8;i++)

		{

			buf.Zero();

			buf.SetLength(0);

			buf.AppendFormat(_L8("%4d: "),i*8);

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

				{

				if ((i*8)+j<len)

					{

					TInt v=aLeft[(i*8)+j];

					buf.AppendFormat(_L8("%02x "),v);

					}

				else

					buf.AppendFormat(_L8("   "));

				}

			buf.AppendFormat(_L8(" | "));

			for (TInt k=0;k<8;k++)

				{

				if ((i*8)+k>=len)

					break;

				TInt v=aRight[(i*8)+k];

				buf.AppendFormat(_L8("%02x "),v);

				}

			buf.AppendFormat(_L8("\r\n"));

			RDebug::RawPrint(buf);	

			}

		}

	if (!r) {

		theSerialPorts[0]->Close();

		theSerialPorts[1]->Close();

		aRight.SetLength(rLen);

		aLeft.SetLength(lLen);

	}

	return r;

}

TInt CheckedWrite(TInt aBufSize)

//

// Write a buffer from one serial port to the other and vice versa.

//

	{

	TUint8* inBuf=new TUint8[aBufSize];

	test(inBuf!=NULL);

	TUint8* outBuf=new TUint8[aBufSize];

	test(outBuf!=NULL);

	TPtr8 outDes(outBuf,aBufSize,aBufSize);

	TPtr8 inDes(inBuf,aBufSize,aBufSize);

	RTimer tim;

	tim.CreateLocal();

	TRequestStatus readStatus;

	TRequestStatus timeStatus;

	StripeMem(outDes,'A','Z');

	inDes.FillZ();

	const TInt KReadFirstPort=0;

	const TInt KWriteFirstPort=1;

	// Check the driver rejects an attempt to read more data than the buffer allows

	theSerialPorts[KReadFirstPort]->Read(readStatus,inDes,aBufSize+1);

	test(readStatus==KErrGeneral);

	// Start reading for real

	theSerialPorts[KReadFirstPort]->Read(readStatus,inDes);

	test_Equal(KRequestPending, readStatus.Int());

	// Synchronous write

	TInt ret=theSerialPorts[KWriteFirstPort]->WriteS(outDes,aBufSize);

	test(ret==KErrNone);

	// Set a 6 second timer going

	const TUint KTimeOut=12000000;

	tim.After(timeStatus,KTimeOut);

	test(timeStatus==KRequestPending);

	// Wait for EITHER the read to complete, OR for the timer to timeout

	User::WaitForRequest(readStatus,timeStatus);

	if (timeStatus==KErrNone) // timer completed normally... oh dear, what happened to the read??

		{

		test.Printf(_L("RComm::Read() timed out!\n\r"));

		theSerialPorts[KReadFirstPort]->ReadCancel();

		test(EFalse);	// fail

		}

	else

		{

		tim.Cancel();

		if (readStatus!=KErrNone)

			test.Printf(_L("Read Failed! (%d)\n\r"),readStatus.Int());

		test(readStatus==KErrNone);

		test(ret==KErrNone);

		test.Printf(_L("\rRead %d of %d\n\r"),inDes.Length(),outDes.Length());

		test(CompareDescriptors(outDes,inDes));

		}

	test.Printf(_L("\t\t\tReverse\n"));

	theSerialPorts[KWriteFirstPort]->Read(readStatus,inDes,aBufSize);

	theSerialPorts[KReadFirstPort]->WriteS(outDes,aBufSize);

	User::WaitForRequest(readStatus);

	tim.After(timeStatus,KTimeOut);

	test(timeStatus==KRequestPending);

	User::WaitForRequest(readStatus,timeStatus);

	if (timeStatus==KErrNone)

		{

		test.Printf(_L("Timed Out!\n\r"));

		theSerialPorts[KWriteFirstPort]->ReadCancel();

		test(EFalse);	// fail

		}

	else

		{

		tim.Cancel();

		if (readStatus!=KErrNone)

				test.Printf(_L("Read Failed! (%d)\n\r"),readStatus.Int());

		test(readStatus==KErrNone);

		test(ret==KErrNone);

		test.Printf(_L("\rRead %d of %d\n\r"),inDes.Length(),outDes.Length());

		outDes.SetLength(inDes.Length());

		test(CompareDescriptors(outDes,inDes));

		}

	tim.Close();

	delete [] inBuf;

	delete [] outBuf;

	return inDes.Length();

	}

TUint CheckZeroTurnaround(TInt aBufSize, TUint aDirection)

//

// Checks that when a Turnaround of 0ms was selected the write takes place immediately

// aBufSize is selected such as it takes only slightly less than User timer granularity

// at the Baud rate selected to transmit that buffer.

// Checks that it takes less than a User side timer tick to complete a Write request

// at the selected Baud rate. Therefore proving the write is not being delayed in the driver

//

	{

	TUint8* inBuf=new TUint8[aBufSize];

	test(inBuf!=NULL);

	TUint8* outBuf=new TUint8[aBufSize];

	test(outBuf!=NULL);

	TPtr8 outDes(outBuf,aBufSize,aBufSize);

	TPtr8 inDes(inBuf,aBufSize,aBufSize);

	TInt numberRead = 0;

	TTimeIntervalMicroSeconds32 aTimeOut=0;

	UserHal::TickPeriod(aTimeOut);

	RTimer timeoutTimer;

	timeoutTimer.CreateLocal();

	TRequestStatus readStatus;

	TRequestStatus writeStatus;

	TRequestStatus timeStatus;

	StripeMem(outDes,'A','Z');

	inDes.FillZ();

	const TUint port_A = aDirection?1:0;

	const TUint port_B = 1 - port_A;

	// queue a read on port_A

	test.Printf(_L("\r\nRead %d \r\n"), port_A);

	theSerialPorts[port_A]->Read(readStatus,inDes);

	test(readStatus==KRequestPending);

	// write on port_B to complete read

	theSerialPorts[port_B]->SetMinTurnaroundTime(0);

	theSerialPorts[port_B]->Write(writeStatus,outDes,aBufSize);

	test(writeStatus==KRequestPending || writeStatus==KErrNone );

	// start the local turnaround timer

	timeoutTimer.After(timeStatus, (20*aTimeOut.Int()));		// give it a 20% margin

	test(timeStatus==KRequestPending);