// Copyright (c) 1997-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_commsk.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>

#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

//	Our own comms object with synchronous writes
class RComm : public RBusDevComm
	{
public:
	TInt WriteS(const TDesC8& aDes);
	TInt WriteS(const TDesC8& aDes,TInt aLength);
	TInt WriteSE(const TDes8& Entered, TInt aLength);
	};

LOCAL_D RTest test(_L("T_COMMSK"));
RComm* theSerialPort;
TCommCaps theCaps1Buf;
TCommCapsV01& theCaps1=theCaps1Buf();
TBool MediaChangeTestingEnabled;

const TInt KWriteSize=250;
const TInt KXonNumReads=0x10;
const TInt KXonReadSize=0x400;	// Must be bigger than comm buffer high water==0x300

class TResult
	{
public:
	enum TResTest {ETestPower,ESimpleWriting};
	TResult();
	void Display(CConsoleBase *aConsole,TInt aCycles);
	void Add(TResTest aTst,TInt anErr);
	inline TInt SetFreeMem(TInt aVal)
		{return(iFreeMem=aVal);}
private:
	TInt iFreeMem;	
	TInt iTestPowerFails;
	TInt iWriteFails;
	};

class TSpeedAndName
	{
public:
	TUint iMask; 
	TBps iSpeed;
	const TText* iName;
	};

const TSpeedAndName KSpeeds[]=
	{
	{KCapsBps50,EBps50,_S("50")}, 
	{KCapsBps2400,EBps2400,_S("2400")},
	{KCapsBps9600,EBps9600,_S("9600")},
	{KCapsBps19200,EBps19200,_S("19200")},
	{KCapsBps57600,EBps57600,_S("57600")},
	{KCapsBps115200,EBps115200,_S("115200")},
	};

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")},
	};

class THandShakeAndName
	{
public:
	TUint iHandshake;
	const TText* iName;
	};

THandShakeAndName KHandshakes[]=
	{
	{KConfigObeyDSR,_S("DSR/DTR")},
	{KConfigObeyCTS,_S("CTS/RTS")},
	};

enum TSerialTestFault {EBadArg,EUnknownSignal};

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;
	Write(s,aDes,aLength);
	User::WaitForRequest(s);
	return(s.Int());
	}

TResult::TResult()
	{

	iTestPowerFails=0;
	iFreeMem=0;
	iWriteFails=0;
	}

void TResult::Display(CConsoleBase *aConsole,TInt aCycles)
//
//	Display test results:
//
	{

	test.Console()->ClearScreen();
	TInt xStartPos=0;
	TInt yStartPos=2;

	aConsole->SetPos(xStartPos,yStartPos);
	test.Printf(_L("Total cycles         : %d"),aCycles);

	//	Display results of Power Down/Up followed by a simple write/read to the Serial Port
	aConsole->SetPos(xStartPos,yStartPos+2);
	if (MediaChangeTestingEnabled)
		test.Printf(_L("Media Change failures: %d\n"),iTestPowerFails);
	else
		test.Printf(_L("Power test failures  : %d\n"),iTestPowerFails);
	aConsole->SetPos(xStartPos,yStartPos+3);
	test.Printf(_L("Serial test failures : %d\n"),iWriteFails);

	aConsole->SetPos(xStartPos,yStartPos+5);
	test.Printf(_L("Free mem (in bytes)  : %d"),iFreeMem);
	}

void TResult::Add(TResTest aTst,TInt anErr)
//	
//	Increment the corresponding variable if test fails
//	
	{

	if (anErr!=KErrNone)
		{
		switch (aTst)
			{
			case ETestPower:
				if (anErr!=KErrNone)
					++iTestPowerFails;
				break;
			case ESimpleWriting:
				if (anErr!=KErrNone)
					++iWriteFails;
				break;
			default:
				iTestPowerFails=0;
				break;
			}
		}
	}

#ifdef _DEBUG_DEVCOMM
LOCAL_C 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);
	}
#else
void CommDebug(RBusDevComm& /*aComm*/)
	{
	test.Printf(_L("Debug Dump not available\r\n"));
	}
#endif

LOCAL_C void Panic(TSerialTestFault const& aFault)
//
// Panic the test code
//
	{
	User::Panic(_L("Comm Test"),aFault);
	}

LOCAL_C 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;
		}
	}

LOCAL_C TInt TestSimpleWriting()
	{	
	
	const TInt KBufSize=100;
	TUint8* inBuf=new TUint8[KBufSize]; 
	TUint8* outBuf=new TUint8[KBufSize];
	TPtr8 outDes(outBuf,KBufSize,KBufSize);
	TPtr8 inDes(inBuf,KBufSize,KBufSize);
	StripeMem(outDes,'A','Z');
	inDes.FillZ();
	inDes.SetLength(1);
	
	TRequestStatus readStatus;
	TRequestStatus timeStatus;
			
	theSerialPort->WriteS(outDes,KBufSize);
	theSerialPort->Read(readStatus,inDes);
	
	RTimer tim;
	test(tim.CreateLocal()==KErrNone);
	tim.After(timeStatus,2000000);  // Async. timer request - 2Secs

			
	User::WaitForRequest(timeStatus,readStatus);
	
	if (readStatus!=KRequestPending)
        {
		//	Serial request is complete - cancel timer
		tim.Cancel();
		User::WaitForRequest(timeStatus);
		if (readStatus==KErrNone)
			{
			test(inDes.Length()==inDes.MaxLength());
			test(inDes.Length()==KBufSize);
			outDes.SetLength(inDes.Length());
			return((inDes.Compare(outDes)==0)?KErrNone:KErrGeneral);
			}
		else 
			return KErrGeneral;	
		}
	
	else if (timeStatus!=KRequestPending)
       	{
		//	Timed out before Serial test completed
		theSerialPort->ReadCancel(); // Cancel serial read
		User::WaitForRequest(readStatus);
		return KErrTimedOut;
		}
	else
		Panic(EUnknownSignal);
	return(KErrNone); // Never gets here
	}

LOCAL_C TInt SetUp()
//
//	Set up the serial port
//
	{
	
	theSerialPort->QueryReceiveBuffer();

	TCommConfig cBuf;
	TCommConfigV01& c=cBuf();
	theSerialPort->Config(cBuf);
	
	c.iFifo=EFifoEnable;
	c.iDataBits=EData8;
	c.iStopBits=EStop1;
	c.iParity=EParityNone;
	c.iRate=EBps115200;
	c.iHandshake=0;

	TInt r=theSerialPort->SetConfig(cBuf);
	return (r);
	}

LOCAL_C TInt TestPower()	
	{	
	
	User::After(1000000);	// Allow 1 second before power down
	RTimer timer;
	TRequestStatus done;
	timer.CreateLocal();
	TTime wakeup;
	wakeup.HomeTime();
	wakeup+=TTimeIntervalSeconds(10);
	timer.At(done,wakeup);
	UserHal::SwitchOff();
	User::WaitForRequest(done);
	return (done.Int());
	}
	
GLDEF_C TInt E32Main()
    {

//	test.SetLogged(EFalse); 	// Turn off serial port debugging!

	test.Title();
	test.Start(_L("Comms Soak Test"));

	TBuf <0x100> cmd;
	User::CommandLine(cmd);
	TInt port=0;
	if ((cmd.Length()>0) && (cmd[0]>='1' && cmd[0]<='4'))
		port=(TInt)(cmd[0]-'0');

	test.Next(_L("Load Ldd/Pdd"));
	TInt r;
    TBuf<10> pddName=PDD_NAME;
#if !defined (__WINS__)
	pddName[5]=(TText)('1'+port);
	TInt muid=0;
	if (HAL::Get(HAL::EMachineUid, muid)==KErrNone)
		{
		// Brutus uses EUART4 for both COM3 and COM4
		if (muid==HAL::EMachineUid_Brutus && port==4)
			pddName[5]=(TText)'4';
		}
#endif
	r=User::LoadPhysicalDevice(pddName);
	test.Printf(_L("Load %S returned %d\n\r"),&pddName,r);
	test(r==KErrNone || r==KErrAlreadyExists);

	r=User::LoadLogicalDevice(LDD_NAME);
	test.Printf(_L("Load LDD returned %d\n\r"),r);
	test(r==KErrNone || r==KErrAlreadyExists);

	theSerialPort=new RComm;
	test(theSerialPort!=NULL);

	//	Set up the serial port
	theSerialPort->Open(port);
	r=SetUp();
	test(r==KErrNone);
	
	MediaChangeTestingEnabled=EFalse;
	test.Printf(_L("\r\nThis test requires a loopback conector on the Serial Port\r\n"));
	test.Printf(_L("<<Hit M for media change testing>>\r\n"));
	test.Printf(_L("<<Any other key for power testing>>\r\n"));
	TChar c=(TUint)test.Getch();
	c.UpperCase();
	if (c=='M')
		MediaChangeTestingEnabled=ETrue;

	//	Continuous Test
	TInt cycles=0;
	TResult results;
	
	TRequestStatus stat;
	test.Console()->Read(stat);
	
	while (stat==KRequestPending)
		{
		// Calculate the amount of free memory
		TMemoryInfoV1Buf membuf;
    	UserHal::MemoryInfo(membuf);
    	TMemoryInfoV1 &memoryInfo=membuf();
		results.SetFreeMem(memoryInfo.iFreeRamInBytes);
	
		if (MediaChangeTestingEnabled)
			{
			// Media Change Test (if enabled) then SetUp Serial Port and test we can still read/write
//			UserSvr::ForceRemountMedia(ERemovableMedia0); // Generate media change
//			User::After(1000000);	// Allow 1 second after power down
			}
		else
			{
			// Power Down then test we can still read/write
			r=TestPower();			
			results.Add(TResult::ETestPower,r);
			}
		r=TestSimpleWriting();
		results.Add(TResult::ESimpleWriting,r);

		//	Display the results of the test cycle
		cycles++;
		results.Display(test.Console(),cycles);
		}  

	User::WaitForRequest(stat);
	theSerialPort->Close();
	test.End();

	return(KErrNone);
	}
