// 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);

 	}