// 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:

 // e32test\lffs\t_lfsdrv2.cpp

 // Test the LFFS Flash media driver

 // 

 //

 #include <e32test.h>

 #include <e32svr.h>

 #include <e32hal.h>

 #include <e32uid.h>

 #include <hal.h>

 #include "u32std.h"

 #include "..\misc\prbs.h"

 _LIT(KTestName,"T_LFSDRV");

 _LIT(KMediaDriverName,"MEDLFS");

 _LIT(KDot,".");

 _LIT(KSemiColon,";");

 RTest test(KTestName);

 TBusLocalDrive Drive;

 TInt DriveNumber;

 TLocalDriveCapsV7 DriveCaps;	// Required for M18 devices

 TBool ChangedFlag;

 TUint32 EbSz;

 TUint32 Size;

 const TInt KBufferSize=4096;

 const TInt KBigBufferSize=4096*4;

 TUint8 Buffer[KBigBufferSize];

 #ifdef _DEBUG

 /***************************************************

  * ControlIO command types - for debug builds, only

  ***************************************************/

 enum TCtrlIoTypes

 	{

 	ECtrlIoRww=0,

 	ECtrlIoTimeout=1

 	};

 // Used only for the ControlIO tests

 #define TYAX_PARTITION_SIZE	0x00200000 	// Partition size for TYAX is 1MB; 2 devices in parallel

 #endif

 /******************************************************************************

  * Extra thread for background erase

  ******************************************************************************/

 struct SEraseInfo

 	{

 	TInt iFirstBlock;

 	TInt iNumBlocks;

 	};

 volatile TInt Block;

 TInt EraseThreadFn(TAny* aPtr)

 	{

 	SEraseInfo& e=*(SEraseInfo*)aPtr;

 	TInt r=KErrNone;

 	for (Block=e.iFirstBlock; Block<e.iFirstBlock+e.iNumBlocks; ++Block)

 		{

 		TInt64 pos64 = MAKE_TINT64(0, Block*EbSz);

 		r=Drive.Format(pos64,EbSz);

 		if (r!=KErrNone)

 			return r;

 		}

 	return KErrNone;

 	}

 SEraseInfo EraseInfo;

 RThread EraseThread;

 TRequestStatus EraseStatus;

 const TInt KHeapSize=0x4000;

 _LIT(KEraseThreadName,"Eraser");

 TInt StartAsyncErase(TInt aFirstBlock, TInt aNumBlocks)

 	{

 	EraseInfo.iFirstBlock=aFirstBlock;

 	EraseInfo.iNumBlocks=aNumBlocks;

 	TInt r=EraseThread.Create(KEraseThreadName,EraseThreadFn,0x4000,KHeapSize,KHeapSize,&EraseInfo,EOwnerThread);

 	if (r!=KErrNone)

 		return r;

 	EraseThread.Logon(EraseStatus);

 	EraseThread.Resume();

 	return KErrNone;

 	}

 TInt WaitForAsyncErase()

 	{

 	User::WaitForRequest(EraseStatus);

 	TInt exitType=EraseThread.ExitType();

 	TInt exitReason=EraseThread.ExitReason();

 	TBuf<16> exitCat=EraseThread.ExitCategory();

 	if((exitType!= EExitKill)||(exitReason!=KErrNone))

 		{

 		test.Printf(_L("Async erase error: %d, block %d\n"),EraseStatus.Int(),Block);

 		test.Printf(_L("Thread exit reason: %d,%d,%S\n"),exitType,exitReason,&exitCat);

 		test(0);		

 		}

 	EraseThread.Close();

 	TUint32 pos=EraseInfo.iFirstBlock*EbSz;

 	TUint32 endpos=pos+EraseInfo.iNumBlocks*EbSz;

 	test.Printf(_L("\nAsync erase completed; verifying...\n"));

 	for (; pos<endpos; pos+=KBufferSize)

 		{

 		TInt64 pos64 = MAKE_TINT64(0, pos);

 		TPtr8 ptr(Buffer,0,KBufferSize);

 		Mem::FillZ(Buffer,KBufferSize);

 		TInt r=Drive.Read(pos64,KBufferSize,ptr);

 		test(r==KErrNone);

 		test(ptr.Length()==KBufferSize);

 		const TUint32* pB=(const TUint32*)Buffer;

 		const TUint32* pE=(const TUint32*)(Buffer+KBufferSize);

 		while (pB<pE && *pB==0xffffffff) ++pB;

 		if (pB<pE)

 			{

 			test.Printf(_L("ERROR: pos %08x data %08x\n"),((TUint32)pB)-((TUint32)Buffer)+pos,*pB);

 			test(0);

 			}

 		test.Printf(KDot);

 		}

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

 	return KErrNone;

 	}

 /******************************************************************************

  * Extra thread for background write, for use in the read-while-write tests

  ******************************************************************************/

 TUint seed[2];

 TInt WriteThreadFn(TAny* aPtr)

 	{

 	// re-use the struct created for the erase thread

 	SEraseInfo& e=*(SEraseInfo*)aPtr;

 	TInt r=KErrNone;

 	TPtrC8 wptr(Buffer,KBufferSize);

 	TUint32* pB=(TUint32*)Buffer;

 	TUint32* pE=(TUint32*)(Buffer+KBufferSize);

 	while (pB<pE)

 		*pB++=Random(seed);

 	for (Block=e.iFirstBlock; Block<e.iFirstBlock+e.iNumBlocks; ++Block)

 		{

 		TInt64 pos64 = MAKE_TINT64(0, Block*EbSz);

 		r=Drive.Write(pos64,wptr);

 		if (r!=KErrNone)

 			return r;

 		}

 	return KErrNone;

 	}

 RThread WriteThread;

 TRequestStatus WriteStatus;

 _LIT(KWriteThreadName,"Writer");

 TInt StartAsyncWrite(TInt aFirstBlock, TInt aNumBlocks)

 	{

 	// re-use the struct created for the erase thread

 	EraseInfo.iFirstBlock=aFirstBlock;

 	EraseInfo.iNumBlocks=aNumBlocks;

 	TInt r=WriteThread.Create(KWriteThreadName,WriteThreadFn,0x4000,KHeapSize,KHeapSize,&EraseInfo,EOwnerThread);

 	if (r!=KErrNone)

 		return r;

 	WriteThread.Logon(WriteStatus);

 	WriteThread.Resume();

 	return KErrNone;

 	}

 TInt WaitForAsyncWrite()

 	{

 	User::WaitForRequest(WriteStatus);

 	TInt exitType=WriteThread.ExitType();

 	TInt exitReason=WriteThread.ExitReason();

 	TBuf<16> exitCat=WriteThread.ExitCategory();

 	if((exitType!= EExitKill)||(exitReason!=KErrNone))

 		{

 		test.Printf(_L("Async Write error: %d, block %d\n"),WriteStatus.Int(),Block);

 		test.Printf(_L("Thread exit reason: %d,%d,%S\n"),exitType,exitReason,&exitCat);

 		test(0);

 		}

 	WriteThread.Close();

 	// No verification performed

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

 	return KErrNone;

 	}

 /******************************************************************************

  * Control mode and Object mode test functions

  ******************************************************************************/

 TInt DoControlModeWriteAndVerify(TUint32 aPattern, TUint32 aStartOffset)

 	{

 	// Writes 4K bytes of a given pattern to the "A" half of programming regions, 

 	// starting at the specified offset, then reads the data back to verify it

 		TUint32* pB=(TUint32*)(Buffer);

 		TUint32* pE=(TUint32*)(Buffer + KBufferSize);

 		TInt r=KErrNone;

 		// Fill the entire buffer with an initial value

 		while (pB<pE)

 			*pB++= aPattern;

 		// In this mode, half the device is available for writing, the other half is reserved;

 		// the available half appears as the first DriveCaps.iControlModeSize bytes, the reserved 

 		// half as the following DriveCaps.iControlModeSize, and this alternating continues.

 		// To perform this discrete-write test, therefore, the data held in Buffer that corresponds

 		// to the reserved area is overwritten with 0xFF; 'writing' this value to the reserved area

 		// has no detrimental effect.

 		TInt i;

 		TUint32 b;

 		pB=(TUint32*)Buffer;

 		for(i=0; i< KBufferSize; i+=(DriveCaps.iControlModeSize*2))

 		{

 			pB = (TUint32 *)((TUint32)pB + DriveCaps.iControlModeSize);

 			for (b=0; b < DriveCaps.iControlModeSize; b+=4)

 			{

 				*pB = 0xFFFFFFFF;

 				pB++;	

 			}

 		}

 		// Write the data

 		for (i=0; i<KBufferSize; i+=(4*DriveCaps.iControlModeSize))

 			{

 			TInt64 pos64(i + aStartOffset);

 			TPtrC8 ptr(Buffer+i,(4*DriveCaps.iControlModeSize));

 			r=Drive.Write(pos64,ptr);

 			test(r==KErrNone);

 			}

 		// Check what has been written

 		Mem::FillZ(Buffer,KBigBufferSize);

 		TPtr8 buf(Buffer,0,KBufferSize);

 		r=Drive.Read(aStartOffset,KBufferSize,buf);

 		test(r==KErrNone);

 		pB=(TUint32*)Buffer;

 		for(i=0; i< KBufferSize; i+=(DriveCaps.iControlModeSize*2))

 			{

 			for (b=0; b< DriveCaps.iControlModeSize; b+=4)

 				{

 				if(*pB++ != aPattern)

 					{ 

 					test.Printf(_L("ERROR: addr %08x data %08x expected %08x\n"),pB,*pB,aPattern);

 					r=KErrCorrupt;

 					break;

 					}

 				}

 			for (b=0; b< DriveCaps.iControlModeSize; b+=4)

 				{

 				if(*pB++ != 0xFFFFFFFF)

 					{ 

 					test.Printf(_L("ERROR: addr %08x data %08x expected 0xFFFFFFFF\n"),pB,*pB);

 					r=KErrCorrupt;

 					break;

 					}

 				}

 			}

 		return r;

 	}

 TInt DoObjectModeWriteAndVerify(TUint32 aOffset, TUint32 aSize)

 	{

 	// Writes 'aSize' bytes of a 'random' pattern to the specified offset

 	// then read back and verify

 	TInt r=KErrNone;

 	// Check that aSize is valid

 	if(aSize>DriveCaps.iObjectModeSize)

 		{

 		test.Printf(_L("ERROR: DoObjectModeWriteAndVerify - aSize=%x is greater than max (%x)\n"),aSize,DriveCaps.iObjectModeSize);

 		return KErrArgument;

 		}

 	// write the data

 	TUint seed[2];

 	seed[0]=0xb17217f8;

 	seed[1]=0;

 	TInt64 pos64 = MAKE_TINT64(0, aOffset);

 	TPtrC8 ptr(Buffer,aSize);

 	TUint32* pB=(TUint32*)Buffer;

 	TUint32* pE=(TUint32*)(Buffer+aSize);

 	while (pB<pE)

 		*pB++=Random(seed);

 	r=Drive.Write(pos64,ptr);

 	if(r!=KErrNone)

 		{

 		return r;

 		}

 	// Read the data back

 	seed[0]=0xb17217f8;

 	seed[1]=0;

 	TPtr8 rptr(Buffer,0,aSize);

 	Mem::FillZ(Buffer,aSize);

 	r=Drive.Read(pos64,aSize,rptr);

 	if(r!=KErrNone)

 		{

 		test.Printf(_L("ERROR: DoObjectModeWriteAndVerify - Read returned %d\n"),r);

 		return r;

 		}

 	test((TUint32)(rptr.Length())==aSize);

 	// Verify the content

 	pB=(TUint32*)Buffer;

 	pE=(TUint32*)(Buffer+aSize);

 	TUint32 ex=0;

 	while (pB<pE && (ex=Random(seed),*pB==ex)) ++pB;

 	if (pB<pE)

 		{

 		test.Printf(_L("ERROR: DoObjectModeWriteAndVerify - addr %08x data %08x expected %08x\n"),pB,*pB,ex);

 		r=KErrCorrupt;

 		}

 	return r;

 	}

 TInt DoControlModeBoundaryWriteAndVerify()

 	{

 	// 

 	TInt r=KErrNone;

 	//test.Printf(_L("Entering: DoControlModeBoundaryWriteAndVerify - Start Test\n"));

 	r=Drive.Format(0,DriveCaps.iEraseBlockSize);

 	test(r==KErrNone);

 	// Program into the last Control mode region in the programming region.

 	TInt64 pos64 = MAKE_TINT64(0, (DriveCaps.iObjectModeSize - (DriveCaps.iControlModeSize*2)));

 	TPtrC8 ptr(Buffer,DriveCaps.iControlModeSize);

 	TUint32* pB=(TUint32*)Buffer;

 	TUint32* pE=(TUint32*)(Buffer+DriveCaps.iControlModeSize);

 	while (pB<pE)

 		*pB++=0xb4b4a5a5;

 	r=Drive.Write(pos64,ptr);

 	if(r!=KErrNone)

 		{

 		test.Printf(_L("ERROR: DoControlModeBoundaryWriteAndVerify - Write 1\n"));

 		return r;

 		}

 	// Program into the next programming region starting at the first byte up to the size of the Control Mode Size.

 	pos64 = MAKE_TINT64(0, DriveCaps.iObjectModeSize);

 	r=Drive.Write(pos64,ptr);

 	if(r!=KErrNone)

 		{

 		test.Printf(_L("ERROR: DoControlModeBoundaryWriteAndVerify - Write 2\n"));

 		return r;

 		}

 	// Read the data back from the first program

 	pos64 = MAKE_TINT64(0, (DriveCaps.iObjectModeSize - (DriveCaps.iControlModeSize*2)));

 	TPtr8 rptr(Buffer,0,(TInt)DriveCaps.iControlModeSize);

 	Mem::FillZ(Buffer,DriveCaps.iControlModeSize);

 	r=Drive.Read(pos64,DriveCaps.iControlModeSize,rptr);

 	if(r!=KErrNone)

 		{

 		test.Printf(_L("ERROR: DoObjectModeWriteAndVerify - Read returned %d\n"),r);

 		return r;

 		}

 	test((TUint32)(rptr.Length())==DriveCaps.iControlModeSize);

 	// Verify the content

 	pB=(TUint32*)Buffer;

 	pE=(TUint32*)(Buffer+DriveCaps.iControlModeSize);

 	TUint32 ex=0xb4b4a5a5;

 	while (pB<pE && (*pB==ex)) ++pB;

 	if (pB<pE)

 		{

 		test.Printf(_L("ERROR: DoObjectModeWriteAndVerify - addr %08x data %08x expected %08x\n"),pB,*pB,ex);

 		r=KErrCorrupt;

 		}

    // Read the data back from the second program

    	pos64 = MAKE_TINT64(0, DriveCaps.iObjectModeSize);

 	TPtr8 rptr2(Buffer,0,((TInt)DriveCaps.iControlModeSize));

 	Mem::FillZ(Buffer,DriveCaps.iControlModeSize);

 	r=Drive.Read(pos64,DriveCaps.iControlModeSize,rptr2);

 	if(r!=KErrNone)

 		{

 		test.Printf(_L("ERROR: DoObjectModeWriteAndVerify - Read returned %d\n"),r);

 		return r;

 		}

 	test((TUint32)(rptr2.Length())==DriveCaps.iControlModeSize);

 	// Verify the content

 	pB=(TUint32*)Buffer;

 	pE=(TUint32*)(Buffer+DriveCaps.iControlModeSize);

 	ex=0xb4b4a5a5;

 	while (pB<pE && (*pB==ex)) ++pB;

 	if (pB<pE)

 		{

 		test.Printf(_L("ERROR: DoObjectModeWriteAndVerify - addr %08x data %08x expected %08x\n"),pB,*pB,ex);

 		r=KErrCorrupt;

 		}

 	// Bit Twiddle the last bit of the last Control Mode Region 

 	// Then bit twiddle the first bit of the first control Mode region.

 	// Program into the last Control mode region in the programming region.

 	pos64 = MAKE_TINT64(0, (DriveCaps.iObjectModeSize - DriveCaps.iControlModeSize - 4));

 	TPtrC8 ptr2(Buffer,4);

 	TUint32* pC=(TUint32*)Buffer;

 	*pC = 0xFFFFFFFE;

 	r=Drive.Write(pos64,ptr2);

 	if(r!=KErrNone)

 		{

 				test.Printf(_L("ERROR: DoControlModeBoundaryWriteAndVerify - Write 3\n"));

 		return r;

 		}

 	// Read the data back from the first program

 	pos64 = MAKE_TINT64(0, (DriveCaps.iObjectModeSize - DriveCaps.iControlModeSize - 4));

 	TPtr8 rptr3(Buffer,0,4);

 	Mem::FillZ(Buffer,4);

 	r=Drive.Read(pos64,4,rptr3);

 	if(r!=KErrNone)

 		{

 		test.Printf(_L("ERROR: DoObjectModeWriteAndVerify - Read returned %d\n"),r);

 		return r;

 		}

 	test(rptr3.Length()==4);

 	// Verify the content

 	pB=(TUint32*)Buffer;

 	if (*pB != 0xb4b4a5a4)

 		{

 		test.Printf(_L("ERROR: DoObjectModeWriteAndVerify - addr %08x data %08x expected 0xb4b4a5a4\n"),pB,*pB);

 		r=KErrCorrupt;

 		}

 	// Program into the last Control mode region in the programming region.

 	pos64 = MAKE_TINT64(0, DriveCaps.iObjectModeSize);

 	TPtrC8 ptr3(Buffer,4);

 	pC=(TUint32*)Buffer;

 	*pC = 0x7FFFFFFF;

 	r=Drive.Write(pos64,ptr3);

 	if(r!=KErrNone)

 		{

 				test.Printf(_L("ERROR: DoControlModeBoundaryWriteAndVerify - Write 4\n"));

 		return r;

 		}

 	// Read the data back from the first program

 	pos64 = MAKE_TINT64(0, DriveCaps.iObjectModeSize);

 	TPtr8 rptr4(Buffer,0,4);

 	Mem::FillZ(Buffer,4);

 	r=Drive.Read(pos64,4,rptr4);

 	if(r!=KErrNone)

 		{

 		test.Printf(_L("ERROR: DoObjectModeWriteAndVerify - Read returned %d\n"),r);

 		return r;

 		}

 	test(rptr4.Length()==4);

 	// Verify the content

 	pB=(TUint32*)Buffer;

 	if (*pB != 0x34b4a5a5)

 		{

 		test.Printf(_L("ERROR: DoObjectModeWriteAndVerify - addr %08x data %08x expected 0x34b4a5a5\n"),pB,*pB);

 		r=KErrCorrupt;

 		}

 	return r;

 	}

 /******************************************************************************

  * Main test program

  ******************************************************************************/

 GLDEF_C TInt E32Main()

 	{

 	test.Title();

 /******************************************************************************

  * Initialisation

  ******************************************************************************/

 	TDriveInfoV1Buf diBuf;

 	UserHal::DriveInfo(diBuf);

 	TDriveInfoV1 &di=diBuf();

 	test.Start(_L("Test the LFFS media driver"));

 	test.Printf(_L("DRIVES PRESENT  :%d\r\n"),di.iTotalSupportedDrives);

 	test.Printf(_L("C:(1ST) DRIVE NAME  :%- 16S\r\n"),&di.iDriveName[0]);

 	test.Printf(_L("D:(2ND) DRIVE NAME  :%- 16S\r\n"),&di.iDriveName[1]);

 	test.Printf(_L("E:(3RD) DRIVE NAME  :%- 16S\r\n"),&di.iDriveName[2]);

 	test.Printf(_L("F:(4TH) DRIVE NAME  :%- 16S\r\n"),&di.iDriveName[3]);

 	test.Printf(_L("G:(5TH) DRIVE NAME  :%- 16S\r\n"),&di.iDriveName[4]);

 	test.Printf(_L("H:(6TH) DRIVE NAME  :%- 16S\r\n"),&di.iDriveName[5]);

 	test.Printf(_L("I:(7TH) DRIVE NAME  :%- 16S\r\n"),&di.iDriveName[6]);

 	test.Printf(_L("J:(8TH) DRIVE NAME  :%- 16S\r\n"),&di.iDriveName[7]);

 	test.Printf(_L("K:(9TH) DRIVE NAME  :%- 16S\r\n"),&di.iDriveName[8]);

 	test.Printf(_L("\r\nWarning - all data on LFFS drive will be lost.\r\n"));

 	test.Printf(_L("<<<Select drive to continue>>>\r\n"));

 	FOREVER

 		{

 		TChar c=(TUint)test.Getch();

 		c.UpperCase();

 		DriveNumber=((TUint)c)-'C';

 		if (DriveNumber>=0&&DriveNumber<='C'+ 8)

 			break;

 		}

 	test.Next(_L("Load media driver"));

 	TInt r=User::LoadPhysicalDevice(KMediaDriverName);

 	test(r==KErrNone || r==KErrAlreadyExists);

 	test.Next(_L("Connect to drive"));

 	r=Drive.Connect(DriveNumber,ChangedFlag);

 	test(r==KErrNone);

 	test.Next(_L("Get capabilities"));

 	DriveCaps.iControlModeSize=0;	// If test invoked for a chip other than Sibley then this element will not be updated

 	DriveCaps.iObjectModeSize=0;	// If test invoked for a chip other than Sibley then this element will not be updated 

 	TPckg<TLocalDriveCapsV7> capsPckg(DriveCaps);

   	r=Drive.Caps(capsPckg);

 	test(r==KErrNone);

 	test.Printf(_L("Size            : %08x\n"),I64LOW(DriveCaps.iSize));

 	test.Printf(_L("Type            : %d\n"),DriveCaps.iType);

 	test.Printf(_L("Connection Bus  : %d\n"),DriveCaps.iConnectionBusType);

 	test.Printf(_L("DriveAtt        : %02x\n"),DriveCaps.iDriveAtt);

 	test.Printf(_L("MediaAtt        : %02x\n"),DriveCaps.iMediaAtt);

 	test.Printf(_L("BaseAddress     : %08x\n"),DriveCaps.iBaseAddress);

 	test.Printf(_L("FileSysID       : %d\n"),DriveCaps.iFileSystemId);

 	test.Printf(_L("Hidden sectors  : %d\n"),DriveCaps.iHiddenSectors);

 	test.Printf(_L("Erase block size: %d\n"),DriveCaps.iEraseBlockSize);

 	test.Printf(_L("Partition size: %d\n"),DriveCaps.iPartitionSize);

 	test.Printf(_L("Control Mode size: %d\n"),DriveCaps.iControlModeSize);

 	test.Printf(_L("Object Mode size: %d\n"),DriveCaps.iObjectModeSize);

 	test.Printf(_L("Press any key...\n\n"));

 	test.Getch();

 	test(DriveCaps.iDriveAtt==(KDriveAttLocal|KDriveAttInternal));

 	test((DriveCaps.iMediaAtt&KMediaAttFormattable)==(KMediaAttFormattable)); // Apply mask since other flags may be set

 #if defined(_DEBUG) && defined(_WINS)

 /******************************************************************************

  * Simulate device timeout

  ******************************************************************************/

 	test.Next(_L("Timeout"));

 	EbSz=DriveCaps.iEraseBlockSize;

 	r=Drive.Format(0,EbSz);

 	test(r==KErrNone);

 	r=Drive.ControlIO(ECtrlIoTimeout, NULL, NULL);

 	if(r!=KErrNotSupported)

 		{

 		if(r==KErrNone)

 			{

 			// Test timeout behaviour for Write operation

 			TPtrC8 ptr(Buffer,1);

 			r=Drive.Write(0,ptr);

 			test(r==KErrNotReady);

 			// Test condition now cleared, ensure normal operation is OK

 			r=Drive.Write(0,ptr);

 			test(r==KErrNone);

 			// Test timeout behaviour for Format operation

 			r=Drive.ControlIO(ECtrlIoTimeout, NULL, NULL);

 			test(r==KErrNone);

 			r=Drive.Format(0,EbSz);

 			test(r==KErrNotReady);

 			// Cleanup

 			r=Drive.Format(0,EbSz);

 			test(r==KErrNone);

 			}

 		else

 			{

 			test.Printf(_L("Timeout ControlIO failed initialisation\n"));

 			test(0);	// Cannot proceed with this test

 			}

 		}

 	else 

 		{

 		test.Printf(_L("Timeout ControlIO not supported\n"));

 		}

 	test.Printf(_L("Press any key...\n"));

 	test.Getch();

 #endif

  /******************************************************************************

  * Formatting

  ******************************************************************************/

 	test.Next(_L("Format"));

 	TUint32 pos;

 	EbSz=DriveCaps.iEraseBlockSize;

 	Size=I64LOW(DriveCaps.iSize);

 // Reduce size so test doesn't take forever

 	if (Size>8*EbSz)

 		Size=8*EbSz;

 	for (pos=0; pos<Size; pos+=EbSz)

 		{

 		TInt64 pos64 = MAKE_TINT64(0, pos);

 		r=Drive.Format(pos64,EbSz);

 		test(r==KErrNone);

 		test.Printf(KDot);

 		}

 	test.Next(_L("\nVerify"));

 	for (pos=0; pos<Size; pos+=KBufferSize)

 		{

 		TInt64 pos64 = MAKE_TINT64(0, pos);

 		TPtr8 ptr(Buffer,0,KBufferSize);

 		Mem::FillZ(Buffer,KBigBufferSize);

 		r=Drive.Read(pos64,KBufferSize,ptr);

 		test(r==KErrNone);

 		test(ptr.Length()==KBufferSize);

 		const TUint32* pB=(const TUint32*)Buffer;

 		const TUint32* pE=(const TUint32*)(Buffer+KBufferSize);

 		while (pB<pE && *pB==0xffffffff) ++pB;

 		if (pB<pE)

 			{

 			test.Printf(_L("ERROR: addr %08x data %08x\n"),pB,*pB);

 			test(0);

 			}

 		test.Printf(KDot);

 		}

 	test.Printf(_L("\nPress any key...\n\n"));

 	test.Getch();

 /******************************************************************************

  * Large block writes

  ******************************************************************************/

 	test.Next(_L("Write"));

 	TUint seed[2];

 	seed[0]=0xb17217f8;

 	seed[1]=0;

 	for (pos=0; pos<Size; pos+=KBufferSize)

 		{

 		TInt64 pos64 = MAKE_TINT64(0, pos);

 		TPtrC8 ptr(Buffer,KBufferSize);

 		TUint32* pB=(TUint32*)Buffer;

 		TUint32* pE=(TUint32*)(Buffer+KBufferSize);

 		while (pB<pE)

 			*pB++=Random(seed);

 		r=Drive.Write(pos64,ptr);

 		test(r==KErrNone);

 		test.Printf(KDot);

 		}

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

 	test.Next(_L("Verify"));

 	seed[0]=0xb17217f8;

 	seed[1]=0;

 	for (pos=0; pos<Size; pos+=KBufferSize)

 		{

 		TInt64 pos64 = MAKE_TINT64(0, pos);

 		TPtr8 ptr(Buffer,0,KBufferSize);

 		Mem::FillZ(Buffer,KBigBufferSize);

 		r=Drive.Read(pos64,KBufferSize,ptr);

 		test(r==KErrNone);

 		test(ptr.Length()==KBufferSize);

 		const TUint32* pB=(const TUint32*)Buffer;

 		const TUint32* pE=(const TUint32*)(Buffer+KBufferSize);

 		TUint32 ex=0;

 		while (pB<pE && (ex=Random(seed),*pB==ex)) ++pB;

 		if (pB<pE)

 			{

 			test.Printf(_L("ERROR: addr %08x data %08x expected %08x\n"),pB,*pB,ex);

 			test(0);

 			}

 		test.Printf(KDot);

 		}

 	test.Printf(_L("\nPress any key...\n\n"));

 	test.Getch();

 /******************************************************************************

  * Single byte writes

  ******************************************************************************/

 	test.Next(_L("Format first block"));

 	r=Drive.Format(0,EbSz);

 	test(r==KErrNone);

 	test.Next(_L("Single byte writes"));

 	seed[0]=0x317b106f;

 	seed[1]=0;

 	TUint32* pB=(TUint32*)Buffer;

 	TUint32* pE=(TUint32*)(Buffer+KBufferSize);

 	while (pB<pE)

 		*pB++= Random(seed);

 	// For M18 devices, this test requires control mode operation.

 	// In this mode, half the device is available for writing, the other half is reserved;

 	// the available half appears as the first DriveCaps.iControlModeSize bytes, the reserved 

 	// half as the following DriveCaps.iControlModeSize, and this alternating continues.

 	// To perform this discrete-write test, therefore, the data held in Buffer that corresponds

 	// to the reserved area is overwritten with 0xFF; 'writing' this value to the reserved area

 	// has no detrimental effect.

 	TInt i;

 	TUint32 b;

 	if (DriveCaps.iControlModeSize > 0)

 	{

 		pB=(TUint32*)Buffer;

 		for(i=0; i< KBufferSize; i+=(DriveCaps.iControlModeSize*2))

 		{

 			pB = (TUint32 *)((TUint32)pB + DriveCaps.iControlModeSize);

 			for (b=0; b < DriveCaps.iControlModeSize; b+=4)

 			{

 				*pB = 0xFFFFFFFF;

 				pB++;	

 			}

 		}

 	} 

 #if 0

 	// Debug - print content of buffer

 	test.Printf(_L("Content of buffer after inserting 0xFFFFFFFFs follows\n"));

 	i=0;

 	TUint32* verifyPtr=(TUint32*)Buffer;

 	while(i<KBufferSize)

 		{

 		test.Printf(_L("%8x %8X %8X\n"),i+=8,*verifyPtr++,*verifyPtr++);

 		}

 #endif

 	for (i=0; i<KBufferSize; ++i)

 		{

 		TInt64 pos64(i);

 		TPtrC8 ptr(Buffer+i,1);

 		r=Drive.Write(pos64,ptr);

 		test(r==KErrNone);

 		if (!(i%16))

 			test.Printf(KDot);

 		}

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

 	test.Next(_L("Verify"));

 	Mem::FillZ(Buffer,KBigBufferSize);

 	TPtr8 buf(Buffer,0,KBufferSize);

 	r=Drive.Read(0,KBufferSize,buf);

 	test(r==KErrNone);

 	seed[0]=0x317b106f;

 	seed[1]=0;

 	pB=(TUint32*)Buffer;

 	TUint32 ex=0;

 	if (DriveCaps.iControlModeSize > 0)

 		{

 		pB=(TUint32*)Buffer;

 		for(i=0; i< KBufferSize; i+=(DriveCaps.iControlModeSize*2))

 			{

 			for (b=0; b< DriveCaps.iControlModeSize; b+=4)

 				{

 				ex=Random(seed);

 				if(*pB++ != ex)

 					{ 

 					test.Printf(_L("ERROR: addr %08x data %08x expected %08x\n"),pB,*pB,ex);

 					break;

 					}

 				}

 			for (b=0; b< DriveCaps.iControlModeSize; b+=4)

 				{

 				ex=Random(seed);

 				if(*pB++ != 0xFFFFFFFF)

 					{ 

 					test.Printf(_L("ERROR: addr %08x data %08x expected 0xFF\n"),pB,*pB);

 					break;

 					}

 				}

 			if (!((i+1)%64))

 				test.Printf(KDot);

 			}

 		}

 	else

 		{	

 		while (pB<pE && (ex=Random(seed),*pB==ex)) ++pB;

 		}

 	if (pB<pE)

 		{

 		test.Printf(_L("ERROR: addr %08x data %08x expected %08x\n"),pB,*pB,ex);

 		test(0);

 		}

 	test.Printf(_L("Single byte writes OK\n"));

 	test.Printf(_L("Press any key...\n\n"));

 	test.Getch();

 /******************************************************************************

  * Random length writes

  ******************************************************************************/

 	test.Next(_L("Random length writes"));

 	// Prepare the device (required if control mode is used for M18 devices)

 	// assume that a maximum of 2 blocks is required

 	r=Drive.Format(0,EbSz);

 	r=Drive.Format(DriveCaps.iEraseBlockSize,EbSz);

 	seed[0]=0xdeadbeef;

 	seed[1]=0;

 	pB=(TUint32*)Buffer;

 	pE=(TUint32*)(Buffer+KBigBufferSize);

 	while (pB<pE)

 		*pB++=Random(seed);

 	TInt remain=KBigBufferSize;

 	TInt objectModeOffset=0;

 	TUint32 writeCount=0;

 	seed[0]=0xdeadbeef;

 	seed[1]=0;

 	for(writeCount=0; remain && (writeCount<512); writeCount++)

 		{

 		TInt l=1+(Random(seed)&255);	 // random length between 1 and 256

 		if (l>remain)

 			l=remain;

 		TInt pos=0;

 		if(DriveCaps.iObjectModeSize == 0)

 			{

 			pos=KBigBufferSize-remain;

 			}

 		TPtrC8 ptr(Buffer+(KBigBufferSize-remain),l);

 		TInt64 pos64(pos+objectModeOffset);  // Start writes in a new programming region if object mode supported

 		r=Drive.Write(pos64,ptr);

 		test(r==KErrNone);

 		objectModeOffset+=DriveCaps.iObjectModeSize;

 		remain-=l;

 		test.Printf(KDot);

 		}

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

 	test.Next(_L("Verify"));

 	Mem::FillZ(Buffer,KBigBufferSize);

 	new (&buf) TPtr8(Buffer,0,KBigBufferSize);

 	if(DriveCaps.iObjectModeSize==0)

 	{

 		r=Drive.Read(0,KBigBufferSize,buf);

 		test(r==KErrNone);

 	}

 	else

 	{

 		remain=KBigBufferSize;

 		objectModeOffset=0;

 		while(remain && writeCount)

 			{

 			TInt totalLength=0;

 			TInt l=1+(Random(seed)&255);	 // random length between 1 and 256

 			if (l>remain)

 				l=remain;

 			TPtr8 ptr(Buffer+(totalLength),l);

 			r=Drive.Read(objectModeOffset,l,ptr);

 			test(r==KErrNone);

 			totalLength +=l;

 			remain-=l;

 			writeCount--;

 			test.Printf(KDot);

 			}

 	}

 	seed[0]=0xdeadbeef;

 	seed[1]=0;

 	pB=(TUint32*)Buffer;

 	ex=0;

 	if(DriveCaps.iObjectModeSize==0)

 	{

 		while (pB<pE && (ex=Random(seed),*pB==ex)) ++pB;

 		if (pB<pE)

 			{

 			test.Printf(_L("ERROR: addr %08x data %08x expected %08x\n"),pB,*pB,ex);

 	//		test.Getch();

 			test(0);

 			}

 	}

 	r=Drive.Format(0,EbSz);

 	r=Drive.Format(DriveCaps.iEraseBlockSize,EbSz);

 	test.Printf(_L("\nPress any key...\n\n"));

 	test.Getch();

 /******************************************************************************

  * Concurrent read/write/erase

  ******************************************************************************/

 	test.Printf(_L("Foreground R/W\n"));

 	r=StartAsyncErase(1,Size/EbSz-1);

 	test(r==KErrNone);

 	seed[0]=0xb17217f8;

 	seed[1]=0;

 	for (pos=KBufferSize+KBigBufferSize; pos<EbSz; pos+=KBufferSize)

 		{

 		TInt64 pos64 = MAKE_TINT64(0, pos);

 		TPtrC8 wptr(Buffer,KBufferSize);

 		TUint32* pB=(TUint32*)Buffer;

 		TUint32* pE=(TUint32*)(Buffer+KBufferSize);

 		while (pB<pE)

 			*pB++=Random(seed);

 		r=Drive.Write(pos64,wptr);

 		test(r==KErrNone);

 		test.Printf(KDot);

 		Mem::FillZ(Buffer+KBufferSize,KBufferSize);

 		TPtr8 rptr(Buffer+KBufferSize,0,KBufferSize);

 		r=Drive.Read(pos64,KBufferSize,rptr);

 		test(r==KErrNone);

 		test(rptr.Length()==KBufferSize);

 		//test(Mem::Compare(Buffer,KBufferSize,Buffer+KBufferSize,KBufferSize)==0);

 		r = Mem::Compare(Buffer,KBufferSize,Buffer+KBufferSize,KBufferSize);

 #if 0

 		if (r!=KErrNone)

 		{

 			pB=(TUint32*)Buffer;

 			pE=(TUint32*)(Buffer+KBufferSize);

 			for(TInt i=0; i < (KBufferSize>>2); i++)

 			{

 			  test.Printf(_L("%d Buffer Content %08x   %08x Flash Content\n"),i, pB[i], pE[i]);			

 			} 

 		}

 #endif

 		test (r==KErrNone);

 		test.Printf(KSemiColon);

 		}

 	r=WaitForAsyncErase();

 	test(r==KErrNone);

     r=Drive.Format(0,EbSz);

 	r=Drive.Format(DriveCaps.iEraseBlockSize,EbSz);

 	test.Printf(_L("Press any key...\n\n"));

 	test.Getch();

 // Perform the following tests for debug builds, only

 #ifdef _DEBUG

 /******************************************************************************

  * Concurrent operations to exercise TYAX Read-While-Write capability

  * First, show read while write denied when attempting to read from a partition 

  * that is being written to

  * Second, show read while write proceeding when reading from a partition other

  * than that which is being written to

  ******************************************************************************/

 	// Do not perform these tests unless read-while-write is supported

 	if(DriveCaps.iMediaAtt&KMediaAttReadWhileWrite)

 		{	

 		test.Next(_L("Denied read while write"));

 		r=Drive.ControlIO(ECtrlIoRww, NULL, NULL);

 		if(r!=KErrNone)

 			{

 			test.Printf(_L("ControlIO not ready, returned %d\n"), r);

 			test(0);	// Cannot proceed with this test

 			}

 		test.Printf(_L("Press any key...\n"));

 		test.Getch();

 		test.Printf(_L("Starting async write for the first RWE/RWW test"));

 		r=StartAsyncWrite(1,3); // Write to the first three blocks, only, to limit duration

 		test(r==KErrNone);

 		// Allow the write thread to be created and ready to run

 		// This will ensure that the driver will have received a write request before the second of the read

 		// requests, below. Following the issue of the ControlIO command, above, the driver will not instigate

 		// the write request until the next (second) read request is received. This is done so that the high priority

 		// driver thread recognises the existence of a read request (from a lower priority test / user thread)

 		// before it executes a sequence of writes to the FLASH device. This is necessary because, although

 		// each write takes a finite amount of time, the poll timer expires so quickly that the driver thread

 		// would not be blocked for a sufficiently long period to allow the read request to be processed. Adopting

 		// the contrived, and artificial, approach of using ControlIO to 'stage' the write allows the read-while-write

 		// capability of the device to be execrised.

 		User::After(1000);	

 		test.Printf(_L("Starting concurrent loop for background write\n"));

 		{

 		// First read - this will be performed before the write thread is run, so does

 		// not exercise read while write.

 		TInt64 pos64 = MAKE_TINT64(0,0);

 		TPtr8 rptr(Buffer+KBufferSize,0,KBufferSize);

 		test.Printf(_L("Issuing Drive.Read 1\n"));

 		r=Drive.Read(pos64,KBufferSize,rptr); 

 		test(r==KErrNone);

 		test.Printf(KSemiColon);		

 		}

 		{

 		// Second read - to same partition (and block) as the active write

 		// This read should be deferred by the driver

 		TInt64 pos64 = MAKE_TINT64(0, 2*EbSz);

 		TPtr8 rptr(Buffer+KBufferSize,0,KBufferSize);

 		test.Printf(_L("Issuing Drive.Read 2\n"));

 		r=Drive.Read(pos64,KBufferSize,rptr); // Should collide with second write

 		test(r==KErrNone);

 		test.Printf(KSemiColon);		

 		}

 		{

 		// Third read - due to the tight poll timer period, this will not be scheduled 

 		// until the write request has completed - so does not exercise read while write.

 		TInt64 pos64 = MAKE_TINT64(0, DriveCaps.iPartitionSize);

 		TPtr8 rptr(Buffer+KBufferSize,0,KBufferSize);

 		test.Printf(_L("Issuing Drive.Read 3\n"));

 		r=Drive.Read(pos64,KBufferSize,rptr);

 		test(r==KErrNone);

 		test.Printf(KSemiColon);		

 		}

 		r=WaitForAsyncWrite();

 		test(r==KErrNone);

 	///////////////////////////////////////////////////////////////////////////////

 		r=Drive.Format(0,EbSz);

 		r=Drive.Format(DriveCaps.iEraseBlockSize,EbSz);

 		r=Drive.Format((DriveCaps.iEraseBlockSize*2),EbSz);

 		r=Drive.Format((DriveCaps.iEraseBlockSize*3),EbSz);

 		test.Printf(_L("Press any key...\n"));

 		test.Getch();

 		test.Next(_L("Supported read while write"));

 		r=Drive.ControlIO(ECtrlIoRww, NULL, NULL);

 		if(r!=KErrNone)

 			{

 			test.Printf(_L("ControlIO not ready\n"));

 			return r;

 			}

 		test.Printf(_L("Press any key...\n"));

 		test.Getch();

 		test.Printf(_L("Starting async write for the second RWE/RWW test"));

 		r=StartAsyncWrite(1,3); // Write to the first three blocks, only, to limit duration

 		test(r==KErrNone);

 		// Allow the write thread to be created and ready to run

 		User::After(1000);	

 		test.Printf(_L("Starting concurrent loop for background write\n"));

 		{

 		// First read - this will be performed before the write thread is run, so does

 		// not exercise read while write.

 		TInt64 pos64 = MAKE_TINT64(0, DriveCaps.iPartitionSize);

 		TPtr8 rptr(Buffer+KBufferSize,0,KBufferSize);

 		test.Printf(_L("Issuing Drive.Read 1\n"));

 		r=Drive.Read(pos64,KBufferSize,rptr); 

 		test(r==KErrNone);

 		test.Printf(KSemiColon);		

 		}

 		{

 		// Second read - to different partition than that targeted by the active write

 		// This read should check the overlap and proceed without being deferred

 		TInt64 pos64 = MAKE_TINT64(0, DriveCaps.iPartitionSize);

 		TPtr8 rptr(Buffer+KBufferSize,0,KBufferSize);

 		test.Printf(_L("Issuing Drive.Read 2\n"));

 		r=Drive.Read(pos64,KBufferSize,rptr); // Should collide with second write

 		test(r==KErrNone);

 		test.Printf(KSemiColon);		

 		}

 		{

 		// Third read - due to the tight poll timer period, this will not be scheduled 

 		// until the write request has completed - so does not exercise read while write.

 		TInt64 pos64 = MAKE_TINT64(0, DriveCaps.iPartitionSize);

 		TPtr8 rptr(Buffer+KBufferSize,0,KBufferSize);

 		test.Printf(_L("Issuing Drive.Read 3\n"));

 		r=Drive.Read(pos64,KBufferSize,rptr);

 		test(r==KErrNone);

 		test.Printf(KSemiColon);		

 		}

 		test.Printf(_L("\nForeground Read OK\n"));

 		r=WaitForAsyncWrite();

 		test(r==KErrNone);

 		}

 #endif		

 	// Clean up

 	r=Drive.Format(0,EbSz);

 	r=Drive.Format(DriveCaps.iEraseBlockSize,EbSz);

 	r=Drive.Format((DriveCaps.iEraseBlockSize*2),EbSz);

 	r=Drive.Format((DriveCaps.iEraseBlockSize*3),EbSz);

 /*****************************************************************************************************

 	Tests for M18 NOR Flash devices

 	These tests assume that object mode and control mode is supported

  *****************************************************************************************************/

 	if((DriveCaps.iControlModeSize !=0) && (DriveCaps.iObjectModeSize != 0))

 		{

 		// Control mode writes

 		// Prove that control mode writes are supported

 		// This requires that data is formatted such that areas coinciding with the "B" Half of a

 		// programming region are set to all 0xFFs

 		// Write to programming region zero

 		test.Next(_L("\nControl mode writes"));

 		r=DoControlModeWriteAndVerify(0xa5a5a5a5, 0);

 		test(r==KErrNone);

 		// Now verify that data written in control mode can be further modified

 		// Do this by ANDing the read-back pattern with a mask that clears particular bits

 		// then write the resulting pattern back to the region

 		r=DoControlModeWriteAndVerify(0x84848484, 0);

 		test(r==KErrNone);

 		// Now verify that data written in control mode can be further modified to all 0x00s

 		// Do this by ANDing the read-back pattern with a mask that clears the remaining bits

 		// then write the resulting pattern back to the region

 		r=DoControlModeWriteAndVerify(0x00000000, 0);

 		test(r==KErrNone);

 		// Erase the block before attempting to re-use the programming region for object mode writing

 		test.Printf(_L("\nErase block 0 before object mode write"));

 		r=Drive.Format(0,EbSz);

 		test(r==KErrNone);

 		test.Next(_L("\n(Subsequent) Object mode writes"));

 		// Control mode writes

 		// Prove that object mode writes are allowd to an erased block that was previously

 		// used in control mode

 		// Use offset zero and length equal to one-quarter of the allowed object mode size (i.e. one-

 		// quarter of the lengh of the programming region) (The write test, above, wrote an entire region

 		// in object mode)

 		test.Printf(_L("\nObject mode write, object mode size=%d"),DriveCaps.iObjectModeSize);

 		r=DoObjectModeWriteAndVerify(0, (DriveCaps.iObjectModeSize>>2));

 		test(r==KErrNone);

 		// Prove that an attempt to append data to an object mode region fails

 		test.Printf(_L("\nAttempt append to object mode region"));

 		r=DoObjectModeWriteAndVerify((DriveCaps.iObjectModeSize>>2),(DriveCaps.iObjectModeSize>>2));

 		test(r==KErrGeneral);

 		// Erase the block after a failed write and before attempting to re-use for programming

 		test.Printf(_L("\nErase block 0 after failed object mode write"));

 		r=Drive.Format(0,EbSz);

 		test(r==KErrNone);

 		test.Next(_L("\n(Subsequent) Object mode writes following an error"));

 		// write to a new object mode region after a failed write and before attempting to erase the block

 		// Prove that erase block can be re-written to

 		test.Printf(_L("\nObject mode write following failed write and erase"));

 		r=DoObjectModeWriteAndVerify(0, (DriveCaps.iObjectModeSize>>2));

 		test(r==KErrNone);

 		// Cause a failed object mode write

 		r=DoObjectModeWriteAndVerify(0, (DriveCaps.iObjectModeSize>>2));

 		test(r==KErrGeneral);

 		// the status register has an error.  Attempt to write in a new region and ensure that it succeeds

 		r=DoObjectModeWriteAndVerify(DriveCaps.iObjectModeSize, DriveCaps.iObjectModeSize);

 		test(r==KErrNone);

 		test.Next(_L("\n(Subsequent) Control mode writes following previous use in object mode"));

 		// Re-use a former object mode region for control mode writes

 		// Erase the block after a failed write and before attempting to re-use for programming

 		r=Drive.Format(0,EbSz);

 		test(r==KErrNone);

 		r=DoControlModeWriteAndVerify(0xa5a5a5a5, 0);

 		test(r==KErrNone);

 		// Verify that data written in control mode can be further modified

 		r=DoControlModeWriteAndVerify(0x84848484, 0);

 		test(r==KErrNone);

 		test.Next(_L("\n(Subsequent) Control mode writes following an error"));

 		// Test that a control mode write can succeed after a previous error

 		// Use a failed object mode write attempt to the "B" half of a control mode region

 		// to cause the error

 		r=DoObjectModeWriteAndVerify(DriveCaps.iControlModeSize,(DriveCaps.iObjectModeSize>>2));

 		test(r==KErrGeneral);

 		r=DoControlModeWriteAndVerify(0x00000000, 0);

 		test(r==KErrNone);

 		test.Next(_L("\nControl mode boundary write test"));

 		r=DoControlModeBoundaryWriteAndVerify();

 		test(r==KErrNone);

 	}

 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////

 	test.Printf(_L("Press any key...\n"));

 	test.Getch();

 	test.End();

 	return KErrNone;

 	}