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