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