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

	}