// 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 "cache_maintenance.inl"

/**

 @file

 @internalComponent

*/

#if defined(GNUC) && !defined(__MARM_ARM4__)

#define	__VOLATILE__	volatile

#else

#define __VOLATILE__

#endif

#if defined(__SMP__) && defined(__CPU_ARM11MP__) 

#define COARSE_GRAINED_TLB_MAINTENANCE

#define BROADCAST_TLB_MAINTENANCE

#endif

FORCE_INLINE void __arm_dmb()

	{

	#if defined(__CPU_ARMV6)

		// dmb instruction...

		#ifdef __GNUC__

			TInt zero = 0;

			asm __VOLATILE__ ("mcr p15, 0, %0, c7, c10, 5 " : : "r"(zero));

		#elif defined(__ARMCC__)

			TInt zero = 0;

			asm("mcr p15, 0, zero, c7, c10, 5 ");

		#elif defined(__GCCXML__)

			// empty

		#else

			#error Unknown compiler

		#endif

	#elif defined(__CPU_ARMV7)

		// deprecated CP15 version of DMB...

		#ifdef __GNUC__

			TInt zero = 0;

			asm __VOLATILE__ ("mcr p15, 0, %0, c7, c10, 5 " : : "r"(zero));

		#elif defined(__ARMCC__)

			TInt zero = 0;

			asm("mcr p15, 0, zero, c7, c10, 5 ");

		#elif defined(__GCCXML__)

			// empty

		#else

			#error Unknown compiler

		#endif

	#else

		// non inline version...

		__e32_memory_barrier();

	#endif

	}

FORCE_INLINE void __arm_dsb()

	{

	#if defined(__CPU_ARMV6)

		// drain write buffer...

		#ifdef __GNUC__

			TInt zero = 0;

			asm __VOLATILE__ ("mcr p15, 0, %0, c7, c10, 4 " : : "r"(zero));

		#elif defined(__ARMCC__)

			TInt zero = 0;

			asm("mcr p15, 0, zero, c7, c10, 4 ");

		#elif defined(__GCCXML__)

			// empty

		#else

			#error Unknown compiler

		#endif

	#elif defined(__CPU_ARMV7)

		// deprecated CP15 version of DSB...

		#ifdef __GNUC__

			TInt zero = 0;

			asm __VOLATILE__ ("mcr p15, 0, %0, c7, c10, 4 " : : "r"(zero));

		#elif defined(__ARMCC__)

			TInt zero = 0;

			asm("mcr p15, 0, zero, c7, c10, 4 ");

		#elif defined(__GCCXML__)

			// empty

		#else

			#error Unknown compiler

		#endif

	#else

		// non inline version...

		__e32_io_completion_barrier();

	#endif

	}

extern "C" void __e32_instruction_barrier();

FORCE_INLINE void __arm_isb()

	{

	#if defined(__CPU_ARMV6)

		// prefetch flush...

		#ifdef __GNUC__

			TInt zero = 0;

			asm __VOLATILE__ ("mcr p15, 0, %0, c7, c5, 4 " : : "r"(zero));

		#elif defined(__ARMCC__)

			TInt zero = 0;

			asm("mcr p15, 0, zero, c7, c5, 4 ");

		#elif defined(__GCCXML__)

			// empty

		#else

			#error Unknown compiler

		#endif

	#elif defined(__CPU_ARMV7)

		// deprecated CP15 version of ISB...

		#ifdef __GNUC__

			TInt zero = 0;

			asm __VOLATILE__ ("mcr p15, 0, %0, c7, c5, 4 " : : "r"(zero));

		#elif defined(__ARMCC__)

			TInt zero = 0;

			asm("mcr p15, 0, zero, c7, c5, 4 ");

		#elif defined(__GCCXML__)

			// empty

		#else

			#error Unknown compiler

		#endif

	#else

		// non inline version...

		__e32_instruction_barrier();

	#endif

	}

/**

Branch predictor invalidate all

*/

FORCE_INLINE void __arm_bpiall()

	{

	#ifdef __GNUC__

		TInt zero = 0;

		asm __VOLATILE__ ("mcr p15, 0, %0, c7, c5, 6 " : : "r"(zero));

	#elif defined(__ARMCC__)

		TInt zero = 0;

		asm("mcr p15, 0, zero, c7, c5, 6 ");

	#elif defined(__GCCXML__)

		// empty

	#else

		#error Unknown compiler

	#endif

	}

#ifdef __SMP__

/**

Branch predictor invalidate all inner-shareable

*/

FORCE_INLINE void __arm_bpiallis()

	{

	// branch predictor invalidate all inner-shareable

	#ifdef __GNUC__

		TInt zero = 0;

		asm __VOLATILE__ ("mcr p15, 0, %0, c7, c1, 6 " : : "r"(zero));

	#elif defined(__ARMCC__)

		TInt zero = 0;

		asm("mcr p15, 0, zero, c7, c1, 6 ");

	#elif defined(__GCCXML__)

		// empty

	#else

		#error Unknown compiler

	#endif

	}

#endif

/**	

This will make sure that the change in page directory is visible by H/W Page-Table Walk.  

Call this function when a single entry in page directory is changed.

*/

FORCE_INLINE void SinglePdeUpdated(TPde* aPde)

  	{

	CacheMaintenance::SinglePdeUpdated((TLinAddr)aPde);

  	}

#ifdef BROADCAST_TLB_MAINTENANCE

/**

Signal other CPU cores to perform TLB maintenance.

@param aLinAddrAndAsid	If == 0, then InvalidateTLB;

						if < KMmuAsidCount, then InvalidateTLBForAsid;

						else InvalidateTLBForPage.

*/

extern void BroadcastInvalidateTLB(TLinAddr aLinAddrAndAsid=0);

#endif

/**

Invalidate a single I+D TLB entry on this CPU core only.

@param aLinAddrAndAsid Virtual address of a page of memory ORed with the ASID value.

*/

FORCE_INLINE void LocalInvalidateTLBForPage(TLinAddr aLinAddrAndAsid)

	{

	#ifdef __GNUC__

		#if defined(__CPU_ARM11MP__) // why?...

			asm __VOLATILE__ ("mcr p15, 0, %0, c8, c7, 3 " : : "r"(aLinAddrAndAsid));

		#else

			asm __VOLATILE__ ("mcr p15, 0, %0, c8, c7, 1 " : : "r"(aLinAddrAndAsid));

		#endif

	#elif defined(__ARMCC__)

		#if defined(__CPU_ARM11MP__) // why?...

			asm("mcr p15, 0, aLinAddrAndAsid, c8, c7, 3 ");

		#else

			asm("mcr p15, 0, aLinAddrAndAsid, c8, c7, 1 ");

		#endif

	#elif defined(__GCCXML__)

		// empty

	#else

		#error Unknown compiler

	#endif

	__arm_bpiall();

	__arm_dsb();

	__arm_isb();

	}

/**

Invalidate a single I+D TLB entry on all CPU cores.

@param aLinAddrAndAsid Virtual address of a page of memory ORed with the ASID value.

*/

FORCE_INLINE void InvalidateTLBForPage(TLinAddr aLinAddrAndAsid)

	{

	#ifdef BROADCAST_TLB_MAINTENANCE

		BroadcastInvalidateTLB(aLinAddrAndAsid);

	#elif !defined(__SMP__)

		LocalInvalidateTLBForPage(aLinAddrAndAsid);

	#else // __SMP__

		// inner-shareable invalidate...

		#ifdef __GNUC__

			asm __VOLATILE__ ("mcr p15, 0, %0, c8, c3, 1 " : : "r"(aLinAddrAndAsid));

		#elif defined(__ARMCC__)

			asm("mcr p15, 0, aLinAddrAndAsid, c8, c3, 1 ");

		#elif defined(__GCCXML__)

			// empty

		#else

			#error Unknown compiler

		#endif

		__arm_bpiallis();

		__arm_dsb();

		__arm_isb();

	#endif

	}

/**

Invalidate entire TLB on this CPU only

*/

FORCE_INLINE void LocalInvalidateTLB()

	{

	#ifdef __GNUC__

		asm __VOLATILE__ ("mcr p15, 0, r0, c8, c7, 0 ");

	#elif defined(__ARMCC__)

		TInt dummy = 0; // damned RVCT

		asm("mcr p15, 0, dummy, c8, c7, 0 ");

	#elif defined(__GCCXML__)

		// empty

	#else

		#error Unknown compiler

	#endif

	__arm_bpiall();

	__arm_dsb();

	__arm_isb();

	}

/**

Invalidate entire TLB on all CPU cores.

*/

FORCE_INLINE void InvalidateTLB()

	{

	#ifdef BROADCAST_TLB_MAINTENANCE

		BroadcastInvalidateTLB(0);

	#elif !defined(__SMP__)

		LocalInvalidateTLB();

	#else // __SMP__

		// inner-shareable invalidate...

		#ifdef __GNUC__

			TInt zero = 0;

			asm __VOLATILE__ ("mcr p15, 0, %0, c8, c3, 0 " : : "r"(zero));

		#elif defined(__ARMCC__)

			TInt zero = 0;

			asm("mcr p15, 0, zero, c8, c3, 0 ");

		#elif defined(__GCCXML__)

			// empty

		#else

			#error Unknown compiler

		#endif

		__arm_bpiallis();

		__arm_dsb();

		__arm_isb();

	#endif

	}

#if defined(__CPU_ARM1136__) && !defined(__CPU_ARM1136_ERRATUM_424067_FIXED)

#define INVALIDATE_TLB_BY_ASID_BROKEN

#endif

#if defined(__CPU_ARM1176__) && !defined(__CPU_ARM1176_ERRATUM_424692_FIXED)

#define INVALIDATE_TLB_BY_ASID_BROKEN

#endif

__ASSERT_COMPILE(KKernelOsAsid==0); // InvalidateTLBForAsid assumes this

/**

Invalidate all TLB entries which match the given ASID value (current CPU only)

*/

FORCE_INLINE void LocalInvalidateTLBForAsid(TUint aAsid)

	{

#ifndef INVALIDATE_TLB_BY_ASID_BROKEN

	if(aAsid&=0xff)

		{

#if defined(__CPU_CORTEX_A9__) && !defined(__CPU_ARM_A9_ERRATUM_571618_FIXED)

		__arm_dmb();	// ARM Cortex-A9 MPCore erratum 571618 workaround

						// Execute memory barrier before interruptible CP15 operations

#endif

		// invalidate all I+D TLB entries for ASID...

		#ifdef __GNUC__

			asm __VOLATILE__ ("mcr p15, 0, %0, c8, c7, 2 " : : "r"(aAsid));

		#elif defined(__ARMCC__)

			asm("mcr p15, 0, aAsid, c8, c7, 2 ");

		#elif defined(__GCCXML__)

			// empty

		#else

			#error Unknown compiler

		#endif

		}

	else

		// ASID==0 means 'kernel' memory. We have to invalidate the entire TLB here

		// as this is the only way of getting rid of global entries...

#endif

		{

		// invalidate entire TLB...

		#ifdef __GNUC__

			asm __VOLATILE__ ("mcr p15, 0, r0, c8, c7, 0 ");

		#elif defined(__ARMCC__)

			TInt dummy = 0; // damned RVCT

			asm("mcr p15, 0, dummy, c8, c7, 0 ");

		#elif defined(__GCCXML__)

			// empty

		#else

			#error Unknown compiler

		#endif

		}

	__arm_bpiall();

	__arm_dsb();

	__arm_isb();

	}

/**

Invalidate all TLB entries which match the given ASID value on all CPU cores.

*/

FORCE_INLINE void InvalidateTLBForAsid(TUint aAsid)	

	{

	aAsid &= 0xff;

	#ifdef BROADCAST_TLB_MAINTENANCE

		BroadcastInvalidateTLB(aAsid);

	#elif !defined(__SMP__)

		LocalInvalidateTLBForAsid(aAsid);

	#else // __SMP__

		if(aAsid!=0)

			{

#if defined(__CPU_CORTEX_A9__) && !defined(__CPU_ARM_A9_ERRATUM_571618_FIXED)

			__arm_dmb();	// ARM Cortex-A9 MPCore erratum 571618 workaround

							// Execute memory barrier before interruptible CP15 operations

#endif

			// invalidate all I+D TLB entries for ASID...

			#ifdef __GNUC__

				asm __VOLATILE__ ("mcr p15, 0, %0, c8, c3, 2 " : : "r"(aAsid));

			#elif defined(__ARMCC__)

				asm("mcr p15, 0, aAsid, c8, c3, 2 ");

			#elif defined(__GCCXML__)

				// empty

			#else

				#error Unknown compiler

			#endif

			}

		else

			{

			// ASID==0 means 'kernel' memory. We have to invalidate the entire TLB here

			// as this is the only way of getting rid of global entries...

			#ifdef __GNUC__

				asm __VOLATILE__ ("mcr p15, 0, %0, c8, c3, 0 " : : "r"(aAsid));

			#elif defined(__ARMCC__)

				asm("mcr p15, 0, aAsid, c8, c3, 0 ");

			#elif defined(__GCCXML__)

				// empty

			#else

				#error Unknown compiler

			#endif

			}

		__arm_bpiallis();

		__arm_dsb();

		__arm_isb();

	#endif

	}

/**

Return the virtual address of the page directory used for address space

\a aOsAsid. Note, the global page directory is mapped after each

address space specific page director in a way which means that it

appears to be a single contiguous page directory which maps the

entire 32bit virtual address range. I.e. the returned page directory

address can be simply indexed by any virtual address without regard

to whether it belongs to the given address space or lies in the

global region.

*/

FORCE_INLINE TPde* Mmu::PageDirectory(TInt aOsAsid)

	{

	return (TPde*)(KPageDirectoryBase+(aOsAsid<<KPageDirectoryShift));

	}

/**

Return the virtual address of the Page Directory Entry (PDE) used to map

the region containing the virtual address \a aAddress in the address space

\a aOsAsid.

*/

FORCE_INLINE TPde* Mmu::PageDirectoryEntry(TInt aOsAsid, TLinAddr aAddress)

	{

	return PageDirectory(aOsAsid) + (aAddress>>KChunkShift);

	}

/**

Return the physical address mapped by the section mapping contained

in the given Page Directory Entry \a aPde. If \a aPde is not a

section mapping, then KPhysAddrInvalid is returned.

*/

FORCE_INLINE TPhysAddr Mmu::PdePhysAddr(TPde aPde)

	{

	if((aPde&KPdePresentMask)==KArmV6PdeSection)

		return aPde&KPdeSectionAddrMask;

	return KPhysAddrInvalid;

	}

#ifdef __CPU_MEMORY_TYPE_REMAPPING

/*

Bits in a PTE which represent access permissions...

AP2 AP1 AP0		usr	wr

0	0	x		n	y

0	1	x		y	y

1	0	x		n	n

1	1	x		y	n

*/

/**

Modify a Page Table Entry (PTE) value so it restricts access to the memory it maps.

The returned PTE value is the same as \a aPte but with its access permissions set

to read-only if \a aReadOnly is true, and set to allow no access if \a aReadOnly is false.

*/

FORCE_INLINE TPte Mmu::MakePteInaccessible(TPte aPte, TBool aReadOnly)

	{

	__NK_ASSERT_DEBUG((aPte&KArmV6PteTypeMask)!=KArmV6PteLargePage);

	if(aPte&KPtePresentMask)

		{

		__NK_ASSERT_DEBUG((bool)(aPte&KArmV6PteSmallTEX1)==(bool)(aPte&KArmV6PteSmallXN)); // TEX1 should be a copy of XN

		if(aReadOnly)

			aPte |= KArmV6PteAP2; // make read only

		else

			aPte &= ~KPtePresentMask; // make inaccessible

		}

	return aPte;

	}

/**

Modify a Page Table Entry (PTE) value so it allows greater access to the memory it maps.

The returned PTE value is the same as \a aPte but with its access permissions set

to read/write if \a aWrite is true, and set to read-only if \a aWrite is false.

*/

FORCE_INLINE TPte Mmu::MakePteAccessible(TPte aPte, TBool aWrite)

	{

	__NK_ASSERT_DEBUG((aPte&KArmV6PteTypeMask)!=KArmV6PteLargePage);

	if((aPte&KPtePresentMask)==0)

		{

		// wasn't accessible, make it so...

		if(aPte&KArmV6PteSmallTEX1)

			aPte |= KArmV6PteSmallXN; // restore XN by copying from TEX1

		aPte |= KArmV6PteSmallPage;

		aPte |= KArmV6PteAP2; // make read only

		}

	if(aWrite)

		aPte &= ~KArmV6PteAP2; // make writable

	return aPte;

	}

#else // not __CPU_MEMORY_TYPE_REMAPPING

/*

Bits in a PTE which represent access permissions...

AP2 AP1 AP0		usr	wr

0	0	0

0	0	1		n	y

0	1	0

0	1	1		y	y

1	0	0

1	0	1		n	n

1	1	0		y	n

1	1	1

*/

FORCE_INLINE TPte Mmu::MakePteInaccessible(TPte aPte, TBool aReadOnly)

	{

	__NK_ASSERT_DEBUG((aPte&KArmV6PteTypeMask)!=KArmV6PteLargePage);

	if(aPte&KPtePresentMask)

		{

		if(!aReadOnly)

			{

			// copy XN to AP0...

			if(aPte&KArmV6PteSmallXN)

				aPte |= KArmV6PteAP0;

			else

				aPte &= ~KArmV6PteAP0;

			// make inaccessible...

			aPte &= ~KPtePresentMask;

			}

		else

			{

			// make read only...

			aPte |= KArmV6PteAP2; // make read only

			if(aPte&KArmV6PteAP1)

				aPte &= ~KArmV6PteAP0; // correct AP0

			}

		}

	return aPte;

	}

FORCE_INLINE TPte Mmu::MakePteAccessible(TPte aPte, TBool aWrite)

	{

	__NK_ASSERT_DEBUG((aPte&KArmV6PteTypeMask)!=KArmV6PteLargePage);

	if((aPte&KPtePresentMask)==0)

		{

		// wasn't accessible, make it so...

		if(aPte&KArmV6PteAP0)

			aPte |= KArmV6PteSmallXN; // restore XN by copying from AP0

		aPte |= KArmV6PteAP0;

		aPte |= KArmV6PteSmallPage;

		// make read only...

		aPte |= KArmV6PteAP2; // make read only

		if(aPte&KArmV6PteAP1)

			aPte &= ~KArmV6PteAP0; // correct AP0

		}

	if(aWrite)

		{

		// make writable...

		aPte &= ~KArmV6PteAP2;

		aPte |= KArmV6PteAP0; 

		}

	return aPte;

	}

#endif // __CPU_MEMORY_TYPE_REMAPPING

/**

Return true if a Page Table Entry (PTE) only allows read-only access to memory.

*/

FORCE_INLINE TBool Mmu::IsPteReadOnly(TPte aPte)

	{

	__NK_ASSERT_DEBUG(aPte&KPtePresentMask); // read-only state is ambiguous if pte not present

	return aPte&KArmV6PteAP2;

	}

/**

Return true if a Page Table Entry (PTE) doesn't allow any access to the memory.

*/

FORCE_INLINE TBool Mmu::IsPteInaccessible(TPte aPte)

	{

	return !(aPte&KPtePresentMask);

	}

/**

Return true if the Page Table Entry \a aNewPte allows greater access to

memory that \a aOldPte. Only the permissions read/write, read-only and no-access

are considered, not any execute or privileged access.

*/

FORCE_INLINE TBool Mmu::IsPteMoreAccessible(TPte aNewPte, TPte aOldPte)

	{

	if(aNewPte&aOldPte&KPtePresentMask)			// if ptes both present

		return (aOldPte&~aNewPte)&KArmV6PteAP2;	//   check for more writable

	else										// else

		return aNewPte&KPtePresentMask;			//   check for new pte being present

	}

/**

Bit flag values representing the memory mapping differences governed by

MMU Page Directory Entries (PDEs). Memory which differs in #TPdeType can

not be mapped using the same Page Table, as they would share the same PDE

entry.

*/

enum TPdeType

	{

	/**

	Legacy (and little-used/unused?) ARM attribute.

	This could potentially be removed (see DMemoryMapping::PdeType()).

	*/

	EPdeTypeECC				= 1<<0,

	/**

	Total number of combinations of #TPdeType values.

	*/

	ENumPdeTypes			= 2

	};

/**

Bit flag values representing the memory mapping differences governed by

MMU Page Table Entries (PTEs).

*/

enum TPteType

	{

	/**

	PTE grants user mode access to memory.

	*/

	EPteTypeUserAccess		= EUser,

	/**

	PTE grants write access to memory.

	*/

	EPteTypeWritable		= EReadWrite,

	/**

	PTE grants execute  access to memory.

	*/

	EPteTypeExecutable		= EExecute,

	/**

	PTE is 'global'. I.e. the memory it maps is intended to be accessible

	in all process contexts, i.e. for mappings at virtual address >= KGlobalMemoryBase.

	The MMU uses this to tag TLB entries as valid for all ASIDs.

	*/

	EPteTypeGlobal			= 1<<3,

	/**

	Total number of combinations of #TPteType values.

	*/

	ENumPteTypes			= 16

	};

__ASSERT_COMPILE(EPteTypeUserAccess==(1<<0));

__ASSERT_COMPILE(EPteTypeWritable==(1<<1));

__ASSERT_COMPILE(EPteTypeExecutable==(1<<2));

#define MMU_SUPPORTS_EXECUTE_NEVER

/**

Return the #TPdeType for memory with the given attributes value.

*/

FORCE_INLINE TUint Mmu::PdeType(TMemoryAttributes aAttributes)

	{

	return aAttributes&EMemoryAttributeUseECC ? EPdeTypeECC : 0;

	}

/**

Return the #TPteType to use for memory mappings requiring the given access permissions

and Global attribute. The global flag is true if #EPteTypeGlobal is to be set.

*/

FORCE_INLINE TUint Mmu::PteType(TMappingPermissions aPermissions, TBool aGlobal)

	{

	__NK_ASSERT_DEBUG(aPermissions&EUser || aGlobal); // can't have supervisor local memory

	TUint pteType =	(aPermissions&(EUser|EReadWrite|EExecute));

	if(aGlobal)

		pteType |= EPteTypeGlobal;

	__NK_ASSERT_DEBUG(pteType<ENumPteTypes);

	return pteType;

	}

/**

Test if a memory access is allowed by a given mapping type.

@param aPteType				#TPteType used for a mapping. E.g. TMemoryMappingBase::PteType()

@param aAccessPermissions	Flags from #TMappingPermissions indicating the memory access

							required.

@return True if a memory access requested with permissions \a aAccessPermissions

		is allowed on a mapping of the specified #TPteType.

		False if the access is not allowed.

*/

FORCE_INLINE TBool Mmu::CheckPteTypePermissions(TUint aPteType, TUint aAccessPermissions)

	{

	aAccessPermissions &= EUser|EReadWrite|EExecute;

	return (aPteType&aAccessPermissions)==aAccessPermissions;

	}

/**

Extract the #TMappingPermissions corresponding to a given #TPteType.

*/

FORCE_INLINE TMappingPermissions Mmu::PermissionsFromPteType(TUint aPteType)

	{

	return (TMappingPermissions)(aPteType&(EPteTypeUserAccess|EPteTypeWritable|EPteTypeExecutable));

	}

extern void UserWriteFault(TLinAddr aAddr);

extern void UserReadFault(TLinAddr aAddr);

//

// TODO: Move these to NKern

//

FORCE_INLINE void inline_DisableAllInterrupts()

	{

#ifdef __GNUC__

	#ifdef __CPU_ARM_HAS_CPS

		CPSIDIF;

	#else

		TInt reg;

		asm __VOLATILE__ ("mrs %0, cpsr" : "=r"(reg));

		asm __VOLATILE__ ("orr %0, %0, #0xc0" : : "r"(reg));

		asm __VOLATILE__ ("msr cpsr_c, %0" : : "r"(reg));

	#endif

/*

#elif defined(__ARMCC__)

	#if defined(__CPU_ARM_HAS_CPS) && __ARMCC_VERSION>=300000

		asm("cpsid if");

	#else

		TInt reg;

		asm("mrs reg, cpsr");

		asm("orr reg, reg, #0xc0");

		asm("msr cpsr_c, reg");

	#endif

*/

#else

	NKern::DisableAllInterrupts();

#endif

	}

FORCE_INLINE void inline_EnableAllInterrupts()

	{

#ifdef __GNUC__

	#ifdef __CPU_ARM_HAS_CPS

		CPSIEIF;

	#else

		TInt reg;

		asm __VOLATILE__ ("mrs %0, cpsr" : "=r"(reg));

		asm __VOLATILE__ ("bic %0, %0, #0xc0" : : "r"(reg));

		asm __VOLATILE__ ("msr cpsr_c, %0" : : "r"(reg));

	#endif

/*

#elif defined(__ARMCC__)

	#if defined(__CPU_ARM_HAS_CPS) && __ARMCC_VERSION>=300000

		asm("cpsie if");

	#else

		TInt reg;

		asm("mrs reg, cpsr");

		asm("bic reg, reg, #0xc0");

		asm("msr cpsr_c, reg");

	#endif

*/

#else

	NKern::EnableAllInterrupts();

#endif

	}

#ifndef	__SMP__

#undef __SPIN_LOCK_IRQ

#define __SPIN_LOCK_IRQ(lock)					(inline_DisableAllInterrupts())

#undef __SPIN_UNLOCK_IRQ

#define __SPIN_UNLOCK_IRQ(lock)					(inline_EnableAllInterrupts())

#undef __SPIN_FLASH_IRQ

#define __SPIN_FLASH_IRQ(lock)					(inline_EnableAllInterrupts(),inline_DisableAllInterrupts(),((TBool)TRUE))

#endif

/**

Indicate whether a PDE entry maps a page table.

@param aPde The PDE entry in question.

*/

FORCE_INLINE TBool Mmu::PdeMapsPageTable(TPde aPde)

	{

	return (aPde & KPdeTypeMask) == KArmV6PdePageTable;

	}

/**

Indicate whether a PDE entry maps a section.

@param aPde The PDE entry in question.

*/

FORCE_INLINE TBool Mmu::PdeMapsSection(TPde aPde)

	{

	return (aPde & KPdeTypeMask) == KArmV6PdeSection;

	}