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

//

#include <plat_priv.h>

#include <kernel/cache.h>

#include "mm.h"

#include "mmu.h"

#include "mrom.h"

#include "mpager.h"

#include "mmanager.h"

#include "mobject.h"

#include "mmapping.h"

#include "maddrcont.h"

#include "mptalloc.h"

#include "mlargemappings.h"

#include "cache_maintenance.inl"

/**

Class representing the resources allocated for a ROM shadow page.

A shadow page is a page of RAM which is mapped by the MMU to replace

a prior existing page at a particular virtual address.

*/

class DShadowPage : public DVirtualPinMapping

	{

public:

	/**

	Create a new #DShadowPage to shadow a specified memory page.

	On success, #iOriginalPage holds the physical address of the original page

	and #iNewPage the physical address of the newly allocated RAM page; the

	contents of this are a copy of the original.

	No MMU entries for the shadow page are changed - it is the responsibility

	of the caller to handle this. However, the new #DShadowPage object will

	have pinned the page table used by \a aMapping which maps the page being

	shadowed, prevent demand paging from discarding any modifications made to

	this.

	@param aMemory		The memory object whose memory is to be shadowed.

	@param aIndex		Page index, within the memory, of the page to shadow.

	@param aMapping		A memory mapping which currently maps the page to be

						shadowed.

	@return The newly created DShadowPage or the null pointer if there was

			insufficient memory.

	*/

	static DShadowPage* New(DMemoryObject* aMemory, TUint aIndex, DMemoryMappingBase* aMapping);

	/**

	Free the allocated shadow page (#iNewPage) and unpin any pages table which

	was pinned, then free this shadow page object.

	The called of this function must ensure that all references to the shadow

	RAM page have been removed from any MMU mappings.

	*/

	void Destroy();

private:

	DShadowPage();

	~DShadowPage();

	/**

	Second phase constructor. For arguments, see #New.

	*/

	TInt Construct(DMemoryObject* aMemory, TUint aIndex, DMemoryMappingBase* aMapping);

public:

	/**

	The physical address of the original page being shadowed.

	*/

	TPhysAddr iOriginalPage;

	/**

	The physical address of the allocated shadow page.

	*/

	TPhysAddr iNewPage;

	};

/**

Specialised manager for the memory object representing the system ROM.

This handles demand paging of the ROM contents if it is not stored in a memory

device capable of execute-in-place random access. E.g. when stored in NAND

flash.

*/

class DRomMemoryManager : public DPagedMemoryManager

	{

public:

	DRomMemoryManager();

	/**

	Allocate a shadow page for the specified ROM address.

	Shadow pages are pages of RAM which are mapped by the MMU so that 

	they replace the original ROM memory. The contents of a shadow page

	are initially the same as the ROM they replace, but may be modified with

	#CopyToShadowMemory.

	@param aRomAddr	An virtual address which lies within the ROM.

	@return KErrNone if successful,

			KErrAlreadyExists if the specified address already has a show page,

			otherwise one of the system wide error codes.

	*/

	TInt AllocShadowPage(TLinAddr aRomAddr);

	/**

	Free a shadow page previously allocated with #AllocShadowPage.

	The original ROM memory page is again mapped at the specified address.

	@param aRomAddr	An virtual address which lies within the ROM.

	@return KErrNone if successful,

			otherwise one of the system wide error codes.

	*/

	TInt FreeShadowPage(TLinAddr aRomAddr);

	/**

	Copy data into a shadow page, modifying its contents.

	@param aDst		An virtual address which lies within the ROM for which a shadow

					page has previously been allocated with #AllocShadowPage.

	@param aSrc		The start address of the data to copy to \a aDst.

	@param aSize	The size, in bytes, of the data to copy.

	@return KErrNone if successful,

			KErrNotFound if the specified address didn't have a shadow page,

			otherwise one of the system wide error codes.

	*/

	TInt CopyToShadowMemory(TLinAddr aDst, TLinAddr aSrc, TUint32 aSize);

protected:

	// from DPagedMemoryManager...

	virtual TInt PageInPinnedDone(DMemoryObject* aMemory, TUint aIndex, SPageInfo* aPageInfo, TPhysAddr* aPageArrayEntry, TPinArgs& aPinArgs);

private:

	// from DMemoryManager...

	virtual void Destruct(DMemoryObject* aMemory);

	virtual TInt HandleFault(	DMemoryObject* aMemory, TUint aIndex, DMemoryMapping* aMapping, 

								TUint aMapInstanceCount, TUint aAccessPermissions);

	virtual TInt Pin(DMemoryObject* aMemory, DMemoryMappingBase* aMapping, TPinArgs& aPinArgs);

	virtual void Unpin(DMemoryObject* aMemory, DMemoryMappingBase* aMapping, TPinArgs& aPinArgs);

	// methods inherited from DPagedMemoryManager

	/**

	@copydoc DPagedMemoryManager::Init3

	This acts as a second phase constructor for the manager which

	creates the memory objects and mappings to represent the ROM.

	*/

	virtual void Init3();

	virtual TInt InstallPagingDevice(DPagingDevice* aDevice);

	virtual TInt AcquirePageReadRequest(DPageReadRequest*& aRequest, DMemoryObject* aMemory, TUint aIndex, TUint aCount);

	virtual TInt ReadPages(DMemoryObject* aMemory, TUint aIndex, TUint aCount, TPhysAddr* aPages, DPageReadRequest* aRequest);

	virtual TBool IsAllocated(DMemoryObject* aMemory, TUint aIndex, TUint aCount);

	virtual void DoUnpin(DMemoryObject* aMemory, TUint aIndex, TUint aCount, DMemoryMappingBase* aMapping, TPinArgs& aPinArgs);

	/**

	Acquire the mutex used to protect shadow page allocation.

	*/

	void ShadowLock();

	/**

	Release the mutex used to protect shadow page allocation.

	*/

	void ShadowUnlock();

private:

	/**

	The ROM paging device which was passed to #InstallPagingDevice.

	*/

	DPagingDevice* iDevice;

	/**

	The memory object containing the ROM.

	*/

	DMemoryObject* iRomMemory;

	/**

	The memory mapping which maps the ROM into a global visible virtual address.

	*/

	DMemoryMapping* iRomMapping;

	/**

	The virtual address for the start of the ROM in the global memory region.

	*/

	TLinAddr iBase;

	/**

	The size, in bytes, of the ROM image.

	This may not be an exact multiple of a page size.

	*/

	TUint iSize;

	/**

	The size, in pages, of the ROM image.

	*/

	TUint iSizeInPages;

	/**

	The offset from the ROM start, in bytes, for the region of the

	ROM which is demand paged.

	*/

	TUint iPagedStart;

	/**

	The size, in bytes, for the region of the ROM which is demand paged.

	*/

	TUint iPagedSize;

	/**

	The address within the ROM for the ROM page index.

	@see TRomHeader::iRomPageIndex.

	*/

	SRomPageInfo* iRomPageIndex;

	/**

	The mutex used to protect shadow page allocation.

	*/

	DMutex* iShadowLock;

	/**

	Container for all allocated DShadowPage objects.

	*/

	RAddressedContainer iShadowPages;

#ifdef __SUPPORT_DEMAND_PAGING_EMULATION__

	TInt iOriginalRomPageCount;

	TPhysAddr* iOriginalRomPages;

	friend void RomOriginalPages(TPhysAddr*& aPages, TUint& aPageCount);

#endif

	friend TBool IsUnpagedRom(TLinAddr aBase, TUint aSize);

public:

	/**

	The single instance of this manager class.

	*/

	static DRomMemoryManager TheManager;

	};

DRomMemoryManager DRomMemoryManager::TheManager;

DPagedMemoryManager* TheRomMemoryManager = &DRomMemoryManager::TheManager;

const TInt KMutexOrdRomMemory = KMutexOrdPageIn+1;

#ifdef __SUPPORT_DEMAND_PAGING_EMULATION__

/**

For use by the emulated paging device to get the location and size of the ROM.

@param aPages		A reference to store a pointer to an array of the physical addresses of each ROM page.

@param aPageCount	A reference to store the number of rom pages.

*/

void RomOriginalPages(TPhysAddr*& aPages, TUint& aPageCount)

	{

	aPages = DRomMemoryManager::TheManager.iOriginalRomPages;

	aPageCount = DRomMemoryManager::TheManager.iOriginalRomPageCount;

	}

#endif

TBool IsUnpagedRom(TLinAddr aBase, TUint aSize)

	{

	TUint offset = aBase-DRomMemoryManager::TheManager.iBase;

	TUint limit = DRomMemoryManager::TheManager.iPagedStart;

	if(offset>=limit)

		return false;

	offset += aSize;

	if(offset>limit || offset<aSize)

		return false;

	return true;

	}

TInt PagifyChunk(TLinAddr aAddress)

	{

	TRACE(("PagifyChunk(0x%08x)",aAddress));

	aAddress &= ~KChunkMask;

	TPde* pPde = Mmu::PageDirectoryEntry(KKernelOsAsid,aAddress);

retry:

	// check there is actually some memory mapped...

	TPde pde = *pPde;

	if(pde==KPdeUnallocatedEntry)

		{

		TRACE(("PagifyChunk returns %d",KErrNotFound));

		return KErrNotFound;

		}

	// end if memory is not a section mapping...

	TPhysAddr pdePhys = Mmu::PdePhysAddr(pde);

	if(pdePhys==KPhysAddrInvalid)

		{

		TRACE(("PagifyChunk returns %d",KErrAlreadyExists));

		return KErrAlreadyExists;

		}

	// get a new page table...

	::PageTables.Lock();

	TPte* pt = ::PageTables.Alloc(false);

	if(!pt)

		{

		TRACE(("PagifyChunk returns %d",KErrNoMemory));

		::PageTables.Unlock();

		return KErrNoMemory;

		}

	// fill page table so it maps the same physical addresses as the section mapping...

	TPte pte = Mmu::SectionToPageEntry(pde);

	pte |= pdePhys;

	TPte* pPte = pt;

	do

		{

		TRACE2(("!PTE %x=%x",pPte,pte));

		*pPte++ = pte;

		pte += KPageSize;

		}

	while(TLinAddr(pPte)&(KPageTableMask/sizeof(TPte)*sizeof(TPte)));

	CacheMaintenance::MultiplePtesUpdated((TLinAddr)pt,KPageTableSize);

	// check memory not changed...

	MmuLock::Lock();

	if(Mmu::PdePhysAddr(*pPde)!=pdePhys)

		{

		// pde was changed whilst we were creating a new page table, need to retry...

		MmuLock::Unlock();

		::PageTables.Free(pt);

		::PageTables.Unlock();

		goto retry;

		}

	// update page counts...

	SPageTableInfo* pti = SPageTableInfo::FromPtPtr(pt);

	TUint count = pti->IncPageCount(KPageTableSize/sizeof(TPte));

	(void)count;

	TRACE2(("pt %x page count=%d",pt,pti->PageCount()));

	__NK_ASSERT_DEBUG(pti->CheckPageCount());

	// swap pde entry to point to new page table...

	pde |= Mmu::PageTablePhysAddr(pt);

	TRACE2(("!PDE %x=%x",pPde,pde));

	*pPde = pde;

	SinglePdeUpdated(pPde);

	InvalidateTLB();

	// done...

	MmuLock::Unlock();

	::PageTables.Unlock();

	TRACE(("PagifyChunk returns %d",KErrNone));

	return KErrNone;

	}

void UnmapROM(TLinAddr aStart, TLinAddr aEnd)

	{

	TRACEB(("UnmapROM 0x%08x..0x%08x",aStart,aEnd));

	TLinAddr p = aStart;

	if(p>=aEnd)

		return;

	PagifyChunk(p);

	MmuLock::Lock(); // hold MmuLock for long time, shouldn't matter as this is only done during boot

	TPte* pPte = Mmu::PtePtrFromLinAddr(p,KKernelOsAsid);

	__NK_ASSERT_ALWAYS(pPte);

	while(p<aEnd && p&KChunkMask)

		{

		*pPte++ = KPteUnallocatedEntry;

		p += KPageSize;

		}

	if(p<aEnd)

		{

		TPde* pPde = Mmu::PageDirectoryEntry(KKernelOsAsid,p);

		while(p<aEnd)

			{

			*pPde++ = KPdeUnallocatedEntry;

			p += KChunkSize;

			}

		}

	MmuLock::Unlock();

	__NK_ASSERT_DEBUG(p==aEnd);

	}

DRomMemoryManager::DRomMemoryManager()

	: iShadowPages(0,iShadowLock)

	{

	}

void DRomMemoryManager::Init3()

	{

	// get ROM info...

	const TRomHeader& romHeader = TheRomHeader();

	iBase = (TLinAddr)&romHeader;

	iSize = romHeader.iUncompressedSize;

	iSizeInPages = MM::RoundToPageCount(iSize);

	TUint chunkSize = ((iSize+KChunkMask)&~KChunkMask);

	TUint committedSize = TheSuperPage().iTotalRomSize; // size of memory loaded by bootstrap

	TRACEB(("DRomMemoryManager::Init3 rom=0x%08x+0x%x",iBase,iSize));

	// get paged rom info...

	if(romHeader.iRomPageIndex)

		iRomPageIndex = (SRomPageInfo*)((TInt)&romHeader+romHeader.iRomPageIndex);

	iPagedSize = romHeader.iPageableRomSize;

	iPagedStart = iPagedSize ? romHeader.iPageableRomStart : 0;

	if(iPagedStart)

		{

		TRACEB(("DRomMemoryManager::Init3() paged=0x%08x+0x%x",(TLinAddr)&romHeader+iPagedStart,iPagedSize));

		__NK_ASSERT_ALWAYS(iPagedStart<iSize && iPagedStart+iPagedSize>iPagedStart && iPagedStart+iPagedSize<=iSize);

#ifdef __SUPPORT_DEMAND_PAGING_EMULATION__

		// get physical addresses of ROM pages...

		iOriginalRomPageCount = iSizeInPages;

		iOriginalRomPages = new TPhysAddr[iOriginalRomPageCount];

		__NK_ASSERT_ALWAYS(iOriginalRomPages);

		MmuLock::Lock(); // hold MmuLock for long time, shouldn't matter as this is only done during boot

		TInt i;

		for(i=0; i<iOriginalRomPageCount; i++)

			iOriginalRomPages[i] = Mmu::LinearToPhysical(iBase+i*KPageSize);

		MmuLock::Unlock();

		// unmap paged part of ROM as the bootstrap will have left it mapped.

		// See CFG_SupportEmulatedRomPaging in the bootstrap code.

		// todo: use FMM for this after memory object created

		UnmapROM(iBase+iPagedStart,iBase+chunkSize);

		committedSize = iPagedStart;

#endif

		}

	if(iPagedStart && committedSize!=iPagedStart)

		{

		// unmap any paged ROM which the bootstrap mapped...

		TRACEB(("DRomMemoryManager::Init3() unmapping unpaged ROM offsets 0x%x thru 0x%x",iPagedStart,committedSize));

		// todo: use FMM for this after memory object created

		UnmapROM(iBase+iPagedStart,iBase+committedSize);

		committedSize = iPagedStart;

		}

	// create memory object for ROM...

	TRACEB(("DRomMemoryManager::Init3() committed ROM memory 0x%x of 0x%x",committedSize,chunkSize));

	TMemoryCreateFlags flags = (TMemoryCreateFlags)(EMemoryCreateNoWipe | EMemoryCreateReadOnly | 

													EMemoryCreateDemandPaged | EMemoryCreateAllowExecution);

	iRomMemory = DLargeMappedMemory::New(&DRomMemoryManager::TheManager,chunkSize>>KPageShift,EMemoryAttributeStandard,flags);

	__NK_ASSERT_ALWAYS(iRomMemory);

	TInt r = MM::MemoryClaimInitialPages(iRomMemory,iBase,committedSize,EUserExecute,false,true);

	__NK_ASSERT_ALWAYS(r==KErrNone);

	r = iRomMemory->iPages.Alloc(committedSize>>KPageShift,(chunkSize-committedSize)>>KPageShift);

	__NK_ASSERT_ALWAYS(r==KErrNone);

	// create mapping for ROM...

	r = MM::MappingNew(iRomMapping, iRomMemory, EUserExecute, KKernelOsAsid, EMappingCreateExactVirtual, iBase);

	__NK_ASSERT_ALWAYS(r==KErrNone);

	__NK_ASSERT_ALWAYS(iRomMapping->IsLarge());

	// Set the paging device to be uninstalled, i.e. NULL.

	iDevice = NULL;

	_LIT(KRomMemoryLockName,"RomMemory");

	r = K::MutexCreate(iShadowLock, KRomMemoryLockName, NULL, EFalse, KMutexOrdRomMemory);

	__NK_ASSERT_ALWAYS(r==KErrNone);

	MM::MemorySetLock(iRomMemory,iShadowLock);

	}

TInt DRomMemoryManager::InstallPagingDevice(DPagingDevice* aDevice)

	{

	TRACEB(("DRomMemoryManager::InstallPagingDevice(0x%08x)",aDevice));

	if(!iPagedStart)

		{

		TRACEB(("ROM is not paged"));

		return KErrNone;

		}

	TAny* null = 0;

	if(!__e32_atomic_cas_ord_ptr(&iDevice, &null, aDevice)) // set iDevice=aDevice if it was originally 0

		{

		// ROM paging device already registered...

		TRACEB(("DRomMemoryManager::InstallPagingDevice returns ALREADY EXISTS!"));

		return KErrAlreadyExists;

		}

	__e32_atomic_ior_ord32(&K::MemModelAttributes, (TUint32)EMemModelAttrRomPaging);

	return KErrNone;

	}

TInt DRomMemoryManager::AcquirePageReadRequest(DPageReadRequest*& aRequest, DMemoryObject* aMemory, TUint aIndex, TUint aCount)

	{

	aRequest = iDevice->iRequestPool->AcquirePageReadRequest(aMemory,aIndex,aCount);

	return KErrNone;

	}

void DRomMemoryManager::Destruct(DMemoryObject* aMemory)

	{

	__NK_ASSERT_DEBUG(0);

	}