--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/kerneltest/e32test/device/t_commsk.cpp	Mon Oct 19 15:55:17 2009 +0100
@@ -0,0 +1,451 @@
+// 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);
+	}