// Copyright (c) 1998-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_pccdsr.cpp

// Stress test a single sector of Compact Flash card (ATA).

// 

//

//#define USE_F32_ACCESS

#include <e32test.h>

#include <e32svr.h>

#include <e32hal.h>

#include <e32uid.h>

#if defined (USE_F32_ACCESS)

#include <f32fsys.h>

#include <f32file.h>

#endif

#define ATA_PDD_NAME _L("MEDATA")

const TInt KAtaSectorSize=512;

const TInt KMaxSectors=8;

const TInt KMaxRdWrBufLen=(KAtaSectorSize*KMaxSectors); // 4K

const TInt KHeapSize=0x4000;

const TInt KMaxErr=8;

#if defined (USE_F32_ACCESS)

GLDEF_D	RFs TheFs;

#else

LOCAL_D	TBusLocalDrive TheDrive;

LOCAL_D TBool ChangedFlag;

#endif

RTest test(_L("Local Drive Stress test"));

LOCAL_D TBuf8<KMaxRdWrBufLen> wrBufPat1,wrBufPat2,rdBuf;

enum TOper {ENone,EWrite,ERead,ECompare};

class TErrInfo

	{

public:

	TErrInfo();

public:

	TInt iError;

	TOper iOperation;

	TInt iCycle;

	};

class TResult

	{

public:

	TResult();

	void Display(CConsoleBase *aConsole, TInt aCycles);

	void Add(TInt anError,TOper anOperation,TInt aCycle);

public:

	TInt iTotalErrs;

	TErrInfo iFirstErr;

	TErrInfo iLastErrs[KMaxErr];

	TInt iNextFreeErr;

	TBool iHadAnError;

	};

LOCAL_C TUint OperationToChar(TOper anOperation)

//

// Convert operation enum to corresponding display character

//

	{

	switch(anOperation)

		{

		case EWrite:

			return('W');

		case ERead:

			return('R');

		case ECompare:

			return('C');

		default:

			return('?');

		}

	}

TErrInfo::TErrInfo()

//

// Constructor

//

	{

	iError=KErrNone;

	iOperation=ENone;

	iCycle=0;

	}

TResult::TResult()

//

// Constructor

//

	{

	iNextFreeErr=0;

	iTotalErrs=0;

	iHadAnError=EFalse;

	}

void TResult::Display(CConsoleBase *aConsole, TInt aCycles)

//

// Display test results

//

	{

	TInt xStartPos=0;

	TInt yStartPos=7;

	aConsole->SetPos(xStartPos,yStartPos);

	test.Printf(_L("CYCLES-> %07d   ERRORS-> %d"),aCycles,iTotalErrs);

	aConsole->SetPos(xStartPos,yStartPos+1);

	test.Printf(_L("FIRST ERROR-> "));

	if (iHadAnError)

		test.Printf(_L("Error:%d Oper:%c Cycle:%07d"),iFirstErr.iError,OperationToChar(iFirstErr.iOperation),iFirstErr.iCycle);

	aConsole->SetPos(xStartPos,yStartPos+2);

	test.Printf(_L("LAST ERRORS->"));

	if (iHadAnError)

		{

		TInt i;

		aConsole->SetPos(xStartPos+3,yStartPos+3);

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

		for (i=0;(i<KMaxErr && iLastErrs[i].iOperation!=ENone);i++)

			test.Printf(_L("% 7d,"),iLastErrs[i].iError);

		aConsole->SetPos(xStartPos+3,yStartPos+4);

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

		for (i=0;(i<KMaxErr && iLastErrs[i].iOperation!=ENone);i++)

			test.Printf(_L("      %c,"),OperationToChar(iLastErrs[i].iOperation));

		aConsole->SetPos(xStartPos+3,yStartPos+5);

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

		for (i=0;(i<KMaxErr && iLastErrs[i].iOperation!=ENone);i++)

			test.Printf(_L("% 7d,"),iLastErrs[i].iCycle);

		}

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

	}

void TResult::Add(TInt anError,TOper anOperation,TInt aCycle)

//

// Add a test result

//

	{

	iTotalErrs++;

	if (!iHadAnError)

		{

		iFirstErr.iError=anError;

		iFirstErr.iOperation=anOperation;

		iFirstErr.iCycle=aCycle;

		iHadAnError=ETrue;

		}

	if (iNextFreeErr>=KMaxErr)

		{

		for (TInt i=0;i<(KMaxErr-1);i++)

			iLastErrs[i]=iLastErrs[i+1];

		iNextFreeErr=(KMaxErr-1);

		}

	iLastErrs[iNextFreeErr].iError=anError;

	iLastErrs[iNextFreeErr].iOperation=anOperation;

	iLastErrs[iNextFreeErr].iCycle=aCycle;

	iNextFreeErr++;

	}

GLDEF_C TInt E32Main()

    {

	TBuf<64> b;

	test.Title();

	TDriveInfoV1Buf diBuf;

	UserHal::DriveInfo(diBuf);

	TDriveInfoV1 &di=diBuf();

	test.Printf(_L("Select Local Drive (C-%c): "),'C'+(di.iTotalSupportedDrives-1));

	TChar c;

	TInt drv;

	FOREVER

		{

		c=(TUint)test.Getch();

		c.UpperCase();

		drv=((TUint)c)-'C';

		if (drv>=0&&drv<di.iTotalSupportedDrives)

			break;

		}

	test.Printf(_L("%c:\r\n"),'C'+drv);

	TInt rdWrLen;

#if !defined (USE_F32_ACCESS)

	test.Printf(_L("Select total sectors to write(1-8): "));

	FOREVER

		{

		c=(TUint)test.Getch();

		rdWrLen=((TUint)c)-'0';

		if (rdWrLen>=1&&rdWrLen<=8)

			break;

		}

	test.Printf(_L("%dSector(s)\r\n"),rdWrLen);

	rdWrLen*=KAtaSectorSize;

#else

	rdWrLen=(KAtaSectorSize*2)+1;

#endif

	b.Format(_L("Init test on drive %c:"),'C'+drv);

	test.Start(b);

	TInt r;

#if defined (USE_F32_ACCESS)

	r=TheFs.Connect();

	test(r==KErrNone);

	RFile f;

	b.Format(_L("%c:\\TEMP.BIN"),'C'+drv);

	r=f.Replace(TheFs,b,EFileShareAny|EFileStream|EFileWrite);

	test(r==KErrNone);

	b.Format(_L("Start testing (%c:\\TEMP.BIN):"),'C'+drv);

#else

	r=User::LoadPhysicalDevice(ATA_PDD_NAME);

	test(r==KErrNone || r==KErrAlreadyExists);

	ChangedFlag=EFalse;

	TheDrive.Connect(drv,ChangedFlag);

	TLocalDriveCapsV2Buf info;

	test(TheDrive.Caps(info)==KErrNone);

	test(info().iType==EMediaHardDisk);

	TInt trgPos=I64LOW(info().iSize)-rdWrLen;	  // Hammer the very end of the disk

	b.Format(_L("Start testing (sector %xH):"),trgPos/KAtaSectorSize);

#endif

	test.Next(b);

	wrBufPat1.SetLength(rdWrLen);

	TInt j;

	for (j=0;j<rdWrLen;j++)

		wrBufPat1[j]=(TUint8)j;

	wrBufPat2.SetLength(rdWrLen);

	for (j=0;j<rdWrLen;j++)

		wrBufPat2[j]=(TUint8)((rdWrLen-1)-j);

	TInt cycles=0;

	TResult results;

	TBool toggleTest=EFalse;

	TRequestStatus kStat;

	test.Console()->Read(kStat);

	FOREVER

		{

		if ((cycles%10)==0)

			results.Display(test.Console(),cycles);

		TInt res;

#if defined (USE_F32_ACCESS)

		TInt len=(toggleTest)?rdWrLen:1;

		wrBufPat1.SetLength(len);

		if ((res=f.SetSize(len))==KErrNone)

			res=f.Write(0,wrBufPat1);		// Write test (Pos=0)

		if (res!=KErrNone)

			results.Add(res,EWrite,cycles);

		// Read test

		rdBuf.Fill(0,len);

		res=f.Read(0,rdBuf,len);

		if (res!=KErrNone)

			results.Add(res,ERead,cycles);

		if (rdBuf.Compare(wrBufPat1)!=0)

			results.Add(0,ECompare,cycles);

#else

		TDes8* wrBuf=(toggleTest)?&wrBufPat2:&wrBufPat1; // Change pattern written

		res=TheDrive.Write(trgPos,*wrBuf);	// Write test

		if (res!=KErrNone)

			results.Add(res,EWrite,cycles);

		rdBuf.Fill(0,rdWrLen);

		res=TheDrive.Read(trgPos,rdWrLen,rdBuf);	// Read test

		if (res!=KErrNone)

			results.Add(res,ERead,cycles);

		if (rdBuf.Compare(*wrBuf)!=0)

			results.Add(0,ECompare,cycles);

#endif

		cycles++;

		toggleTest^=0x01;

		if (kStat!=KRequestPending)

			{

			TKeyCode c=test.Console()->KeyCode();

			if (c==EKeySpace)

				break;

			test.Console()->Read(kStat);

			}

		}

	test.Next(_L("Close"));

#if defined (USE_F32_ACCESS)

	f.Close();

	TheFs.Close();

#else

	TheDrive.Disconnect();

#endif

	test.End();

	return(0);

	}