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

// e32test\mmu\d_shadow.cpp

// LDD for testing ROM shadowing

// 

//

#include <kernel/kern_priv.h>

#include "platform.h"

#include <kernel/cache.h>

#include "d_shadow.h"

const TInt KMajorVersionNumber=0;

const TInt KMinorVersionNumber=1;

const TInt KBuildVersionNumber=1;

_LIT(KLddName,"Shadow");

class DShadow;

class DShadowFactory : public DLogicalDevice

//

// Shadow ROM LDD factory

//

	{

public:

	DShadowFactory();

	virtual TInt Install();						//overriding pure virtual

	virtual void GetCaps(TDes8& aDes) const;	//overriding pure virtual

	virtual TInt Create(DLogicalChannelBase*& aChannel);	//overriding pure virtual

	};

class DShadow : public DLogicalChannelBase

//

// Shadow ROM logical channel

//

	{

public:

	DShadow();

	~DShadow();

protected:

	virtual TInt DoCreate(TInt aUnit, const TDesC8* anInfo, const TVersion& aVer);

	virtual TInt Request(TInt aFunction, TAny* a1, TAny* a2);

	};

DECLARE_STANDARD_LDD()

	{

    return new DShadowFactory;

    }

DShadowFactory::DShadowFactory()

//

// Constructor

//

    {

    iVersion=TVersion(KMajorVersionNumber,KMinorVersionNumber,KBuildVersionNumber);

    //iParseMask=0;//No units, no info, no PDD

    //iUnitsMask=0;//Only one thing

    }

TInt DShadowFactory::Create(DLogicalChannelBase*& aChannel)

//

// Create a new DShadow on this logical device

//

    {

	aChannel=new DShadow;

	return aChannel?KErrNone:KErrNoMemory;

    }

TInt DShadowFactory::Install()

//

// Install the LDD - overriding pure virtual

//

    {

    return SetName(&KLddName);

    }

void DShadowFactory::GetCaps(TDes8& aDes) const

//

// Get capabilities - overriding pure virtual

//

    {

    TCapsShadowV01 b;

    b.iVersion=TVersion(KMajorVersionNumber,KMinorVersionNumber,KBuildVersionNumber);

    Kern::InfoCopy(aDes,(TUint8*)&b,sizeof(b));

    }

DShadow::DShadow()

//

// Constructor

//

    {

    }

TInt DShadow::DoCreate(TInt /*aUnit*/, const TDesC8* /*anInfo*/, const TVersion& aVer)

//

// Create channel

//

    {

    if (!Kern::QueryVersionSupported(TVersion(KMajorVersionNumber,KMinorVersionNumber,KBuildVersionNumber),aVer))

    	return KErrNotSupported;

	return KErrNone;

	}

DShadow::~DShadow()

//

// Destructor

//

    {

    }

#ifdef __MARM__

extern TInt DoRead(TAny*);

extern TInt GetMmuId();

extern TInt GetCacheType();

extern TUint GetTTBCR();

extern TUint GetControlRegister();

#endif

LOCAL_C TInt KernStackSize()

	{

	TRomEntry* pE=(TRomEntry*)Kern::SuperPage().iPrimaryEntry;

	TRomImageHeader* pI=(TRomImageHeader*)pE->iAddressLin;

	return pI->iStackSize;

	}

LOCAL_C TInt MeasureKernStackUse()

	{

	TLinAddr kstack=Kern::RoundToPageSize(Epoc::RomHeader().iKernDataAddress + Epoc::RomHeader().iTotalSvDataSize);

	TLinAddr kstackEnd=kstack+KernStackSize();

	TUint32 *pS=(TUint32*)kstack;

	while(*pS==0xffffffff) pS++;

	TUint used=kstackEnd-TLinAddr(pS);

	return (TInt)used;

	}

#if !defined(__WINS__)

TInt DShadow::Request(TInt aFunction, TAny* a1, TAny* a2)

	{

	TInt pageSize=Kern::RoundToPageSize(1);

	TInt r=KErrNone;

	switch (aFunction)

		{

		case RShadow::EControlAllocShadow:

			NKern::ThreadEnterCS();

			r=Epoc::AllocShadowPage(TLinAddr(a1));

			NKern::ThreadLeaveCS();

			break;

		case RShadow::EControlFreeShadow:

			NKern::ThreadEnterCS();

			r=Epoc::FreeShadowPage(TLinAddr(a1));

			NKern::ThreadLeaveCS();

			break;

		case RShadow::EControlWriteShadow: //copy 4KB(page size) data to shadow page

			{

			NKern::ThreadEnterCS();

			void* alloc = Kern::Alloc(pageSize); //CopyToShadowMemory assumes Kernel adress space. Copy here first

			if (alloc)

				{

				kumemget(alloc,a2,pageSize);//From user space to kernel heap

				for (TInt i=0;i<pageSize;i+=32)

					Epoc::CopyToShadowMemory((TLinAddr)((TInt)a1+i),(TLinAddr)((TInt)alloc+i),32);

				Cache::IMB_Range((TLinAddr)a1,pageSize);

				Kern::Free(alloc);

				}

			else

				r = KErrNoMemory;

			NKern::ThreadLeaveCS();

			}

			break;

		case RShadow::EControlFreezeShadow:

			NKern::ThreadEnterCS();

			r=Epoc::FreezeShadowPage(TLinAddr(a1));

			NKern::ThreadLeaveCS();

			break;

		case RShadow::EControlSetPriority:

			{

			TInt h=(TInt)a1;

			TInt p=(TInt)a2;

			NKern::LockSystem();

			DThread *pT=(DThread*)Kern::CurrentThread().ObjectFromHandle(h);

			pT->SetThreadPriority(p);

			NKern::UnlockSystem();

			break;

			}

#ifdef __MARM__

		case RShadow::EControlRead:

			r=DoRead(a1);

			break;

		case RShadow::EControlMmuId:

			r=GetMmuId();

			break;

		case RShadow::EControlCacheType:

			r=GetCacheType();

			break;

#endif

		case RShadow::EControlMeasureKernStackUse:

			r=MeasureKernStackUse();

			break;

		case RShadow::EControlMeasureKernHeapFree:

			r=KErrNotSupported;

			break;

		case RShadow::EControlCallFunction:

			{

			TThreadFunction f=(TThreadFunction)a1;

			r=(*f)(a2);

			break;

			}

		case RShadow::EControlAllocPhys:

			{

			TInt size=(TInt)a1;

			TInt align=(TInt)a2;

			TPhysAddr pa;

			NKern::ThreadEnterCS();

			r=Epoc::AllocPhysicalRam(size,pa,align);

			NKern::ThreadLeaveCS();

			if (r==KErrNone)

				{

				if (pa&0x0f)

					r=KErrCorrupt;

				else

					r=pa>>4;

				}

			break;

			}

		case RShadow::EControlFreePhys:

			{

			TPhysAddr pa=(TPhysAddr)a1;

			TInt size=(TInt)a2;

			NKern::ThreadEnterCS();

			r=Epoc::FreePhysicalRam(pa,size);

			NKern::ThreadLeaveCS();

			break;

			}

		case RShadow::EControlClaimPhys:

			{

			TPhysAddr pa=(TPhysAddr)a1;

			TInt size=(TInt)a2;

			NKern::ThreadEnterCS();

			r=Epoc::ClaimPhysicalRam(pa,size);

			NKern::ThreadLeaveCS();

			break;

			}

		// GetMemoryArchitecture

		case RShadow::EControlGetMemoryArchitecture:

			{

			TCpu* cpu = (TCpu*) a1;

			TUint* flags = (TUint*) a2;

#if defined(__CPU_ARM)

			*cpu=ECpuArm;

			*flags = GetControlRegister();

#elif defined(__CPU_X86)

			*cpu=ECpuX86;

			*flags =0;

#else

			*cpu=ECpuUnknown;

			*flags =0;

#endif

			break;

			}

		// GetMemModelInfo

		case RShadow::EControlGetMemModelInfo:

			{

			TUint pageTable;

			TUint numPds;

#ifdef __EPOC32__

#if defined(__MEMMODEL_MULTIPLE__) || defined(__MEMMODEL_FLEXIBLE__)

			numPds = KMaxNumberOfPageDirectories;

#else

			numPds = 0;								

#endif			

			r = KMemoryModel;

#endif

			pageTable = KPageTableBase;			

			kumemput(a1, &pageTable, sizeof(TUint));

			kumemput(a2, &numPds, sizeof(TUint));

			break;

			}

		// GetPdInfo

		case RShadow::EControlGetPdInfo:

			{

			TUint pd;

			kumemget(&pd, a1, sizeof(TUint));

			TUint pdSize;

			TUint pdBase;

			r=KErrNoPageTable;

#if defined(__MEMMODEL_MOVING__)

			if (pd==KGlobalPageDirectory)

				{

				pdSize=KPageDirectorySize;

				pdBase=KPageDirectoryBase;

				r = KErrNone;

				}

#elif defined(__MEMMODEL_MULTIPLE__) || defined(__MEMMODEL_FLEXIBLE__)

#ifdef __CPU_X86

			TUint ttbcr = KPsudoX86TTBCR;

#else

			TUint ttbcr = KPageDirectorySize >> GetTTBCR();

#endif

			if (pd==KGlobalPageDirectory)

				{

				pdSize=KPageDirectorySize - ttbcr;

				pdBase=KPageDirectoryBase + ttbcr*4;

				r = ttbcr & KPageOffsetMask;

				}

			else

				{

				pdSize = ttbcr;

				pdBase=KPageDirectoryBase + pd * KPageDirectorySize * 4;

				TPhysAddr phys=Epoc::LinearToPhysical((TLinAddr)pdBase);				

				r = (phys==KPhysAddrInvalid) ? KErrNoPageTable : KErrNone;

				}

#endif  //memmodel

			if ((r & KErrNoPageTable) == 0)

				{

				kumemput(a1, &pdSize, sizeof(TUint));

				kumemput(a2, &pdBase, sizeof(TUint));

				}

			break;	

			}

		default:

			r=KErrNotSupported;

			break;

		}

	return r;

	}

#else

TInt DShadow::Request(TInt /*aFunction*/, TAny* /*a1*/, TAny* /*a2*/)

	{

	return KErrNotSupported;

	}

#endif