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

    }