// Copyright (c) 1998-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\memmodel\epoc\multiple\mmu.cpp

 // 

 //

 #include "memmodel.h"

 #include <ramalloc.h>

 _LIT(KLitGlobalDollarCode,"GLOBAL$CODE");

 /*******************************************************************************

  * "Independent" MMU code

  *******************************************************************************/

 void Mmu::Panic(TPanic aPanic)

 	{

 	Kern::Fault("MMU",aPanic);

 	}

 TPde* Mmu::LocalPageDir(TInt aOsAsid)

 	{

 	__ASSERT_DEBUG(TUint32(aOsAsid)<TUint32(iNumOsAsids),Panic(ELocalPageDirBadAsid));

 	return (TPde*)(iPdeBase+(aOsAsid<<iGlobalPdShift));

 	}

 TPde* Mmu::GlobalPageDir(TInt aOsAsid)

 	{

 	__ASSERT_DEBUG(TUint32(aOsAsid)<TUint32(iNumOsAsids),Panic(EGlobalPageDirBadAsid));

 	if (iAsidInfo[aOsAsid]&1)

 		return (TPde*)(iPdeBase+(aOsAsid<<iGlobalPdShift));

 	return (TPde*)iPdeBase;

 	}

 /*

 TPde& Mmu::PDE(TLinAddr aAddr, TInt aOsAsid)

 	{

 	__ASSERT_DEBUG(TUint32(aOsAsid)<TUint32(iNumOsAsids),Panic(EPDEBadAsid));

 	TPde* p=(TPde*)(iPdeBase+(aOsAsid<<iGlobalPdShift));

 	if (aAddr>=iUserSharedEnd && (iAsidInfo[aOsAsid]&1))

 		p=(TPde*)iPdeBase;

 	p+=(aAddr>>iChunkShift);

 	__KTRACE_OPT(KMMU,Kern::Printf("PDE(%08x,%d) at %08x",aAddr,aOsAsid,p));

 	return *p;

 	}

 */

 TInt Mmu::NewOsAsid(TBool aSeparateGlobal)

 //

 // Allocate a new OS ASID and page directory.

 // Map the page directory at the expected linear address and initialise it.

 //

 	{

 	__KTRACE_OPT(KMMU,Kern::Printf("Mmu::NewOsAsid(%x)",aSeparateGlobal));

 	TInt os_asid=iOsAsidAllocator->Alloc();

 	if (os_asid<0)

 		return KErrNoMemory;

 	TPhysAddr pdPhys;

 	TInt pdPages=0;

 	TInt r=NewPageDirectory(os_asid,aSeparateGlobal,pdPhys,pdPages);

 	__KTRACE_OPT(KMMU,Kern::Printf("NewPageDirectory: %d %08x %d",r,pdPhys,pdPages));

 	if (r!=KErrNone)

 		{

 		iOsAsidAllocator->Free(os_asid);

 		return KErrNoMemory;

 		}

 	TBool global=(pdPages<<iPageShift==iGlobalPdSize)?1:0;

 	TLinAddr pdLin=iPdeBase+(os_asid<<iGlobalPdShift);

 	if (((os_asid & iAsidGroupMask)==0) && (!iOsAsidAllocator->NotFree(os_asid+1,iAsidGroupMask)) )

 		{

 		// expand page directory mapping

 		TInt xptid=AllocPageTable();

 		if (xptid<0)

 			{

 			iRamPageAllocator->FreePhysicalRam(pdPhys,pdPages<<iPageShift);

 			iOsAsidAllocator->Free(os_asid);

 			return KErrNoMemory;

 			}

 		AssignPageTable(xptid, SPageTableInfo::EGlobal, NULL, pdLin, iPdPdePerm);	// map XPT

 		}

 	TInt i;

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

 		MapRamPage(pdLin+(i<<iPageShift), pdPhys+(i<<iPageShift), iPdPtePerm);

 	InitPageDirectory(os_asid, global);

 	iNumGlobalPageDirs+=global;

 	iAsidInfo[os_asid]=global;

 	__KTRACE_OPT(KMMU,Kern::Printf("Mmu::NewOsAsid returns %d (%d)",os_asid,global));

 	return os_asid;

 	}

 void Mmu::FreeOsAsid(TInt aOsAsid)

 //

 // Free an OS ASID and the corresponding page directory.

 // Assumes any local PDEs have already been unmapped.

 //

 	{

 	__KTRACE_OPT(KMMU,Kern::Printf("Mmu::FreeOsAsid(%d)",aOsAsid));

 	__ASSERT_DEBUG(TUint32(aOsAsid)<TUint32(iNumOsAsids),Panic(EFreeOsAsidBadAsid));

 	TBool global=iAsidInfo[aOsAsid]&1;

 	iAsidInfo[aOsAsid]=0;

 	iOsAsidAllocator->Free(aOsAsid);

 	iNumGlobalPageDirs-=global;

 	TLinAddr pdLin=iPdeBase+(aOsAsid<<iGlobalPdShift);

 	TUint32 size=global?iGlobalPdSize:iLocalPdSize;

 	UnmapAndFree(pdLin,size>>iPageShift);

 #ifdef BTRACE_KERNEL_MEMORY

 	BTrace4(BTrace::EKernelMemory, BTrace::EKernelMemoryMiscFree, size);

 	Epoc::KernelMiscPages -= size>>iPageShift;

 #endif

 	TInt asid_group=aOsAsid&~iAsidGroupMask;

 	if (!iOsAsidAllocator->NotFree(asid_group,iAsidGroupSize))

 		{

 		// shrink page directory mapping

 		TInt xptid=PageTableId(pdLin,0);

 		DoUnassignPageTable(pdLin, GLOBAL_MAPPING);

 		FreePageTable(xptid);

 		}

 	}

 TPhysAddr Mmu::LinearToPhysical(TLinAddr aLinAddr)

 //

 // Find the physical address corresponding to a given linear address

 // Call with system locked

 //

 	{

 	DMemModelProcess* pP=(DMemModelProcess*)TheCurrentThread->iOwningProcess;

 	return LinearToPhysical(aLinAddr, pP->iOsAsid);

 	}

 TInt Mmu::LinearToPhysical(TLinAddr aLinAddr, TInt aSize, TPhysAddr& aPhysicalAddress, TPhysAddr* aPhysicalPageList)

 	{

 	DMemModelProcess* pP=(DMemModelProcess*)TheCurrentThread->iOwningProcess;

 	return LinearToPhysical(aLinAddr, aSize, aPhysicalAddress, aPhysicalPageList, pP->iOsAsid);

 	}

 TInt Mmu::PageTableId(TLinAddr aAddr)

 	{

 	DMemModelProcess* pP=(DMemModelProcess*)TheCurrentThread->iOwningProcess;

 	return PageTableId(aAddr, pP->iOsAsid);

 	}

 void Mmu::Init1()

 	{

 	__KTRACE_OPT2(KBOOT,KMMU,Kern::Printf("Mmu::Init1"));

 	iMaxPageTables=65535;		// possibly reduced when RAM size known

 	memclr(iAsidInfo, iNumOsAsids*sizeof(TUint32));

 	MmuBase::Init1();

 	}

 void Mmu::CreateUserGlobalSection(TLinAddr aBase, TLinAddr aEnd)

 	{

 	iUserGlobalSection=TLinearSection::New(aBase, aEnd);

 	__ASSERT_ALWAYS(iUserGlobalSection,Panic(ECreateUserGlobalSectionFailed));

 	}

 void Mmu::DoInit2()

 	{

 	__KTRACE_OPT2(KBOOT,KMMU,Kern::Printf("Mmu::DoInit2"));

 	iSharedSection=TLinearSection::New(iUserSharedBase, iUserSharedEnd);

 	__ASSERT_ALWAYS(iSharedSection,Panic(ECreateSharedSectionFailed));

 	iOsAsidAllocator=TBitMapAllocator::New(iNumOsAsids,ETrue);

 	__ASSERT_ALWAYS(iOsAsidAllocator,Panic(EOsAsidAllocCreateFailed));

 	iOsAsidAllocator->Alloc(0,1);	// 0=kernel process

 	DMemModelProcess* pP=(DMemModelProcess*)K::TheKernelProcess;

 	if (iLocalPdSize)

 		pP->iLocalPageDir=LinearToPhysical(TLinAddr(LocalPageDir(0)));

 	pP->iGlobalPageDir=LinearToPhysical(TLinAddr(GlobalPageDir(0)));

 	__KTRACE_OPT(KMMU,Kern::Printf("Kernel process: LPD=%08x GPD=%08x",pP->iLocalPageDir,pP->iGlobalPageDir));

 	MM::UserCodeAllocator=TBitMapAllocator::New(iMaxUserCodeSize>>iAliasShift, ETrue);	// code is aligned to alias size

 	__ASSERT_ALWAYS(MM::UserCodeAllocator,Panic(EUserCodeAllocatorCreateFailed));

 	MM::DllDataAllocator=TBitMapAllocator::New(iMaxDllDataSize>>iPageShift, ETrue);

 	__ASSERT_ALWAYS(MM::DllDataAllocator,Panic(EDllDataAllocatorCreateFailed));

 	__ASSERT_ALWAYS(TheRomHeader().iUserDataAddress==iDllDataBase+iMaxDllDataSize,Panic(ERomUserDataAddressInvalid));

 	__ASSERT_ALWAYS((TheRomHeader().iTotalUserDataSize&iPageMask)==0,Panic(ERomUserDataSizeInvalid));

 	TInt rom_dll_pages=TheRomHeader().iTotalUserDataSize>>iPageShift;

 	__KTRACE_OPT2(KBOOT,KMMU,Kern::Printf("UserCodeAllocator @ %08x DllDataAllocator @ %08x, %d ROM DLL Data Pages",

 		MM::UserCodeAllocator, MM::DllDataAllocator, rom_dll_pages));

 	if (rom_dll_pages)

 		MM::DllDataAllocator->Alloc(0, rom_dll_pages);	// low bit numbers represent high addresses

 	}

 void Mmu::SetupInitialPageInfo(SPageInfo* aPageInfo, TLinAddr aChunkAddr, TInt aPdeIndex)

 	{

 	__ASSERT_ALWAYS(aChunkAddr>=iUserSharedEnd,Panic(EBadInitialPageAddr));

 	TLinAddr addr=aChunkAddr+(aPdeIndex<<iPageShift);

 	if (aPageInfo->Type()!=SPageInfo::EUnused)

 		return;	// already set (page table)

 	if (addr==(TLinAddr)iPtInfo)

 		{

 		aPageInfo->SetPtInfo(0);

 		aPageInfo->Lock();

 		}

 	else if (addr>=iPdeBase && addr<iPdeBase+iGlobalPdSize)

 		{

 		aPageInfo->SetPageDir(0,aPdeIndex);

 		aPageInfo->Lock();

 		}

 	else

 		aPageInfo->SetFixed();

 	}

 void Mmu::SetupInitialPageTableInfo(TInt aId, TLinAddr aChunkAddr, TInt aNumPtes)

 	{

 	__ASSERT_ALWAYS(aChunkAddr>=iUserSharedEnd || aChunkAddr==0,Panic(EBadInitialPageAddr));

 	SPageTableInfo& pti=PtInfo(aId);

 	pti.iCount=aNumPtes;

 	pti.SetGlobal(aChunkAddr>>iChunkShift);

 	}

 void Mmu::AssignPageTable(TInt aId, TInt aUsage, TAny* aObject, TLinAddr aAddr, TPde aPdePerm)

 	{

 	__KTRACE_OPT(KMMU,Kern::Printf("Mmu::AssignPageTable id=%d, u=%08x, obj=%08x, addr=%08x, perm=%08x",

 					aId, aUsage, aObject, aAddr, aPdePerm));

 	const TAny* asids=GLOBAL_MAPPING;

 	SPageTableInfo& pti=PtInfo(aId);

 	switch (aUsage)

 		{

 		case SPageTableInfo::EChunk:

 			{

 			DMemModelChunk* pC=(DMemModelChunk*)aObject;

 			TUint32 ccp=K::CompressKHeapPtr(pC);

 			TUint32 offset=(aAddr-TLinAddr(pC->iBase))>>iChunkShift;

 			pti.SetChunk(ccp,offset);

 			if (pC->iOsAsids)

 				asids=pC->iOsAsids;

 			else if (pC->iOwningProcess)

 				asids=(const TAny*)((DMemModelProcess*)pC->iOwningProcess)->iOsAsid;

 			break;

 			}

 //		case SPageTableInfo::EHwChunk:

 //			break;

 		case SPageTableInfo::EGlobal:

 			pti.SetGlobal(aAddr>>iChunkShift);

 			break;

 		default:

 			Panic(EAssignPageTableInvalidUsage);

 		}

 	DoAssignPageTable(aId, aAddr, aPdePerm, asids);

 	}

 TInt Mmu::UnassignPageTable(TLinAddr aAddr)

 	{

 	__KTRACE_OPT(KMMU,Kern::Printf("Mmu::UnassignPageTable addr=%08x", aAddr));

 	TInt id=PageTableId(aAddr, 0);

 	if (id>=0)

 		DoUnassignPageTable(aAddr, GLOBAL_MAPPING);

 	return id;

 	}

 TInt Mmu::CreateGlobalCodeChunk()

 //

 // Enter and return with neither system lock nor MMU mutex held

 //

 	{

 	__KTRACE_OPT(KDLL,Kern::Printf("Mmu::CreateGlobalCodeChunk"));

 	TInt maxsize=Min(TheSuperPage().iTotalRamSize/2, 0x01000000);

 	SChunkCreateInfo c;

 	c.iGlobal=ETrue;

 	c.iAtt=TChunkCreate::EDisconnected;

 	c.iForceFixed=EFalse;

 	c.iOperations=SChunkCreateInfo::EAdjust|SChunkCreateInfo::EAdd;

 	c.iRunAddress=0;

 	c.iPreallocated=0;

 	c.iType=EDll;

 	c.iMaxSize=maxsize;

 	c.iName.Set(KLitGlobalDollarCode);

 	c.iOwner=NULL;

 	c.iInitialBottom=0;

 	c.iInitialTop=0;

 	TLinAddr runAddr;

 	return K::TheKernelProcess->NewChunk((DChunk*&)iGlobalCode,c,runAddr);

 	}