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

		}