// Copyright (c) 2007-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_nandbm.cpp

// Test read/write performance for NAND drives accessed directly

// through the Local Media Sub-System

// When no command parameter is supplied search for first 

// writeable NAND drive that can be found

// If a drive number parameter in the range 0 - F is provided,

// interpret this as a local drive number in the range 0 - 15

// and test the drive if it is a writeable NAND drive

// Please note that local drive numbers at the Local Media Sub-System 

// level are not the same as drive numbers / drive letters at the 

// File Server level. File Server drive numbers / drive letters fall

// in the range 0 - 25 / a - z. The mapping between local drive numbers 

// and File Server drive numbers / drive letters is defined in 

// estart.txt or its equivalent 

// Use TBusLocalDrive directly and bypass the File Server

// Fill NAND user data drive with data prior to executing actual 

// performance tests. TBusLocalDrive should read from areas that have 

// been written to and are therefore assigned. Where areas are 

// unassigned, XSR FTL returns FFs without accessing the NAND flash 

// hardware. This type of behaviour generates misleadingly quick 

// performance figures

// Test various block sizes in the range 16 - 65536 bytes

// 

//

#include <e32test.h>

#include <f32fsys.h>

#include <e32hal.h>

#include <e32uid.h>

#include <f32dbg.h>

LOCAL_D TBuf<1048576> DataBuf;

LOCAL_D	TBusLocalDrive TheDrive;

LOCAL_D TBool ChangedFlag;

LOCAL_D RFs TheFs;

RTest test(_L("Local NAND Drive BenchMark Test"));

LOCAL_C void DoRead(TInt aReadBlockSize)

//

// Do Read benchmark

//

	{

    TInt msgHandle = KLocalMessageHandle;

	TLocalDriveCapsV2 info;

	TPckg<TLocalDriveCapsV2> infoPckg(info);

	TInt maxSize;

	TheDrive.Caps(infoPckg);

	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

//

	{

    TInt msgHandle = KLocalMessageHandle;

	TLocalDriveCapsV2 info;

	TPckg<TLocalDriveCapsV2> infoPckg(info);

	TInt maxSize;

	TheDrive.Caps(infoPckg);

	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.Write(pos,aWriteBlockSize,&DataBuf,msgHandle,0)==KErrNone)

			count++;

		else

			err++;

		pos+=aWriteBlockSize;

		if (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()

    {

	test.Title();

	TBuf<0x100> cmd;

	User::CommandLine(cmd);						// put command line into decriptor

	TLex lex(cmd);

	TPtrC param=lex.NextToken();				// point token at local drive number if any

	test.Printf(_L("Local Drive = %S\r\n"),&param);

	TChar localDrv;

	TInt localDrvNum;

	TBusLocalDrive drive;

	TBool changeFlag;

	TLocalDriveCapsV4 driveCaps;

	TPckg<TLocalDriveCapsV4> capsPckg(driveCaps);

	TInt r;

	if (param.Length()==0)

		{

		// locate writeable NAND drive

		for (localDrvNum=0; localDrvNum<KMaxLocalDrives; localDrvNum++)

			{

			r = drive.Connect(localDrvNum,changeFlag);

			if (r!=KErrNone)

				continue;

			r = drive.Caps(capsPckg);

  			drive.Disconnect();

			if ((r==KErrNone)

				&&(driveCaps.iType==EMediaNANDFlash)

				&&!(driveCaps.iMediaAtt&KMediaAttWriteProtected)

				&&(driveCaps.iPartitionType!=KPartitionTypeSymbianCrashLog))

			break;

			}

		if (localDrvNum==16)

			{

			test.Printf(_L("Suitable drive could not be found\r\n"));

			test.Printf(_L("Writeable NAND drive required for test\r\n"));

			return(KErrGeneral);

			}

		}

	else

		{

		// is selected local drive number in the range 0-15

		localDrv=param[0];

		localDrv.UpperCase();

		if (localDrv>='0'&&localDrv<='9')

			{

			localDrvNum=((TInt)localDrv-'0');

			}

		else if (localDrv>='A'&&localDrv<='F')

			{

			localDrvNum=((TInt)localDrv-'A'+10);

			}

		else

			{

			test.Printf(_L("Commandline %S invalid\r\n"), &cmd);

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

			test.Printf(_L("t_nandbm with no arguments, test first suitable NAND drive \r\n"));

			test.Printf(_L("t_nandbm x, where x = 0-F test local drive number 0-15\r\n"));

			return(KErrGeneral);

			}

		// is selected drive suitable for test

		r = drive.Connect(localDrvNum,changeFlag);

		if(r!=KErrNone)

			{

			test.Printf(_L("Can't connect to drive %d\r\n"), localDrvNum);

			return(KErrGeneral);

			}

		r = drive.Caps(capsPckg);

		if(r!=KErrNone)

			{

			test.Printf(_L("Drive %d caps method error\r\n"), localDrvNum);

			return(KErrGeneral);

			}

 		drive.Disconnect();

		if ((driveCaps.iType!=EMediaNANDFlash)

			||(driveCaps.iMediaAtt&KMediaAttWriteProtected)

			||(driveCaps.iPartitionType==KPartitionTypeSymbianCrashLog))

			{

			test.Printf(_L("Drive %d has unsuitable capabilities\r\n"), localDrvNum);

			test.Printf(_L("Writeable NAND drive required for test\r\n"));

			return(KErrGeneral);

			}

		}

	// Fill the nand user data drive with data so TBusLocalDrive reads 

	// from areas that have been written to and are therefore assigned.

	// Where areas are unassigned, XSR FTL returns FFs without accessing 

	// the NAND flash hardware. This type of behaviour generates misleadingly 

	// quick performance figures.

	TInt writesize=1048576;

	TInt pos = 0;

	TInt msgHandle = KLocalMessageHandle;

	TheDrive.Connect(localDrvNum,ChangedFlag);

	test.Printf( _L("Fill up NAND drive %d\r\n"),localDrvNum);

	while(writesize>=1)

		{

		test.Printf( _L("%d byte write to pos %d of NAND drive\r\n"),writesize,pos);

		if (TheDrive.Write(pos,writesize,&DataBuf,msgHandle,0)!=KErrNone)

			{

			writesize/=16;

			}

		else

			{

			pos += writesize;

			}

		}

	test.Start(_L("Start Benchmarking ..."));

	DoRead(16);

	DoRead(256);

	DoRead(512);

	DoRead(513);

	DoRead(2048);

	DoRead(4096);

	DoRead(16384);

	DoRead(32768);

	DoRead(65536);

	DoWrite(16);

	DoWrite(256);

	DoWrite(512);

	DoWrite(513); 

	DoWrite(2048);

	DoWrite(4096);

	DoWrite(16384);

	DoWrite(32768);

	DoWrite(65536);

	test.End();

	TheFs.Close();

	return(KErrNone);

	}