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