// Copyright (c) 2005-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\lffs\t_lfsdrvbm.cpp
// 
//

#include <e32test.h>
#include <e32svr.h>
#include <e32hal.h>
#include <e32uid.h>
#include "../misc/prbs.h"


LOCAL_D TBuf<16384> DataBuf;
LOCAL_D	TBusLocalDrive TheDrive;
LOCAL_D TBool ChangedFlag;

const TInt KBufferSize=4096;
const TInt KBigBufferSize=4096*4;
TUint8 Buffer[KBigBufferSize];


#define LFFS_PDD_NAME _L("MEDLFS")


RTest test(_L("LFFS Driver BenchMark Test"));

LOCAL_C void DoRead(TInt aReadBlockSize)
//
// Do Read benchmark
//
	{
    TInt msgHandle = KLocalMessageHandle;
	TLocalDriveCapsV7 info;
	TPckg<TLocalDriveCapsV7> capsPckg(info);
  	TheDrive.Caps(capsPckg);
	TInt maxSize;
	maxSize=I64LOW(info.iSize);
	TInt count,pos,err;
	count=pos=err=0;

	RTimer timer;
	timer.CreateLocal();
	TRequestStatus reqStat;
	timer.After(reqStat,10000000); // After 10 secs
	while(reqStat==KRequestPending)
		{
		if (TheDrive.Read(pos,aReadBlockSize,&DataBuf,msgHandle,0)==KErrNone)
			count++;
		else
			err++;
		pos+=aReadBlockSize;
		if (pos>=(maxSize-aReadBlockSize))
			pos=0;
		}
#if defined (__WINS__)
	test.Printf(_L("Read %d %d byte blocks in 10 secs\n"),count,aReadBlockSize);
#else
	TBuf<60> buf;
	TReal32 rate=((TReal32)(count*aReadBlockSize))/10240.0F;
	TRealFormat rf(10,2);
	buf.Format(_L("Read %d %d byte blocks in 10 secs ("),count,aReadBlockSize);
	buf.AppendNum(rate,rf);
	buf.Append(_L("Kb/s)\n"));
	test.Printf(buf);
#endif
	test.Printf(_L("Errors:%d\n"),err);
	}

LOCAL_C void DoWrite(TInt aWriteBlockSize)
//
// Do write benchmark
//
	{
	TLocalDriveCapsV7 info;
	TPckg<TLocalDriveCapsV7> capsPckg(info);
  	TheDrive.Caps(capsPckg);
	TInt maxSize;
	maxSize=I64LOW(info.iSize);
	TInt count,err;
	TUint pos;
	count=pos=err=0;

	// Erase the first 16 blocks to ensure write completes OK
	TUint32 EbSz=(TInt)info.iEraseBlockSize;
	TInt r=KErrNone;
	for (pos=0; pos<16*EbSz; pos+=EbSz)
		{
		TInt64 pos64 = MAKE_TINT64(0, pos);
		r=TheDrive.Format(pos64,EbSz);
		test(r==KErrNone);
		}

	pos=0;
	RTimer timer;
	timer.CreateLocal();
	TRequestStatus reqStat;
	TPtrC8 ptr(Buffer,aWriteBlockSize);
	timer.After(reqStat,10000000); // After 10 secs
	while(reqStat==KRequestPending)
		{
		TInt64 pos64 = MAKE_TINT64(0, pos);
		TInt r=TheDrive.Write(pos64,ptr);
		if (r==KErrNone)
			count++;
		else
			err++;
		pos+=aWriteBlockSize;
		if ((TInt)pos>=(maxSize-aWriteBlockSize))
			pos=0;
		}

#if defined (__WINS__)
	test.Printf(_L("Write %d %d byte blocks in 10 secs\n"),count,aWriteBlockSize);
#else
	TBuf<60> buf;
	TReal32 rate=((TReal32)(count*aWriteBlockSize))/10240.0F;
	TRealFormat rf(10,2);
	buf.Format(_L("Write %d %d byte blocks in 10 secs ("),count,aWriteBlockSize);
	buf.AppendNum(rate,rf);
	buf.Append(_L("Kb/s)\n"));
	test.Printf(buf);
#endif
	test.Printf(_L("Errors:%d\n"),err);
	}


GLDEF_C TInt E32Main()
    {
	TBuf<32> b;

	test.Title();
	TDriveInfoV1Buf diBuf;
	UserHal::DriveInfo(diBuf);
	TDriveInfoV1 &di=diBuf();
	TInt r;
	TInt drv;

	test.Printf(_L("DRIVES PRESENT  :%d\r\n"),di.iTotalSupportedDrives);
	test.Printf(_L("C:(1ST) DRIVE NAME  :%- 16S\r\n"),&di.iDriveName[0]);
	test.Printf(_L("D:(2ND) DRIVE NAME  :%- 16S\r\n"),&di.iDriveName[1]);
	test.Printf(_L("E:(3RD) DRIVE NAME  :%- 16S\r\n"),&di.iDriveName[2]);
	test.Printf(_L("F:(4TH) DRIVE NAME  :%- 16S\r\n"),&di.iDriveName[3]);
	test.Printf(_L("G:(5TH) DRIVE NAME  :%- 16S\r\n"),&di.iDriveName[4]);
	test.Printf(_L("H:(6TH) DRIVE NAME  :%- 16S\r\n"),&di.iDriveName[5]);
	test.Printf(_L("I:(7TH) DRIVE NAME  :%- 16S\r\n"),&di.iDriveName[6]);
	test.Printf(_L("J:(8TH) DRIVE NAME  :%- 16S\r\n"),&di.iDriveName[7]);
	test.Printf(_L("K:(9TH) DRIVE NAME  :%- 16S\r\n"),&di.iDriveName[8]);

	test.Printf(_L("Select Local Drive (C-%c):\r\n"),'C'+ 8);
	TChar c;
	FOREVER
		{
		c=(TUint)test.Getch();
		c.UpperCase();
		drv=((TUint)c)-'C';
		if (drv>=0&&drv<='C'+ 8)
			break;
		}

	r=User::LoadPhysicalDevice(LFFS_PDD_NAME);
	test(r==KErrNone || r==KErrAlreadyExists);


	b.Format(_L("Connect to drive %c:"),'C'+drv);
	test.Next(b);
	TheDrive.Connect(drv,ChangedFlag);

	TLocalDriveCapsV7 info;
	TPckg<TLocalDriveCapsV7> capsPckg(info);
  	TheDrive.Caps(capsPckg);

	test.Start(_L("Starting write tests\n"));

	// Full buffer write test - pre-load the buffer and write 
	TUint32* pB=(TUint32*)(Buffer);
	TUint32* pE=(TUint32*)(Buffer+KBufferSize);
	TUint seed[2];
	seed[0]=0xb17217f8;
	seed[1]=0;
	while (pB<pE)
		*pB++=Random(seed);

	pB=(TUint32*)(Buffer);
	if(info.iWriteBufferSize)
		DoWrite(info.iWriteBufferSize);

	// Erase test
	// Get the current time
	TInt64 zeroTime=MAKE_TINT64(0, 0);
	TTime TheTimer=TTime(zeroTime);

	// Invoke the erase sequuence

	// Report the time interval
	TInt64 currentTime=TheTimer.Int64();
test.Printf(_L("currentTime now = %d\n"),(TInt)currentTime);

currentTime=TheTimer.Int64();
test.Printf(_L("currentTime now = %d\n"),(TInt)currentTime);

currentTime=TheTimer.Int64();
test.Printf(_L("currentTime now = %d\n"),(TInt)currentTime);


	if ((info.iWriteBufferSize)<1024)
	/* 
	these tests would cause errors on M18 Intel Strataflash. this type
	of Strataflash operates in object and control mode. when writing 16
	byte blocks the first write puts puts each M18 1024 byte programming 
	region into control mode so that all susequent even numbered writes 
	succeed but all subsequent odd numbered writes fail (in control 
	mode writes to bytes 16 - 31, 48 - 63 aren't allowed). successes match
	failures. when writing 256 byte blocks only 1 in 4 writes succeeds -
	the first write in each programming region succeeds and puts the 
	region into object mode so that the subsequent three writes to the 
	same programming region fail (in object mode a programming region may
	only be written to once). when writing 512 byte blocks 1 in 2 writes 
	fail with the first write to each programming region succeeding and the 
	second failing. with 513 byte writes the analysis is slightly more 
	complex than with 512 byte writes but the failure rate of 1 in 2 still
	applies. 
	*/		
		{
		DoWrite(16);
		DoWrite(256);
		DoWrite(512);
		DoWrite(513); 
		}
	DoWrite(1024); 
	DoWrite(2048);
	DoWrite(16384);


	DoRead(16);
	DoRead(256);
	DoRead(512);
	DoRead(513);
	DoRead(2048);
	DoRead(16384);

   test.End();

	return(0);
	}
  
