// Copyright (c) 2004-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:

// template\Template_Variant\Specific\lffsdev.cpp

// Implementation of a Logging Flash file system (LFFS) physical device driver 

// for a standard Common Flash Interface (CFI) based NOR flash chip.

// This file is part of the Template Base port

// N.B. This sample code assumes that:

// (1)	the device does not provide an interrupt i.e. it needs to be polled using a timer 

// to ascertain when an Erase/Write operation has completed.

// (2) the flash chip does not have 'read-while-write' support.

// 

//

#include "lffsdev.h"

#include "variant.h"

#ifdef _DEBUG

#define CHANGE_ERASE_STATE(x)	{TUint32 s=iEraseState; iEraseState=x; __KTRACE_OPT(KLOCDRV,Kern::Printf("ErSt: %d->%d",s,x));}

#else

#define CHANGE_ERASE_STATE(x)	iEraseState=x

#endif

//

// TO DO: (mandatory)

//

// Define the pyhsical base address of the NOR-Flash

// This is only example code... you will need to modify it for your hardware

const TPhysAddr KFlashPhysicalBaseAddress = 0x04000000;

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

 * Common Flash Interface (CFI) query stuff

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

/**

Read an 8-bit value from the device at the specified offset

@param	aOffset	the address in device words 

*/

TUint32 DMediaDriverFlashTemplate::ReadQueryData8(TUint32 aOffset)

	{

	volatile TUint8* pF=(volatile TUint8*)(iBase+FLASH_ADDRESS_IN_BYTES(aOffset));

	return pF[0];

	}

/**

Read a 16-bit value from the device at the specified offset

@param	aOffset	the address in device words 

*/

TUint32 DMediaDriverFlashTemplate::ReadQueryData16(TUint32 aOffset)

	{

	volatile TUint8* pF=(volatile TUint8*)(iBase);

	return 

		 pF[FLASH_ADDRESS_IN_BYTES(aOffset+0)] | 

		(pF[FLASH_ADDRESS_IN_BYTES(aOffset+1)] << 8);

	}

/**

 Put the device into query mode to read the flash parameters.

 */

void DMediaDriverFlashTemplate::ReadFlashParameters()

	{

	volatile TFLASHWORD* pF=(volatile TFLASHWORD*)iBase + KCmdReadQueryOffset;

	*pF=KCmdReadQuery;

	TUint32 qd=ReadQueryData16(KQueryOffsetQRY)|(ReadQueryData8(KQueryOffsetQRY+2)<<16);

	__KTRACE_OPT(KLOCDRV,Kern::Printf("Flash:Query QRY=%08x",qd));

	__ASSERT_ALWAYS(qd==0x595251,FLASH_FAULT());

	qd = FLASH_BUS_DEVICES << ReadQueryData8(KQueryOffsetSizePower);

	__KTRACE_OPT(KLOCDRV,Kern::Printf("Flash:Query Size=%08x",qd));

	iTotalSize=qd;

	qd = FLASH_BUS_DEVICES << ReadQueryData16(KQueryOffsetWriteBufferSizePower);

	__KTRACE_OPT(KLOCDRV,Kern::Printf("Flash:Query WBSize=%08x",qd));

	iWriteBufferSize=qd;

	qd = (ReadQueryData16(KQueryOffsetEraseBlockSize)) << (8 + FLASH_BUS_DEVICES-1);

	__KTRACE_OPT(KLOCDRV,Kern::Printf("Flash:Query EBSize=%08x",qd));

	iEraseBlockSize=qd;

	*pF=KCmdReadArray;

	}

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

 * Common Flash Interface (CFI) main code

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

/**

NOR flash LFFS constructor.

@param aMediaId            Media id number from ELOCD

*/

DMediaDriverFlashTemplate::DMediaDriverFlashTemplate(TInt aMediaId)

	:	DMediaDriverFlash(aMediaId),

		iHoldOffTimer(HoldOffTimerFn,this),

		iEventDfc(EventDfc,this,NULL,2)

	{

	// iWriteState = EWriteIdle;

	// iEraseState = EEraseIdle;

	}

/**

Device specific implementation of the NOR LFFS initialisation routine.

@see DMediaDriverFlash::Initialise

@return KErrNone unless the write data buffer couldn't be allocated or the

         timer interrupt could not be bound.

 */

TInt DMediaDriverFlashTemplate::Initialise()

	{

	iEventDfc.SetDfcQ(iPrimaryMedia->iDfcQ);

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

	if (!iData)

		return KErrNoMemory;

	// Create temporary HW chunk to read FLASH device parameters (especially size)

	DPlatChunkHw* pC = NULL;

	TInt r = DPlatChunkHw::New(pC, KFlashPhysicalBaseAddress, 0x1000, EMapAttrSupRw|EMapAttrFullyBlocking);

	if (r!=KErrNone)

		return r;

	iBase = pC->LinearAddress();

	ReadFlashParameters();

	// close temporary chunk and open chunk with correct size

	pC->Close(NULL);

	r = DPlatChunkHw::New(iFlashChunk, KFlashPhysicalBaseAddress, iTotalSize, EMapAttrSupRw|EMapAttrFullyBlocking);

	if (r!=KErrNone)

		return r;

	iBase = iFlashChunk->LinearAddress();

	r=Interrupt::Bind(KIntIdTimer1, Isr, this);

	if (r!=KErrNone)

		{

		__KTRACE_OPT(KLOCDRV, Kern::Printf("Flash:Isr Bind failed"));

		return r;

		}

	// TO DO: (mandatory)

	// Write to the appropriate hardware register(s) to

	// configure (if necessary) and enable the timer hardware

	//

	// Enable the timer interrupt

	Interrupt::Enable(KIntIdTimer1);

	return KErrNone;

	}

/**

Used by the generic flash media driver code to get the erase block size in

bytes. 

 */

TUint32 DMediaDriverFlashTemplate::EraseBlockSize()

	{

	return iEraseBlockSize;

	}

/**

@return Return size of lffs in bytes

*/

TUint32 DMediaDriverFlashTemplate::TotalSize()

	{

	return iTotalSize;

	}

/**

Read at the location indicated by DMediaDriverFlash::iReadReq. 

Where Pos() is the read location

@return >0			Defer request to ELOCD. A write is in progress

@return KErrNone	Erase has been started

@return <0			An error has occured.

*/

TInt DMediaDriverFlashTemplate::DoRead()

	{

	if (iWriteReq)

		return KMediaDriverDeferRequest;	// write in progress so defer read

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

	if (iEraseState==EEraseIdle || iEraseState==ESuspended)

		{

		// can do the read now

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

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

		__KTRACE_OPT(KLOCDRV,Kern::Printf("Flash:DoRead ibase: %x, pos: %x, len: %x",iBase,pos,len));

		// Issue a read array command

		// Porting note: Some devices may work without this step.

		// Ensure that the write is always dword aligned

		volatile TFLASHWORD* pF=(volatile TFLASHWORD*)((iBase+pos)&0xFFFFFFF0);

		*pF=KCmdReadArray;

		TPtrC8 des((const TUint8*)(iBase+pos),len);

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

		Complete(EReqRead,r);

		// resume erase if necessary

		if (iEraseState==ESuspended)

			StartErase();

		}

	else if (iEraseState==EErase)

		{

		// erase in progress - suspend it

		SuspendErase();

		}

	else if (iEraseState==EEraseNoSuspend)

		CHANGE_ERASE_STATE(ESuspendPending);	// wait for suspend to complete

	return KErrNone;

	}

/**

Write at the location indicated by DMediaDriverFlash::iWriteReq

@return >0			Defer request to ELOCD. A read is in progress

@return KErrNone	Erase has been started

@return <0			An error has occured.

 */

TInt DMediaDriverFlashTemplate::DoWrite()

	{

	if (iReadReq)

		return KMediaDriverDeferRequest;	// read in progress so defer write

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

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

	if (len==0)

		return KErrCompletion;

	TUint32 wb_mask=iWriteBufferSize-1;

	iWritePos=pos & ~wb_mask;	// round media position down to write buffer boundary

	TInt wb_off=pos & wb_mask;	// how many bytes of padding at beginning

	TInt start_len=Min(len,KDataBufSize-(TInt)wb_off);

	TInt write_len=(start_len+wb_off+wb_mask)&~wb_mask;

	memset(iData,0xff,iWriteBufferSize);

	memset(iData+write_len-iWriteBufferSize,0xff,iWriteBufferSize);

	TPtr8 des(iData+wb_off,0,start_len);

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

	if (r!=KErrNone)

		return r;

	iWriteReq->RemoteDesOffset()+=start_len;

	iWriteReq->Length()-=start_len;

	iDataBufPos=0;

	iDataBufRemain=write_len;

	iWriteError=KErrNone;

	__KTRACE_OPT(KLOCDRV,Kern::Printf("Flash:Write iWritePos=%08x iDataBufRemain=%x",iWritePos,iDataBufRemain));

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

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

	if (iEraseState==EEraseIdle || iEraseState==ESuspended)

		{

		// can start the write now

		iWriteState=EWriting;

		WriteStep();

		}

	else if (iEraseState==EErase)

		{

		// erase in progress - suspend it

		SuspendErase();

		}

	else if (iEraseState==EEraseNoSuspend)

		CHANGE_ERASE_STATE(ESuspendPending);	// wait for suspend to complete

	return KErrNone;

	}

void DMediaDriverFlashTemplate::WriteStep()

	{

	__KTRACE_OPT(KLOCDRV,Kern::Printf("Flash:WriteStep @%08x",iWritePos));

	if (iDataBufRemain)

		{

		// still data left in buffer

		volatile TFLASHWORD* pF=(volatile TFLASHWORD*)(iBase+iWritePos);

		TInt i=KMaxWriteSetupAttempts;

		*pF=KCmdClearStatusRegister;

		TUint32 s=0;

		for (; i>0 && ((s&KStsReady)!=KStsReady); --i)

			{

			*pF=KCmdWriteToBuffer;		// send write command

			*pF=KCmdReadStatusRegister;	// send read status command

			s=*pF;						// read status reg

			}

		__KTRACE_OPT(KLOCDRV,Kern::Printf("i=%d, s=%08x",i,s));

		// calculate the buffer size in words -1 

		TFLASHWORD l = (FLASH_BYTES_TO_WORDS(iWriteBufferSize)) - 1;

#if FLASH_BUS_DEVICES == 2		// 2x16bit or 2x8bit devices

		l|= l<< BUS_WIDTH_PER_DEVICE;

#elif FLASH_BUS_DEVICES == 4	// 4x8bit device

		l|= (l<<BUS_WIDTH_PER_DEVICE) | (l<<BUS_WIDTH_PER_DEVICE*2) (l<<BUS_WIDTH_PER_DEVICE*3);

#endif

		// write the data length in words to the device(s)

		*pF=l;

		const TFLASHWORD* pS=(const TFLASHWORD*)(iData+iDataBufPos);

		// write the data

		TInt len;

		for (len = l; len>=0; len--)

			{

			*pF++=*pS++;

			}

		*(volatile TFLASHWORD *)(iBase+iWritePos) = KCmdConfirm; 

		// set up timer to poll for completion

		StartPollTimer(KFlashWriteTimerPeriod,KFlashWriteTimerRetries);

		iWritePos+=iWriteBufferSize;

		iDataBufPos+=iWriteBufferSize;

		iDataBufRemain-=iWriteBufferSize;

		if (!iDataBufRemain)

			{

			// refill buffer

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

			if (!len)

				return;	// all data has been written, complete request next time

			TUint32 wb_mask=iWriteBufferSize-1;

			TInt block_len=Min(len,KDataBufSize);

			TInt write_len=(block_len+wb_mask)&~wb_mask;

			memset(iData+write_len-iWriteBufferSize,0xff,iWriteBufferSize);

			TPtr8 des(iData,0,block_len);

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

			if (r!=KErrNone)

				{

				iWriteError=r;

				return;	// leave iDataBufRemain=0 so request is terminated when write completes

				}

			iWriteReq->RemoteDesOffset()+=block_len;

			iWriteReq->Length()-=block_len;

			iDataBufPos=0;

			iDataBufRemain=write_len;

			}

		}

	else

		{

		// write request should have completed, maybe with an error

		__ASSERT_ALWAYS(iWriteReq->Length()==0 || iWriteError,FLASH_FAULT());

		iWriteState=EWriteIdle;

		Complete(EReqWrite,iWriteError);

		if (iEraseState==ESuspended)

			StartErase();

		}

	}

/**

Erase at the location indicated by DMediaDriverFlash::iEraseReq

@return >0			Defer request to ELOCD. Read or a write is in progress

@return KErrNone	Erase has been started

@return <0			An error has occured.

 */

TInt DMediaDriverFlashTemplate::DoErase()

	{

	if (iReadReq || iWriteReq)

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

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

	TUint32 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

	iErasePos=pos;

	__ASSERT_ALWAYS(iEraseState==EEraseIdle,FLASH_FAULT());

	StartErase();

	return KErrNone;

	}

void DMediaDriverFlashTemplate::StartHoldOffTimer()

	{

	// if this is a retry, don't allow suspends

	if (iEraseAttempt==0)

		iHoldOffTimer.OneShot(KEraseSuspendHoldOffTime);

	}

void DMediaDriverFlashTemplate::CancelHoldOffTimer()

	{

	iHoldOffTimer.Cancel();

	ClearEvents(EHoldOffEnd);

	}

void DMediaDriverFlashTemplate::ClearEvents(TUint32 aEvents)

	{

	__e32_atomic_and_ord32(&iEvents, ~aEvents);

	}

void DMediaDriverFlashTemplate::HoldOffTimerFn(TAny* aPtr)

	{

	DMediaDriverFlashTemplate* p=(DMediaDriverFlashTemplate*)aPtr;

	p->IPostEvents(EHoldOffEnd);

	}

void DMediaDriverFlashTemplate::StartPollTimer(TUint32 aPeriod, TUint32 aRetries)

	{

	__KTRACE_OPT(KLOCDRV,Kern::Printf("Flash:Tmr %d * %d",aPeriod,aRetries));

	ClearEvents(EPollTimer);

	iPollPeriod=aPeriod;

	iPollRetries=aRetries;

	StartPollTimer();

	}

void DMediaDriverFlashTemplate::StartPollTimer()

	{

	// TO DO: (mandatory)

	// Configure the hardware timer to expire after iPollPeriod ticks

	// and start the timer

	}

void DMediaDriverFlashTemplate::EventDfc(TAny* aPtr)

	{

	DMediaDriverFlashTemplate* p=(DMediaDriverFlashTemplate*)aPtr;

	TUint32 e = __e32_atomic_swp_ord32(&p->iEvents, 0);

	if (e)

		p->HandleEvents(e);

	}

void DMediaDriverFlashTemplate::HandleEvents(TUint32 aEvents)

	{

	__KTRACE_OPT(KLOCDRV,Kern::Printf("Flash:Events %x",aEvents));

	if (aEvents & EHoldOffEnd)

		{

		if (iEraseState==ESuspendPending)

			{

			SuspendErase();

			}

		else if (iEraseState==EEraseNoSuspend)

			{

			CHANGE_ERASE_STATE(EErase);	// can now be suspended

			}

		else

			{

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

			FLASH_FAULT();

			}

		}

	if (aEvents & EPollTimer)

		{

		volatile TFLASHWORD* pF=(volatile TFLASHWORD*)iBase;

		*pF=KCmdReadStatusRegister;

		if ((*pF & KStsReady)!=KStsReady)

			{

			// not ready yet

			if (--iPollRetries)

				{

				// try again

				StartPollTimer();

				}

			else

				// timed out

				aEvents|=ETimeout;

			}

		else

			{

			// ready

			TFLASHWORD s=*pF;	// read full status value

			*pF=KCmdClearStatusRegister;

			DoFlashReady(s);

			}

		}

	if (aEvents & ETimeout)

		{

		DoFlashTimeout();

		}

	}

void DMediaDriverFlashTemplate::StartErase()

	{

	TFLASHWORD s=KStsReady;

	TInt i;

	volatile TFLASHWORD* pF=(volatile TFLASHWORD*)(iBase+iErasePos);

	__KTRACE_OPT(KLOCDRV,Kern::Printf("Flash:StartErase %08x",pF));

	switch (iEraseState)

		{

		case EEraseIdle:	// first attempt to erase

			iEraseAttempt=-1;

			// coverity[fallthrough]

			// fallthrough after attempt

		case EErase:	// retry after verify failed

		case EEraseNoSuspend:

			++iEraseAttempt;

			*pF=KCmdBlockErase;

			*pF=KCmdConfirm;

			CHANGE_ERASE_STATE(EEraseNoSuspend);

			iEraseError=0;

			StartHoldOffTimer();

			break;

		case ESuspended:

			*pF=KCmdClearStatusRegister;

			*pF=KCmdEraseResume;

			CHANGE_ERASE_STATE(EEraseNoSuspend);

			i=KMaxEraseResumeAttempts;

			for (; i>0 && ((s&KStsReady)!=0); --i)

				{

				*pF=KCmdReadStatusRegister;	// send read status command

				s=*pF;						// read status reg

				s=*pF;						// read status reg

				}

			__KTRACE_OPT(KLOCDRV,Kern::Printf("RESUME: i=%d, s=%08x",i,s));

			StartHoldOffTimer();

			break;

		default:

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

			FLASH_FAULT();

		}

	StartPollTimer(KFlashEraseTimerPeriod,KFlashEraseTimerRetries);

	}

void DMediaDriverFlashTemplate::SuspendErase()

	{

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

	volatile TFLASHWORD* pF=(volatile TFLASHWORD*)(iBase+iErasePos);

	__KTRACE_OPT(KLOCDRV,Kern::Printf("Flash:SuspendErase %08x",pF));

	*pF=KCmdEraseSuspend;

	CHANGE_ERASE_STATE(ESuspending);

	StartPollTimer(KFlashSuspendTimerPeriod,KFlashSuspendTimerRetries);

	}

void DMediaDriverFlashTemplate::StartPendingRW()

	{

	// start any pending read or write requests

	if (iReadReq)

		DoRead();

	if (iWriteReq)

		{

		// can start the write now

		iWriteState=EWriting;

		WriteStep();

		}

	}

void DMediaDriverFlashTemplate::DoFlashReady(TUint32 aStatus)

	{

	// could be write completion, erase completion or suspend completion

	if (iWriteState==EWriting)

		{

		// write completion

		__KTRACE_OPT(KLOCDRV,Kern::Printf("Flash:WriteComplete %08x",aStatus));

		TUint32 err=aStatus & (KStsWriteError|KStsVppLow|KStsLocked);

		if (err)

			{

			iWriteState=EWriteIdle;

			Complete(EReqWrite,KErrGeneral);

			if (iEraseState==ESuspended)

				StartErase();

			}

		else

			WriteStep();

		return;

		}

	// put the FLASH back into read mode

	volatile TFLASHWORD* pF=(volatile TFLASHWORD*)(iBase+iErasePos);

	*pF=KCmdReadArray;

	if (iEraseState==ESuspending)

		{

		// erase suspend completion

		__KTRACE_OPT(KLOCDRV,Kern::Printf("Flash:SuspendComplete %08x",aStatus));

		// accumulate errors during erase

		iEraseError|=(aStatus & (KStsEraseError|KStsVppLow|KStsLocked));

		if (aStatus & KStsSuspended)

			{

			// at least one of the two FLASH devices has suspended

			CHANGE_ERASE_STATE(ESuspended);

			// start any pending read or write requests

			StartPendingRW();

			return;					// in case erase has been resumed by DoRead()

			}

		// erase completed before we suspended it

		CHANGE_ERASE_STATE(EErase);

		}

	if (iEraseState==EErase || iEraseState==EEraseNoSuspend)

		{

		// erase completion

		__KTRACE_OPT(KLOCDRV,Kern::Printf("Flash:EraseComplete %08x",aStatus));

		CancelHoldOffTimer();

		// accumulate errors during erase

		iEraseError|=(aStatus & (KStsEraseError|KStsVppLow|KStsLocked));

		TFLASHWORD x = FLASH_ERASE_WORD_VALUE;

		// if no device error, verify that erase was successful

		if (!iEraseError)

			{

			volatile TFLASHWORD* p=pF;

			volatile TFLASHWORD* pE=p + FLASH_BYTES_TO_WORDS(iEraseBlockSize);

			while(p<pE)

				x&=*p++;

			}

		else

			{

			}

		if (x == FLASH_ERASE_WORD_VALUE)

			{

			// erase OK

			__KTRACE_OPT(KLOCDRV,Kern::Printf("Flash:VerifyErase OK"));

			CHANGE_ERASE_STATE(EEraseIdle);

			// complete the erase request

			TInt r=iEraseError?KErrGeneral:KErrNone;

			Complete(EReqErase,r);

			// start any pending read or write requests

			StartPendingRW();

			}

		else

			{

			// erase failed, so retry

			__KTRACE_OPT(KLOCDRV,Kern::Printf("Flash:VerifyErase BAD"));

			StartErase();

			}

		}

	}

void DMediaDriverFlashTemplate::DoFlashTimeout()

	{

	// TO DO: (optional)

	// Take appropriate action to handle a timeout.

	FLASH_FAULT();	// // EXAMPLE ONLY:

	}

DMediaDriverFlash* DMediaDriverFlash::New(TInt aMediaId)

	{

	return new DMediaDriverFlashTemplate(aMediaId);

	}

void DMediaDriverFlashTemplate::Isr(TAny* aPtr)

	{

	DMediaDriverFlashTemplate& d=*(DMediaDriverFlashTemplate*)aPtr;

	// TO DO: (mandatory)

	// Write to the timer hardware register(s) to

	// clear the timer interrupt

	//

	d.IPostEvents(EPollTimer);

	}

void DMediaDriverFlashTemplate::IPostEvents(TUint32 aEvents)

	{

	iEvents|=aEvents;

	iEventDfc.Add();

	}