// Copyright (c) 1996-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:
// Performs some benchmarking of the LFFS media driver
// 
//

/**
 @file bf_raw.cpp
*/

#include <e32std.h>
#include <e32std_private.h>
#include <e32base.h>
#include <e32base_private.h>
#include <e32test.h>
#include <e32svr.h>
#include "bf_raw.h"
#include "user_config.h"

const TInt KAverageOverInSeconds=10;	///< Number of seconds to run tests for

//TInt64 Count;				///< Global variable used to count number of operations completed
TUint32 Count;

RTest test(_L("BF_RAW"));


TTestInfo	TestInfo;		///< Data passed to exector thread

TBusLocalDrive	drive;
TLocalDriveCapsV2Buf driveInfo;

GLDEF_D	HBufC8*	writeBuffer;	///< Buffer for transferring data
GLDEF_D	HBufC8*	readBuffer;		///< Buffer for transferring data

GLDEF_D TBool StopTest;		///< set to ETrue to stop the test


GLREF_C TInt BmWrite(TAny*);
GLREF_C TInt BmWriteThread(TAny*);
GLREF_C TInt BmRead(TAny*);
GLREF_C TInt BmReadThread(TAny*);

GLDEF_D TInt	mainThreadHandle;

TUint32 runTest(TThreadFunction aFunction)
    /**
	 * Function which actually runs the test.
	 *
	 * It creates a new thread to exeute the operations and then waits
	 * for a pre-determined time. The executor thread increments a counter
	 * each time it completes one operation. After the time period expires
	 * the counter is averaged to get an "operations per second". This is
	 * then multiplied by the data size to obtain tranfer rate
	 */
	{

    RThread thread;
	TInt r=thread.Create(_L("TESTER"),aFunction,KDefaultStackSize,&User::Heap(),NULL);
	if(r!=KErrNone)
		{
		test.Printf(_L("Failed to create thread with error %d\n"),r);
		return(r);
		}
	StopTest = EFalse;	// allow the test to run
    TRequestStatus deadStat;
	thread.Logon( deadStat );

	RThread().SetPriority( EPriorityMuchMore );

	thread.Resume();
    User::After(1000000);
    Count=0;
    User::After(KAverageOverInSeconds*1000000);
    TUint32 result=Count;
	
	// tell test to stop and wait for thread to exit.
	StopTest = ETrue;
	User::WaitForRequest( deadStat );
	
	CLOSE_AND_WAIT(thread);
    return(result);
    }

void PrintResult( TUint32 aCount, const TDesC& aTitle )
	/**
	 * Prints result of test
	 */
	{
	TInt64 count(static_cast<TUint>(aCount));
	TInt64 transferRate = (count * TestInfo.iLength) / KAverageOverInSeconds;

    test.Printf(_L("%S: %d bytes/second\n"),
					&aTitle,
					I64LOW(transferRate) );
	}


LOCAL_C TInt EraseSegment( TInt aSegmentNumber )
	/**
	 * Erases a segment on Flash
	 *
	 * @param aSegmentNumber index of segment to erase
	 * @return KErrNone or error code
	 */
	{
	TInt offset = aSegmentNumber * driveInfo().iEraseBlockSize;
	
	TInt r = drive.Format( offset, driveInfo().iEraseBlockSize );
	return  r;
	}


/**
 * Structure defining tests
 */
class TTestData
	{
	public:
		TThreadFunction		iFunction;	///< function to execute, NULL for end of list
		TInt				iLength;	///< data length
		TInt				iOffset;	///< Flash offset
		const TDesC*				iDescription;	///< descriptive text
	};


_LIT( KErasingSegment0, "Erasing segment 0" );

_LIT( KWrite1Start, "Write, 1 byte, 32-byte boundary, current thread" );
_LIT( KWrite24Start, "Write, 24 bytes, 32-byte boundary, current thread" );
_LIT( KWrite64Start, "Write, 64 bytes, 32-byte boundary, current thread" );
_LIT( KWrite512Start, "Write, 512 bytes, 32-byte boundary, current thread" );

_LIT( KRead1Start, "Read, 1 byte, 32-byte boundary, current thread" );
_LIT( KRead24Start, "Read, 24 bytes, 32-byte boundary, current thread" );
_LIT( KRead64Start, "Read, 64 bytes, 32-byte boundary, current thread" );
_LIT( KRead512Start, "Read, 512 bytes, 32-byte boundary, current thread" );

const TThreadFunction KEraseSegment = (TThreadFunction)0x000000F1;

const TTestData testData[] =		///< the test data
	{
		{ KEraseSegment, 0, 0, &KErasingSegment0 },

		{ BmWrite, 1, 0, &KWrite1Start },
		{ BmWrite, 24, 32, &KWrite24Start },
		{ BmWrite, 64, 64, &KWrite64Start },
		{ BmWrite, 512, 128, &KWrite512Start },

		{ BmRead, 1, 0, &KRead1Start },
		{ BmRead, 24, 0, &KRead24Start },
		{ BmRead, 64, 0, &KRead64Start },
		{ BmRead, 512, 0, &KRead512Start },

		{ NULL, 0, 0, NULL }
	};



void Initialize()
	/**
	 * Open channel to media driver
	 */
	{
	//
	// Load the media driver
	//
#ifndef SKIP_PDD_LOAD
	test.Printf( _L("Loading %S\n"), &KLfsDriverName );
	TInt r = User::LoadPhysicalDevice( KLfsDriverName );
	test( KErrNone == r || KErrAlreadyExists == r );
#endif

#ifdef UNMOUNT_DRIVE
	RFs fs;
	test( KErrNone == fs.Connect() );
#if 0
	// XXX - not EKA2
	test( KErrNone == fs.SetDefaultPath( _L("Z:\\") ) );
#endif
	TFullName name;
	fs.FileSystemName( name, KLffsLogicalDriveNumber );
	if( name.Length() > 0 )
		{
		test.Printf( _L("Unmounting drive") );
		test( KErrNone == fs.DismountFileSystem( _L("Lffs"), KLffsLogicalDriveNumber) );
		User::After( 2000000 );
		test.Printf( _L("Drive unmounted") );
		}
	fs.Close();
#endif

	//
	// Open a TBusLogicalDevice to it
	//
	test.Printf( _L("Opening media channel\n") );
	TBool changedFlag = EFalse;
	test( KErrNone == drive.Connect( KDriveNumber, changedFlag ) );
	
	//
	// Get size of Flash drive, block size, block count
	//
    drive.Caps(driveInfo);

	//
	// Create data buffer
	//
	writeBuffer = HBufC8::New( 1024 );
	test( NULL != writeBuffer );
	writeBuffer->Des().FillZ(1024);

	readBuffer = HBufC8::New( 1024 );
	test( NULL != readBuffer );
	readBuffer->Des().FillZ(1024);

	mainThreadHandle = RThread().Handle();
	}



TInt E32Main()
    {

    test.Title();
    test.Start(_L("Benchmarks for media driver"));

	Initialize();

	const TTestData* pTest = &testData[0];
	while( pTest->iFunction )
		{
		if( KEraseSegment == pTest->iFunction )
			{
			test.Printf( *pTest->iDescription );
			TInt r = EraseSegment( pTest->iOffset );
			test( KErrNone == r );
			test.Printf( _L("Segment erased") );
			}
		else
			{
			TestInfo.iLength = pTest->iLength;
			TestInfo.iOffset = pTest->iOffset;
			PrintResult( runTest( pTest->iFunction ), *pTest->iDescription );
			}
		++pTest;
		}

	drive.Disconnect();
    test.End();
	return(KErrNone);
    }