// 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:

// e32\memmodel\epoc\moving\arm\xsched.cia

// 

//

#include <e32cia.h>

#include <arm_mem.h>

#define iMState		iWaitLink.iSpare1

//#define __DEBUG_BAD_ADDR

#define iCurrentVMProcess				iExtras[0]

#define	iCurrentDataSectionProcess		iExtras[1]

#define	iCompleteDataSectionProcess		iExtras[2]

#ifdef __REQUEST_COMPLETE_MACHINE_CODED__

#if defined(_DEBUG)

extern "C" void __DebugMsgRequestComplete(TInt a0, TInt a1, TInt a2);

extern "C" void __DebugMsgReqCompleteWrite(TInt a0, TInt a1, TInt a2);

#endif

__NAKED__ void DThread::RequestComplete(TRequestStatus*& /*aStatus*/, TInt /*aReason*/)

//

// Signal this threads request semaphore.

// Enter with system locked, return with system unlocked.

//

	{

	ASM_DEBUG2(DThreadRequestComplete,r0,lr);

	asm("ldr r3, [r1] ");					// r3 points to TRequestStatus

	asm("mov r12, #0 ");

	asm("str r12, [r1] ");					// aStatus=NULL

	asm(".global _asm_RequestComplete ");

	asm("_asm_RequestComplete: ");

#ifdef BTRACE_REQUESTS

	asm("stmdb sp!,{r0-r3,lr}");

	asm("mov r1,r3");

	asm("mov r3,r2");											// arg3 = aReason

	asm("mov r2,r1");											// arg2 = aStatus

	asm("add r1,r0,#%a0" : : "i" _FOFF(DThread,iNThread));		// arg1 = &this->iNThread

	asm("ldr r0,_threadReqequestCompleteTraceHeader");			// arg0 = header

	asm("bl " CSM_ZN6BTrace4OutXEmmmm);

	asm("ldmia sp!,{r0-r3,lr}");

#endif

	ASM_DEBUG3(RequestComplete,r0,r3,r2);

	asm("ldrb r12, [r0, #%a0]" : : "i" _FOFF(DThread,iMState));

	asm("stmfd sp!, {r4-r6} ");

	asm("add r6, r0, #%a0" : : "i" _FOFF(DThread,iNThread));

	asm("ldr r0, [r0, #%a0]" : : "i" _FOFF(DThread,iOwningProcess));

	asm("cmp r12, #%a0" : : "i" (DThread::EDead));	// test if iMState=EDead

	asm("ldr r12, [r0, #%a0]!" : : "i" _FOFF(DMemModelProcess, iNumChunks));	// step r0 on to iChunks[0]

	asm("beq req_complete_dead_thread ");	// if it is, finished

	asm("b req_complete_2");

	// lookup r3 in address space of process r0

	asm("req_complete_1: ");

	asm("ldmcsib r0!, {r1,r4} ");			// r1=data section base, r4=chunk ptr

	asm("subcss r1, r3, r1 ");				// r1=offset

	asm("ldrcs r5, [r4, #%a0]" : : "i" _FOFF(DChunk,iMaxSize));	// if offset>=0, r5=chunk max size

	asm("cmpcs r1, r5 ");					// and compare offset to max size

	asm("addcs r0, r0, #4 ");				// if offset>=max size, move to next entry

	asm("req_complete_2: ");

 	asm("subcss r12, r12, #1 ");			// and decrement counter

	asm("bcs req_complete_1 ");				// loop if more chunks to check

	asm("cmp r12, #0 ");					// did we find chunk?

	asm("ldrge r3, [r4, #%a0]" : : "i" _FOFF(DMemModelChunk,iHomeRegionOffset));

	asm("ldrge r5, [r4, #%a0]" : : "i" _FOFF(DMemModelChunk,iHomeRegionSize));

	asm("cmpge r1, r3 ");					// if we did but offset<iHomeRegionOffset, no good

	asm("blt req_complete_invalid ");		// or if we didn't find it, no good

	asm("add r3, r3, r5 ");					// r3=home region offset+home region size

	asm("cmp r1, r3 ");						// if offset >= iHomeRegionOffset+iHomeRegionSize, no good

	asm("ldrlt r0, [r4, #%a0]" : : "i" _FOFF(DChunk,iBase));	// if OK, r0=chunk base

	asm("bge req_complete_invalid ");

											// Zero flag always clear here

	ASM_DEBUG3(ReqCompleteWrite,r0,r1,r2);

	asm(".global __magic_address_reqc ");

	asm("__magic_address_reqc: ");			// this instruction is magically immune from exceptions

	asm("str r2, [r0, r1] ");				// r0+r1=current address, store completion code

	asm("movne r0, r6 ");					// if write OK, r0->iNThread

	asm("ldmnefd sp!, {r4-r6} ");			// restore registers

	asm("movne r1, #0 ");

	asm("bne  " CSM_ZN5NKern19ThreadRequestSignalEP7NThreadP10NFastMutex);

#ifndef __DEBUG_BAD_ADDR

	asm("req_complete_invalid: ");

	asm("ldmfd sp!, {r4-r6} ");				// restore registers

	asm("b  " CSM_ZN5NKern12UnlockSystemEv);

#endif

#ifdef __DEBUG_BAD_ADDR

	asm("req_complete_invalid: ");			//DEBUG

	asm("mov r9, #0xde000000 ");

	asm("str r9, [r9, #0xaf] ");			//HACK-CRASH SYSTEM

#endif

	asm("req_complete_dead_thread: ");

	asm("ldmfd sp!, {r4-r6} ");				// restore registers

	asm("b  " CSM_ZN5NKern12UnlockSystemEv);

#ifdef BTRACE_REQUESTS

	asm("_threadReqequestCompleteTraceHeader:");

	asm(".word %a0" : : "i" (BTRACE_HEADER_C(16,BTrace::ERequests,BTrace::ERequestComplete)));

#endif

	}

#endif

#ifdef __SCHEDULER_MACHINE_CODED__

#if defined(_DEBUG)

extern "C" void __DebugMsgFixedAddress();

extern "C" void __DebugMsgMoving();

extern "C" void __DebugMsgProtectChunks(int aProc);

extern "C" void __DebugMsgUnprotectChunks(int aProc);

extern "C" void __DebugMsgMoveChunksToHome(int aProc);

extern "C" void __DebugMsgMoveChunksToData(int aProc);

extern "C" void __DebugMsgMoveChunkToHomeAddress(int aChunk);

extern "C" void __DebugMsgProtectChunk(int aChunk);

extern "C" void __DebugMsgMoveChunkToRunAddress(int aChunk, int aRunAddr);

extern "C" void __DebugMsgUnprotectChunk(int aChunk);

#endif

GLDEF_C __NAKED__ void DoProcessSwitch()

	{

	//

	// Enter and return in mode_svc with system lock held, kernel unlocked, interrupts enabled.

	// On entry r0->scheduler, r2->current thread, r5->current address space, r9->new address space

	// Must preserve r0,r2, can modify other registers

	//

	asm("mrc p15, 0, r7, c3, c0, 0 ");		// r7=DACR

	asm("ldr r4, [r0, #%a0]" : : "i" _FOFF(TScheduler,iCurrentVMProcess));

	asm("mov r1, r9 ");

	asm("stmfd sp!, {r7,lr} ");

	asm("orr r7, r7, #0x30 ");				// unlock page tables

	asm("mcr p15, 0, r7, c3, c0, 0 ");		// set DACR

	CPWAIT(,ip);

	asm("ldr lr, [r9, #%a0]" : : "i" _FOFF(DArmPlatProcess,iAttributes));

	asm("mov ip, #0 ");

	asm("cmp r4, #0 ");

	asm("ldrne ip, [r4, #%a0]" : : "i" _FOFF(DArmPlatProcess,iAttributes));

	// register contents at this point are:

	// r0->TheScheduler, r1->new process, r2->new thread, r3=scratch, r4=current VM process

	// r5=scratch, r7-11 scratch, r12=current VM process attributes,

	// r14=new process attributes

	asm("ands r6, lr, #%a0" : : "i" ((TInt)DMemModelProcess::EMoving));

	asm("beq resched_fixed ");				// skip if new process is fixed

	// The current process has moving chunks

	ASM_DEBUG0(Moving)

#ifdef __CPU_WRITE_BACK_CACHE

	// We need to flush the DCache before moving anything.

	// Condition for flush here is

	// NEW PROCESS MOVING && (NEW PROCESS!=COMPLETE DATA SECTION PROCESS)

	asm("ldr r3, [r0, #%a0]" : : "i" _FOFF(TScheduler,iCompleteDataSectionProcess));	// r3=complete data section process

	asm("cmp r3, r1 ");						// check if TheCurrentProcess==TheCompleteDataSectionProcess

	asm("blne SyncMapChangeAttempt ");		// if not same, flush the DCache; on return ZF=0 means abort

											// stack alignment OK since called function is assembler

	asm("bne end_process_switch ");			// if contention, just exit now

#endif

	asm("mov r6, #0 ");

	asm("str r6, [r0, #%a0]" : : "i" _FOFF(TScheduler,iAddressSpace));

	// if (pD && pD!=pP) ...

	asm("ldr r3, [r0, #%a0]" : : "i" _FOFF(TScheduler,iCurrentDataSectionProcess));		// r3=current data section process

	asm("mov r8, #0 ");

	asm("str r8, [r0, #%a0]" : : "i" _FOFF(TScheduler,iCompleteDataSectionProcess));

	asm("cmp r3, #0 ");						// if !TheCurrentDataSectionProcess

	asm("cmpne r3, r1 ");					// || TheCurrentDataSectionProcess==TheCurrentProcess

	asm("beq resched_moving1 ");			// skip next section

	// Move TheCurrentDataSectionProcess to the home section and protect it

	ASM_DEBUG1(MoveChunksToHome,r3)

	asm("ldr r5, [r3, #%a0]" : : "i" _FOFF(DMemModelProcess,iNumChunks));

	asm("cmp r5, #0 ");						// check if current data section process has no chunks

	asm("beq resched_moving1b ");			// skip if it does

	asm("stmfd sp!, {r1-r4,r12} ");

	asm("add r4, r3, #%a0" : : "i" (_FOFF(DMemModelProcess,iChunks)+4));

	asm("resched_moving1a: ");

	asm("ldr r7, [r4], #12 ");				// r7=address of chunk to move

	asm("bl MoveHomeOrProtectChunk ");		// move chunk - this must preserve r0

	asm("ldr ip, [r0, #%a0]" : : "i" _FOFF(TScheduler,iLock.iWaiting));

	asm("cmp ip, #0 ");						// check for contention

	asm("bne abort_resched_mh ");			// if there is, abort

#ifdef BTRACE_FAST_MUTEX

	asm("ldrb ip, [r0, #%a0]" : : "i" (_FOFF(TScheduler,iFastMutexFilter)));

	asm("cmp ip, #0");

	asm("ldrne r2, [sp, #4]"); // current thread

	asm("blne procswitch_trace_flash");

#endif

	asm("subs r5, r5, #1 ");

	asm("bne resched_moving1a ");

	asm("ldmfd sp!, {r1-r4,r12} ");

	asm("resched_moving1b: ");

	asm("cmp r3, r4 ");

	asm("moveq r4, #0 ");					// ... TheCurrentVMProcess=NULL

	asm("streq r4, [r0, #%a0]" : : "i" _FOFF(TScheduler,iCurrentVMProcess));

	asm("mov r3, #0 ");						// TheCurrentDataSectionProcess=NULL

	asm("str r3, [r0, #%a0]" : : "i" _FOFF(TScheduler,iCurrentDataSectionProcess));

	// if (pV && pV!=pP)

	asm("resched_moving1: ");

	asm("cmp r4, #0 ");						// if !TheCurrentVMProcess

	asm("cmpne r4, r1 ");					// || TheCurrentVMProcess==TheCurrentProcess

	asm("beq resched_moving2 ");			// skip next section

	// Protect TheCurrentVMProcess but don't move it

	// register contents at this point are:

	// r0->TheScheduler, r2->new thread, r1->TheCurrentProcess, r4=current VM process

	// r12=current VM process attributes, r3,r5,r7-r11->scratch

	ASM_DEBUG1(ProtectChunks,r4)

	asm("tst r12, #%a0" : : "i" (DMemModelProcess::EVariableAccess));	// r12=TheCurrentVMProcess->iAttributes

	asm("beq resched_moving2 ");			// if fixed access process, nothing to do

	asm("ldr r5, [r4, #%a0]" : : "i" _FOFF(DMemModelProcess,iNumChunks));

	asm("cmp r5, #0 ");

	asm("beq resched_moving2b ");			// if number of chunks=0, nothing to do

	asm("add r11, r4, #%a0" : : "i" (_FOFF(DMemModelProcess,iChunks)+4));

	asm("resched_moving2a: ");

	asm("ldr r7, [r11], #12 ");				// r7=address of chunk to protect

	asm("bl ProtectChunk ");				// protect it

	asm("ldr r7, [r0, #%a0]" : : "i" _FOFF(TScheduler,iLock.iWaiting));

	asm("cmp r7, #0 ");						// check for contention

	asm("bne abort_resched_mp ");			// if there is, abort

#ifdef BTRACE_FAST_MUTEX

	asm("ldrb ip, [r0, #%a0]" : : "i" (_FOFF(TScheduler,iFastMutexFilter)));

	asm("cmp ip, #0");

	asm("blne procswitch_trace_flash");

#endif

	asm("subs r5, r5, #1 ");

	asm("bne resched_moving2a ");

	asm("resched_moving2b: ");

	asm("mov r4, #0 ");						// TheCurrentVMProcess=NULL

	asm("str r4, [r0, #%a0]" : : "i" _FOFF(TScheduler,iCurrentVMProcess));

	asm("resched_moving2: ");

	asm("str r1, [r0, #%a0]" : : "i" _FOFF(TScheduler,iCurrentDataSectionProcess));

	asm("str r1, [r0, #%a0]" : : "i" _FOFF(TScheduler,iCurrentVMProcess));

	// Unprotect the TheCurrentProcess and move it to the data section if necessary

	// register contents at this point are:

	// r0->TheScheduler, r2->new thread, r1->TheCurrentProcess

	// r12=current VM process attributes, r3,r5,r7-r11->scratch

	ASM_DEBUG1(MoveChunksToData,r1)

	asm("ldr r5, [r1, #%a0]" : : "i" _FOFF(DMemModelProcess,iNumChunks));

	asm("cmp r5, #0 ");

	asm("beq resched_finish ");				// if number of chunks=0, nothing to do

	asm("stmfd sp!, {r1-r2,r12} ");			// don't need r3 or r4 any more

	asm("add r4, r1, #%a0" : : "i" _FOFF(DMemModelProcess,iChunks));

	asm("resched_moving3a: ");

	asm("ldmia r4!, {r7,r8,r9} ");			// r7=run address, r8=ptr to chunk, r9 top 16bits=isReadOnly

	asm("bl MoveRunOrUnprotectChunk ");		// move chunk to data section and/or unprotect it

	asm("ldr ip, [r0, #%a0]" : : "i" _FOFF(TScheduler,iLock.iWaiting));

	asm("cmp ip, #0 ");						// check for contention

	asm("bne abort_resched_mr ");			// if there is, abort

#ifdef BTRACE_FAST_MUTEX

	asm("ldrb ip, [r0, #%a0]" : : "i" (_FOFF(TScheduler,iFastMutexFilter)));

	asm("cmp ip, #0");

	asm("blne procswitch_trace_flash");

#endif

	asm("subs r5, r5, #1 ");

	asm("bne resched_moving3a ");

	asm("ldmfd sp!, {r1-r2,r12} ");

	asm("str r1, [r0, #%a0]" : : "i" _FOFF(TScheduler,iCompleteDataSectionProcess));

	asm("b resched_finish ");

	// The current process has no moving chunks

	asm("resched_fixed: ");

	ASM_DEBUG0(FixedAddress)

	asm("str r6, [r0, #%a0]" : : "i" _FOFF(TScheduler,iAddressSpace));

	asm("cmp r4, #0	");						// if TheCurrentVMProcess==NULL

	asm("beq resched_fixed1 ");				// skip this section

	// Protect TheCurrentVMProcess

	ASM_DEBUG1(ProtectChunks,r4)

	asm("ldr r5, [r4, #%a0]" : : "i" _FOFF(DMemModelProcess,iNumChunks));

	asm("add r11, r4, #%a0" : : "i" (_FOFF(DMemModelProcess,iChunks)+4));

	asm("cmp r5, #0 ");

	asm("beq resched_fixed1b ");			// if number of chunks=0, nothing to do

	asm("resched_fixed1a: ");

	asm("ldr r7, [r11], #12 ");				// r7=address of chunk to protect

	asm("bl ProtectChunk ");				// protect it

	asm("ldr r7, [r0, #%a0]" : : "i" _FOFF(TScheduler,iLock.iWaiting));

	asm("cmp r7, #0 ");						// check for contention

	asm("bne abort_resched_fp ");			// if there is, abort

#ifdef BTRACE_FAST_MUTEX

	asm("ldrb ip, [r0, #%a0]" : : "i" (_FOFF(TScheduler,iFastMutexFilter)));

	asm("cmp ip, #0");

	asm("blne procswitch_trace_flash");

#endif

	asm("subs r5, r5, #1 ");

	asm("bne resched_fixed1a ");

	asm("resched_fixed1b: ");

	asm("mov r4, #0 ");						// TheCurrentVMProcess=NULL

	asm("str r4, [r0, #%a0]" : : "i" _FOFF(TScheduler,iCurrentVMProcess));

	asm("resched_fixed1: ");

	// Unprotect TheCurrentProcess

	ASM_DEBUG1(UnprotectChunks,r1)

	asm("ldr r5, [r1, #%a0]" : : "i" _FOFF(DMemModelProcess,iNumChunks));

	asm("str r1, [r0, #%a0]" : : "i" _FOFF(TScheduler,iCurrentVMProcess));

	asm("cmp r5, #0 ");

	asm("beq resched_finish ");				// if number of chunks=0, nothing to do

	asm("add r11, r1, #%a0" : : "i" _FOFF(DMemModelProcess,iChunks));

	asm("resched_fixed2a: ");

	asm("ldmia r11!, {r7,r8,r9} ");			// r7=run address, r8=ptr to chunk, r9 top 16bits=isReadOnly

	asm("bl UnprotectChunk ");				// unprotect chunk

	asm("ldr r7, [r0, #%a0]" : : "i" _FOFF(TScheduler,iLock.iWaiting));

	asm("cmp r7, #0 ");						// check for contention

	asm("bne abort_resched_fu ");			// if there is, abort

#ifdef BTRACE_FAST_MUTEX

	asm("ldrb ip, [r0, #%a0]" : : "i" (_FOFF(TScheduler,iFastMutexFilter)));

	asm("cmp ip, #0");

	asm("blne procswitch_trace_flash");

#endif

	asm("subs r5, r5, #1 ");

	asm("bne resched_fixed2a ");

	asm("resched_finish: ");

	asm("str r1, [r0, #%a0]" : : "i" _FOFF(TScheduler,iAddressSpace));	// iAddressSpace=new process

	asm("resched_flush: ");

#ifdef __CPU_SPLIT_TLB

	asm("tst r6, #%a0" : : "i" (Mmu::EFlushDPermChg));

	asm("mov r1, #0 ");

	FLUSH_DTLB(ne,r1);

	asm("tst r6, #%a0" : : "i" (Mmu::EFlushIPermChg));

	FLUSH_ITLB(ne,r1);

#else

	asm("tst r6, #%a0" : : "i" (Mmu::EFlushDPermChg|Mmu::EFlushIPermChg));

	asm("mov r1, #0 ");

	FLUSH_IDTLB(ne,r1);

#endif

#ifdef __CPU_WRITE_BACK_CACHE

//#ifdef __CPU_SPLIT_CACHE

	// D cache flush already done

//	asm("tst r6, #%a0" : : "i" (Mmu::EFlushIMove));	Should never need to flush ICache during context switch

//	FLUSH_ICACHE(ne,r1);

//#endif

#else

#ifdef __CPU_SPLIT_CACHE

	asm("tst r6, #%a0" : : "i" (Mmu::EFlushDMove));

	FLUSH_DCACHE(ne,r1);

//	asm("tst r6, #%a0" : : "i" (Mmu::EFlushIMove));	Should never need to flush ICache during context switch

//	FLUSH_ICACHE(ne,r1);

#else

	asm("tst r6, #%a0" : : "i" (Mmu::EFlushDMove|Mmu::EFlushIMove));

	FLUSH_IDCACHE(ne,r1);

#endif

#endif

	asm("cmp r6, #0 ");						// any page table changes?

	DRAIN_WRITE_BUFFER(ne,r1,r7);			// if so, make sure page table changes take effect

	asm("end_process_switch: ");

	asm("ldmia sp!, {r7,lr} ");

	asm("mcr p15, 0, r7, c3, c0 ");			// restore DACR

	CPWAIT(,r3);

	__JUMP(,lr);

	asm("abort_resched_mh: ");				// Reschedule aborted during MoveToHome

	asm("ldmfd sp!, {r1-r4,r12} ");

	asm("subs r5, r5, #1 ");

	asm("bne resched_flush ");				// if MoveToHome incomplete skip

	asm("cmp r3, r4 ");						// if TheCurrentDataSectionProcess==TheCurrentVMProcess ...

	asm("streq r5, [r0, #%a0]" : : "i" _FOFF(TScheduler,iCurrentVMProcess));	// ... TheCurrentVMProcess=NULL

	asm("str r5, [r0, #%a0]" : : "i" _FOFF(TScheduler,iCurrentDataSectionProcess));	// TheCurrentDataSectionProcess=NULL

	asm("b resched_flush ");				//

	asm("abort_resched_mp: ");				// Reschedule aborted during protect before moving

	asm("subs r5, r5, #1 ");

	asm("streq r5, [r0, #%a0]" : : "i" _FOFF(TScheduler,iCurrentVMProcess));

	asm("b resched_flush ");				//

	asm("abort_resched_mr: ");				// Reschedule aborted during MoveToRunAddress

	asm("ldmfd sp!, {r1-r2,r12} ");

	asm("subs r5, r5, #1 ");

	asm("streq r1, [r0, #%a0]" : : "i" _FOFF(TScheduler,iCompleteDataSectionProcess));

	asm("b resched_flush ");				//

	asm("abort_resched_fp: ");				// Reschedule aborted during protect before fixed

	asm("subs r5, r5, #1 ");

	asm("streq r5, [r0, #%a0]" : : "i" _FOFF(TScheduler,iCurrentVMProcess));

	asm("b resched_flush ");				//

	asm("abort_resched_fu: ");				// Reschedule aborted during unprotect

	asm("subs r5, r5, #1 ");

	asm("streq r1, [r0, #%a0]" : : "i" _FOFF(TScheduler,iAddressSpace));	// iAddressSpace=new process

	asm("b resched_flush ");				//

	//

	// Subroutines

	//

	// MoveHomeOrProtectChunk

	// If a chunk is movable and not at its home address, move it to the home address;

	// if the chunk is variable-access and not protected, protect it

	// r7 points to chunk

	// modifies r1-r3 and r8-r12

	asm("MoveHomeOrProtectChunk: ");

	asm("ldr r10, [r7, #%a0]" : : "i" _FOFF(DMemModelChunk,iAttributes));

	asm("tst r10, #%a0" : : "i" (DMemModelChunk::EFixedAddress));

	asm("bne ProtectChunk1 ");

	asm("ldr r11, [r7, #%a0]" : : "i" _FOFF(DMemModelChunk,iHomeBase));	// r11=home base

	asm("ldr r12, [r7, #%a0]" : : "i" _FOFF(DMemModelChunk,iBase));	// r12=iBase

	asm("cmp r11, r12 ");

	asm("beq ProtectChunk1 ");			// already at home address

	ASM_DEBUG1(MoveChunkToHomeAddress,r7)

	asm("str r11, [r7, #%a0]" : : "i" _FOFF(DMemModelChunk,iBase));	// iBase=iHomeBase

	asm("add r8, r7, #%a0" : : "i" _FOFF(DMemModelChunk,iNumPdes));

	asm("ldmia r8, {r8-r10} ");	// r8=numpdes r9=base pdes, r10=home pdes

	asm("cmp r8, #0 ");

	asm("str r10, [r7, #%a0]" : : "i" _FOFF(DMemModelChunk,iPdes));

	asm("beq MoveHome0 ");

	asm("ldr r12, [r7, #%a0]" : : "i" _FOFF(DMemModelChunk,iPdePermissions[0]));

	asm("mov r1, #0 ");

	asm("str r1, [r7, #%a0]" : : "i" _FOFF(DMemModelChunk,iChunkState));	// iChunkState=ENotRunning

	asm("MoveHome1: ");

	asm("ldr r3, [r9] ");				// fetch old pde

	asm("str r1, [r9], #4 ");			// clear old pde

	asm("bics r3, r3, #0x3fc ");		// mask out permissions and check for not present PDE

	asm("orrne r3, r3, r12 ");			// if present, or in new permissions

	asm("moveq r3, #0 ");				// else zero entry

	asm("str r3, [r10], #4 ");			// put into new pde

	asm("subs r8, r8, #1 ");

	asm("bne MoveHome1 ");				// loop to do next PDE

	asm("orr r6, r6, #%a0" : : "i" (Mmu::EFlushDMove|Mmu::EFlushDPermChg));	// moving chunk can't contain code

	__JUMP(,lr);

	asm("MoveHome0: ");

	asm("str r8, [r7, #%a0]" : : "i" _FOFF(DMemModelChunk,iChunkState));	// iChunkState=ENotRunning

	__JUMP(,lr);

	// ProtectChunk

	// Protect a chunk - r7 points to chunk

	// r8-r10,r12 modified

	asm("ProtectChunk: ");

	asm("ldr r10, [r7, #%a0]" : : "i" _FOFF(DMemModelChunk,iAttributes));

	asm("ProtectChunk1: ");

	asm("tst r10, #%a0" : : "i" (DMemModelChunk::EFixedAccess));

	asm("ldreq r12, [r7, #%a0]" : : "i" _FOFF(DMemModelChunk,iChunkState));

	__JUMP(ne,lr);

	asm("cmp r12, #0 ");

	__JUMP(eq,lr);						// if already in non-running state, nothing to do

	asm("ldr r8, [r7, #%a0]" : : "i" _FOFF(DMemModelChunk,iNumPdes));	// r8=number of chunk pdes

	asm("ldr r9, [r7, #%a0]" : : "i" _FOFF(DMemModelChunk,iPdes));	// r9=pde address

	ASM_DEBUG1(ProtectChunk,r7)

	asm("cmp r8, #0 ");

	asm("beq ProtectChunk0 ");

	asm("tst r10, #%a0" : : "i" (DMemModelChunk::ECode));		// check if chunk contains code

	asm("orrne r6, r6, #%a0" : : "i" (Mmu::EFlushIPermChg));	// if it does, may need to flush ITLB

	asm("ldr r10, [r7, #%a0]" : : "i" _FOFF(DMemModelChunk,iPdePermissions[0]));	//r10=new permissions

	asm("ProtectChunk2: ");

	asm("ldr r12, [r9] ");				// fetch old pde

	asm("bics r12, r12, #0x3fc ");		// mask out permissions and check for not present PDE

	asm("orrne r12, r12, r10 ");		// if present, or in new permissions

	asm("moveq r12, #0 ");				// else zero pde

	asm("str r12, [r9], #4 ");			// replace pde

	asm("subs r8, r8, #1 ");

	asm("bne ProtectChunk2 ");			// loop for next PDE

	asm("orr r6, r6, #%a0" : : "i" (Mmu::EFlushDPermChg));

	asm("ProtectChunk0: ");

	asm("str r8, [r7, #%a0]" : : "i" _FOFF(DMemModelChunk,iChunkState));	// iChunkState=ENotRunning

	__JUMP(,lr);

	// MoveRunOrUnprotectChunk

	// If a chunk is movable and not at its run address in this process, move it to the run address;

	// if the chunk is variable-access and not unprotected, unprotect it.

	// r7=run address, r8 points to chunk

	// ignore read-only flag since the ARM cannot support it

	// r1-r3, r7, r9-r12 modified, r8 unmodified

	asm("MoveRunOrUnprotectChunk: ");

	asm("mov r9, #2 ");					// r9=state of chunk

	asm("MoveToRunAddress: ");

	asm("ldr r12, [r8, #%a0]" : : "i" _FOFF(DMemModelChunk,iAttributes));

	asm("tst r12, #%a0" : : "i" (DMemModelChunk::EFixedAddress));

	asm("bne UnprotectChunk1 ");

	asm("ldr r11, [r8, #%a0]" : : "i" _FOFF(DMemModelChunk,iBase));	// r11=old base

	asm("cmp r11, r7 ");				// check if already at run address

	asm("beq UnprotectChunk1 ");		// if it is, just unprotect it

	ASM_DEBUG2(MoveChunkToRunAddress,r8,r7)

	asm("str r7, [r8, #%a0]" : : "i" _FOFF(DMemModelChunk,iBase));	// iBase=run address

	asm("ldr r12, [r8, #%a0]" : : "i" _FOFF(DMemModelChunk,iNumPdes));

	asm("str r9, [r8, #%a0]" : : "i" _FOFF(DMemModelChunk,iChunkState));	// store new chunk state

	asm("cmp r12, #0 ");

	asm("beq MoveRun0 ");

	asm("ldr r10, [r8, #%a0]" : : "i" _FOFF(DMemModelChunk,iPdes));

	asm("mov r1, #0 ");

	asm("add r7, r10, r7, lsr #18 ");	// r7=iPdes+(new address/2^18)

	asm("sub r7, r7, r11, lsr #18 ");	// r7=iPdes+(new address-old address)/2^18

	asm("str r7, [r8, #%a0]" : : "i" _FOFF(DMemModelChunk,iPdes));

	asm("add r9, r8, r9, lsl #2 ");

	asm("ldr r9, [r9, #%a0]" : : "i" (_FOFF(DMemModelChunk,iPdePermissions[0])));	// r9=PDE permissions to use

	asm("MoveRun1: ");

	asm("ldr r3, [r10] ");				// fetch old pde

	asm("str r1, [r10], #4 ");			// clear old pde

	asm("bics r3, r3, #0x3fc ");		// mask out permissions and check for not present PDE

	asm("orrne r3, r3, r9 ");			// if present, or in new permissions

	asm("moveq r3, #0 ");				// else clear pde

	asm("str r3, [r7], #4 ");			// put into new pde

	asm("subs r12, r12, #1 ");

	asm("bne MoveRun1 ");

	asm("orr r6, r6, #%a0" : : "i" (Mmu::EFlushDMove|Mmu::EFlushDPermChg));	// moving chunk can't contain code

	asm("MoveRun0: ");

	__JUMP(,lr);

	// UnprotectChunk

	// Apply running permissions to a chunk

	// r8 points to chunk

	// ignore read-only flag since the ARM cannot support it

	// r7,r9,r10,r12 modified, r8,r11 unmodified

	asm("UnprotectChunk: ");

	asm("mov r9, #2 ");					// r9=new state of chunk

	asm("ApplyTopLevelPermissions: ");

	asm("ldr r12, [r8, #%a0]" : : "i" _FOFF(DMemModelChunk,iAttributes));

	asm("UnprotectChunk1: ");

	asm("tst r12, #%a0" : : "i" (DMemModelChunk::EFixedAccess));

	asm("ldreq r10, [r8, #%a0]" : : "i" _FOFF(DMemModelChunk,iChunkState));	// r10=old chunk state

	__JUMP(ne,lr);

	asm("cmp r10, r9 ");

	__JUMP(eq,lr);						// if state already correct, nothing to do

	asm("ldr r10, [r8, #%a0]" : : "i" _FOFF(DMemModelChunk,iNumPdes));

	ASM_DEBUG1(UnprotectChunk,r8)

	asm("str r9, [r8, #%a0]" : : "i" _FOFF(DMemModelChunk,iChunkState));	// iChunkState=ERunningRW

	asm("cmp r10, #0 ");

	asm("beq UnprotectChunk0 ");

	asm("tst r12, #%a0" : : "i" (DMemModelChunk::ECode));		// check if chunk contains code

	asm("orrne r6, r6, #%a0" : : "i" (Mmu::EFlushIPermChg));	// if it does, may need to flush ITLB

	asm("ldr r12, [r8, #%a0]" : : "i" _FOFF(DMemModelChunk,iPdes));

	asm("add r9, r8, r9, lsl #2 ");

	asm("ldr r9, [r9, #%a0]" : : "i" (_FOFF(DMemModelChunk,iPdePermissions[0])));	//r9=new permissions

	asm("UnprotectChunk2: ");

	asm("ldr r7, [r12] ");				// fetch old pde

	asm("bics r7, r7, #0x3fc ");		// mask out permissions and check for not present PDE

	asm("orrne r7, r7, r9 ");			// if present, or in new permissions

	asm("moveq r7, #0 ");				// else clear pde

	asm("str r7, [r12], #4 ");			// replace pde

	asm("subs r10, r10, #1 ");

	asm("bne UnprotectChunk2 ");

	asm("orr r6, r6, #%a0" : : "i" (Mmu::EFlushDPermChg));

	asm("UnprotectChunk0: ");

	__JUMP(,lr);

#ifdef BTRACE_FAST_MUTEX

	// expects scheduler in r0, current thread in r2, preserves all but r10

	asm("procswitch_trace_flash:");

	asm("mov r10, sp");

	asm("bic sp, sp, #7"); 					// align stack to 8 bytes

	asm("stmdb sp!,{r3,ip}");

	asm("stmdb sp!,{r0,r1,r2,lr}");		// 4th item on stack is PC value for trace

	asm("mov r1, r0");

	asm("ldr r0, procswitch_trace_header"); // header parameter in r0

	asm("add r3, r1, #%a0" : : "i" _FOFF(TScheduler,iLock)); // fast mutex parameter in r3

	asm("mov lr, pc");

	asm("ldr pc, [r1, #%a0]" : : "i" _FOFF(TScheduler,iBTraceHandler));	

	asm("ldmia sp!,{r0,r1,r2,lr}");

	asm("ldmia sp!,{r3,ip}");

	asm("mov sp, r10");					// put stack back

	__JUMP(,lr);

	asm("procswitch_trace_header:");

	asm(".word %a0" : : "i" ((TInt)(16<<BTrace::ESizeIndex) + ((BTrace::EContextIdPresent|BTrace::EPcPresent) << BTrace::EFlagsIndex*8) + (BTrace::EFastMutex<< BTrace::ECategoryIndex*8) + (BTrace::EFastMutexFlash << BTrace::ESubCategoryIndex*8)) );

#endif

	// Global data references

	asm("__TheScheduler: ");

	asm(".word TheScheduler ");

	asm("__TheMmu: ");

	asm(".word %a0" : : "i" ((TInt)&::TheMmu));

	};

__NAKED__ TUint32 DMemModelChunk::ApplyTopLevelPermissions(TChunkState /*aChunkState*/)

	{

	asm("stmfd sp!, {r6-r11,lr} ");

	asm("mov r8, r0 ");		// r8 = chunk ptr

	asm("mov r9, r1 ");		// r9 = chunk state

	asm("mrc p15, 0, r3, c3, c0, 0 ");	// r3=DACR

	asm("mov r6, #0 ");

	asm("orr r1, r3, #0x30 ");

	asm("mcr p15, 0, r1, c3, c0, 0 ");	// unlock page tables

	CPWAIT(,lr);

	asm("bl ApplyTopLevelPermissions ");

	asm("mcr p15, 0, r3, c3, c0, 0 ");	// lock page tables

	asm("mov r0, r6 ");					// return flush flags

	DRAIN_WRITE_BUFFER(,r1,r1);

	CPWAIT(,r1);

	asm("ldmfd sp!, {r6-r11,pc} ");

	}

__NAKED__ TUint32 DMemModelChunk::MoveToRunAddress(TLinAddr /*aLinAddr*/, TChunkState /*aChunkState*/)

	{

	asm("stmfd sp!, {r5-r11,lr} ");

	asm("mov r8, r0 ");		// r8 = chunk ptr

	asm("mov r7, r1 ");		// r7 = run address

	asm("mrc p15, 0, r5, c3, c0, 0 ");	// r5=DACR

	asm("mov r9, r2 ");		// r9 = chunk state

	asm("mov r6, #0 ");

	asm("orr r1, r5, #0x30 ");

	asm("mcr p15, 0, r1, c3, c0, 0 ");	// unlock page tables

	CPWAIT(,lr);

	asm("bl MoveToRunAddress ");

	asm("mcr p15, 0, r5, c3, c0, 0 ");	// lock page tables

	asm("mov r0, r6 ");					// return flush flags

	DRAIN_WRITE_BUFFER(,r1,r1);

	CPWAIT(,r1);

	asm("ldmfd sp!, {r5-r11,pc} ");

	}

__NAKED__ TUint32 DMemModelChunk::MoveToHomeSection()

	{

	asm("stmfd sp!, {r5-r11,lr} ");

	asm("mov r7, r0 ");		// r7 = chunk ptr

	asm("mrc p15, 0, r0, c3, c0, 0 ");	// r0=DACR

	asm("mov r6, #0 ");

	asm("orr r1, r0, #0x30 ");

	asm("mcr p15, 0, r1, c3, c0, 0 ");	// unlock page tables

	CPWAIT(,lr);

	asm("bl MoveHomeOrProtectChunk ");

	asm("mcr p15, 0, r0, c3, c0, 0 ");	// lock page tables

	asm("mov r0, r6 ");					// return flush flags

	DRAIN_WRITE_BUFFER(,r1,r1);

	CPWAIT(,r1);

	asm("ldmfd sp!, {r5-r11,pc} ");

	}

#endif