// Copyright (c) 1996-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\pccd\t_atadr3.cpp

// Test the Compact Flash card (ATA) media driver

// 

//

#include <e32test.h>

#include <e32svr.h>

#include <e32hal.h>

#include "u32std.h"

#include "../misc/prbs.h"

//#define __USE_MUTEX__

//#define __DISABLE_KILLER__

#define SYSTEM	ETrue

const TInt KErrVerify=-100;

const TInt KSectorSize=512;

const TInt KSectorShift=9;

const TInt KVerifyBlockSize=8;	// in sectors

LOCAL_D TBusLocalDrive WriterDrive;

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

LOCAL_D TInt DriveNumber;

LOCAL_D TInt DriveSizeInSectors;

LOCAL_D RThread TheWriterThread;

LOCAL_D RThread TheKillerThread;

LOCAL_D RSemaphore Sem;

LOCAL_D TInt CurrentSector=0;

LOCAL_D TInt MediaChanges=0;

LOCAL_D TInt PowerDowns=0;

LOCAL_D TInt Kills=0;

LOCAL_D TInt SectorsWritten=0;

LOCAL_D TInt Aborts=0;

LOCAL_D TUint WritePattern=0;

#ifdef __USE_MUTEX__

LOCAL_D RMutex Mutex;

#define WAIT		Mutex.Wait()

#define SIGNAL		Mutex.Signal()

#else

#define WAIT

#define SIGNAL

#endif

inline TUint RoundDownToSector(TUint aPos)

	{ return aPos&~0x1ff; }

inline TUint RoundUpToSector(TUint aPos)

	{ return (aPos+0x1ff)&~0x1ff; }

LOCAL_C TInt WriteSectors(TBusLocalDrive& aDrive, TInt aSector, TInt aCount, TUint8* aBuf)

	{

	WAIT;

	TInt r=KErrNotReady;

	TInt pos=aSector<<KSectorShift;

	TPtrC8 p(aBuf,aCount*KSectorSize);

	while (r==KErrNotReady || (r==KErrAbort && (++Aborts,1)))

		r=aDrive.Write(pos,p);

	SIGNAL;

	return r;

	}

LOCAL_C TInt ReadSectors(TBusLocalDrive& aDrive, TInt aSector, TInt aCount, TUint8* aBuf)

	{

	WAIT;

	TInt r=KErrNotReady;

	TInt pos=aSector<<KSectorShift;

	TInt len=aCount*KSectorSize;

	TPtr8 p(aBuf,0,len);

	while (r==KErrNotReady || r==KErrAbort)

		r=aDrive.Read(pos,len,p);

	if (r==KErrNone && p.Length()!=len)

		r=KErrUnderflow;

	SIGNAL;

	return r;

	}

LOCAL_C void GenerateTestPattern(TInt aSector, TUint aState, TUint8* aBuf)

	{

	TUint seed[2];

	seed[1]=0;

	seed[0]=TUint(aSector)^(aState<<16);

	*aBuf++=TUint8(aState&0xff);

	*aBuf++=TUint8((aState>>8)&0xff);

	TInt i;

	for (i=0; i<KSectorSize-2; i++)

		*aBuf++=TUint8(Random(seed));

	}

LOCAL_C void Write(TBusLocalDrive& aDrive, TInt aSector, TInt aCount, TUint8* aBuf)

	{

	TInt n;

	for (n=0; n<aCount; n++)

		GenerateTestPattern(aSector+n,WritePattern,aBuf+n*KSectorSize);

	TInt r=WriteSectors(aDrive,aSector,aCount,aBuf);

	if (r!=KErrNone)

		User::Panic(_L("WRITE"),r);

	}

LOCAL_C void Write(TBusLocalDrive& aDrive, TInt aSector, TInt aCount)

	{

	const TInt KMaxLen = KSectorSize * 8;

	TInt len=aCount*KSectorSize;

	test (len <= KMaxLen);

	TUint8 buf[KMaxLen];

	Write(aDrive,aSector,aCount,buf);

	}

LOCAL_C TInt Verify(TInt aSector, TInt aCount, TUint8* aBuf)

	{

	TUint32 buf[KSectorSize/4];

	TUint8* pB=(TUint8*)buf;

	while(aCount--)

		{

		TUint state=aBuf[0]|(aBuf[1]<<8);

		GenerateTestPattern(aSector,state,pB);

		if (Mem::Compare(aBuf,KSectorSize,pB,KSectorSize)!=0)

			return KErrVerify;

		++aSector;

		aBuf+=KSectorSize;

		}

	return KErrNone;

	}

LOCAL_C TInt Verify(TBusLocalDrive& aDrive, TInt aSector, TInt aCount)

	{

	const TInt KMaxLen = KSectorSize * 8;

	TInt len=aCount*KSectorSize;

	test (len <= KMaxLen);

	TUint8 buf[KMaxLen];

	TInt r=ReadSectors(aDrive,aSector,aCount,buf);

	if (r!=KErrNone)

		return r;

	return Verify(aSector,aCount,buf);

	}

LOCAL_C TInt WriterThread(TAny*)

	{

/* 

 * SetSystem() API was removed by __SECURE_API__	

 *	"Systemize" will be implemented later calling a LDD which will set thread's "system" flag

	RThread().SetSystem(SYSTEM);

 */

	TUint seed[2];

	seed[0]=User::NTickCount();

	seed[1]=0;

	TUint32 buf[8*KSectorSize/4];

	TUint8* pB=(TUint8*)buf;

	TBool medChg=EFalse;

	WriterDrive.Close();	// close handle from previous incarnation of this thread

	TInt r=WriterDrive.Connect(DriveNumber,medChg);

	if (r!=KErrNone)

		User::Panic(_L("WRITER-CONNECT"),r);

	FOREVER

		{

		TInt remain=DriveSizeInSectors-CurrentSector;

		TInt n=Random(seed)&15;

		if (n>8 || n==0)

			n=1;

		if (n>remain)

			n=remain;

		if (n==1)

			{

			Write(WriterDrive,CurrentSector,1,pB);

			++WritePattern;

			Write(WriterDrive,CurrentSector,1,pB+KSectorSize);

			SectorsWritten+=2;

			}

		else

			{

			Write(WriterDrive,CurrentSector,n,pB);

			SectorsWritten+=n;

			}

		CurrentSector+=n;

		if (CurrentSector==DriveSizeInSectors)

			{

			CurrentSector=0;

			++WritePattern;

			}

		}

	}

LOCAL_C TInt KillerThread(TAny*)

	{

/* 

 * SetSystem() API was removed by __SECURE_API__	

 *	"Systemize" will be implemented later calling a LDD which will set thread's "system" flag

 	RThread().SetSystem(SYSTEM);

 */

	TUint seed[2];

	seed[0]=0xadf85458;

	seed[1]=0;

	TBusLocalDrive drive;

	TBool medChg=EFalse;

	TInt r=drive.Connect(DriveNumber,medChg);

	if (r!=KErrNone)

		User::Panic(_L("KILLER-CONNECT"),r);

	RTimer timer;

	r=timer.CreateLocal();

	if (r!=KErrNone)

		User::Panic(_L("KILLER-TIMER"),r);

	TInt action=0;

	FOREVER

		{

		TUint x=Random(seed);

		TUint ms=1000+(x&4095);

		User::AfterHighRes(ms*1000);

		switch (action)

			{

			case 0:

#ifndef __DISABLE_KILLER__

				drive.ForceMediaChange();

#endif

				++MediaChanges;

				break;

			case 1:

				{

#ifndef __DISABLE_KILLER__

				TTime now;

				now.HomeTime();

				now+=TTimeIntervalSeconds(2);

				TRequestStatus s;

				timer.At(s,now);

				UserHal::SwitchOff();

				User::WaitForRequest(s);

				++PowerDowns;

#endif

				break;

				}

			case 2:

#ifndef __DISABLE_KILLER__

				TheWriterThread.Kill(0);

#endif

				++Kills;

#ifndef __DISABLE_KILLER__

				++WritePattern;

				Sem.Wait();

				TheWriterThread.SetPriority(EPriorityNormal);

#endif

				break;

			case 3:

#ifndef __DISABLE_KILLER__

				drive.ForceMediaChange();

#endif

				++MediaChanges;

#ifndef __DISABLE_KILLER__

				x=Random(seed);

				ms=50+(x&511);

				User::AfterHighRes(ms*1000);

				TheWriterThread.Kill(0);

#endif

				++Kills;

#ifndef __DISABLE_KILLER__

				++WritePattern;

				Sem.Wait();

				TheWriterThread.SetPriority(EPriorityNormal);

#endif

				break;

			case 4:

				break;

			}

		if (++action==5)

			action=0;

#ifndef __DISABLE_KILLER__

		TInt curr=CurrentSector;

		TInt remain=DriveSizeInSectors-curr;

		TInt n=(remain<8)?remain:8;

		r=Verify(drive,curr,n);

		if (r!=KErrNone)

			User::Panic(_L("VERIFY"),r);

#endif

		}

	}

LOCAL_C TInt CreateKillerThread()

	{

	TInt r=TheKillerThread.Create(_L("Killer"),KillerThread,0x2000,NULL,NULL);

	if (r!=KErrNone)

		return r;

	TheKillerThread.SetPriority(EPriorityMore);

	TheKillerThread.Resume();

	return KErrNone;

	}

LOCAL_C TInt CreateWriterThread()

	{

	FOREVER

		{

		TInt r=TheWriterThread.Create(_L("Writer"),WriterThread,0x2000,NULL,NULL);

		if (r==KErrNone)

			break;

		if (r!=KErrAlreadyExists)

			return r;

		test.Printf(_L("Writer thread still exists\n"));

		User::After(200000);

		}

	TheWriterThread.SetPriority(EPriorityLess);

	TheWriterThread.Resume();

	return KErrNone;

	}

GLDEF_C TInt E32Main()

	{

/* 

 * SetSystem() API was removed by __SECURE_API__	

 *	"Systemize" will be implemented later calling a LDD which will set thread's "system" flag

	RThread().SetSystem(SYSTEM);

 */

	WriterDrive.SetHandle(0);

	test.Title();

	TInt drv=-1;

	while (drv<0 || drv>=KMaxLocalDrives)

		{

		test.Printf(_L("\nSelect drive C-K: "));

		TChar c=(TUint)test.Getch();

		c.UpperCase();

		if (c.IsAlpha())

			drv=TUint(c)-'C';

		else

			drv=-1;

		}

	TBuf<1> b;

	b.SetLength(1);

	b[0]=(TText)(drv+'C');

	test.Printf(_L("%S\n"),&b);

	TBuf<80> buf=_L("Connect to drive ");

	buf+=b;

	test.Start(buf);

	TBusLocalDrive drive;

	TBool medChg=EFalse;

	TInt r=drive.Connect(drv,medChg);

	test(r==KErrNone);

	DriveNumber=drv;

	test.Next(_L("Get capabilities"));

	TLocalDriveCapsV2 driveCaps;

	TPckg<TLocalDriveCapsV2> capsPckg(driveCaps);

	r=drive.Caps(capsPckg);

	test(r==KErrNone);

	TUint driveSize=I64LOW(driveCaps.iSize);

	DriveSizeInSectors=(driveSize&~0xfff)>>KSectorShift;	// round down to multiple of 8 sectors

	test.Printf(_L("Drive size       = %08x (%dK)\n"),driveSize,driveSize>>10);

	test.Printf(_L("Media type       = %d\n"),driveCaps.iType);

	test.Printf(_L("Connection Bus   = %d\n"),driveCaps.iConnectionBusType);

	test.Printf(_L("Drive attributes = %08x\n"),driveCaps.iDriveAtt);

	test.Printf(_L("Media attributes = %08x\n"),driveCaps.iMediaAtt);

	test.Printf(_L("Base address     = %08x\n"),driveCaps.iBaseAddress);

	test.Printf(_L("File system ID   = %08x\n"),driveCaps.iFileSystemId);

	test.Printf(_L("Hidden sectors   = %08x\n"),driveCaps.iHiddenSectors);

	test.Printf(_L("Press any key...\n"));

	test.Getch();

#ifdef __USE_MUTEX__

	test.Next(_L("Create mutex"));

	r=Mutex.CreateLocal();

	test(r==KErrNone);

#endif

	test.Next(_L("Initialise drive"));

	TInt sector;

	for (sector=0; sector<DriveSizeInSectors; sector+=8)

		{

		Write(drive,sector,8);

		if ((sector&127)==0)

			test.Printf(_L("."));

		}

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

	test.Next(_L("Verify drive"));

	for (sector=0; sector<DriveSizeInSectors; sector+=8)

		{

		test(Verify(drive,sector,8)==KErrNone);

		if ((sector&127)==0)

			test.Printf(_L("."));

		}

	test.Printf(_L("\n\nPress ENTER to continue..."));

	TKeyCode k=EKeyNull;

	while (k!=EKeyEnter)

		k=test.Getch();

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

	test.Next(_L("Create semaphore"));

	r=Sem.CreateLocal(0);

	test(r==KErrNone);

	test.Next(_L("Create writer thread"));

	r=CreateWriterThread();

	test(r==KErrNone);

	TheWriterThread.SetPriority(EPriorityNormal);

	test.Next(_L("Create killer thread"));

	r=CreateKillerThread();

	test(r==KErrNone);

	TBool exit=EFalse;

	sector=0;

	TInt verifies=0;

	TInt fails=0;

	while (!exit)

		{

		r=Verify(drive,sector,KVerifyBlockSize);

		if (r!=KErrNone)

			{

			++fails;

			test.Printf(_L("Sector %d Fail %d\n"),sector,r);

			}

		else

			++verifies;

		sector+=KVerifyBlockSize;

		if (sector==DriveSizeInSectors)

			{

			sector=0;

			test.Printf(_L("W %d VER %d FAIL %d MC %d PD %d K %d A %d\n"),SectorsWritten,verifies,fails,MediaChanges,PowerDowns,Kills,Aborts);

			}

		if ((sector&63)==0)

			{

			if (TheKillerThread.ExitType()!=EExitPending)

				{

				const TDesC& cat=TheKillerThread.ExitCategory();

				test.Printf(_L("KillerThread exited %d,%d,%S\n"),TheKillerThread.ExitType(),

														TheKillerThread.ExitReason(),&cat);

				break;

				}

			TExitType xt=TheWriterThread.ExitType();

			if (xt==EExitPanic)

				{

				const TDesC& cat=TheWriterThread.ExitCategory();

				test.Printf(_L("WriterThread Panic %S %d\n"),&cat,TheWriterThread.ExitReason());

				break;

				}

			if (xt!=EExitPending)

				{

				// restart writer thread

				TheWriterThread.Close();

				r=CreateWriterThread();

				if (r!=KErrNone)

					{

					test.Printf(_L("Restart writer thread failed %d\n"),r);

					break;

					}

				Sem.Signal();

				}

			}

		}

	buf=_L("Disconnect from drive ");

	buf+=b;

	test.Next(buf);

	drive.Disconnect();

	test.End();

	return 0;

	}