// Copyright (c) 2005-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:
// e32/drivers/paging/emulated/emulated_rom_paging.cpp
// 
//

#include <kernel/kern_priv.h>
#include <kernel/kernel.h>
#include <memmodel/epoc/platform.h>

class DEmulatedDataPagingDevice : public DPagingDevice
	{
public:
	static TInt Install();
private:
	TInt Construct();
	TInt Read(TThreadMessage* aReq,TLinAddr aBuffer,TUint aOffset,TUint aSize,TInt);
	TInt Write(TThreadMessage* aReq,TLinAddr aBuffer,TUint aOffset,TUint aSize,TBool aBackground);

	static void ReadTimerCallback(TAny* aSem);
	static void ReadDfcCallback(TAny* aReq);
	void ReadDfc();

	static void WriteTimerCallback(TAny* aSem);
	static void WriteDfcCallback(TAny* aReq);
	void WriteDfc();
private:
	TLinAddr iDataStore;
	TDfcQue* iDfcQue;
	DMutex* iMutex;

	struct TDataRequest
		{
		TLinAddr iBuffer;
		TLinAddr iOffset;
		TUint	 iSize;
		NFastSemaphore* iSemaphore;
		TInt iResult;
		};

	TDataRequest iReadRequest;
	TInt iAccumulatedReadDelay;
	TInt iReadPageDelay;
	TInt iReadPageCPUDelay;

	TDataRequest iWriteRequest;
	TInt iAccumulatedWriteDelay;
	TInt iWritePageDelay;
	TInt iWritePageCPUDelay;
	};


TInt DEmulatedDataPagingDevice::Install()
	{
	__KTRACE_OPT2(KPAGING,KBOOT,Kern::Printf(">DEmulatedDataPagingDevice::Install"));
	TInt r;
	DEmulatedDataPagingDevice* dataDevice = new DEmulatedDataPagingDevice;
	if(!dataDevice)
		r = KErrNoMemory;
	else
		{
		r = dataDevice->Construct();
		if(r==KErrNone)
			Kern::InstallPagingDevice(dataDevice);
		else
			delete dataDevice;
		}
	__KTRACE_OPT2(KPAGING,KBOOT,Kern::Printf("<DEmulatedDataPagingDevice::Install returns %d",r));
	return r;
	}


TInt DEmulatedDataPagingDevice::Construct()
	{
	__KTRACE_OPT2(KPAGING,KBOOT,Kern::Printf(">DEmulatedDataPagingDevice::Construct"));

	// Initialise DPagingDevice base class
	iType = EData;
	iReadUnitShift = 9; // 512 byte units
	iName = "EmulatedDataPagingDevice";

	// Calculate swap size
	TInt free = Kern::FreeRamInBytes()>>20; // megabytes free
	TInt swapSize = free/2;
	if(swapSize>256)
		swapSize = 256;
	swapSize <<= 20;
	iSwapSize = swapSize>>iReadUnitShift;
	__KTRACE_OPT2(KPAGING,KBOOT,Kern::Printf("DEmulatedDataPagingDevice::Construct swap size 0x%x",swapSize));

	TInt r = Kern::MutexCreate(iMutex, _L("EmulDataPageDev"), KMutexOrdNone);
	__NK_ASSERT_ALWAYS(r==KErrNone);
	// Create a shared chunk to map the ROM pages
	TChunkCreateInfo info;
	info.iType = TChunkCreateInfo::ESharedKernelSingle;
	info.iMaxSize = swapSize;
	info.iMapAttr = EMapAttrFullyBlocking;
	info.iOwnsMemory = ETrue;
	DChunk* chunk;
	TUint32 mapAttr;
	r = Kern::ChunkCreate(info,chunk,iDataStore,mapAttr);
	__NK_ASSERT_ALWAYS(r==KErrNone);
	r = Kern::ChunkCommit(chunk,0,swapSize);
	__NK_ASSERT_ALWAYS(r==KErrNone);

	// create DFC thread for NAND read simulation
	_LIT8(KDemandPagingDelay,"DataPagingDelay");
	r = Kern::DfcQCreate(iDfcQue,24,&KDemandPagingDelay); // DFC thread of same priority as NAND driver
	__NK_ASSERT_ALWAYS(r==KErrNone);

	// setup delays used for simulation
	SDemandPagingConfig config = Epoc::RomHeader().iDemandPagingConfig;
	iReadPageDelay = config.iSpare[0];
	iReadPageCPUDelay = config.iSpare[1];
	iWritePageDelay = config.iSpare[0]*2;
	iWritePageCPUDelay = config.iSpare[1];
	__KTRACE_OPT2(KPAGING,KBOOT,Kern::Printf("DEmulatedDataPagingDevice::Construct emulated delays=%d,%d",iReadPageDelay,iReadPageCPUDelay));

	__KTRACE_OPT2(KPAGING,KBOOT,Kern::Printf("<DEmulatedDataPagingDevice::Construct"));
	return KErrNone;
	}


TInt DEmulatedDataPagingDevice::Read(TThreadMessage* /*aReq*/,TLinAddr aBuffer,TUint aOffset,TUint aSize,TInt)
	{
	aOffset <<= iReadUnitShift;
	aSize <<= iReadUnitShift;

	if(iReadPageCPUDelay==0 || KDebugNum(KTESTFAST))
		{
		// don't do emulated NAND delay, just copy it immediately...
		memcpy((TAny*)aBuffer,(TAny*)(iDataStore+aOffset),aSize);
		return KErrNone;
		}
	
	// make sure we are single threaded when we use the DFC.
	Kern::MutexWait(*iMutex);
	
	// get a DFC to do the simulated read
	NFastSemaphore sem;
	NKern::FSSetOwner(&sem,NULL);
	iReadRequest.iBuffer = aBuffer;
	iReadRequest.iOffset = aOffset;
	iReadRequest.iSize = aSize;
	iReadRequest.iSemaphore = &sem;
	TDfc dfc(ReadDfcCallback,this,iDfcQue,0);
	dfc.Enque();
	NKern::FSWait(&sem);
	TInt result = iReadRequest.iResult;
	
	// let any other threads have a go.
	Kern::MutexSignal(*iMutex);
	return result;
	}


void DEmulatedDataPagingDevice::ReadTimerCallback(TAny* aSem)
	{
	NKern::FSSignal((NFastSemaphore*)aSem);
	}


void DEmulatedDataPagingDevice::ReadDfcCallback(TAny* aSelf)
	{
	((DEmulatedDataPagingDevice*)aSelf)->ReadDfc();
	}


void DEmulatedDataPagingDevice::ReadDfc()
	{
	// calculate number of ticks to stall to emulate elapsed time for page read request
	iAccumulatedReadDelay += iReadPageDelay;
	TInt tick = NKern::TickPeriod();
	TInt delay = 0;
	if(iAccumulatedReadDelay>tick)
		{
		delay = iAccumulatedReadDelay/tick;
		iAccumulatedReadDelay -= delay*tick+(tick>>1);
		}
	NFastSemaphore sem;
	NKern::FSSetOwner(&sem,NULL);
	NTimer timer(ReadTimerCallback,&sem);
	if(delay)
		timer.OneShot(delay,ETrue);

	// emulate CPU load for processing read
	Kern::NanoWait(iReadPageCPUDelay*1000);

	// get data using memcpy
	memcpy((TAny*)iReadRequest.iBuffer,(TAny*)(iDataStore+iReadRequest.iOffset),iReadRequest.iSize);

	// wait for delay timer
	if(delay)
		NKern::FSWait(&sem);

	// signal done
	iReadRequest.iResult = KErrNone;
	NKern::FSSignal(iReadRequest.iSemaphore);
	}


TInt DEmulatedDataPagingDevice::Write(TThreadMessage* /*aReq*/,TLinAddr aBuffer,TUint aOffset,TUint aSize,TBool aBackground)
	{
	aOffset <<= iReadUnitShift;
	aSize <<= iReadUnitShift;

	if(iWritePageCPUDelay==0 || KDebugNum(KTESTFAST))
		{
		// don't do emulated NAND delay, just copy it immediately...
		memcpy((TAny*)(iDataStore+aOffset),(TAny*)aBuffer,aSize);
		return KErrNone;
		}
	
	// make sure we are single threaded when we use the DFC.
	Kern::MutexWait(*iMutex);
	
	// get a DFC to do the simulated write
	NFastSemaphore sem;
	NKern::FSSetOwner(&sem,NULL);
	iWriteRequest.iBuffer = aBuffer;
	iWriteRequest.iOffset = aOffset;
	iWriteRequest.iSize = aSize;
	iWriteRequest.iSemaphore = &sem;
	TDfc dfc(WriteDfcCallback,this,iDfcQue,0);
	dfc.Enque();
	NKern::FSWait(&sem);
	TInt result = iWriteRequest.iResult;
	
	// let any other threads have a go.
	Kern::MutexSignal(*iMutex);
	return result;
	}


void DEmulatedDataPagingDevice::WriteTimerCallback(TAny* aSem)
	{
	NKern::FSSignal((NFastSemaphore*)aSem);
	}


void DEmulatedDataPagingDevice::WriteDfcCallback(TAny* aSelf)
	{
	((DEmulatedDataPagingDevice*)aSelf)->WriteDfc();
	}


void DEmulatedDataPagingDevice::WriteDfc()
	{
	// calculate number of ticks to stall to emulate elapsed time for page read request
	iAccumulatedWriteDelay += iWritePageDelay;
	TInt tick = NKern::TickPeriod();
	TInt delay = 0;
	if(iAccumulatedWriteDelay>tick)
		{
		delay = iAccumulatedWriteDelay/tick;
		iAccumulatedWriteDelay -= delay*tick+(tick>>1);
		}
	NFastSemaphore sem;
	NKern::FSSetOwner(&sem,NULL);
	NTimer timer(WriteTimerCallback,&sem);
	if(delay)
		timer.OneShot(delay,ETrue);

	// emulate CPU load for processing read
	Kern::NanoWait(iWritePageCPUDelay*1000);

	// write data using memcpy
	memcpy((TAny*)(iDataStore+iWriteRequest.iOffset),(TAny*)iWriteRequest.iBuffer,iWriteRequest.iSize);

	// wait for delay timer
	if(delay)
		NKern::FSWait(&sem);

	// signal done
	iWriteRequest.iResult = KErrNone;
	NKern::FSSignal(iWriteRequest.iSemaphore);
	}


DECLARE_STANDARD_EXTENSION()
	{
	return DEmulatedDataPagingDevice::Install();
	}