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

 // wins\specific\lffsdev.cpp

 // 

 //

 #include <flash_media.h>

 #include <emulator.h>

 #include <property.h>

 #define FLASH_FAULT()	Kern::Fault("LFFSDEV",__LINE__)

 //#define M18_EMULATION // Test for Control Mode operation

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

  * Driver definitions

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

 /** LFFS image name */

 const CHAR KLfsFileName[] = "LFSLDRV.BIN";

 //-- default values for LFFS related entries in "epoc.ini" file

 const TInt      KDefaultFlashSize = 0x400000;   //-- "FlashSize"        entry, default 4MB

 const TInt      KEraseBlockSize   = 0x20000;	//-- "FlashEraseSize"   entry, default 128KB

 const TUint32   KFlashEraseTime   =	1000000;	//-- "FlashEraseTime"   entry, default 1s

 const TInt      KWriteBlockSize   = 64;         //-- "FlashWriteSize"   entry

 const TInt      KFlashWriteTime   = 406;		//-- "FlashWriteTime"   entry, default 406us

 const TInt      KResumeTime       = 5000;		//-- "FlashResumeTime"  entry, default 5ms

 //-- other possible LFFS related entries in "epoc.ini" file:

 //-- "FlashHoldOffTime"   default value = iEraseTime/10

 //-- "FlashForceImgMount" default value = 0. If not 0 LFFS image will be mounted as it is, even if it doesn't have TLfsParams structure in the end.

 //-- Moreover, it won't be zero filled and TLfsParams structure won't be written at the end of the image file.

 //-- shall be useful for dealing with real images from the real devices

 /** 

     This cunning structure is supposed to be at the very end of the LFFS image file. If it is not foung there, 

     the image gets zero-filled (depends on "FlashForceImgMount" flag in epoc.ini). 

 */

 struct TLfsParams

 	{

 	TInt iEraseSize;

 	};

 #ifdef _DEBUG

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

  * ControlIO command types - for debug builds, only

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

 enum TCtrlIoTypes

 	{

 	//KCtrlIoRww=0,

 	KCtrlIoTimeout=1

 	};

 #endif

 const TInt KDataBufSize=1024;

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

  * Media driver class

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

 class DMediaDriverFlashWin32 : public DMediaDriverFlash

 	{

 public:

 	enum TState

 		{

 		EIdle=0,

 		EWriting=1,

 		EEraseNoSuspend=2,

 		EErase=3,

 		ESuspendPending=4,

 		ESuspending=5,

 		ESuspended=6,

 		EErasePending=7

 		};

 public:

 	DMediaDriverFlashWin32(TInt aMediaId);

 public:

 	// replacing pure virtual - FLASH device specific stuff

 	virtual TInt Initialise();

 	virtual TUint32 EraseBlockSize();

 	virtual TUint32 TotalSize();

 	virtual TInt DoRead();

 	virtual TInt DoWrite();

 	virtual TInt DoErase();

 	virtual TInt Caps(TLocalDriveCapsV2& caps);

 public:

 	void HandleEvent();

 	void StartTimer(TInt aMicros);

 	void StartErase();

 	void SuspendErase();

 	void CompleteErase();

 	void CompleteWrite();

 	void CompleteSuspend();

 	void StartPendingRW();

 	void ReadFlashParameters();

 public:

 	static void TimerFn(TAny* aPtr);

 	static void EventDfc(TAny* aPtr);

 #ifdef _DEBUG

 public:

     enum TCtrlIoState {/*EIdle=0,ECtrlIoWaitWr=1,ECtrlIoWaitRd=2,ECtrlIoWrActive=3,*/ECtrlIoTimeOutPrep=4};

     TInt ControlIO(TInt aCommand,TAny* aParam1,TAny* /*aParam2*/);

 	TInt Request(TLocDrvRequest& m);

 #endif

 public:

 	TState iState;

 	TInt iSize;

 	TInt iEraseBlockSize;

 	TInt iEraseTime;

 	TInt iSuspendHoldOffTime;

 	TInt iResumeTime;

 	TInt iWriteBlockSize;

 	TInt iWriteTime;

 	HANDLE iFile;

 	HANDLE iMapping;

 	TUint8* iBase;

 	TUint8* iData;		// data being written

 	NTimer iTimer;

 	TDfc iEventDfc;

 	TUint32 iTickPeriod;

 	TUint32 iEraseCounter;

 	TUint32 iErasePos;

 	TInt iTimerExtra;

 #ifdef _DEBUG

 public:

     TUint8 iCtrlIoState;

 #endif

 	};

 DMediaDriverFlashWin32::DMediaDriverFlashWin32(TInt aMediaId)

 	:	DMediaDriverFlash(aMediaId),

 		iTimer(&TimerFn,this),

 		iEventDfc(&EventDfc,this,NULL,2),

 		iTickPeriod(NKern::TickPeriod())

 	{

 	// iState=EIdle;

 #ifdef _DEBUG

     //iCtrlIoState=EIdle;

 #endif

 	}

 void DMediaDriverFlashWin32::ReadFlashParameters()

 //

 // Read the flash parameters from the ini file, or use defaults

 //

 	{

 	iSize = Property::GetInt("FlashSize", KDefaultFlashSize);

 	TInt nblocks = Property::GetInt("FlashEraseBlocks", 0);

 	if (nblocks == 0)

 		nblocks = iSize/Property::GetInt("FlashEraseSize", KEraseBlockSize);

 	iEraseBlockSize = iSize / nblocks;

 	__ASSERT_ALWAYS(iEraseBlockSize * nblocks == iSize, FLASH_FAULT());

 	__ASSERT_ALWAYS((iEraseBlockSize & (iEraseBlockSize-1)) == 0, FLASH_FAULT());

 	iEraseTime = Property::GetInt("FlashEraseTime", KFlashEraseTime);

 	iSuspendHoldOffTime = Property::GetInt("FlashHoldOffTime", iEraseTime/10);

 	iResumeTime = Property::GetInt("FlashResumeTime", KResumeTime);

 	iWriteBlockSize = Property::GetInt("FlashWriteSize", KWriteBlockSize);

 	__ASSERT_ALWAYS((iWriteBlockSize & (iWriteBlockSize-1)) == 0, FLASH_FAULT());

 	iWriteTime = Property::GetInt("FlashWriteTime", KFlashWriteTime);

 	}

 TInt DMediaDriverFlashWin32::Initialise()

 	{

 	iEventDfc.SetDfcQ(iPrimaryMedia->iDfcQ);

 	iData=(TUint8*)Kern::Alloc(KDataBufSize);

 	if (!iData)

 		return KErrNoMemory;

 	ReadFlashParameters();

 	// locate/open the file that models the flash

 	CHAR filename[MAX_PATH];

 	strcpy(filename, Property::GetString("EmulatorMediaPath"));

 	if (!Emulator::CreateAllDirectories(filename))

 		return Emulator::LastError();

 	strcat(filename, KLfsFileName);

 	iFile = CreateFileA(filename, GENERIC_READ|GENERIC_WRITE, 0, NULL, OPEN_ALWAYS, FILE_FLAG_RANDOM_ACCESS, NULL);

 	if (iFile == INVALID_HANDLE_VALUE)

 		return Emulator::LastError();

 	TLfsParams p;

 	p.iEraseSize = -1;

 	DWORD bytes;

 	TBool valid;

     //-- try to read TLfsParams structure from the end of the image file.

 	if (SetFilePointer(iFile, iSize, NULL, FILE_BEGIN) != -1

 		&& ReadFile(iFile, &p, sizeof(TLfsParams), &bytes, NULL)

 		&& p.iEraseSize == iEraseBlockSize)

 	{

         valid = ETrue; //-- read it OK.

 	}

 	else

 	{//-- couldn't read TLfsParams structure from the end of the image file.

      //-- if "FlashForceImgMount" parameter from epoc.ini is 0 or not present,

      //-- zero-fill the lffs image file and write TLfsParams structure at the end of the file.

 		const TInt forceImgMount = Property::GetInt("FlashForceImgMount", 0);

         if(!forceImgMount)

 		{

 		p.iEraseSize = iEraseBlockSize;

 		if (SetFilePointer(iFile,iSize, NULL, FILE_BEGIN) == -1

 			|| !WriteFile(iFile, &p, sizeof(p), &bytes, NULL)

 			|| !SetEndOfFile(iFile))

 			return Emulator::LastError();

 		valid = EFalse;

 		}

         else

         {//-- mount LFFS image forcingly.

             valid = ETrue;

         }

 	}

 	iMapping = CreateFileMappingA(iFile, NULL, PAGE_READWRITE, 0, iSize, NULL);

 	if (iMapping == NULL)

 		return Emulator::LastError();

 	iBase = (TUint8*)MapViewOfFile(iMapping, FILE_MAP_WRITE, 0, 0, iSize);

 	if (iBase == NULL)

 		return Emulator::LastError();

 	//-- zero-fill media image it doesn't contain TLfsParams data at the very end.

 	if (!valid)

 	    {

 		memclr(iBase, iSize);

         }

 	return KErrNone;

 	}

 TUint32 DMediaDriverFlashWin32::EraseBlockSize()

 	{

 	return iEraseBlockSize;

 	}

 TUint32 DMediaDriverFlashWin32::TotalSize()

 	{

 	return iSize;

 	}

 TInt DMediaDriverFlashWin32::DoRead()

 	{

 	if (iWriteReq)

 		return 1;	// write in progress so defer read

 	__KTRACE_OPT(KLOCDRV,Kern::Printf("Flash:DoRead"));

 	if (iState==EErasePending)

 		{

 		iTimer.Cancel();

 		iState = ESuspended;

 		}

 	if (iState==EIdle || iState==ESuspended)

 		{

 		// can do the read now

 		TInt pos=(TInt)iReadReq->Pos();

 		TInt len=(TInt)iReadReq->Length();

 		TPtrC8 des(iBase+pos,len);

 		TInt r=iReadReq->WriteRemote(&des,0);

 		Complete(EReqRead,r);

 		if (iState==ESuspended)

 			StartErase();

 		}

 	else if (iState==EErase)

 		{

 		// erase in progress - suspend it

 		SuspendErase();

 		}

 	else if (iState==EEraseNoSuspend)

 		iState=ESuspendPending;

 	// wait for suspend to complete

 	return KErrNone;

 	}

 TInt DMediaDriverFlashWin32::DoWrite()

 	{

 	if (iReadReq)

 		return 1;	// read in progress so defer write

 	if (iState==EErasePending)

 		{

 		iTimer.Cancel();

 		iState = ESuspended;

 		}

 	if (iState==EIdle || iState==ESuspended)

 		{

 		// can start the write now

 		__KTRACE_OPT(KLOCDRV,Kern::Printf("Flash:Write Pos=%08x Length=%08x RemDesOff=%08x",

 											(TInt)iWriteReq->Pos(),(TInt)iWriteReq->Length(),iWriteReq->RemoteDesOffset()));

 		if (iState==EIdle)

 			iState=EWriting;

 		TInt pos = (TInt)iWriteReq->Pos();

 		TInt end = pos + (TInt)iWriteReq->Length();

 		pos &= ~(iWriteBlockSize-1);

 		end = (end + iWriteBlockSize-1) & ~(iWriteBlockSize-1);

 		StartTimer(((end-pos)/iWriteBlockSize) * iWriteTime);

 		}

 	else if (iState==EErase)

 		{

 		// erase in progress - suspend it

 		SuspendErase();

 		}

 	else if (iState==EEraseNoSuspend)

 		iState=ESuspendPending;

 	// wait for suspend to complete

 	return KErrNone;

 	}

 void DMediaDriverFlashWin32::CompleteWrite()

 //

 // Do the actual write in the completion

 // Transfer data in blocks from the client and AND it to the 'flash'

 //

 	{

 	__KTRACE_OPT(KLOCDRV,Kern::Printf("Flash:WriteComplete"));

 	TInt r = KErrNone;

 	TUint8* flash = iBase + (TInt)iWriteReq->Pos();

 	TInt len = (TInt)iWriteReq->Length();

 	TInt offset = 0;

 	while (len > 0)

 		{

 		TInt size = Min(len, KDataBufSize);

 		TPtr8 des(iData,size);

 		r = iWriteReq->ReadRemote(&des, offset);

 		if (r!=KErrNone)

 			break;

 		len -= size;

 		offset += size;

 		const TUint8* ptr = iData;

 		do

 			{

 			*flash++ &= *ptr++;

 			} while (--size > 0);

 		}

 	if (iState == EWriting)

 		iState = EIdle;

 	Complete(EReqWrite,r);

 	if (iState == ESuspended)

 		StartErase();

 	}

 TInt DMediaDriverFlashWin32::DoErase()

 	{

 	if (iReadReq || iWriteReq)

 		return 1;		// read or write in progress so defer this request

 	TInt pos=(TUint32)iEraseReq->Pos();

 	TInt len=(TUint32)iEraseReq->Length();

 	__KTRACE_OPT(KLOCDRV,Kern::Printf("Flash:DoErase %d@%08x",len,pos));

 	if (len!=iEraseBlockSize)

 		return KErrArgument;	// only allow single-block erase

 	if (pos & (iEraseBlockSize-1))

 		return KErrArgument;	// start position must be on erase block boundary

 	__ASSERT_ALWAYS(iState==EIdle,FLASH_FAULT());

 	iErasePos=pos;

 	StartErase();

 	return KErrNone;

 	}

 void DMediaDriverFlashWin32::StartTimer(TInt aMicros)

 	{

 	aMicros += iTimerExtra - (iTickPeriod>>1);

 	if (aMicros < 0)

 		{

 		iTimerExtra = aMicros + (iTickPeriod>>1);

 		iEventDfc.Enque();		// go off 'immediately'

 		}

 	else

 		{

 		iTimerExtra = 0;

 		iTimer.OneShot(aMicros / iTickPeriod);

 		}

 	}

 void DMediaDriverFlashWin32::TimerFn(TAny* aPtr)

 	{

 	((DMediaDriverFlashWin32*)aPtr)->iEventDfc.Add();

 	}

 void DMediaDriverFlashWin32::EventDfc(TAny* aPtr)

 	{

 	((DMediaDriverFlashWin32*)aPtr)->HandleEvent();

 	}

 void DMediaDriverFlashWin32::HandleEvent()

 	{

 	__KTRACE_OPT(KLOCDRV,Kern::Printf("Flash:Event %d", iState));

 	switch (iState)

 		{

 	case ESuspended:

 	case EWriting:	// write completed

 		{

 #ifdef _DEBUG

 		if(iCtrlIoState==ECtrlIoTimeOutPrep)

 			{

 			iState=EIdle;

 			iCtrlIoState=EIdle;

 			Complete(EReqWrite,KErrNotReady);

 			}

 		else

 #endif

 			CompleteWrite();

 		break;

 		}

 	case EEraseNoSuspend:

 		{

 #ifdef _DEBUG

 		if(iCtrlIoState==ECtrlIoTimeOutPrep)

 			{

 			iState=EIdle;

 			iCtrlIoState=EIdle;

 			Complete(EReqErase,KErrNotReady);

 			}

 		else

 			{

 #endif

 		TInt remain = iEraseCounter - NKern::TickCount();

 		if (remain <= 0)

 			CompleteErase();

 		else

 			{

 			iState=EErase;

 			StartTimer(remain * iTickPeriod);

 			}

 #ifdef _DEBUG

 			}

 #endif

 		break;

 		}

 	case EErasePending:

 		StartErase();

 		break;

 	case EErase:	// erase completed

 		CompleteErase();

 		break;

 	case ESuspendPending:

 		if (TInt(iEraseCounter - NKern::TickCount()) <= 0)

 			CompleteErase();

 		else

 			SuspendErase();

 		break;

 	case ESuspending:

 		CompleteSuspend();

 		break;

 	default:

 		__KTRACE_OPT(KPANIC,Kern::Printf("iState=%d",iState));

 		FLASH_FAULT();

 		}

 	}

 void DMediaDriverFlashWin32::StartErase()

 //

 // Continue an erase - iEraseCounter has the remaining time for the erase

 //

 	{

 	__KTRACE_OPT(KLOCDRV,Kern::Printf("Flash:StartErase %08x",iBase+iErasePos));

 	switch (iState)

 		{

 	case ESuspended:

 		iState = EErasePending;

 		StartTimer(iResumeTime);

 		break;

 	case EIdle:	// starting to erase

 		iEraseCounter = iEraseTime;

 	case EErasePending:

 		{

 		iState = EEraseNoSuspend;

 		TUint32 remain = iEraseCounter;

 		iEraseCounter = NKern::TickCount() + remain/iTickPeriod;

 		StartTimer(Min(remain, iSuspendHoldOffTime));

 		}

 		break;

 	default:

 		__KTRACE_OPT(KPANIC,Kern::Printf("iState=%d",iState));

 		FLASH_FAULT();

 		}

 	}

 void DMediaDriverFlashWin32::SuspendErase()

 	{

 	__ASSERT_ALWAYS(iState==EErase || iState==ESuspendPending,FLASH_FAULT());

 	__KTRACE_OPT(KLOCDRV,Kern::Printf("Flash:SuspendErase %08x",iBase+iErasePos));

 	iTimer.Cancel();

 	TInt remain = Max(0, TInt(iEraseCounter - NKern::TickCount()));

 	iEraseCounter = remain * iTickPeriod;

 	iState = ESuspending;

 	StartTimer(0);

 	}

 void DMediaDriverFlashWin32::CompleteSuspend()

 	{

 	// erase suspend completion

 	__KTRACE_OPT(KLOCDRV,Kern::Printf("Flash:SuspendComplete"));

 	iState = ESuspended;

 	// start any pending read or write requests

 	StartPendingRW();

 	}

 void DMediaDriverFlashWin32::CompleteErase()

 //

 // Do the actual erase in the completion

 //

 	{

 	// erase completion

 	__KTRACE_OPT(KLOCDRV,Kern::Printf("Flash:EraseComplete"));

 	memset(iBase + iErasePos, 0xff, iEraseBlockSize);

 	// complete the erase request

 	iState = EIdle;

 	Complete(EReqErase,KErrNone);

 	// start any pending read or write requests

 	StartPendingRW();

 	}

 void DMediaDriverFlashWin32::StartPendingRW()

 	{

 	// start any pending read or write requests

 	if (iReadReq)

 		DoRead();

 	if (iWriteReq)

 		DoWrite();

 	}

 #ifdef _DEBUG

 // Override the base class version in order to provide access to ControlIO

 //

 TInt DMediaDriverFlashWin32::Request(TLocDrvRequest& m)

 	{

 	TInt r;

 	TInt id=m.Id();

 	__KTRACE_OPT(KLOCDRV,Kern::Printf(">DMediaDriverFlashWin32::Request %d",id));

 	if (id!=DLocalDrive::EControlIO)

 		{

 		r=DMediaDriverFlash::Request(m);

 		return r;

 		}

 	r=ControlIO((TInt)m.iArg[0],m.iArg[1],m.iArg[2]);

 	DMediaDriver::Complete(m,r);

 	return r;

 	}

 TInt DMediaDriverFlashWin32::ControlIO(TInt aCommand,TAny* /*aParam1*/,TAny* /*aParam2*/)

 	{

 	switch (aCommand)

 		{

 		case(KCtrlIoTimeout):

 			{

 			__KTRACE_OPT(KLOCDRV,Kern::Printf("Flash:DoControlIO invoked for KCtrlIoTimeout"));

 			// The aim of this test is simulate a flash timeout (and so exercise the consequent

 			// actions of the software that initiated the request)				

 			if(iCtrlIoState!=EIdle)

 				{

 				__KTRACE_OPT(KLOCDRV,Kern::Printf("Flash: ControlIO request before previous completed"));

 				return KErrServerBusy;

 				}

 			else

 				{

 				__KTRACE_OPT(KLOCDRV,Kern::Printf("Flash: ControlIO timeout initiated"));

 				iCtrlIoState=ECtrlIoTimeOutPrep;

 				}

 			break;

 			}

 		default:

 			{

 			__KTRACE_OPT(KLOCDRV,Kern::Printf("Flash: ERROR - unrecognised ControlIO command %d",aCommand));

 			FLASH_FAULT();

 			break;

 			}

 		}

 	return KErrNone;

 	}

 #endif

 TInt DMediaDriverFlashWin32::Caps(TLocalDriveCapsV2& aCaps)

 // On return, aCaps data contains capability information about the 

 // flash device, in the form of a class derived from TLocalDriveCapsV2. 

 // The size of the derived class should not exceed KMaxLocalDriveCapsLength 

 // which is defined and used in e32\drivers\locmedia\locmedia.cpp. If a 

 // larger sized capabilities class is used, and this code is modified to 

 // write to member data beyond KMaxLocalDriveCapsLength this will cause a 

 // fault.

 	{

 	// Invoke the base class method then update the sizes for

 	// Control Mode and Object Mode as required.

 	DMediaDriverFlash::Caps(aCaps);

 #if defined (M18_EMULATION)

 	TLocalDriveCapsV7* caps = &((TLocalDriveCapsV7&)(aCaps));

 	caps->iControlModeSize=16;

 	caps->iObjectModeSize=1024;

     __KTRACE_OPT( KLOCDRV, Kern::Printf("MLFS: ) ControlModeSize UPDATED as=0x%x", caps->iControlModeSize) );

     __KTRACE_OPT( KLOCDRV, Kern::Printf("MLFS: ) ObjectModeSize UPDATED as=0x%x", caps->iObjectModeSize) );

 #endif

 	return KErrCompletion;	// synchronous completion

 	}

 DMediaDriverFlash* DMediaDriverFlash::New(TInt aDevice)

 	{

 	return new DMediaDriverFlashWin32(aDevice);

 	}