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