// Copyright (c) 2008-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\nkernsmp\arm\ncthrd.cia
// 
//

#define __INCLUDE_NTHREADBASE_DEFINES__

#include <arm.h>
#include <e32cia.h>

#undef	iDfcState
#define	iDfcState		i8816.iHState16

extern "C" void send_accumulated_resched_ipis();

/******************************************************************************
 * Thread
 ******************************************************************************/
extern "C" __NAKED__ void __StartThread()
	{
	// On entry:
	//		R0->TSubScheduler, R1=0, R2=1, R3->current thread
	//		R12=resched IPIs
	// Interrupts disabled

	// need to send any outstanding reschedule IPIs
	asm("cmp	r12, #0 ");
	asm("blne " CSM_CFUNC(send_accumulated_resched_ipis));
#ifdef __USER_MEMORY_GUARDS_ENABLED__
	asm("ldr	r0, [sp, #%a0]" : : "i" _FOFF(SThreadExcStack, iCPSR));
	asm("tst	r0, #0x0f ");
	asm("bne	2f ");
	USER_MEMORY_GUARD_OFF(,r0,r0);
	asm("2:		");
#endif
	asm("ldmia	sp, {r0-r14}^ ");			// load initial values for R0-R12, R13_usr, R14_usr
	asm("nop	");							// don't access banked register immediately after
	asm("add	sp, sp, #64 ");				// point to saved PC, CPSR (skip iExcCode)
	asm("adr	lr, 1f ");					// set lr_svc in case thread returns
	RFEIAW(13);								// restore PC and CPSR - jump to thread entry point

	asm("1:		");
	asm("b "	CSM_ZN5NKern4ExitEv);		// if control returns, call NKern::Exit()
	}


extern "C" __NAKED__ TInt get_kernel_context_type(TLinAddr /*aReschedReturn*/)
	{
	asm("adr	r1, 9f ");
	asm("mov	r3, r0 ");
	asm("mvn	r0, #0 ");
	asm("1:		");
	asm("ldr	r2, [r1], #4 ");
	asm("add	r0, r0, #1 ");
	asm("cmp	r2, r3 ");
	asm("beq	2f ");
	asm("cmp	r2, #0 ");
	asm("bne	1b ");
	asm("mvn	r0, #0 ");
	asm("2:		");
	__JUMP(,	lr);

	asm("9:		");
	asm(".word " CSM_CFUNC(__StartThread));
	asm(".word	nkern_unlock_resched_return ");
	asm(".word	nkern_preemption_point_resched_return ");
	asm(".word	nkern_wfar_resched_return ");
	asm(".word	irq_resched_return ");
	asm(".word	exec_wfar_resched_return ");
	asm(".word	0 ");
	}


/**	Mark the beginning of an event handler tied to a thread or thread group

	Return the number of the CPU on which the event handler should run
*/
__NAKED__ TInt NSchedulable::BeginTiedEvent()
	{
	asm("add r1, r0, #%a0" : : "i" _FOFF(NSchedulable,iEventState));
	asm("1: ");
	LDREX(0,1);						// r0 = original value of iEventState
	asm("add r2, r0, #%a0" : : "i" ((TInt)EEventCountInc));
	STREX(3,2,1);
	asm("cmp r3, #0 ");
	asm("bne 1b ");
	__DATA_MEMORY_BARRIER__(r3);
	asm("tst r0, #%a0" : : "i" ((TInt)EEventParent));
	asm("ldrne r2, [r1, #%a0]" : : "i" (_FOFF(NSchedulable,iParent) - _FOFF(NSchedulable,iEventState)));
	asm("beq bte0 ");				// EEventParent not set so don't look at group
	asm("cmp r2, #0 ");
	asm("addne r2, r2, #%a0" : : "i" _FOFF(NSchedulable,iEventState));
	asm("beq bte_bad ");
	asm("cmp r2, r1 ");
	asm("beq bte2 ");				// parent not yet updated, use iNewParent
	asm("bte1: ");
	LDREX(0,2);						// r0 = original value of iEventState
	asm("add r3, r0, #%a0" : : "i" ((TInt)EEventCountInc));
	STREX(12,3,2);
	asm("cmp r12, #0 ");
	asm("bne 1b ");
	__DATA_MEMORY_BARRIER__(r12);
	asm("bte0: ");
	asm("and r0, r0, #%a0" : : "i" ((TInt)EEventCpuMask));
	__JUMP(,lr);					// return event CPU

	asm("bte2: ");
	__DATA_MEMORY_BARRIER__(r3);	// make sure iNewParent is read after iParent
	asm("ldr r2, [r1, #%a0]" : : "i" (_FOFF(NThreadBase,iNewParent) - _FOFF(NSchedulable,iEventState)));
	asm("cmp r2, #0 ");
	asm("addne r2, r2, #%a0" : : "i" _FOFF(NSchedulable,iEventState));
	asm("bne bte1 ");				// iNewParent set so OK
	__DATA_MEMORY_BARRIER__(r3);	// make sure iParent is read after iNewParent
	asm("ldr r2, [r1, #%a0]" : : "i" (_FOFF(NSchedulable,iParent) - _FOFF(NSchedulable,iEventState)));
	asm("cmp r2, #0 ");
	asm("addne r2, r2, #%a0" : : "i" _FOFF(NSchedulable,iEventState));
	asm("cmp r2, r1 ");
	asm("bne bte1 ");				// iParent now set so OK, otherwise something is wrong

	asm("bte_bad: ");
	__ASM_CRASH();
	}


/**	Mark the end of an event handler tied to a thread or thread group

*/
__NAKED__ void NSchedulable::EndTiedEvent()
	{
	__DATA_MEMORY_BARRIER_Z__(r12);
	asm("ldr r1, [r0, #%a0]!" : : "i" _FOFF(NSchedulable, iEventState));
	asm("tst r1, #%a0" : : "i" ((TInt)EEventParent));
	asm("bne etep0 ");				// branch out if EEventParent set

	// r0->NSchedulable::iEventState
	asm("ete1: ");
	LDREX(1,0);
	asm("sub r1, r1, #%a0" : : "i" ((TInt)EEventCountInc));	// decrement event count
	asm("cmp r1, #%a0" : : "i" ((TInt)EEventCountInc));		// check if now zero
	asm("biccc r1, r1, #0xFF ");	// if so, mask event CPU ...
	asm("andcc r2, r1, #0x1F00 ");	// ... and r2 = thread CPU << 8 ...
	asm("orrcc r1, r1, r2, lsr #8 ");	// ... and event CPU = thread CPU
	STREX(12,1,0);
	asm("teq r12, #0 ");			// test for success, leave carry alone
	asm("bne ete1 ");				// retry if STREX failed
	asm("bcs ete2 ");				// if not last tied event, finish
	asm("tst r1, #%a0" : : "i" ((TInt)EDeferredReady));
	asm("addne r0, r0, #%a0" : : "i" (_FOFF(NSchedulable,i_IDfcMem) - _FOFF(NSchedulable,iEventState)));
	asm("bne " CSM_ZN4TDfc3AddEv );	// if deferred ready, add IDFC to action it
	asm("ete2: ");					// ready not deferred so finish
	__JUMP(,lr);

	asm("etep0: ");
	__DATA_MEMORY_BARRIER__(r12);	// make sure iParent is read after seeing parent flag set
	asm("ldr r3, [r0, #%a0]" : : "i" (_FOFF(NSchedulable,iParent) - _FOFF(NSchedulable,iEventState)));
	asm("cmp r3, #0 ");
	asm("addne r3, r3, #%a0" : : "i" _FOFF(NSchedulable,iEventState));
	asm("beq ete_bad ");			// no parent - shouldn't happen
	asm("cmp r3, r0 ");				// parent == this ?
	asm("beq etep1 ");				// if so, parent not yet updated so use iNewParent

	asm("etep2: ");
	asm("stmfd sp!, {r0,lr} ");		// save this and return address
	asm("mov r0, r3 ");				// operate on parent
	asm("bl ete1 ");				// update parent state
	asm("ldmfd sp!, {r0,lr} ");
	asm("1: ");
	LDREX(1,0);
	asm("sub r1, r1, #%a0" : : "i" ((TInt)EEventCountInc));	// decrement event count
	STREX(12,1,0);
	asm("cmp r12, #0 ");
	asm("bne 1b ");
	__JUMP(,lr);

	asm("etep1: ");
	__DATA_MEMORY_BARRIER__(r12);	// make sure iNewParent is read after iParent
	asm("ldr r3, [r0, #%a0]" : : "i" (_FOFF(NThreadBase,iNewParent) - _FOFF(NSchedulable,iEventState)));
	asm("cmp r3, #0 ");
	asm("addne r3, r3, #%a0" : : "i" _FOFF(NSchedulable,iEventState));
	asm("bne etep2 ");				// iNewParent set so OK
	__DATA_MEMORY_BARRIER__(r12);	// make sure iParent is read after iNewParent
	asm("ldr r3, [r0, #%a0]" : : "i" (_FOFF(NSchedulable,iParent) - _FOFF(NSchedulable,iEventState)));
	asm("cmp r3, #0 ");
	asm("addne r3, r3, #%a0" : : "i" _FOFF(NSchedulable,iEventState));
	asm("cmp r3, r0 ");
	asm("bne etep2 ");				// iParent now set so OK, otherwise something is wrong

	asm("ete_bad: ");
	__ASM_CRASH();
	}


/**	Check for concurrent tied events when a thread/group becomes ready

	This is only ever called on a lone thread or a group, not on a thread
	which is part of a group.

	Update the thread CPU field in iEventState
	If thread CPU != event CPU and event count nonzero, atomically
	set the ready deferred flag and return TRUE, else return FALSE.
	If event count zero, set event CPU = thread CPU atomically.

	@param aCpu the CPU on which the thread/group is to become ready
	@return	TRUE if the ready must be deferred.
*/
__NAKED__ TBool NSchedulable::TiedEventReadyInterlock(TInt /*aCpu*/)
	{
	asm("add r0, r0, #%a0" : : "i" _FOFF(NSchedulable,iEventState));
	asm("1: ");
	LDREX(2,0);						// r2 = original iEventState
	asm("bic r3, r2, #0x1F00 ");	// r3 = original iEventState with thread CPU zeroed out
	asm("orr r3, r3, r1, lsl #8 ");	// set thread CPU field = aCpu
	asm("cmp r3, #%a0" : : "i" ((TInt)EEventCountInc));
	asm("bhs 2f ");					// branch if event count nonzero
	asm("bic r3, r3, #0xFF ");		// else mask event CPU ...
	asm("orr r3, r3, r1 ");			// ... and set event CPU = thread CPU = aCpu
	asm("3: ");
	STREX(12,3,0);
	asm("teq r12, #0 ");
	asm("bne 1b ");
	asm("eor r0, r2, r3 ");			// r0 = old event state ^ new event state
	asm("and r0, r0, #%a0" : : "i" ((TInt)EDeferredReady));
	__JUMP(,lr);					// return TRUE if we just set EDeferredReady

	// event count is nonzero
	asm("2: ");
	asm("eor r12, r3, r3, lsr #8 ");	// r12 bottom 5 bits = thread CPU ^ event CPU
	asm("tst r12, #0x1F ");				// thread CPU == event CPU?
	asm("orrne r3, r3, #%a0" : : "i" ((TInt)EDeferredReady));	// if not, set EDeferredReady
	asm("b 3b ");
	}


/**	Check for concurrent tied events when a thread leaves a group

	If event count zero, atomically	set the event and thread CPUs to the
	current CPU, clear the parent flag and return TRUE, else return FALSE.

	@return	TRUE if the parent flag has been cleared
	@pre	Preemption disabled
*/
__NAKED__ TBool NThreadBase::TiedEventLeaveInterlock()
	{
	GET_RWNO_TID(, r1);					// R1->SubScheduler
	asm("ldr r1, [r1, #%a0]" : : "i" _FOFF(TSubScheduler, iCpuNum));
	asm("add r0, r0, #%a0" : : "i" _FOFF(NSchedulable,iEventState));
	asm("orr r1, r1, r1, lsl #8 ");		// event CPU = thread CPU = this CPU, EDeferredReady, EEventParent clear
	asm("1: ");
	LDREX(2,0);
	asm("cmp r2, #%a0" : : "i" ((TInt)EEventCountInc));		// check if event count zero
	asm("bhs 0f ");						// if not, finish and return FALSE
	STREX(3,1,0);						// else update CPUs and clear parent flag
								// NOTE: Deferred ready flag must have been clear since thread is running
	asm("cmp r3, #0 ");
	asm("bne 1b ");
	__JUMP(,lr);				// return TRUE (assumes this!=0)
	asm("0:");
	asm("mov r0, #0 ");
	__JUMP(,lr);				// return FALSE
	}


/**	Check for concurrent tied events when a thread joins a group

	If event count zero, atomically	set the parent flag and return TRUE,
	else return FALSE.

	@return	TRUE if the parent flag has been set
	@pre	Preemption disabled
*/
__NAKED__ TBool NThreadBase::TiedEventJoinInterlock()
	{
	asm("add r0, r0, #%a0" : : "i" _FOFF(NSchedulable,iEventState));
	asm("1: ");
	LDREX(1,0);
	asm("cmp r1, #%a0" : : "i" ((TInt)EEventCountInc));		// check if event count zero
	asm("bhs 0f ");						// if not, finish and return FALSE
	asm("orr r2, r1, #%a0" : : "i" ((TInt)EEventParent));	// else set parent flag
	STREX(3,2,0);
	asm("cmp r3, #0 ");
	asm("bne 1b ");
	__JUMP(,lr);				// return TRUE (assumes this!=0)
	asm("0:");
	asm("mov r0, #0 ");
	__JUMP(,lr);				// return FALSE
	}


#ifdef __FAST_SEM_MACHINE_CODED__
/******************************************************************************
 * Fast semaphore
 ******************************************************************************/

/** Waits on a fast semaphore.

    Decrements the signal count for the semaphore and
	removes the calling thread from the ready-list if the semaphore becomes
	unsignalled. Only the thread that owns a fast semaphore can wait on it.
	
	Note that this function does not block, it merely updates the NThread state,
	rescheduling will only occur when the kernel is unlocked. Generally threads
	would use NKern::FSWait() which manipulates the kernel lock for you.

	@pre The calling thread must own the semaphore.
	@pre No fast mutex can be held.
	@pre Kernel must be locked.
	
	@post Kernel is locked.
	
	@see NFastSemaphore::Signal()
	@see NKern::FSWait()
	@see NKern::Unlock()
 */
EXPORT_C __NAKED__ void NFastSemaphore::Wait()
	{
	ASM_DEBUG1(FSWait,r0);

	GET_RWNO_TID(,r1);
	asm("stmfd	sp!, {r4-r7} ");
	asm("ldr	r6, [r1, #%a0]" : : "i" _FOFF(TSubScheduler,iCurrentThread));
	asm("mov	r3, r0 ");
	asm("mov	r2, #%a0" : : "i" ((TInt)NThreadBase::EWaitFastSemaphore << 8));
	asm("add	r7, r6, #%a0" : : "i" _FOFF(NThreadBase, iWaitState));
	asm("orr	r2, r2, #%a0" : : "i" ((TInt)NThreadWaitState::EWtStWaitPending));
	asm("1:		");
	LDREXD(		4,7);
	STREXD(		12,2,7);
	asm("cmp	r12, #0 ");
	asm("bne	1b ");
	asm("str	r12, [r7, #%a0]" : : "i" _FOFF(NThreadWaitState, iTimer.iTriggerTime));
	asm("cmp	r4, #0 ");
	asm("bne	0f ");

	__DATA_MEMORY_BARRIER__(r12);
	asm("1:		");
	LDREX(		2,0);					// count
	asm("mov	r5, r6, lsr #2 ");		// thread>>2
	asm("orr	r5, r5, #0x80000000 ");
	asm("subs	r4, r2, #1 ");
	asm("movlt	r4, r5 ");				// if --count<0, r4=(thread>>2)|0x80000000
	STREX(		12,4,0);
	asm("teq	r12, #0 ");
	asm("bne	1b ");
	__DATA_MEMORY_BARRIER__(r12);

	asm("cmp	r2, #0 ");				// original count zero ?
	asm("bne	2f ");					// if yes, don't need to wait
	asm("mov	r2, #1 ");
	asm("strb	r2, [r1, #%a0]" : : "i" _FOFF(TSubScheduler,iRescheduleNeededFlag));	// else we need to reschedule
	asm("ldmfd	sp!, {r4-r7} ");
	__JUMP(,	lr);

	asm("2:		");
	asm("mov	r2, #0 ");
	asm("mov	r3, #0 ");
	asm("1:		");
	LDREXD(		4,7);
	STREXD(		12,2,7);
	asm("cmp	r12, #0 ");
	asm("bne	1b ");
	asm("tst	r4, #%a0" : : "i" ((TInt)(NThreadWaitState::EWtStDead|NThreadWaitState::EWtStWaitActive)));
	asm("bne	0f ");
	asm("ldmfd	sp!, {r4-r7} ");
	__JUMP(,	lr);

	asm("0:		");
	__ASM_CRASH();
	}


/** Waits on a fast semaphore.

    Decrements the signal count for the semaphore
	and waits for a signal if the semaphore becomes unsignalled. Only the
	thread that owns a fast	semaphore can wait on it.

	@param aSem The semaphore to wait on.
	
	@pre The calling thread must own the semaphore.
	@pre No fast mutex can be held.
	
	@see NFastSemaphore::Wait()
*/
EXPORT_C __NAKED__ void NKern::FSWait(NFastSemaphore* /*aSem*/)
	{
	ASM_DEBUG1(NKFSWait,r0);

	__ASM_CLI();							// all interrupts off
	GET_RWNO_TID(,r1);
	asm("stmfd	sp!, {r4,r5,r11,lr} ");
	asm("ldr	r11, [r1, #%a0]" : : "i" _FOFF(TSubScheduler,iCurrentThread));
	asm("mov	r2, #%a0" : : "i" ((TInt)NThreadBase::EWaitFastSemaphore << 8));
	asm("orr	r2, r2, #%a0" : : "i" ((TInt)NThreadWaitState::EWtStWaitPending));
	asm("mov	r3, r0 ");
	asm("add	r0, r11, #%a0" : : "i" _FOFF(NThreadBase, iWaitState));
	asm("b		nkfswait1 ");
	}


/** Waits for a signal on the current thread's I/O semaphore.

	@pre No fast mutex can be held.
	@pre Call in a thread context.
	@pre Kernel must be unlocked
	@pre interrupts enabled
 */
EXPORT_C __NAKED__ void NKern::WaitForAnyRequest()
	{
	ASM_DEBUG0(WFAR);

	__ASM_CLI();							// all interrupts off
	GET_RWNO_TID(,r1);
	asm("stmfd	sp!, {r4,r5,r11,lr} ");
	asm("ldr	r11, [r1, #%a0]" : : "i" _FOFF(TSubScheduler,iCurrentThread));
	asm("mov	r2, #%a0" : : "i" ((TInt)NThreadBase::EWaitFastSemaphore << 8));
	asm("orr	r2, r2, #%a0" : : "i" ((TInt)NThreadWaitState::EWtStWaitPending));
	asm("add	r0, r11, #%a0" : : "i" _FOFF(NThreadBase, iWaitState));
	asm("add	r3, r11, #%a0" : : "i" _FOFF(NThreadBase, iRequestSemaphore));

	asm("nkfswait1: ");
	asm("1:		");
	LDREXD(		4,0);
	STREXD(		12,2,0);
	asm("cmp	r12, #0 ");
	asm("bne	1b ");
	asm("str	r12, [r0, #%a0]" : : "i" _FOFF(NThreadWaitState, iTimer.iTriggerTime));
	asm("cmp	r4, #0 ");
	asm("bne	0f ");

	__DATA_MEMORY_BARRIER__(r12);
	asm("1:		");
	LDREX(		2,3);					// count
	asm("mov	r5, r11, lsr #2 ");		// thread>>2
	asm("orr	r5, r5, #0x80000000 ");
	asm("subs	r4, r2, #1 ");
	asm("movlt	r4, r5 ");				// if --count<0, r4=(thread>>2)|0x80000000
	STREX(		12,4,3);
	asm("teq	r12, #0 ");
	asm("bne	1b ");
	__DATA_MEMORY_BARRIER__(r12);

	asm("cmp	r2, #0 ");				// original count zero ?
	asm("beq	2f ");					// if so we must wait
	asm("mov	r2, #0 ");
	asm("mov	r3, #0 ");
	asm("1:		");
	LDREXD(		4,0);
	STREXD(		12,2,0);
	asm("cmp	r12, #0 ");
	asm("bne	1b ");
	asm("tst	r4, #%a0" : : "i" ((TInt)(NThreadWaitState::EWtStDead|NThreadWaitState::EWtStWaitActive)));
	asm("bne	0f ");
	__ASM_STI();
	__POPRET("r4,r5,r11,");

	asm("0:		");
	__ASM_CRASH();

	asm("2:		");
	asm("ldmfd	sp!, {r4-r5} ");
	asm("mov	r2, #1 ");
	asm("str	r2, [r1, #%a0]" : : "i" _FOFF(TSubScheduler,iKernLockCount));			// else lock the kernel
	__ASM_STI();
	asm("strb	r2, [r1, #%a0]" : : "i" _FOFF(TSubScheduler,iRescheduleNeededFlag));	// and set the reschedule flag
	asm("stmfd	sp!, {r0,r4-r10} ");
	asm("bl "	CSM_ZN10TScheduler10RescheduleEv );	// reschedule
	asm(".global nkern_wfar_resched_return ");
	asm("nkern_wfar_resched_return: ");

	// need to send any outstanding reschedule IPIs
	asm("cmp	r12, #0 ");
	asm("blne " CSM_CFUNC(send_accumulated_resched_ipis));
	__ASM_STI();
	__POPRET("r0,r4-r11,");

	asm(".global wait_for_any_request ");
	asm("wait_for_any_request: ");
	asm("add	r3, r9, #%a0" : : "i" _FOFF(NThreadBase,iRequestSemaphore));
	asm("mov	r2, #%a0" : : "i" ((TInt)NThreadBase::EWaitFastSemaphore << 8));
	asm("add	r7, r9, #%a0" : : "i" _FOFF(NThreadBase, iWaitState));
	asm("orr	r2, r2, #%a0" : : "i" ((TInt)NThreadWaitState::EWtStWaitPending));
	asm("1:		");
	LDREXD(		4,7);
	STREXD(		12,2,7);
	asm("cmp	r12, #0 ");
	asm("bne	1b ");
	asm("str	r12, [r7, #%a0]" : : "i" _FOFF(NThreadWaitState, iTimer.iTriggerTime));
	asm("cmp	r4, #0 ");
	asm("bne	0b ");

	__DATA_MEMORY_BARRIER__(r12);
	asm("1:		");
	LDREX(		0,3);					// count
	asm("mov	r5, r9, lsr #2 ");		// thread>>2
	asm("orr	r5, r5, #0x80000000 ");
	asm("subs	r4, r0, #1 ");
	asm("movlt	r4, r5 ");				// if --count<0, r4=(thread>>2)|0x80000000
	STREX(		12,4,3);
	asm("teq	r12, #0 ");
	asm("bne	1b ");
	__DATA_MEMORY_BARRIER__(r12);
#ifdef __RECORD_STATE__
	asm("str	r0, [r9, #%a0]" : : "i" _FOFF(NThreadBase,iNThreadBaseSpare6));
#endif

	asm("cmp	r0, #0 ");				// original count zero ?
	asm("beq	exec_wfar_wait ");		// yes - must wait
	asm("mov	r2, #0 ");
	asm("mov	r3, #0 ");
	asm("1:		");
	LDREXD(		4,7);
	STREXD(		12,2,7);
	asm("cmp	r12, #0 ");
	asm("bne	1b ");
	asm("tst	r4, #%a0" : : "i" ((TInt)(NThreadWaitState::EWtStDead|NThreadWaitState::EWtStWaitActive)));
	asm("ldreq	r4, [r9, #%a0]" : : "i" _FOFF(NThreadBase,iUserModeCallbacks));	// check for callbacks
	asm("beq	exec_wfar_finish ");
	asm("b		0b ");
	}


/** Signals a fast semaphore.

    Increments the signal count of a fast semaphore by
	one and releases any waiting thread if the semphore becomes signalled.
	
	Note that a reschedule will not occur before this function returns, this will
	only take place when the kernel is unlocked. Generally threads
	would use NKern::FSSignal() which manipulates the kernel lock for you.
	
	@pre Kernel must be locked.
	@pre Call either in a thread or an IDFC context.
	
	@post Kernel is locked.
	
	@see NFastSemaphore::Wait()
	@see NKern::FSSignal()
	@see NKern::Unlock()
 */
EXPORT_C __NAKED__ void NFastSemaphore::Signal()
	{
	ASM_DEBUG1(FSSignal,r0);

	asm("mov	r1, #1 ");
	asm("fssignal1: ");
	__DATA_MEMORY_BARRIER_Z__(r12);
	asm("1:		");
	LDREX(		2,0);				// count
	asm("cmp	r2, #0 ");
	asm("sublt	r3, r1, #1 ");		// if count<0, replace with aCount-1
	asm("addges	r3, r2, r1 ");		// if count>=0, add aCount
	asm("bvs	0f ");				// if overflow, leave alone
	STREX(		12,3,0);
	asm("teq	r12, #0 ");
	asm("bne	1b ");
	asm("cmp	r2, #0 ");
	asm("movlt	r1, r2, lsl #2 ");	// if original count<0 r1 = original count<<2 = thread
	asm("blt	fs_signal_wake ");
	asm("0:		");
	__JUMP(,	lr);				// else finished

	asm("fs_signal_wake: ");
	asm("stmfd	sp!, {r4-r6,lr} ");
	asm("mov	r4, r0 ");
	asm("mov	r5, r1 ");
	asm("mov	r0, r1 ");
	asm("bl		AcqSLock__12NSchedulable "); // CSM needed
	asm("add	r0, r5, #%a0" : : "i" _FOFF(NThreadBase, iWaitState));
	asm("mov	r1, #%a0" : : "i" ((TInt)NThreadBase::EWaitFastSemaphore));
	asm("mov	r2, r4 ");
	asm("mov	r3, #0 ");
	asm("bl		UnBlockT__16NThreadWaitStateUiPvi "); // CSM needed
	asm("mov	r0, r5 ");
	asm("ldmfd	sp!, {r4-r6,lr} ");
	asm("b		RelSLock__12NSchedulable "); // CSM needed
	}


/** Signals a fast semaphore multiple times.

	@pre Kernel must be locked.
	@pre Call either in a thread or an IDFC context.
	
	@post Kernel is locked.

	@internalComponent	
 */
EXPORT_C __NAKED__ void NFastSemaphore::SignalN(TInt /*aCount*/)
	{
	ASM_DEBUG2(FSSignalN,r0,r1);

	asm("cmp	r1, #0 ");
	asm("bgt	fssignal1 ");
	__JUMP(,	lr);
	}


/** Signals the request semaphore of a nanothread several times.

	This function is intended to be used by the EPOC layer and personality
	layers.  Device drivers should use Kern::RequestComplete instead.

	@param aThread Nanothread to signal.  If NULL, the current thread is signaled.
	@param aCount Number of times the request semaphore must be signaled.
	
	@pre aCount >= 0

	@see Kern::RequestComplete()
 */
EXPORT_C __NAKED__ void NKern::ThreadRequestSignal(NThread* /*aThread*/, TInt /*aCount*/)
	{
	ASM_DEBUG2(NKThreadRequestSignalN,r0,r1);

	asm("cmp	r1, #0 ");
	asm("ble	0f ");
	asm("cmp	r0, #0 ");
	asm("addne	r0, r0, #%a0" : : "i" _FOFF(NThreadBase,iRequestSemaphore));
	asm("bne	nkfssignal1 ");
	__ASM_CLI();
	GET_RWNO_TID(,r0);
	asm("ldr	r0, [r0, #%a0]" : : "i" _FOFF(TSubScheduler,iCurrentThread));
	asm("add	r0, r0, #%a0" : : "i" _FOFF(NThreadBase,iRequestSemaphore));
	asm("b		nkfssignal2 ");

	asm("0:		");
	__JUMP(eq,	lr);
	__ASM_CRASH();
	}


/** Signals the request semaphore of a nanothread.

	This function is intended to be used by the EPOC layer and personality
	layers.  Device drivers should use Kern::RequestComplete instead.

	@param aThread Nanothread to signal. Must be non NULL.

	@see Kern::RequestComplete()

	@pre Interrupts must be enabled.
	@pre Do not call from an ISR
 */
EXPORT_C __NAKED__ void NKern::ThreadRequestSignal(NThread* /*aThread*/)
	{
	ASM_DEBUG1(NKThreadRequestSignal,r0);
	asm("add	r0, r0, #%a0" : : "i" _FOFF(NThreadBase,iRequestSemaphore));

	/* fall through to FSSignal() ... */
	}


/** Signals a fast semaphore.

    Increments the signal count of a fast semaphore
	by one and releases any	waiting thread if the semaphore becomes signalled.
	
	@param aSem The semaphore to signal.

	@see NKern::FSWait()

	@pre Interrupts must be enabled.
	@pre Do not call from an ISR
 */
EXPORT_C __NAKED__ void NKern::FSSignal(NFastSemaphore* /*aSem*/)
	{
	ASM_DEBUG1(NKFSSignal,r0);

	asm("mov	r1, #1 ");
	asm("nkfssignal1: ");
	__ASM_CLI();
	asm("nkfssignal2: ");
	__DATA_MEMORY_BARRIER_Z__(r12);
	asm("1:		");
	LDREX(		2,0);				// count
	asm("cmp	r2, #0 ");
	asm("sublt	r3, r1, #1 ");		// if count<0, replace with aCount-1
	asm("addges	r3, r2, r1 ");		// if count>=0, add aCount
	asm("bvs	0f ");				// if overflow, leave alone
	STREX(		12,3,0);
	asm("teq	r12, #0 ");
	asm("bne	1b ");
	asm("cmp	r2, #0 ");
	asm("blt	2f ");
	asm("0:		");
	__ASM_STI();
	__JUMP(,	lr);				// else finished

	asm("2:		");
	GET_RWNO_TID(,r3);
	asm("mov	r1, r2, lsl #2 ");	// if original count<0 r1 = original count<<2 = thread
	asm("ldr	r12, [r3, #%a0]" : : "i" _FOFF(TSubScheduler,iKernLockCount));
	asm("stmfd	sp!, {r4,lr} ");
	asm("add	r12, r12, #1 ");			// lock the kernel
	asm("str	r12, [r3, #%a0]" : : "i" _FOFF(TSubScheduler,iKernLockCount));
	__ASM_STI();
	asm("bl		fs_signal_wake ");			// wake up the thread
	asm("ldmfd	sp!, {r4,lr} ");
	asm("b " CSM_ZN5NKern6UnlockEv);
	}


/** Signals a fast semaphore multiple times.

    Increments the signal count of a
	fast semaphore by aCount and releases any waiting thread if the semphore
	becomes signalled.
	
	@param aSem The semaphore to signal.
	@param aCount The number of times to signal the semaphore.

	@see NKern::FSWait()

	@pre Interrupts must be enabled.
	@pre Do not call from an ISR
 */
EXPORT_C __NAKED__ void NKern::FSSignalN(NFastSemaphore* /*aSem*/, TInt /*aCount*/)
	{
	ASM_DEBUG2(NKFSSignalN,r0,r1);

	asm("cmp	r1, #0 ");
	asm("bgt	nkfssignal1 ");
	__JUMP(,	lr);
	}


/** Cancels a wait on a fast semaphore.

	@pre Kernel must be locked.
	@pre Call either in a thread or an IDFC context.
	
	@post Kernel is locked.

	@internalComponent	
 */
__NAKED__ void NFastSemaphore::WaitCancel()
	{
	asm("mov	r1, #1 ");
	/* Fall through ... */
	}

/* Fall through ... */
#endif
/* Fall through ... */

/**	Increment a fast semaphore count

	Do memory barrier
	If iCount >= 0, increment by aCount and return 0
	If iCount < 0, set count equal to aCount-1 and return (original count << 2)

	Release semantics
*/
__NAKED__ NThreadBase* NFastSemaphore::Inc(TInt /*aCount*/)
	{
	__DATA_MEMORY_BARRIER_Z__(r12);
	asm("1: ");
	LDREX(2,0);					// count
	asm("cmp r2, #0 ");
	asm("sublt r3, r1, #1 ");	// if count<0, replace with aCount-1
	asm("addges r3, r2, r1 ");	// if count>=0, add aCount
	asm("bvs 0f ");				// if overflow leave alone
	STREX(12,3,0);
	asm("teq r12, #0 ");
	asm("bne 1b ");
	asm("0: ");
	asm("cmp r2, #0 ");
	asm("movlt r0, r2, lsl #2 ");	// if original count<0, return count<<2
	asm("movge r0, #0 ");			// else return 0
	__JUMP(,lr);
	}


/**	Decrement a fast semaphore count

	If count > 0, decrement
	If count = 0, set equal to (thread>>2)|0x80000000
	Return original count
	Full barrier semantics
*/
__NAKED__ TInt NFastSemaphore::Dec(NThreadBase*)
	{
	__DATA_MEMORY_BARRIER_Z__(r12);
	asm("1: ");
	LDREX(2,0);					// count
	asm("subs r3, r2, #1 ");
	asm("movlt r3, #0x80000000 ");
	asm("orrlt r3, r3, r1, lsr #2 ");	// if --count<0, r3=(thread>>2)|0x80000000
	STREX(12,3,0);
	asm("teq r12, #0 ");
	asm("bne 1b ");
	__DATA_MEMORY_BARRIER__(r12);
	asm("mov r0, r2 ");			// return original count
	__JUMP(,lr);
	}

/**	Reset a fast semaphore count

	Do memory barrier
	If iCount >= 0, set iCount=0 and return 0
	If iCount < 0, set iCount=0 and return (original count << 2)

	Release semantics
*/
__NAKED__ NThreadBase* NFastSemaphore::DoReset()
	{
	__DATA_MEMORY_BARRIER_Z__(r3);
	asm("1: ");
	LDREX(2,0);					// count
	STREX(12,3,0);				// zero count
	asm("teq r12, #0 ");
	asm("bne 1b ");
	asm("cmp r2, #0 ");
	asm("movlt r0, r2, lsl #2 ");	// if original count<0, return count<<2
	asm("movge r0, #0 ");			// else return 0
	__JUMP(,lr);
	}


#ifdef __NTHREAD_WAITSTATE_MACHINE_CODED__
/******************************************************************************
 * Thread wait state
 ******************************************************************************/

__NAKED__ void NThreadWaitState::SetUpWait(TUint /*aType*/, TUint /*aFlags*/, TAny* /*aWaitObj*/)
	{
	asm("stmfd	sp!, {r4-r5} ");
	asm("and	r2, r2, #%a0" : : "i" ((TInt)EWtStObstructed));
	asm("and	r1, r1, #0xff ");
	asm("orr	r2, r2, #%a0" : : "i" ((TInt)EWtStWaitPending));
	asm("orr	r2, r2, r1, lsl #8 ");
	asm("1:		");
	LDREXD(		4,0);
	STREXD(		12,2,0);
	asm("cmp	r12, #0 ");
	asm("bne	1b ");
	asm("cmp	r4, #0 ");
	asm("bne	0f ");
	asm("ldmfd	sp!, {r4-r5} ");
	asm("str	r12, [r0, #%a0]" : : "i" _FOFF(NThreadWaitState, iTimer.iTriggerTime));
	__JUMP(,	lr);

	asm("0:		");
	__ASM_CRASH();
	}

__NAKED__ void NThreadWaitState::SetUpWait(TUint /*aType*/, TUint /*aFlags*/, TAny* /*aWaitObj*/, TUint32 /*aTimeout*/)
	{
	asm("stmfd	sp!, {r4-r5} ");
	asm("and	r2, r2, #%a0" : : "i" ((TInt)EWtStObstructed));
	asm("and	r1, r1, #0xff ");
	asm("orr	r2, r2, #%a0" : : "i" ((TInt)EWtStWaitPending));
	asm("orr	r2, r2, r1, lsl #8 ");
	asm("1:		");
	LDREXD(		4,0);
	STREXD(		12,2,0);
	asm("cmp	r12, #0 ");
	asm("bne	1b ");
	asm("ldr	r12, [sp, #8] ");
	asm("cmp	r4, #0 ");
	asm("bne	0f ");
	asm("ldmfd	sp!, {r4-r5} ");
	asm("str	r12, [r0, #%a0]" : : "i" _FOFF(NThreadWaitState, iTimer.iTriggerTime));
	__JUMP(,	lr);

	asm("0:		");
	__ASM_CRASH();
	}

__NAKED__ void NThreadWaitState::CancelWait()
	{
	asm("mov	r12, r0 ");
	asm("mov	r2, #0 ");
	asm("mov	r3, #0 ");
	asm("1:		");
	LDREXD(		0,12);
	STREXD(		1,2,12);
	asm("cmp	r1, #0 ");
	asm("bne	1b ");
	asm("tst	r0, #%a0" : : "i" ((TInt)(EWtStDead|EWtStWaitActive)));
	asm("bne	0f ");
	__JUMP(,	lr);

	asm("0:		");
	__ASM_CRASH();
	}

__NAKED__ TInt NThreadWaitState::DoWait()
	{
	asm("ldr	r1, [r0, #%a0]" : : "i" _FOFF(NThreadWaitState,iTimer.iTriggerTime));
	asm("1:		");
	LDREXD(		2,0);
	asm("cmp	r1, #0 ");
	asm("orrne	r2, r2, #%a0" : : "i" ((TInt)EWtStTimeout));
	asm("tst	r2, #%a0" : : "i" ((TInt)EWtStDead));
	asm("bne	0f ");
	asm("tst	r2, #%a0" : : "i" ((TInt)EWtStWaitPending));
	asm("beq	9f ");
	asm("bic	r2, r2, #%a0" : : "i" ((TInt)EWtStWaitPending));
	asm("orr	r2, r2, #%a0" : : "i" ((TInt)EWtStWaitActive));
	STREXD(		12,2,0);
	asm("cmp	r12, #0 ");
	asm("bne	1b ");
	asm("cmp	r1, #0 ");
	asm("bne	2f ");
	asm("mov	r0, r2, lsr #8 ");
	__JUMP(,	lr);

	asm("2:		");
	asm("stmfd	sp!, {r2-r4,lr} ");
	asm("mov	r4, r0 ");
	asm("add	r0, r0, #%a0" : : "i" _FOFF(NThreadWaitState,iTimer));
	asm("mov	r2, #1 ");
	asm("bl	"	CSM_ZN6NTimer7OneShotEii );
	asm("ldr	r1, [r4, #%a0]" : : "i" _FOFF(NThreadWaitState,iTimer.iNTimerSpare1));
	asm("cmp	r0, #0 ");
	asm("bne	8f ");
	asm("add	r1, r1, #1 ");
	asm("str	r1, [r4, #%a0]" : : "i" _FOFF(NThreadWaitState,iTimer.iNTimerSpare1));
	asm("ldmfd	sp!, {r2-r4,lr} ");
	asm("mov	r0, r2, lsr #8 ");
	__JUMP(,	lr);

	asm("0:		");
	asm("mvn	r0, #%a0" : : "i" (~KErrDied));
	__JUMP(,	lr);
	asm("9:		");
	asm("mvn	r0, #%a0" : : "i" (~KErrGeneral));
	__JUMP(,	lr);
	asm("8:		");
	__ASM_CRASH();
	}

__NAKED__ TInt NThreadWaitState::UnBlockT(TUint /*aType*/, TAny* /*aWaitObj*/, TInt /*aReturnValue*/)
	{
	asm("stmfd	sp!, {r4-r6,lr} ");
	asm("mov	r6, r2 ");					// r6 = aWaitObj
	asm("mov	r2, #0 ");
	__DATA_MEMORY_BARRIER__(r2);
	asm("1:		");
	LDREXD(		4,0);						// r5:r4 = oldws64
	asm("cmp	r5, r6 ");					// does iWaitObj match?
	asm("bne	2f ");						// no
	asm("eor	r12, r4, r1, lsl #8 ");		// does wait type match?
	asm("cmp	r12, #%a0" : : "i" ((TInt)EWtStDead));
	asm("bhs	2f ");						// no
	STREXD(		12,2,0);					// yes - wait matches - try to write return value
	asm("cmp	r12, #0 ");					// success?
	asm("bne	1b ");						// no - retry
	asm("mov	r6, r0 ");
	asm("tst	r4, #%a0" : : "i" ((TInt)EWtStTimeout));
	asm("blne	CancelTimerT__16NThreadWaitState "); // CSM needed
	asm("tst	r4, #%a0" : : "i" ((TInt)EWtStWaitActive));
	asm("beq	0f ");
	asm("ldr	r1, [r6, #%a0]" : : "i" (_FOFF(NThreadBase,iPauseCount)-_FOFF(NThreadBase,iWaitState)));
	asm("sub	r0, r6, #%a0" : : "i" _FOFF(NThreadBase,iWaitState));	// r0 = Thread()
	asm("movs	r1, r1, lsl #16 ");				// check if iPauseCount=iSuspendCount=0
	asm("andeq	r1, r4, #%a0" : : "i" ((TInt)EWtStObstructed));
	asm("bleq	ReadyT__12NSchedulableUi ");	// if so, make thread ready // CSM needed
	asm("0:		");
	asm("mov	r0, #0 ");
	__POPRET("	r4-r6,");					// return KErrNone

	asm("2:		");
	STREXD(		12,4,0);					// no matching wait - write back to check atomicity
	asm("cmp	r12, #0 ");					// success?
	asm("bne	1b ");						// no - retry
	asm("mvn	r0, #%a0" : : "i" (~KErrGeneral));
	__POPRET("	r4-r6,");					// no matching wait - return KErrGeneral
	}

__NAKED__ TUint32 NThreadWaitState::ReleaseT(TAny*& /*aWaitObj*/, TInt /*aReturnValue*/)
	{
	asm("stmfd	sp!, {r4-r5} ");
	asm("mov	r3, r2 ");
	asm("mov	r2, #0 ");
	__DATA_MEMORY_BARRIER__(r2);
	asm("1:		");
	LDREXD(		4,0);
	asm("and	r2, r4, #%a0" : : "i" ((TInt)EWtStDead));
	STREXD(		12,2,0);
	asm("cmp	r12, #0 ");
	asm("bne	1b ");
	__DATA_MEMORY_BARRIER__(r12);
	asm("str	r5, [r1] ");
	asm("tst	r4, #%a0" : : "i" ((TInt)EWtStTimeout));
	asm("bne	2f ");
	asm("mov	r0, r4 ");
	asm("ldmfd	sp!, {r4-r5} ");
	__JUMP(,	lr);

	asm("2:		");
	asm("mov	r5, lr ");
	asm("bl		CancelTimerT__16NThreadWaitState "); // CSM needed
	asm("mov	r0, r4 ");
	asm("mov	lr, r5 ");
	asm("ldmfd	sp!, {r4-r5} ");
	__JUMP(,	lr);
	}
#endif


#ifdef __FAST_MUTEX_MACHINE_CODED__
/******************************************************************************
 * Fast mutex
 ******************************************************************************/

/** Releases a previously acquired fast mutex.
	
	Generally, threads would use NKern::FMSignal() which manipulates the kernel lock
	for you.
	
	@pre The calling thread holds the mutex.
	@pre Kernel must be locked.
	
	@post Kernel is locked.
	
	@see NFastMutex::Wait()
	@see NKern::FMSignal()
*/
EXPORT_C __NAKED__ void NFastMutex::Signal()
	{
	ASM_DEBUG1(FMSignal,r0);
#ifdef BTRACE_FAST_MUTEX
//	BTraceContext4(BTrace::EFastMutex, BTrace::EFastMutexSignal, this);
	asm("stmfd	sp!, {r0,lr} ");
	asm("mov	r1, r0 ");
	asm("ldr	r0, btrace_hdr_fmsignal ");
	asm("mov	r2, #0 ");
	asm("mov	r3, #0 ");
	asm("bl	" CSM_ZN6BTrace4OutXEmmmm);
	asm("ldmfd	sp!, {r0,lr} ");
#endif
	GET_RWNO_TID(,r3);
	asm("mov	r12, #0 ");
	__DATA_MEMORY_BARRIER__(r12);
	asm("ldr	r1, [r3, #%a0]" : : "i" _FOFF(TSubScheduler,iCurrentThread));
	__ASM_CLI();
	asm("1:		");
	LDREX(		2,0);				// r2=aMutex->iHoldingThread
	asm("cmp	r2, r1 ");			// anyone else waiting?
	asm("mov	r2, #0 ");
	asm("bne	2f ");				// branch out if someone else waiting
	STREX(		12,2,0);			// else try to clear the holding thread
	asm("teq	r12, #0 ");
	asm("bne	1b ");
	asm("str	r12, [r1, #%a0]" : : "i" _FOFF(NThreadBase,iHeldFastMutex));
	__ASM_STI();
	__JUMP(,lr);					// mutex released without contention

#ifdef BTRACE_FAST_MUTEX
	asm("btrace_hdr_fmsignal: ");
	asm(".word %a0" : : "i" (BTRACE_HEADER_C(8,BTrace::EFastMutex,BTrace::EFastMutexSignal)));
#endif

	// there is contention
	asm("2:		");
	asm("orr	r12, r0, #1 ");
	asm("str	r12, [r1, #%a0]" : : "i" _FOFF(NThreadBase,iHeldFastMutex));
	__ASM_STI();
	asm("b		DoSignalL__10NFastMutex "); // CSM needed
	}


/** Acquires the System Lock.

    This will block until the mutex is available, and causes
	the thread to enter an implicit critical section until the mutex is released.

	@post System lock is held.

	@see NKern::UnlockSystem()
	@see NKern::FMWait()

	@pre No fast mutex can be held.
	@pre Call in a thread context.
	@pre Kernel must be unlocked
	@pre interrupts enabled

*/
EXPORT_C __NAKED__ void NKern::LockSystem()
	{
	asm("ldr	r0, __SystemLock ");

	/* fall through to FMWait() ... */
	}

/** Acquires a fast mutex.

    This will block until the mutex is available, and causes
	the thread to enter an implicit critical section until the mutex is released.

	@param aMutex The fast mutex to acquire.
	
	@post The calling thread holds the mutex.
	
	@see NFastMutex::Wait()
	@see NKern::FMSignal()

	@pre No fast mutex can be held.
	@pre Call in a thread context.
	@pre Kernel must be unlocked
	@pre interrupts enabled

*/
EXPORT_C __NAKED__ void NKern::FMWait(NFastMutex* /*aMutex*/)
	{
	ASM_DEBUG1(NKFMWait,r0);

	__ASM_CLI();
	GET_RWNO_TID(,r3);
	asm("ldr	r1, [r3, #%a0]" : : "i" _FOFF(TSubScheduler,iCurrentThread));
	asm("1:		");
	LDREX(		2,0);				// r2=aMutex->iHoldingThread
	asm("cmp	r2, #0 ");			//
	asm("bne	2f ");				// branch out if mutex held
	STREX(		12,1,0);			// else try to set us as holding thread
	asm("teq	r12, #0 ");
	asm("bne	1b ");
	asm("str	r0, [r1, #%a0]" : : "i" _FOFF(NThreadBase,iHeldFastMutex));
	__DATA_MEMORY_BARRIER__(r12);
	__ASM_STI();
#ifdef BTRACE_FAST_MUTEX
//	BTraceContext4(BTrace::EFastMutex, BTrace::EFastMutexWait, aMutex);
	asm("mov	r1, r0 ");
	asm("ldr	r0, btrace_hdr_fmwait ");
	asm("mov	r2, #0 ");
	asm("mov	r3, #0 ");
	asm("b " CSM_ZN6BTrace4OutXEmmmm);
#endif
	__JUMP(,lr);					// mutex acquired without contention

	// there is contention
	asm("2:		");
	asm("mov	r2, #1 ");
	asm("str	r0, [r1, #%a0]" : : "i" _FOFF(NThreadBase,iHeldFastMutex));
	asm("str	r2, [r3, #%a0]" : : "i" _FOFF(TSubScheduler,iKernLockCount));
	__ASM_STI();
	__DATA_MEMORY_BARRIER_Z__(r12);
	asm("stmfd	sp!, {r4,lr} ");
	asm("bl		DoWaitL__10NFastMutex "); // CSM needed
	asm("ldmfd	sp!, {r4,lr} ");
	asm("b " CSM_ZN5NKern6UnlockEv);

	asm("__SystemLock: ");
	asm(".word	%a0" : : "i" ((TInt)&TheScheduler.iLock));
#ifdef BTRACE_FAST_MUTEX
	asm("btrace_hdr_fmwait: ");
	asm(".word %a0" : : "i" (BTRACE_HEADER_C(8,BTrace::EFastMutex,BTrace::EFastMutexWait)));
#endif
	}


/** Releases the System Lock.

	@pre System lock must be held.

	@see NKern::LockSystem()
	@see NKern::FMSignal()
*/
EXPORT_C __NAKED__ void NKern::UnlockSystem()
	{
	asm("ldr	r0, __SystemLock ");

	/* fall through to FMSignal() ... */
	}

/** Releases a previously acquired fast mutex.
	
	@param aMutex The fast mutex to release.
	
	@pre The calling thread holds the mutex.
	
	@see NFastMutex::Signal()
	@see NKern::FMWait()
*/
EXPORT_C __NAKED__ void NKern::FMSignal(NFastMutex* /*aMutex*/)
	{
	ASM_DEBUG1(NKFMSignal,r0);
#ifdef BTRACE_FAST_MUTEX
//	BTraceContext4(BTrace::EFastMutex, BTrace::EFastMutexSignal, this);
	asm("stmfd	sp!, {r0,lr} ");
	asm("mov	r1, r0 ");
	asm("ldr	r0, btrace_hdr_fmsignal ");
	asm("mov	r2, #0 ");
	asm("mov	r3, #0 ");
	asm("bl	" CSM_ZN6BTrace4OutXEmmmm);
	asm("ldmfd	sp!, {r0,lr} ");
#endif
	__ASM_CLI();
	GET_RWNO_TID(,r3);
	asm("mov	r12, #0 ");
	__DATA_MEMORY_BARRIER__(r12);
	asm("ldr	r1, [r3, #%a0]" : : "i" _FOFF(TSubScheduler,iCurrentThread));
	asm("1:		");
	LDREX(		12,0);				// r12=aMutex->iHoldingThread
	asm("mov	r2, #0 ");
	asm("cmp	r12, r1 ");			// anyone else waiting?
	asm("bne	2f ");				// branch out if someone else waiting
	STREX(		12,2,0);			// else try to clear the holding thread
	asm("teq	r12, #0 ");
	asm("bne	1b ");
	asm("str	r12, [r1, #%a0]" : : "i" _FOFF(NThreadBase,iHeldFastMutex));
	__ASM_STI();
	__JUMP(,lr);					// mutex released without contention

	// there is contention
	asm("2:		");
	asm("stmfd	sp!, {r4,lr} ");
	asm("mov	r12, #1 ");
	asm("orr	r4, r0, #1 ");
	asm("str	r12, [r3, #%a0]" : : "i" _FOFF(TSubScheduler,iKernLockCount));
	asm("str	r4, [r1, #%a0]" : : "i" _FOFF(NThreadBase,iHeldFastMutex));
	__ASM_STI();
	asm("bl		DoSignalL__10NFastMutex "); // CSM needed
	asm("ldmfd	sp!, {r4,lr} ");
	asm("b " CSM_ZN5NKern6UnlockEv);
	}


/** Temporarily releases the System Lock if there is contention.

    If there
	is another thread attempting to acquire the System lock, the calling
	thread releases the mutex and then acquires it again.
	
	This is more efficient than the equivalent code:
	
	@code
	NKern::UnlockSystem();
	NKern::LockSystem();
	@endcode

	Note that this can only allow higher priority threads to use the System
	lock as lower priority cannot cause contention on a fast mutex.

	@return	TRUE if the system lock was relinquished, FALSE if not.

	@pre	System lock must be held.

	@post	System lock is held.

	@see NKern::LockSystem()
	@see NKern::UnlockSystem()
*/
EXPORT_C __NAKED__ TBool NKern::FlashSystem()
	{
//	CHECK_PRECONDITIONS(MASK_SYSTEM_LOCKED,"NKern::FlashSystem");
	asm("ldr	r0, __SystemLock ");

	/* fall through to FMFlash() ... */
	}

/** Temporarily releases a fast mutex if there is contention.

    If there is another thread attempting to acquire the mutex, the calling
	thread releases the mutex and then acquires it again.
	
	This is more efficient than the equivalent code:
	
	@code
	NKern::FMSignal();
	NKern::FMWait();
	@endcode

	@return	TRUE if the mutex was relinquished, FALSE if not.

	@pre	The mutex must be held.

	@post	The mutex is held.
*/
EXPORT_C __NAKED__ TBool NKern::FMFlash(NFastMutex* /*aM*/)
	{
	ASM_DEBUG1(NKFMFlash,r0);
	__ASM_CLI();
	GET_RWNO_TID(,r3);
	asm("ldr	r1, [r3, #%a0]" : : "i" _FOFF(TSubScheduler,iCurrentThread));
	asm("ldrb	r2, [r1, #%a0]" : : "i" _FOFF(NThreadBase,iMutexPri));
	asm("ldrb	r12, [r1, #%a0]" : : "i" _FOFF(NThreadBase,iBasePri));
	asm("cmp	r2, r12 ");
	asm("bhs	1f ");							// a thread of greater or equal priority is waiting
	__ASM_STI();
#ifdef BTRACE_FAST_MUTEX
//	BTraceContext4(BTrace::EFastMutex, BTrace::EFastMutexFlash, aM);
	asm("mov	r1, r0 ");
	asm("ldr	r0, btrace_hdr_fmsignal ");
	asm("stmfd	sp!, {r4,lr} ");
	asm("mov	r2, #0 ");
	asm("mov	r3, #0 ");
	asm("bl	" CSM_ZN6BTrace4OutXEmmmm);
	asm("ldmfd	sp!, {r4,lr} ");
#endif
	asm("mov	r0, #0 ");
	__JUMP(,lr);								// return FALSE

#ifdef BTRACE_FAST_MUTEX
	asm("btrace_hdr_fmflash: ");
	asm(".word %a0" : : "i" (BTRACE_HEADER_C(8,BTrace::EFastMutex,BTrace::EFastMutexFlash)));
#endif

	asm("1:		");
	asm("mov	r12, #1 ");
	asm("str	r12, [r3, #%a0]" : : "i" _FOFF(TSubScheduler,iKernLockCount));
	__ASM_STI();
	asm("stmfd	sp!, {r4,lr} ");
	asm("mov	r4, r0 ");
	asm("bl	" CSM_ZN10NFastMutex6SignalEv);
	asm("bl	" CSM_ZN5NKern15PreemptionPointEv);
	asm("mov	r0, r4 ");
	asm("bl	" CSM_ZN10NFastMutex4WaitEv);
	asm("bl	" CSM_ZN5NKern6UnlockEv);
	asm("ldmfd	sp!, {r4,lr} ");
	asm("mov	r0, #1 ");
	__JUMP(,lr);								// return TRUE
	}
#endif



/** Check whether a thread holds a fast mutex.
	If so set the mutex contention flag and return TRUE, else return FALSE.

	Called with kernel lock held

	@internalComponent
 */
__NAKED__ TBool NThreadBase::CheckFastMutexDefer()
	{
	asm("ldr r1, [r0, #%a0]" : : "i" _FOFF(NThreadBase,iHeldFastMutex));
	asm("bics r2, r1, #3 ");		// r2 = pointer to mutex if any, r1 bit 0 = flag
	asm("bne 1f ");
	asm("mov r0, #0 ");				// no mutex - return FALSE
	__JUMP(,lr);

	// iHeldFastMutex points to a mutex
	asm("1: ");
	asm("tst r1, #1 ");				// test flag
	asm("beq 2f ");					// branch if not being released

	// mutex being released
	asm("3: ");
	LDREX(3,2);						// r3 = m->iHoldingThread
	asm("sub r3, r3, r0 ");			// m->iHoldingThread - this
	asm("cmp r3, #1 ");
	asm("bhi 4f ");					// if m->iHoldingThread != this or this+1, skip
	asm("orr r3, r0, #1 ");			// if m->iHoldingThread = this or this+1, set m->iHoldingThread = this+1
	STREX(12,3,2);
	asm("teq r12, #0 ");
	asm("bne 3b ");
	asm("mov r0, #1 ");				// return TRUE
	__JUMP(,lr);

	asm("4: ");
	asm("mov r3, #0 ");				// already released, so set iHeldFastMutex=0
	asm("str r3, [r0, #%a0]" : : "i" _FOFF(NThreadBase,iHeldFastMutex));
	asm("0: ");
	asm("mov r0, #0 ");				// no mutex - return FALSE
	__JUMP(,lr);

	// mutex being acquired or has been acquired
	// if it has been acquired set the contention flag and return TRUE, else return FALSE
	asm("2: ");
	LDREX(3,2);						// r3 = m->iHoldingThread
	asm("sub r3, r3, r0 ");			// m->iHoldingThread - this
	asm("cmp r3, #1 ");
	asm("bhi 0b ");					// if m->iHoldingThread != this or this+1, finish and return FALSE
	asm("orr r3, r0, #1 ");			// if m->iHoldingThread = this or this+1, set m->iHoldingThread = this+1
	STREX(12,3,2);
	asm("teq r12, #0 ");
	asm("bne 2b ");
	asm("mov r0, #1 ");				// return TRUE
	__JUMP(,lr);

	asm("4: ");
	asm("mov r3, #0 ");				// already released, so set iHeldFastMutex=0
	asm("str r3, [r0, #%a0]" : : "i" _FOFF(NThreadBase,iHeldFastMutex));
	asm("mov r0, #0 ");				// no mutex - return FALSE
	__JUMP(,lr);
	}


/******************************************************************************
 * IDFC/DFC
 ******************************************************************************/

/**	Transition the state of an IDFC or DFC when Add() is called

	0000->008n, 00Cn->00En, all other states unchanged
	Return original state.

	Enter and return with interrupts disabled.
*/
__NAKED__ TUint32 TDfc::AddStateChange()
	{
	GET_RWNO_TID(, r1);				// r1->SubScheduler
	asm("add r3, r0, #%a0" : : "i" _FOFF(TDfc,iDfcState));
	asm("ldr r1, [r1, #%a0]" : : "i" _FOFF(TSubScheduler,iCpuNum));	// r1 = current CPU number
	__DATA_MEMORY_BARRIER_Z__(r12);
	asm("1: ");
	LDREXH(0,3);
	asm("cmp r0, #0 ");				// original state 0000 ?
	asm("orreq r2, r1, #0x0080 ");	// yes -> 008n
	asm("movne r2, r0 ");			// no -> R2=original state ...
	asm("eorne r12, r0, #0x00C0 ");	// ... and R12=original state^00C0 ...
	asm("cmpne r12, #0x0020 ");		// ... and check if result < 0020 (i.e. original==00C0..00DF)
	asm("addlo r2, r2, #0x0020 ");	// 00Cn->00En otherwise leave R2 alone
	STREXH(12,2,3);
	asm("cmp r12, #0 ");
	asm("bne 1b ");
	__DATA_MEMORY_BARRIER__(r12);
	__JUMP(,lr);
	}

/**	Transition the state of an IDFC just before running it.

	002g->00Cn, 008n->00Cn, 00An->00Cn, XXYY->XX00, XX00->0000
	other initial states invalid
	Return original state

	Enter and return with interrupts disabled.
*/
__NAKED__ TUint32 TDfc::RunIDFCStateChange()
	{
	GET_RWNO_TID(, r1);				// r1->SubScheduler
	asm("add r3, r0, #%a0" : : "i" _FOFF(TDfc,iDfcState));
	asm("ldr r1, [r1, #%a0]" : : "i" _FOFF(TSubScheduler,iCpuNum));	// r1 = current CPU number
	__DATA_MEMORY_BARRIER_Z__(r12);
#ifdef _DEBUG
	asm("str r4, [sp, #-4]! ");
	asm("ldr r4, __IdleGeneration ");
	asm("ldrb r4, [r4] ");			// r4 = TheScheduler.iIdleGeneration
	asm("eor r4, r4, #0x0021 ");	// r4 = expected state of idle IDFCs
#endif
	asm("1: ");
	LDREXH(0,3);
	asm("eor r2, r0, #0x0080 ");
	asm("cmp r2, #0x0040 ");
	asm("bhs 2f ");					// branch out unless 008n or 00An
#ifdef _DEBUG
	asm("and r2, r0, #0x001F ");
	asm("cmp r2, r1 ");
	asm("bne 0f ");					// if n!=current CPU number, die
#endif
	asm("orr r2, r1, #0x00C0 ");	// 008n->00Cn, 00An->00Cn
	asm("3: ");
	STREXH(12,2,3);
	asm("cmp r12, #0 ");
	asm("bne 1b ");
	__DATA_MEMORY_BARRIER__(r12);
#ifdef _DEBUG
	asm("ldr r4, [sp], #4 ");
#endif
	__JUMP(,lr);

	asm("2: ");
	asm("bic r2, r0, #1 ");
	asm("cmp r2, #0x0020 ");
	asm("orreq r2, r1, #0x00C0 ");	// 002g->00Cn
#ifdef _DEBUG
	asm("bne 4f ");
	asm("cmp r0, r4 ");
	asm("bne 0f ");					// wrong idle state
	asm("4: ");
#endif
	asm("beq 3b ");
	asm("cmp r0, #0x0100 ");		// C=1 if XXYY or XX00, C=0 if bad state
	asm("bic r2, r0, #0x00FF ");	// XXYY->XX00, C unchanged
	asm("tst r0, #0x00FF ");		// C unchanged
	asm("moveq r2, #0 ");			// XX00->0000, C unchanged
	asm("bcs 3b ");					// branch to STREX if valid state

	asm("0: ");
	__ASM_CRASH();					// bad state

	asm("__IdleGeneration: ");
	asm(".word %a0 " : : "i" ((TInt)&TheScheduler.iIdleGeneration));
	}

/**	Transition the state of an IDFC just after running it.

	First swap aS->iCurrentIDFC with 0
	If original value != this, return 0xFFFFFFFF and don't touch *this
	Else 00Cn->0000, 00En->008n, 006n->006n, XXCn->XX00, XXEn->XX00, XX6n->XX00, XX00->0000
	other initial states invalid
	Return original state

	Enter and return with interrupts disabled.
*/
__NAKED__ TUint32 TDfc::EndIDFCStateChange(TSubScheduler* /*aS*/)
	{
	asm("add r1, r1, #%a0" : : "i" _FOFF(TSubScheduler,iCurrentIDFC));
	__DATA_MEMORY_BARRIER_Z__(r12);
	asm("1: ");
	LDREX(2,1);
	asm("subs r2, r2, r0 ");		// aS->iCurrentIDFC == this?
	asm("bne 9f ");					// no - bail out immediately
	STREX(12,2,1);					// yes - set aS->iCurrentIDFC=0
	asm("cmp r12, #0 ");
	asm("bne 1b ");

	asm("add r3, r0, #%a0" : : "i" _FOFF(TDfc,iDfcState));
	__DATA_MEMORY_BARRIER__(r12);
#ifdef _DEBUG
	asm("str r4, [sp, #-4]! ");
	GET_RWNO_TID(, r4);				// r4->SubScheduler
	asm("ldr r4, [r4, #%a0]" : : "i" _FOFF(TSubScheduler,iCpuNum));	// r4 = current CPU number
#endif
	asm("2: ");
	LDREXH(0,3);					// r0 = original DFC state
	asm("mov r2, #0 ");				// r2 = 0 to begin with
#ifdef _DEBUG
	asm("tst r0, #0x00FF ");
	asm("beq 5f ");
	asm("eor r12, r0, r4 ");		// original state ^ CPU number, should be xxC0, xxE0 or xx60
	asm("and r12, r12, #0x00E0 ");
	asm("cmp r12, #0x00E0 ");
	asm("cmpne r12, #0x00C0 ");
	asm("cmpne r12, #0x0060 ");
	asm("beq 5f ");
	__ASM_CRASH();					// bad state
	asm("5: ");
#endif
	asm("bic r12, r0, #0x001F ");
	asm("cmp r12, #0x00E0 ");
	asm("bhi 4f ");					// branch out if XXYY or XX00
	asm("subeq r2, r0, #0x0060 ");	// 00En->008n
	asm("cmp r12, #0x0060 ");
	asm("moveq r2, r0 ");			// 006n->006n, else R2=0
	asm("3: ");
	STREXH(12,2,3);
	asm("cmp r12, #0 ");
	asm("bne 2b ");
	__DATA_MEMORY_BARRIER__(r12);
#ifdef _DEBUG
	asm("ldr r4, [sp], #4 ");
#endif
	__JUMP(,lr);

	asm("4: ");
	asm("tst r0, #0x00FF ");
	asm("bicne r2, r0, #0x00FF ");	// XXYY->XX00, XX00->0000
	asm("b 3b ");

	asm("9: ");
	asm("mvn r0, #0 ");				// return 0xFFFFFFFF
	__JUMP(,lr);
	}

/**	Transition the state of an IDFC just after running it.

	006n->002g where g = TheScheduler.iIdleGeneration
	XX6n->XX00
	other initial states invalid
	Return original state

	Enter and return with interrupts disabled.
*/
__NAKED__ TUint32 TDfc::EndIDFCStateChange2()
	{
	asm("ldr r12, __IdleGeneration ");
	asm("add r3, r0, #%a0" : : "i" _FOFF(TDfc,iDfcState));
#ifdef _DEBUG
	asm("str r4, [sp, #-4]! ");
	GET_RWNO_TID(, r4);				// r4->SubScheduler
	asm("ldr r4, [r4, #%a0]" : : "i" _FOFF(TSubScheduler,iCpuNum));	// r4 = current CPU number
#endif
	asm("ldrb r1, [r12] ");			// r1 = TheScheduler.iIdleGeneration
	asm("1: ");
	LDREXH(0,3);
#ifdef _DEBUG
	asm("eor r12, r0, r4 ");
	asm("and r12, r12, #0x00FF ");
	asm("cmp r12, #0x0060 ");		// should be 006n or XX6n
	asm("beq 2f ");
	__ASM_CRASH();					// if not, die
	asm("2: ");
#endif
	asm("tst r0, #0xFF00 ");		// XX6n or 006n ?
	asm("orreq r2, r1, #0x0020 ");	// 006n->002g
	asm("bicne r2, r0, #0x00FF ");	// XX6n->XX00
	STREXH(12,2,3);
	asm("cmp r12, #0 ");
	asm("bne 1b ");
	__DATA_MEMORY_BARRIER__(r12);
#ifdef _DEBUG
	asm("ldr r4, [sp], #4 ");
#endif
	__JUMP(,lr);
	}

/**	Transition the state of a DFC just before moving it from the IDFC queue to
	its final queue.

	002g->0001, 008n->0001, XX2g->XX00, XX8n->XX00, XX00->0000
	other initial states invalid
	Return original state
*/
__NAKED__ TUint32 TDfc::MoveToFinalQStateChange()
	{
	asm("add r3, r0, #%a0" : : "i" _FOFF(TDfc,iDfcState));
	__DATA_MEMORY_BARRIER_Z__(r12);
#ifdef _DEBUG
	asm("str r4, [sp, #-4]! ");
	asm("ldr r4, __IdleGeneration ");
	GET_RWNO_TID(, r1);				// r1->SubScheduler
	asm("ldrb r4, [r4] ");			// r4 = TheScheduler.iIdleGeneration
	asm("ldr r1, [r1, #%a0]" : : "i" _FOFF(TSubScheduler,iCpuNum));	// r1 = current CPU number
	asm("eor r4, r4, #0x0021 ");	// r4 = expected state of idle IDFCs
	asm("orr r1, r1, #0x0080 ");
#endif
	asm("1: ");
	LDREXH(0,3);
#ifdef _DEBUG
	asm("cmp r0, #0 ");
	asm("beq 0f ");					// 0000 -> die
	asm("ands r2, r0, #0x00FF ");
	asm("beq 3f ");					// XX00 -> OK
	asm("cmp r2, r4 ");				// 002g ?
	asm("beq 3f ");					// yes -> OK
	asm("cmp r2, r1 ");				// 008n ?
	asm("beq 3f ");					// yes -> OK
	asm("0: ");
	__ASM_CRASH();					// otherwise die
	asm("3: ");
#endif
	asm("bics r2, r0, #0x00FF ");	// XXYY->XX00
	asm("moveq r2, #0x0001 ");		// 002g,008n->0001
	asm("beq 2f ");
	asm("tst r0, #0x00FF ");
	asm("moveq r2, #0 ");			// XX00->0000
	asm("2: ");
	STREXH(12,2,3);
	asm("cmp r12, #0 ");
	asm("bne 1b ");
	__DATA_MEMORY_BARRIER__(r12);
#ifdef _DEBUG
	asm("ldr r4, [sp], #4 ");
#endif
	__JUMP(,lr);
	}

/**	Transition the state of an IDFC when transferring it to another CPU

	002g->00Am, 008n->00Am, XXYY->XX00, XX00->0000
	other initial states invalid
	Return original state

	Enter and return with interrupts disabled and target CPU's ExIDfcLock held.
*/
__NAKED__ TUint32 TDfc::TransferIDFCStateChange(TInt /*aCpu*/)
	{
	asm("add r3, r0, #%a0" : : "i" _FOFF(TDfc,iDfcState));
	__DATA_MEMORY_BARRIER_Z__(r12);
#ifdef _DEBUG
	asm("stmfd sp!, {r4-r5} ");
	asm("ldr r4, __IdleGeneration ");
	GET_RWNO_TID(, r5);				// r5->SubScheduler
	asm("ldrb r4, [r4] ");			// r4 = TheScheduler.iIdleGeneration
	asm("ldr r5, [r5, #%a0]" : : "i" _FOFF(TSubScheduler,iCpuNum));	// r5 = current CPU number
	asm("eor r4, r4, #0x0021 ");	// r4 = expected state of idle IDFCs
	asm("orr r5, r5, #0x0080 ");
#endif
	asm("1: ");
	LDREXH(0,3);
#ifdef _DEBUG
	asm("cmp r0, #0 ");
	asm("beq 0f ");					// 0000 -> die
	asm("ands r2, r0, #0x00FF ");
	asm("beq 3f ");					// XX00 -> OK
	asm("cmp r2, r4 ");				// 002g ?
	asm("beq 3f ");					// yes -> OK
	asm("cmp r2, r5 ");				// 008n ?
	asm("beq 3f ");					// yes -> OK
	asm("0: ");
	__ASM_CRASH();					// otherwise die
	asm("3: ");
#endif
	asm("bics r2, r0, #0x00FF ");	// XXYY->XX00
	asm("orreq r2, r1, #0x00A0 ");	// 002g,008n->00Am
	asm("beq 2f ");
	asm("tst r0, #0x00FF ");
	asm("moveq r2, #0 ");			// XX00->0000
	asm("2: ");
	STREXH(12,2,3);
	asm("cmp r12, #0 ");
	asm("bne 1b ");
	__DATA_MEMORY_BARRIER__(r12);
#ifdef _DEBUG
	asm("ldmfd sp!, {r4-r5} ");
#endif
	__JUMP(,lr);
	}

/**	Transition the state of an IDFC/DFC just before cancelling it.

	0000->0000, XX00->ZZ00, xxYY->zzYY
	Return original state

	Enter and return with interrupts disabled.
*/
__NAKED__ TUint32 TDfc::CancelInitialStateChange()
	{
	GET_RWNO_TID(,r1);
	asm("add r3, r0, #%a0" : : "i" _FOFF(TDfc,iDfcState));
	__DATA_MEMORY_BARRIER_Z__(r12);
	asm("ldr r1, [r1, #%a0]" : : "i" _FOFF(TSubScheduler,iCpuMask));	// r1 = mask of current CPU number

	asm("1: ");
	LDREXH(0,3);
	asm("cmp r0, #0 ");
	asm("beq 2f ");				// if original state 0000 leave alone
	asm("orr r2, r0, r1, lsl #8 ");	// else set bit 8-15 corresponding to CPU number
	STREXH(12,2,3);
	asm("cmp r12, #0 ");
	asm("bne 1b ");
	asm("2: ");
	__DATA_MEMORY_BARRIER__(r12);
	__JUMP(,lr);
	}

/**	Transition the state of an IDFC/DFC at the end of a cancel operation

	XXYY->XX00, XX00->0000
	Return original state

	Enter and return with interrupts disabled.
*/
__NAKED__ TUint32 TDfc::CancelFinalStateChange()
	{
	asm("add r3, r0, #%a0" : : "i" _FOFF(TDfc,iDfcState));
	__DATA_MEMORY_BARRIER_Z__(r12);

	asm("1: ");
	LDREXH(0,3);
	asm("tst r0, #0x00FF ");
	asm("bicne r2, r0, #0x00FF ");	// XXYY->XX00
	asm("moveq r2, #0 ");			// xx00->0000
	STREXH(12,2,3);
	asm("cmp r12, #0 ");
	asm("bne 1b ");
	__DATA_MEMORY_BARRIER__(r12);
	__JUMP(,lr);
	}

/**	Transition the state of an IDFC or DFC when QueueOnIdle() is called

	0000->002g where g = TheScheduler.iIdleGeneration,
	00Cn->006n, all other states unchanged
	Return original state.

	Enter and return with interrupts disabled and IdleSpinLock held.
*/
__NAKED__ TUint32 TDfc::QueueOnIdleStateChange()
	{
	asm("ldr r12, __IdleGeneration ");
	asm("add r3, r0, #%a0" : : "i" _FOFF(TDfc,iDfcState));
	asm("ldrb r1, [r12] ");			// r1 = TheScheduler.iIdleGeneration
	__DATA_MEMORY_BARRIER_Z__(r12);
	asm("1: ");
	LDREXH(0,3);
	asm("cmp r0, #0 ");				// original state 0000 ?
	asm("orreq r2, r1, #0x0020 ");	// yes -> 002g
	asm("movne r2, r0 ");			// no -> R2=original state ...
	asm("eorne r12, r0, #0x00C0 ");	// ... and R12=original state^00C0 ...
	asm("cmpne r12, #0x0020 ");		// ... and check if result < 0020 (i.e. original==00C0..00DF)
	asm("sublo r2, r2, #0x0060 ");	// 00Cn->006n otherwise leave R2 alone
	STREXH(12,2,3);
	asm("cmp r12, #0 ");
	asm("bne 1b ");
	__DATA_MEMORY_BARRIER__(r12);
	__JUMP(,lr);
	}


__NAKED__ void TDfc::ResetState()
	{
	asm("add r3, r0, #%a0" : : "i" _FOFF(TDfc,iDfcState));
	__DATA_MEMORY_BARRIER_Z__(r2);
#ifdef _DEBUG
	asm("1: ");
	LDREXH(0,3);
	asm("cmp r0, #0 ");
	asm("beq 0f ");				// if state already zero, die
	STREXH(12,2,3);
	asm("cmp r12, #0 ");
	asm("bne 1b ");
#else
	asm("strh r2, [r3] ");		// __e32_atomic_store_rel16(&iDfcState, 0)
#endif
	__JUMP(,lr);
#ifdef _DEBUG
	asm("0: ");
	__ASM_CRASH();
#endif
	}



