// Copyright (c) 1996-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\emul\win32\minit.cpp
// 
//

#include "memmodel.h"
#include <emulator.h>
#include <property.h>

_LIT8(KKernelFullPathName,"EKern.exe");
_LIT8(KLitRamAlloc,"RamAlloc");

void M::Init1()
	{
	__KTRACE_OPT2(KBOOT,KMMU,Kern::Printf("M::Init1"));
	
	SAddressInfo ainfo;
	Emul::TheAsic->AddressInfo(ainfo);

	MM::RamChunkSize = KRamChunkSize;
	MM::RamChunkShift = KRamChunkShift;
	MM::RamPageSize = KRamPageSize;
	MM::RamPageShift = KRamPageShift;
	MM::FreeMemory = ainfo.iTotalRamSize;
	TheSuperPage().iTotalRamSize = ainfo.iTotalRamSize;
	K::MaxFreeRam = ainfo.iTotalRamSize;
	PP::RamDriveMaxSize = ainfo.iRamDriveMaxSize;

	K::SupervisorThreadStackSize=0x1000;	// 4K

	K::MachineConfig=(TMachineConfig*)A::MachineConfiguration().Ptr();

	K::MaxMemCopyInOneGo=KDefaultMaxMemCopyInOneGo;
	__KTRACE_OPT(KBOOT,Kern::Printf("K::MaxMemCopyInOneGo=0x%x",K::MaxMemCopyInOneGo));

	LPVOID kheap = VirtualAlloc(NULL, KKernelHeapSizeMax, MEM_RESERVE, PAGE_READWRITE);
	__ASSERT_ALWAYS(kheap, MM::Panic(MM::EKernelHeapReserveFailed));
	kheap = VirtualAlloc(kheap, KKernelHeapSizeMin, MEM_COMMIT, PAGE_READWRITE);
	__ASSERT_ALWAYS(kheap, MM::Panic(MM::EKernelHeapCommitFailed));
	MM::KernelHeapAddress = kheap;
	K::MemModelAttributes = (TUint32)(EMemModelTypeEmul|EMemModelAttrNonExProt|EMemModelAttrWriteProt|EMemModelAttrVA);
	
	MM::Init1();
	}

void M::Init2()
	{
	__KTRACE_OPT2(KBOOT,KMMU,Kern::Printf("M::Init2"));
	TInt r=K::MutexCreate((DMutex*&)MM::RamAllocatorMutex, KLitRamAlloc, NULL, EFalse, KMutexOrdRamAlloc);
	__ASSERT_ALWAYS(r==KErrNone, MM::Panic(MM::ERamAllocMutexCreateFailed));
	}

void M::Init3()
	{
	__KTRACE_OPT2(KBOOT,KMMU,Kern::Printf("M::Init3"));
	}

void M::Init4()
    {
    // Fourth phase MMU initialisation - Not required on this memory model.
    }

// kernel heap construction

void P::KernelInfo(TProcessCreateInfo& aInfo, TAny*& aStack, TAny*& aHeap)
	{
	memclr(&aInfo.iUids, sizeof(TProcessCreateInfo)-sizeof(aInfo.iFileName));
	aInfo.iFileName=KKernelFullPathName;
	aInfo.iRootNameOffset=0;
	aInfo.iRootNameLength=9;
	aInfo.iExtOffset=5;
	aInfo.iAttr=ECodeSegAttKernel|ECodeSegAttFixed;

	aStack=NULL;
	aHeap=(TAny*)MM::KernelHeapAddress;

#ifdef _UNICODE
	TUint16 nameW[KMaxFileName+1];
	int index;
	for(index=0;index<aInfo.iFileName.Length();index++)
		nameW[index] = (TUint16)aInfo.iFileName[index];
	nameW[index] = 0;
	Emulator::RImageFile pefile;
	TInt r = pefile.Open((LPCTSTR)nameW);
#else
	TFileName name=aInfo.iFileName;
	name.Append('\0');
	Emulator::RImageFile pefile;
	TInt r = pefile.Open((LPCTSTR)name.Ptr());
#endif
	if (r == KErrNone)
		{
		pefile.GetInfo(aInfo);
		pefile.Close();
		}
	__ASSERT_ALWAYS(r==KErrNone, FAULT());
	aInfo.iHeapSizeMin = KKernelHeapSizeMin;
	aInfo.iHeapSizeMax = KKernelHeapSizeMax;
	aInfo.iDataRunAddress = (TLinAddr)MM::KernelHeapAddress;
	aInfo.iStackSize = 0;
	}

TInt M::InitSvHeapChunk(DChunk* aChunk, TInt aSize)
	{
	DWin32Chunk* pC=(DWin32Chunk*)aChunk;
	aSize = MM::RoundToPageSize(aSize);
	pC->iSize = aSize;
	pC->iBase = (TUint8*)K::Allocator;
// mark the kernel heap pages as allocated
	MM::FreeMemory -= aSize;
	__KTRACE_OPT(KBOOT,Kern::Printf("Created SvHeap chunk, addr %08X, init size %08X max size %08X",pC->Base(),aSize,pC->MaxSize()));
	K::HeapInfo.iChunk = aChunk;
	K::HeapInfo.iBase = pC->iBase;
	K::HeapInfo.iMaxSize = pC->MaxSize();
	return KErrNone;
	}

void RHeapK::Mutate(TInt aOffset, TInt aMaxLength)
//
// Used by the kernel to mutate a fixed heap into a chunk heap.
//
	{
	iMinLength += aOffset;
	iMaxLength = aMaxLength + aOffset;
	iOffset = aOffset;
	iChunkHandle = (TInt)K::HeapInfo.iChunk;
	iPageSize = M::PageSizeInBytes();
	iGrowBy = iPageSize;
	iFlags &= ~(RAllocator::ESingleThreaded|RAllocator::EFixedSize);
	}

//

TInt M::InitSvStackChunk()
	{
	return KErrNone;
	}