// 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 DEmulatedRomPagingDevice : public DPagingDevice
	{
public:
	static TInt Install();
private:
	TInt Construct();
	TInt Read(TThreadMessage* aReq,TLinAddr aBuffer,TUint aOffset,TUint aSize,TInt);
	static void ReadTimerCallback(TAny* aSem);
	static void ReadDfcCallback(TAny* aReq);
	void ReadDfc();
private:
	TLinAddr iRomStore;

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

	TReadRequest iReadRequest;
	TDfcQue* iDfcQue;
	TInt iAccumulatedDelay;
	TInt iReadPageDelay;
	TInt iReadPageCPUDelay;
	DMutex* iMutex;
	};


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


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

	// Initialise DPagingDevice base class
	iType = ERom;
	iReadUnitShift = 9; // 512 byte units
	iName = "EmulatedRomPagingDevice";

	// Get info about ROM
	TPhysAddr* romPages;
	TInt numRomPages;
	TInt r=Kern::HalFunction(EHalGroupVM,EVMHalGetOriginalRomPages,&romPages,&numRomPages);
	__KTRACE_OPT2(KPAGING,KBOOT,Kern::Printf("DEmulatedRomPagingDevice::Construct numRomPages=%08x",numRomPages));
	__NK_ASSERT_ALWAYS(r==KErrNone);

	r = Kern::MutexCreate(iMutex, _L("EmulRomPageDev"), KMutexOrdNone);
	__NK_ASSERT_ALWAYS(r==KErrNone);
	// Create a shared chunk to map the ROM pages
	TInt pageSize = Kern::RoundToPageSize(1);
	TChunkCreateInfo info;
	info.iType = TChunkCreateInfo::ESharedKernelSingle;
	info.iMaxSize = numRomPages*pageSize;
	info.iMapAttr = EMapAttrFullyBlocking;
	info.iOwnsMemory = EFalse;
	DChunk* chunk;
	TUint32 mapAttr;
	r = Kern::ChunkCreate(info,chunk,iRomStore,mapAttr);
	__NK_ASSERT_ALWAYS(r==KErrNone);
	r = Kern::ChunkCommitPhysical(chunk,0,numRomPages*pageSize,romPages);
	__NK_ASSERT_ALWAYS(r==KErrNone);

	// create DFC thread for NAND read simulation
	_LIT8(KDemandPagingDelay,"DemandPagingDelay");
	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];
	__KTRACE_OPT2(KPAGING,KBOOT,Kern::Printf("DEmulatedRomPagingDevice::Construct emulated delays=%d,%d",iReadPageDelay,iReadPageCPUDelay));

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


TInt DEmulatedRomPagingDevice::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*)(iRomStore+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 DEmulatedRomPagingDevice::ReadTimerCallback(TAny* aSem)
	{
	NKern::FSSignal((NFastSemaphore*)aSem);
	}


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


void DEmulatedRomPagingDevice::ReadDfc()
	{
	// calculate number of ticks to stall to emulate elapsed time for page read request
	iAccumulatedDelay += iReadPageDelay;
	TInt tick = NKern::TickPeriod();
	TInt delay = 0;
	if(iAccumulatedDelay>tick)
		{
		delay = iAccumulatedDelay/tick;
		iAccumulatedDelay -= 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*)(iRomStore+iReadRequest.iOffset),iReadRequest.iSize);

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

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


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