// Copyright (c) 2003-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:

 // Tests erasing of Flash. Does not test suspending (see TF_SUSPEND)

 // 

 //

 #include <e32std.h>

 #include <e32std_private.h>

 #include <e32svr.h>

 #include <e32test.h>

 #include "randgen.h"

 #include "user_config.h"

 RTest test( _L("TF_ERASE") );

 class CEraseTest : public CBase

 	{

 	public:

 		~CEraseTest();

 		void CreateL();

 		void DoTest();

 	private:

 		void DoSimpleTest();

 		void DoSimpleTest2();

 		void DoPseudoRandomTest();

 		void DoRangeTest();

 		TInt EraseOneBlock( TInt aBlockNumber );

 		TInt ZeroFillBlock( TInt aBlockNumber );

 		TBool ValidateBlock( TInt aBlockNumber, TUint32 aFillWord );

 	private:

 		TBusLocalDrive	iDrive;

 		TBool			iDriveOpened;

 		TInt			iFlashSize;

 		TInt			iBlockSize;

 		TInt			iBlockCount;

 		TBuf8<512>		iReadBuffer;

 	};

 CEraseTest::~CEraseTest()

 	{

 	if( iDriveOpened )

 		{

 		iDrive.Disconnect();

 		}

 	}

 void CEraseTest::CreateL()

 	{

 	//

 	// Load the device drivers

 	//

 #ifndef SKIP_PDD_LOAD

 	test.Printf( _L("Loading %S\n"), &KLfsDriverName );

 	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 drive

 	//

 	test.Printf( _L("Opening media channel\n") );

 	static TBool changedFlag = EFalse;

 	User::LeaveIfError( iDrive.Connect( KDriveNumber, changedFlag ) );

 	iDriveOpened = ETrue;

 	//

 	// Get size of Flash drive, block size, block count

 	//

 	TLocalDriveCapsV2Buf info;

     iDrive.Caps(info);

 	iFlashSize = I64LOW(info().iSize);

 	iBlockSize = info().iEraseBlockSize;

 	iBlockCount = iFlashSize / iBlockSize;

 	test.Printf( _L("Flash size is 0x%x bytes\n"), iFlashSize );

 	test.Printf( _L("Block size is 0x%x bytes\n"), iBlockSize );

 	test.Printf( _L("Block count is %d\n"), iBlockCount );

 	test.Printf( _L("CreateL complete\n") );

 	}

 void CEraseTest::DoTest()

 	//

 	// Main test dispatcher

 	//

 	{

 	test.Next( _L("Starting tests...") );

 	DoSimpleTest();

 	DoSimpleTest2();

 	DoPseudoRandomTest();

 	DoRangeTest();

 	}

 TInt CEraseTest::EraseOneBlock( TInt aBlockNumber )

 	//

 	// Erases block aBlockNumber on Flash

 	//

 	{

 	TInt blockBaseOffset = aBlockNumber * iBlockSize;

 	test.Printf( _L("Erasing block %d (offs=0x%x)\n"), aBlockNumber, blockBaseOffset );

 	TInt r = iDrive.Format( blockBaseOffset, iBlockSize );

 	test.Printf( _L("... Format returned %d\n"), r );

 	return r;

 	}

 TBool CEraseTest::ValidateBlock( TInt aBlockNumber, TUint32 aFillWord )

 	//

 	// Checks that every word in block aBlockNumber has the value aFillWord

 	//

 	{

 	TUint offset = aBlockNumber * iBlockSize;

 	test.Printf( _L("Validating block %d (offs=0x%x)\n"), aBlockNumber, offset );

 	TBool failed = EFalse;

 	const TInt readBufLen = iReadBuffer.MaxLength();

 	for( TInt len = iBlockSize; len > 0 && !failed ;)

 		{

 		TInt r = iDrive.Read( offset, readBufLen, iReadBuffer );

 		if( r != KErrNone )

 			{

 			test.Printf( _L("... FAIL: read failed (%d) at offset 0x%x\n"), r, offset );

 			test( KErrNone == r );

 			}

 		test( iReadBuffer.Length() == readBufLen );

 		TUint32* p = (TUint32*)iReadBuffer.Ptr();

 		for( TInt i = 0; i < readBufLen; i += 4 )

 			{

 			if( aFillWord != *p )

 				{

 				failed = ETrue;

 				test.Printf( _L("... FAILED: word @ offs=0x%x, read=0x%x, expected=0x%x\n"), 

 								offset+i, p[0], aFillWord );

 				break;

 				}

 			++p;

 			}

 		offset += readBufLen;

 		len -= readBufLen;

 		}

 	return !failed;

 	}

 TInt CEraseTest::ZeroFillBlock( TInt aBlockNumber )

 	//

 	// Zero-fills an entire block

 	// The requires that writing works (so as a side-effect performs a

 	// very basic test of writing)

 	//

 	{

 	test.Printf( _L("Zero-filling block %d\n"), aBlockNumber );

 	//

 	// Create a buffer full of zeros

 	//

 	const TInt KZeroBufSize = 512;

 	TBuf8<KZeroBufSize> buf;

 	buf.FillZ( buf.MaxLength() );

 	//

 	// Write the data out to the Flash

 	//

 	TInt writeCount = iBlockSize / KZeroBufSize;

 	TInt r = KErrNone;

 	TInt blockBaseOffset = aBlockNumber * iBlockSize;

 	for( ; (writeCount > 0) && (KErrNone == r); writeCount-- )

 		{

 		r = iDrive.Write( blockBaseOffset, buf );

 		if( r != KErrNone )

 			{

 			test.Printf( _L("... FAIL: write failed (%d) at offset 0x%x\n"), r, blockBaseOffset );

 			}

 		blockBaseOffset += KZeroBufSize;

 		}

 	return r;

 	}

 void CEraseTest::DoSimpleTest()

 	//

 	// Simple erase test. This just zero-fills and then erases each block in turn

 	//

 	{

 	test.Next( _L("Simple test: erases each block in turn\n") );

 	for( TInt block = 0; block < iBlockCount; block++ )

 		{

 		test( KErrNone == ZeroFillBlock( block ) );

 		test( ValidateBlock( block, 0 ) );

 		test( KErrNone == EraseOneBlock( block ) );

 		test( ValidateBlock( block, 0xFFFFFFFF ) );

 		}

 	}

 void CEraseTest::DoSimpleTest2()

 	//

 	// Another simple erase test.

 	// This time we zero-fill all blocks first, then erase them all

 	//

 	{

 	test.Next( _L("Simple test2 : zero-fills whole Flash, then erases all blocks\n") );

 	for( TInt block = 0; block < iBlockCount; block++ )

 		{

 		test( KErrNone == ZeroFillBlock( block ) );

 		test( ValidateBlock( block, 0 ) );

 		}

 	for( TInt block = 0; block < iBlockCount; block++ )

 		{

 		test( KErrNone == EraseOneBlock( block ) );

 		test( ValidateBlock( block, 0xFFFFFFFF ) );

 		}

 	}

 void CEraseTest::DoPseudoRandomTest()

 	//

 	// Erases the blocks in pseudo-random order, zero-filling first

 	//

 	{

 	test.Next( _L("Test random erase order\n") );

 	TRandomGenerator random;

 #if 0

 	random.SetSeed( TInt64(0x1020466E, 0x3F9C0C00) );

 #else

 	random.SetSeed( 0x1020466E );

 #endif

 	for( TInt count = 0; count < 50; count++ )

 		{

 		TUint block = random.Next() % iBlockCount;

 		test( KErrNone == ZeroFillBlock( block ) );

 		test( ValidateBlock( block, 0 ) );

 		test( KErrNone == EraseOneBlock( block ) );

 		test( ValidateBlock( block, 0xFFFFFFFF ) );

 		}

 	}

 void CEraseTest::DoRangeTest()

 	//

 	// Simple erase test. This just zero-fills and then erases each block in turn

 	//

 	{

 	test.Next( _L("Range test: check that erase only affects erased block\n") );

 	//

 	// Pre-fill all blocks with zero

 	//

 	test.Printf( _L("Pre-zeroing blocks\n") );

 	for( TInt block = 0; block < iBlockCount; block++ )

 		{

 		test( KErrNone == ZeroFillBlock( block ) );

 		test( ValidateBlock( block, 0 ) );

 		}

 	//

 	// The test is to erase a block. Check it is erased and all

 	// other blocks are still zeros. Then we re-zero the block just

 	// erased and repeat test with next block

 	//

 	test.Printf( _L("Now testing erase...\n") );

 	for( TInt eraseBlock = 0; eraseBlock < iBlockCount; eraseBlock++ )

 		{

 		test( KErrNone == EraseOneBlock( eraseBlock ) );

 		test( ValidateBlock( eraseBlock, 0xFFFFFFFF ) );

 		// check all other blocks are still zero

 		for( TInt j = 0; j < iBlockCount; j++ )

 			{

 			if( j != eraseBlock )

 				{

 				// test if not the one we just erased

 				test( ValidateBlock( j, 0 ) );

 				}

 			}

 		// Now zero-fill the block we just erased and move to next block

 		test( KErrNone == ZeroFillBlock( eraseBlock ) );

 		test( ValidateBlock( eraseBlock, 0 ) );

 		}

 	}

 TInt E32Main()

 	{

 	test.Title();

 	test.Start(_L("Testing media erase operations"));

 	CEraseTest eraseTest;

 	TRAPD( ret, eraseTest.CreateL() );

 	if( KErrNone == ret )

 		{

 		eraseTest.DoTest();

 		}

 	test.End();

 	return KErrNone;

 	}