// 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 "mm.h"

#include "mmu.h"

#include "mmapping.h"

#include "mobject.h"

#include "maddressspace.h"

#include "mptalloc.h"

#include "mmanager.h" // needed for DMemoryManager::Pin/Unpin, not nice, but no obvious way to break dependency

#include "cache_maintenance.inl"

//

// DMemoryMapping

//

DMemoryMapping::DMemoryMapping(TUint aType)

	: DMemoryMappingBase(aType)

	{

	}

TInt DMemoryMapping::Construct(TMemoryAttributes aAttributes, TMappingCreateFlags aFlags, TInt aOsAsid, TLinAddr aAddr, TUint aSize, TLinAddr aColourOffset)

	{

	TRACE(("DMemoryMapping[0x%08x]::Construct(0x%x,0x%x,%d,0x%08x,0x%08x,0x%08x)",this,(TUint32&)aAttributes,aFlags,aOsAsid,aAddr,aSize,aColourOffset));

	// setup PDE values...

	iBlankPde = Mmu::BlankPde(aAttributes);

	// setup flags...

	if(aFlags&EMappingCreateReserveAllResources)

		Flags() |= EPermanentPageTables;

	// allocate virtual memory...

	TInt r = AllocateVirtualMemory(aFlags,aOsAsid,aAddr,aSize,aColourOffset);

	if(r==KErrNone)

		{

		// add to address space...

		TLinAddr addr = iAllocatedLinAddrAndOsAsid&~KPageMask;

		TInt osAsid = iAllocatedLinAddrAndOsAsid&KPageMask;

		r = AddressSpace[osAsid]->AddMapping(addr,this);

		if(r!=KErrNone)

			FreeVirtualMemory();

		}

	return r;

	}

DMemoryMapping::~DMemoryMapping()

	{

	TRACE(("DMemoryMapping[0x%08x]::~DMemoryMapping()",this));

	__NK_ASSERT_DEBUG(!IsAttached());

	// remove from address space...

	TLinAddr addr = iAllocatedLinAddrAndOsAsid&~KPageMask;

	TInt osAsid = iAllocatedLinAddrAndOsAsid&KPageMask;

	TAny* removed = AddressSpace[osAsid]->RemoveMapping(addr);

	if(removed)

		__NK_ASSERT_DEBUG(removed==this);

	FreeVirtualMemory();

	}

void DMemoryMapping::BTraceCreate()

	{

	MmuLock::Lock();

	TUint32 data[4] = { iStartIndex, iSizeInPages, OsAsid(), Base() };

	BTraceContextN(BTrace::EFlexibleMemModel,BTrace::EMemoryMappingCreate,this,Memory(),data,sizeof(data));

	MmuLock::Unlock();

	}

TInt DMemoryMapping::Map(DMemoryObject* aMemory, TUint aIndex, TUint aCount, TMappingPermissions aPermissions)

	{

	TRACE(("DMemoryMapping[0x%08x]::Map(0x%08x,0x%x,0x%x,0x%08x)",this,aMemory,aIndex,aCount,aPermissions));

	__NK_ASSERT_DEBUG(!IsAttached());

	// check reserved resources are compatible (memory objects with reserved resources 

	// don't expect to have to allocate memory when mapping new pages),,,

	if(aMemory->iFlags&DMemoryObject::EReserveResources && !(Flags()&EPermanentPageTables))

		return KErrArgument;

	// check arguments for coarse mappings...

	if(IsCoarse())

		{

		if(!aMemory->IsCoarse())

			return KErrArgument;

		if((aCount|aIndex)&(KChunkMask>>KPageShift))

			return KErrArgument;

		}

	TLinAddr base = iAllocatedLinAddrAndOsAsid & ~KPageMask;

	TLinAddr top = base + (aCount << KPageShift);

	// check user/supervisor memory partitioning...

	if (aPermissions & EUser)

		{

		if (base > KUserMemoryLimit || top > KUserMemoryLimit)

			return KErrAccessDenied;

		}

	else

		{

		if (base < KUserMemoryLimit || top < KUserMemoryLimit)

			return KErrAccessDenied;

		}

	// check that mapping doesn't straddle KUserMemoryLimit or KGlobalMemoryBase ...

	__NK_ASSERT_DEBUG((base < KUserMemoryLimit) == (top <= KUserMemoryLimit));

	__NK_ASSERT_DEBUG((base < KGlobalMemoryBase) == (top <= KGlobalMemoryBase));

	// check that only global memory is mapped into the kernel process

	TBool global = base >= KGlobalMemoryBase;

	__NK_ASSERT_DEBUG(global || (iAllocatedLinAddrAndOsAsid & KPageMask) != KKernelOsAsid);

	// setup attributes...

	PteType() =	Mmu::PteType(aPermissions,global);

	iBlankPte = Mmu::BlankPte(aMemory->Attributes(),PteType());

	// setup base address... 

	TUint colourOffset = ((aIndex&KPageColourMask)<<KPageShift);

	if(colourOffset+aCount*KPageSize > iAllocatedSize)

		return KErrTooBig;

	__NK_ASSERT_DEBUG(!iLinAddrAndOsAsid || ((iLinAddrAndOsAsid^iAllocatedLinAddrAndOsAsid)&~(KPageColourMask<<KPageShift))==0); // new, OR, only differ in page colour

	iLinAddrAndOsAsid = iAllocatedLinAddrAndOsAsid+colourOffset;

	// attach to memory object...

	TInt r = Attach(aMemory,aIndex,aCount);

	// cleanup if error...

	if(r!=KErrNone)

		iLinAddrAndOsAsid = 0;

	return r;

	}

void DMemoryMapping::Unmap()

	{

	Detach();

	// we can't clear iLinAddrAndOsAsid here because this may be needed by other code,

	// e.g. DFineMapping::MapPages/UnmapPages/RestrictPages/PageIn

	}

TInt DMemoryMapping::AllocateVirtualMemory(TMappingCreateFlags aFlags, TInt aOsAsid, TLinAddr aAddr, TUint aSize, TLinAddr aColourOffset)

	{

	TRACE(("DMemoryMapping[0x%08x]::AllocateVirtualMemory(0x%x,%d,0x%08x,0x%08x,0x%08x)",this,aFlags,aOsAsid,aAddr,aSize,aColourOffset));

	__NK_ASSERT_DEBUG((aAddr&KPageMask)==0);

	__NK_ASSERT_DEBUG(!iAllocatedLinAddrAndOsAsid);

	__NK_ASSERT_DEBUG(!iAllocatedSize);

	// setup PDE type...

	TUint pdeType = 0;

	if(aFlags&EMappingCreateCommonVirtual)

		pdeType |= EVirtualSlabTypeCommonVirtual;

	if(aFlags&EMappingCreateDemandPaged)

		pdeType |= EVirtualSlabTypeDemandPaged;

	TInt r;

	TUint colourOffset = aColourOffset&(KPageColourMask<<KPageShift);

	TLinAddr addr;

	TUint size;

	if(aFlags&(EMappingCreateFixedVirtual|EMappingCreateAdoptVirtual))

		{

		// just use the supplied virtual address...

		__NK_ASSERT_ALWAYS(aAddr);

		__NK_ASSERT_ALWAYS(colourOffset==0);

		__NK_ASSERT_DEBUG((aFlags&EMappingCreateAdoptVirtual)==0 || AddressSpace[aOsAsid]->CheckPdeType(aAddr,aSize,pdeType));

		addr = aAddr;

		size = aSize;

		r = KErrNone;

		}

	else

		{

		if(aFlags&(EMappingCreateExactVirtual|EMappingCreateCommonVirtual))

			{

			__NK_ASSERT_ALWAYS(aAddr); // address must be specified

			}

		else

			{

			__NK_ASSERT_ALWAYS(!aAddr); // address shouldn't have been specified

			}

		// adjust for colour...

		TUint allocSize = aSize+colourOffset;

		TUint allocAddr = aAddr;

		if(allocAddr)

			{

			allocAddr -= colourOffset;

			if(allocAddr&(KPageColourMask<<KPageShift))

				return KErrArgument; // wrong colour

			}

		// allocate virtual addresses...

		if(aFlags&EMappingCreateUserGlobalVirtual)

			{

			if(aOsAsid!=(TInt)KKernelOsAsid)

				return KErrArgument;

			r = DAddressSpace::AllocateUserGlobalVirtualMemory(addr,size,allocAddr,allocSize,pdeType);

			}

		else

			r = AddressSpace[aOsAsid]->AllocateVirtualMemory(addr,size,allocAddr,allocSize,pdeType);

		}

	if(r==KErrNone)

		{

		iAllocatedLinAddrAndOsAsid = addr|aOsAsid;

		iAllocatedSize = size;

		}

	TRACE(("DMemoryMapping[0x%08x]::AllocateVirtualMemory returns %d address=0x%08x",this,r,addr));

	return r;

	}

void DMemoryMapping::FreeVirtualMemory()

	{

	if(!iAllocatedSize)

		return; // no virtual memory to free

	TRACE(("DMemoryMapping[0x%08x]::FreeVirtualMemory()",this));

	iLinAddrAndOsAsid = 0;

	TLinAddr addr = iAllocatedLinAddrAndOsAsid&~KPageMask;

	TInt osAsid = iAllocatedLinAddrAndOsAsid&KPageMask;

	AddressSpace[osAsid]->FreeVirtualMemory(addr,iAllocatedSize);

	iAllocatedLinAddrAndOsAsid = 0;

	iAllocatedSize = 0;

	}

//

// DCoarseMapping

//

DCoarseMapping::DCoarseMapping()

	: DMemoryMapping(ECoarseMapping)

	{

	}

DCoarseMapping::DCoarseMapping(TUint aFlags)

	: DMemoryMapping(ECoarseMapping|aFlags)

	{

	}

DCoarseMapping::~DCoarseMapping()

	{

	}

TInt DCoarseMapping::DoMap()

	{

	TRACE(("DCoarseMapping[0x%08x]::DoMap()", this));

	__NK_ASSERT_DEBUG(((iStartIndex|iSizeInPages)&(KChunkMask>>KPageShift))==0); // be extra paranoid about alignment

	MmuLock::Lock();

	TPde* pPde = Mmu::PageDirectoryEntry(OsAsid(),Base());

	DCoarseMemory* memory = (DCoarseMemory*)Memory(true); // safe because we're called from code which has added mapping to memory

	TUint flash = 0;

	TUint chunk = iStartIndex >> KPagesInPDEShift;

	TUint endChunk = (iStartIndex + iSizeInPages) >> KPagesInPDEShift;

	TBool sectionMappingsBroken = EFalse;

	while(chunk < endChunk)

		{

		MmuLock::Flash(flash,KMaxPdesInOneGo*2);

		TPte* pt = memory->GetPageTable(PteType(), chunk);

		if(!pt)

			{

			TRACE2(("!PDE %x=%x (was %x)",pPde,KPdeUnallocatedEntry,*pPde));

			__NK_ASSERT_DEBUG(*pPde==KPdeUnallocatedEntry);

			}

		else

			{

			TPde pde = Mmu::PageTablePhysAddr(pt)|iBlankPde;

#ifdef	__USER_MEMORY_GUARDS_ENABLED__

			if (IsUserMapping())

				pde = PDE_IN_DOMAIN(pde, USER_MEMORY_DOMAIN);

#endif

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

			if (Mmu::PdeMapsSection(*pPde))

				{

				// break previous section mapping...

				__NK_ASSERT_DEBUG(*pPde==Mmu::PageToSectionEntry(pt[0],iBlankPde));

				sectionMappingsBroken = ETrue;

				}

			else

				__NK_ASSERT_DEBUG(*pPde==KPdeUnallocatedEntry || ((*pPde^pde)&~KPdeMatchMask)==0); 

			*pPde = pde;

			SinglePdeUpdated(pPde);

			flash += 3; // increase flash rate because we've done quite a bit more work

			}

		++pPde;

		++chunk;

		}

	MmuLock::Unlock();

	if (sectionMappingsBroken)

		{

		// We must invalidate the TLB since we broke section mappings created by the bootstrap.

		// Since this will only ever happen on boot, we just invalidate the entire TLB for this

		// process.

		InvalidateTLBForAsid(OsAsid());

		}

	return KErrNone;

	}

void DCoarseMapping::DoUnmap()

	{

	TRACE(("DCoarseMapping[0x%08x]::DoUnmap()", this));

	MmuLock::Lock();

	TPde* pPde = Mmu::PageDirectoryEntry(OsAsid(),Base());

	TPde* pPdeEnd = pPde+(iSizeInPages>>(KChunkShift-KPageShift));

	TUint flash = 0;

	do

		{

		MmuLock::Flash(flash,KMaxPdesInOneGo);

		TPde pde = KPdeUnallocatedEntry;

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

		*pPde = pde;

		SinglePdeUpdated(pPde);

		++pPde;

		}

	while(pPde<pPdeEnd);

	MmuLock::Unlock();

	InvalidateTLBForAsid(OsAsid());

	}

TInt DCoarseMapping::MapPages(RPageArray::TIter aPages, TUint aMapInstanceCount)

	{

	// shouldn't ever be called because coarse mappings don't have their own page tables...

	__NK_ASSERT_DEBUG(0);

	return KErrNotSupported;

	}

void DCoarseMapping::UnmapPages(RPageArray::TIter aPages, TUint aMapInstanceCount)

	{

	// shouldn't ever be called because coarse mappings don't have their own page tables...

	__NK_ASSERT_DEBUG(0);

	}

void DCoarseMapping::RemapPage(TPhysAddr& aPageArray, TUint aIndex, TUint aMapInstanceCount, TBool aInvalidateTLB)

	{

	// shouldn't ever be called because coarse mappings don't have their own page tables...

	__NK_ASSERT_DEBUG(0);

	}

void DCoarseMapping::RestrictPagesNA(RPageArray::TIter aPages, TUint aMapInstanceCount)

	{

	// shouldn't ever be called because coarse mappings don't have their own page tables...

	__NK_ASSERT_DEBUG(0);

	}

TInt DCoarseMapping::PageIn(RPageArray::TIter aPages, TPinArgs& aPinArgs, TUint aMapInstanceCount)

	{

	MmuLock::Lock();

	if(!IsAttached())

		{

		MmuLock::Unlock();

		return KErrNotFound;

		}

	DCoarseMemory* memory = (DCoarseMemory*)Memory(true); // safe because we've checked mapping IsAttached

	return memory->PageIn(this, aPages, aPinArgs, aMapInstanceCount);

	}

TBool DCoarseMapping::MovingPageIn(TPhysAddr& aPageArrayPtr, TUint aIndex)

	{

	__NK_ASSERT_DEBUG(MmuLock::IsHeld());

	__NK_ASSERT_DEBUG(IsAttached());

	DCoarseMemory* memory = (DCoarseMemory*)Memory(true); // safe because we've checked mapping IsAttached

	TBool success = memory->MovingPageIn(this, aPageArrayPtr, aIndex);

	if (success)

		{

		TLinAddr addr = Base() + (aIndex - iStartIndex) * KPageSize;

		InvalidateTLBForPage(addr);

		}

	return success;

	}

TPte* DCoarseMapping::FindPageTable(TLinAddr aLinAddr, TUint aMemoryIndex)

	{

	TRACE(("DCoarseMapping::FindPageTable(0x%x, %d)", aLinAddr, aMemoryIndex));

	__NK_ASSERT_DEBUG(MmuLock::IsHeld());

	__NK_ASSERT_DEBUG(IsAttached());

	DCoarseMemory* memory = (DCoarseMemory*)Memory(true); // safe because we've checked mapping IsAttached

	return memory->FindPageTable(this, aLinAddr, aMemoryIndex);

	}

//

// DFineMapping

//

DFineMapping::DFineMapping()

	: DMemoryMapping(0)

	{

	}

DFineMapping::~DFineMapping()

	{

	TRACE(("DFineMapping[0x%08x]::~DFineMapping()",this));

	FreePermanentPageTables();

	}

#ifdef _DEBUG

void DFineMapping::ValidatePageTable(TPte* aPt, TLinAddr aAddr)

	{

	if(aPt)

		{

		// check page table is correct...

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

		__NK_ASSERT_DEBUG(pti->CheckFine(aAddr&~KChunkMask,OsAsid()));

		DMemoryObject* memory = Memory();

		if(memory)

			{

			if(memory->IsDemandPaged() && !IsPinned() && !(Flags()&EPageTablesAllocated))

				__NK_ASSERT_DEBUG(pti->IsDemandPaged());

			else

				__NK_ASSERT_DEBUG(!pti->IsDemandPaged());

			}

		}

	}

#endif

TPte* DFineMapping::GetPageTable(TLinAddr aAddr)

	{

	__NK_ASSERT_DEBUG(MmuLock::IsHeld());

	// get address of PDE which refers to the page table...

	TPde* pPde = Mmu::PageDirectoryEntry(OsAsid(),aAddr);

	// get page table...

	TPte* pt = Mmu::PageTableFromPde(*pPde);

#ifdef _DEBUG

	ValidatePageTable(pt, aAddr);

#endif

	return pt;

	}

TPte* DFineMapping::GetOrAllocatePageTable(TLinAddr aAddr)

	{

	__NK_ASSERT_DEBUG(MmuLock::IsHeld());

	// get address of PDE which refers to the page table...

	TPde* pPde = Mmu::PageDirectoryEntry(OsAsid(),aAddr);

	// get page table...

	TPte* pt = Mmu::PageTableFromPde(*pPde);

	if(!pt)

		{

		pt = AllocatePageTable(aAddr,pPde);

#ifdef _DEBUG

		ValidatePageTable(pt, aAddr);

#endif

		}

	return pt;

	}

TPte* DFineMapping::GetOrAllocatePageTable(TLinAddr aAddr, TPinArgs& aPinArgs)

	{

	__NK_ASSERT_DEBUG(aPinArgs.iPinnedPageTables);

	if(!aPinArgs.HaveSufficientPages(KNumPagesToPinOnePageTable))

		return 0;

	TPte* pinnedPt = 0;

	for(;;)

		{

		TPte* pt = GetOrAllocatePageTable(aAddr);

		if(pinnedPt && pinnedPt!=pt)

			{

			// previously pinned page table not needed...

			PageTableAllocator::UnpinPageTable(pinnedPt,aPinArgs);

			// make sure we have memory for next pin attempt...

			MmuLock::Unlock();

			aPinArgs.AllocReplacementPages(KNumPagesToPinOnePageTable);

			MmuLock::Lock();

			if(!aPinArgs.HaveSufficientPages(KNumPagesToPinOnePageTable)) // if out of memory...

				{

				// make sure we free any unneeded page table we allocated...

				if(pt)

					FreePageTable(Mmu::PageDirectoryEntry(OsAsid(),aAddr));

				return 0;

				}

			}

		if(!pt)

			return 0; // out of memory