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