// 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\nkern\arm\ncsched.cia

// 

//

// NThreadBase member data

#define __INCLUDE_NTHREADBASE_DEFINES__

// TDfc member data

#define __INCLUDE_TDFC_DEFINES__

#include <e32cia.h>

#include <arm.h>

#include "highrestimer.h"

#include "nkern.h"

#include "emievents.h"

#if defined(MONITOR_THREAD_CPU_TIME) && !defined(HAS_HIGH_RES_TIMER)

#error MONITOR_THREAD_CPU_TIME is defined, but high res timer is not supported

#endif

#ifdef _DEBUG

#define ASM_KILL_LINK(rp,rs)	asm("mov "#rs", #0xdf ");\

								asm("orr "#rs", "#rs", "#rs", lsl #8 ");\

								asm("orr "#rs", "#rs", "#rs", lsl #16 ");\

								asm("str "#rs", ["#rp"] ");\

								asm("str "#rs", ["#rp", #4] ");

#else

#define ASM_KILL_LINK(rp,rs)

#endif

#define ALIGN_STACK_START			\

	asm("mov r12, sp");				\

	asm("tst sp, #4");				\

	asm("subeq sp, sp, #4");		\

	asm("str r12, [sp,#-4]!")

#define ALIGN_STACK_END				\

	asm("ldr sp, [sp]")

#ifdef __CPU_HAS_VFP

#ifdef __CPU_HAS_COPROCESSOR_ACCESS_REG

#define	FPEXC_REG	10

#define	FPEXC_REG3	4

#else

#define	FPEXC_REG	11

#define	FPEXC_REG3	10

#endif

#endif

//////////////////////////////////////////////////////////////////////////////

//	Macros to define which standard ARM registers are used to save 

//	required co-processor registers on a reschedule.

//	They rely on the fact that the compiler will concatenate adjacent strings

//	so "r" "9" "," "r" "10" "," will be converted in the assembler file to:

//		r9,r10

/////////////////////////////////////////////////////////////////////////////

#ifdef __CPU_HAS_CP15_THREAD_ID_REG

#define TID_SP_REG(reg)		"r"#reg","

#else

#define TID_SP_REG(reg)

#endif //__CPU_HAS_CP15_THREAD_ID_REG

#ifdef __CPU_HAS_VFP

#define FPEXC_SP_REG(reg) 	"r"#reg","

#else

#define FPEXC_SP_REG(reg)

#endif //__CPU_HAS_VFP

#ifdef __CPU_HAS_COPROCESSOR_ACCESS_REG

#define CAR_SP_REG(reg)		"r"#reg","

#else

#define CAR_SP_REG(reg)

#endif //__CPU_HAS_COPROCESSOR_ACCESS_REG

#ifdef __CPU_ARM_USE_DOMAINS

#define DACR_SP_REG(reg)	"r"#reg","

#else

#define DACR_SP_REG(reg)

#endif //__CPU_ARM_USE_DOMAINS

#ifdef __CPU_SUPPORT_THUMB2EE

#define THUMB2EE_SP_REG(reg)	"r"#reg","

#else 

#define THUMB2EE_SP_REG(reg)

#endif  // __CPU_SUPPORT_THUMB2EE

//	NOTE THIS WILL PRODUCE A WARNING IF REGISTERS ARE NOT IN ASCENDING ORDER

#define EXTRA_STACK_LIST(thumb2ee, tid, fpexc, car, dacr)\

THUMB2EE_SP_REG(thumb2ee) TID_SP_REG(tid) FPEXC_SP_REG(fpexc) CAR_SP_REG(car) DACR_SP_REG(dacr)

//////////////////////////////////////////////////////////////////////////////

//#define __DEBUG_BAD_ADDR

extern "C" void PanicFastSemaphoreWait();

#ifdef __DFC_MACHINE_CODED__

__ASSERT_COMPILE(_FOFF(TDfcQue,iPresent) == 0);	

__ASSERT_COMPILE(_FOFF(TDfc,iNext) == 0);

__ASSERT_COMPILE(_FOFF(TDfc,iPrev) == 4);

__ASSERT_COMPILE(_FOFF(TDfc,iPriority) % 4 == 0);	

__ASSERT_COMPILE(_FOFF(TDfc,iOnFinalQ) == _FOFF(TDfc,iPriority) + 2);	

__ASSERT_COMPILE(_FOFF(TDfc,iQueued) == _FOFF(TDfc,iOnFinalQ) + 1);	

__NAKED__ void TDfcQue::ThreadFunction(TAny* /*aDfcQ*/)

	{

	asm("ldr r11, __TheScheduler2 ");

	asm("mov r4, r0 ");					// r4=aDfcQ

	asm("ldr r10, [r11, #%a0]" : : "i" _FOFF(TScheduler,iCurrentThread));

	asm("mov r7, #0 ");

	asm("mov r9, #1 ");

	SET_INTS_1(r5, MODE_SVC, INTS_ALL_ON);

	SET_INTS_1(r6, MODE_SVC, INTS_ALL_OFF);

	asm("dfc_thrd_fn_check_queue: ");

	SET_INTS_2(r5, MODE_SVC, INTS_ALL_ON);	// enable interrupts

	asm("dfc_thrd_fn_check_queue2: ");

	asm("str r9, [r11, #%a0]" : : "i" _FOFF(TScheduler,iKernCSLocked));	// lock the kernel

	asm("ldr r3, [r4, #%a0]" : : "i" _FOFF(TDfcQue,iPresent));			// r3=aDfcQ->iPresent

	asm("add lr, r4, #%a0" : :  "i" _FOFF(TDfcQue,iQueue));				// lr=address of priority 0 queue

#ifdef __CPU_ARM_HAS_CLZ

	CLZ(12,3);							// r12=31-MSB(r3), 32 if r3=0

	asm("rsbs r12, r12, #31 ");			// r12=ms bit number set, -1 if queue empty

	asm("bmi dfc_thrd_fn_wait ");		// if empty, wait for next request

#else

	asm("movs r2, r3 ");				// check if queue empty

	asm("beq dfc_thrd_fn_wait ");		// if empty, wait for next request

	asm("mov r12, #7 ");

	asm("cmp r2, #0x10 ");

	asm("movcc r2, r2, lsl #4 ");

	asm("subcc r12, r12, #4 ");

	asm("cmp r2, #0x40 ");

	asm("movcc r2, r2, lsl #2 ");

	asm("subcc r12, r12, #2 ");

	asm("cmp r2, #0x80 ");

	asm("subcc r12, r12, #1 ");			// r12=ms bit number set

#endif

	asm("ldr r8, [lr, r12, lsl #2]! ");	// lr=address of highest priority non-empty queue, r8=address of first DFC

	asm("ldmia r8, {r0-r1} ");			// r0=first->next, r1=first->prev

	asm("cmp r0, r8 ");					// check if this is the only one at this priority

	asm("strne r0, [r1, #0] ");			// if not, prev->next=next

	asm("strne r1, [r0, #4] ");			// and next->prev=prev

	asm("streq r7, [lr] ");				// if this was only one, set head pointer for this priority to NULL

	asm("strne r0, [lr] ");				// else set head pointer to first->next

	ASM_KILL_LINK(r8,r1);

	asm("strh r7, [r8, #%a0]" : : "i" _FOFF(TDfc, iOnFinalQ));			// iOnFinalQ=iQueued=FALSE - can't touch link pointers after this

	asm("biceq r3, r3, r9, lsl r12 ");	// if no more at this priority clear bit in iPresent

	asm("streq r3, [r4, #%a0]" : : "i" _FOFF(TDfcQue,iPresent));

	SET_INTS_2(r6, MODE_SVC, INTS_ALL_OFF);	// interrupts off

	asm("ldr r3, [r11, #%a0]" : : "i" _FOFF(TScheduler,iRescheduleNeededFlag));	// check if reschedule required

	asm("cmp r3, #0 ");

	asm("streq r7, [r11, #%a0]" : : "i" _FOFF(TScheduler,iKernCSLocked));	// if no reschedule required unlock the kernel

	asm("blne  " CSM_ZN10TScheduler10RescheduleEv);	// if reschedule required, do it

	SET_INTS_2(r5, MODE_SVC, INTS_ALL_ON);	// restore interrupts

	asm("ldr r1, [r8, #%a0]" : : "i" _FOFF(TDfc, iFunction));			// r1=function address

	asm("adr lr, dfc_thrd_fn_check_queue2 ");							// set up return address

	asm("ldr r0, [r8, #%a0]" : : "i" _FOFF(TDfc, iPtr));				// r0=DFC argument

	__JUMP(,r1);						// call DFC

	asm("dfc_thrd_fn_wait: ");

	asm("mov r0, #%a0" : : "i" ((TInt)NThreadBase::EWaitDfc));

	asm("strb r0, [r10, #%a0]" : : "i" _FOFF(NThreadBase,iNState));

	asm("strb r9, [r11, #%a0]" : : "i" _FOFF(TScheduler,iRescheduleNeededFlag));

	asm("mov r0, r11 ");

	asm("mov r1, r10 ");

	asm("bl unready ");

	asm("adr lr, dfc_thrd_fn_check_queue ");	// set up return address

	asm("b  " CSM_ZN10TScheduler10RescheduleEv);

	asm("__TheScheduler2: ");

	asm(".word TheScheduler ");

	}

/** Cancels an IDFC or DFC.

	This function does nothing if the IDFC or DFC is not queued.

	@return	TRUE	if the DFC was actually dequeued by this call. In that case

					it is guaranteed that the DFC will not execute until it is

					queued again.

			FALSE	if the DFC was not queued on entry to the call, or was in

					the process of being executed or cancelled. In this case

					it is possible that the DFC executes after this call

					returns.

	@post	However in either case it is safe to delete the DFC object on

			return from this call provided only that the DFC function does not

			refer to the DFC object itself.

	@pre IDFC or thread context. Do not call from ISRs.

	@pre If the DFC function accesses the DFC object itself, the user must ensure that

	     Cancel() cannot be called while the DFC function is running.

 */

__NAKED__ EXPORT_C TBool TDfc::Cancel()

	{

	ASM_CHECK_PRECONDITIONS(MASK_NOT_ISR);

	asm("ldr r1, __TheScheduler2 ");

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

	asm("add r3, r3, #1 ");

	asm("str r3, [r1, #%a0]" : : "i" _FOFF(TScheduler,iKernCSLocked));	// lock the kernel

	asm("ldr r2, [r0, #%a0]" : : "i" _FOFF(TDfc,iPriority));			// r2=priority/flags

	SET_INTS_1(r12, MODE_SVC, INTS_ALL_OFF);

	asm("tst r2, #0xff000000 ");		// test queued flag

	asm("moveq r0, #0 ");				// if not queued, return FALSE

	asm("beq 0f ");

	SET_INTS_2(r12, MODE_SVC, INTS_ALL_OFF);	// otherwise disable interrupts while we dequeue

	asm("ldmia r0, {r3,r12} ");			// r3=next, r12=prev

	SET_INTS_1(r1, MODE_SVC, INTS_ALL_ON);

	asm("str r3, [r12, #0] ");			// prev->next=next

	asm("str r12, [r3, #4] ");			// next->prev=prev

	SET_INTS_2(r1, MODE_SVC, INTS_ALL_ON);	// reenable interrupts

	asm("tst r2, #0x00ff0000 ");		// check iOnFinalQ

	asm("beq 1f ");						// if FALSE, finish up

	asm("ldr r1, [r0, #%a0]" : : "i" _FOFF(TDfc,iDfcQ));				// r1=iDfcQ

	asm("and r2, r2, #0xff ");			// r2=iPriority

	asm("subs r12, r3, r0 ");			// check if queue is now empty, r12=0 if it is

	asm("beq 2f ");						// branch if now empty

	asm("add r1, r1, r2, lsl #2 ");		// r1=&iDfcQ->iQueue[iPriority]-_FOFF(TDfcQue.iPriority)

	asm("ldr r12, [r1, #%a0]" : : "i" _FOFF(TDfcQue,iQueue));			// r12=iDfcQ->iQueue[iPriority]

	asm("cmp r12, r0 ");				// is this one first?

	asm("streq r3, [r1, #%a0]" : : "i" _FOFF(TDfcQue,iQueue));			// if so, iQueue[pri]=next

	asm("b 1f ");

	asm("2: ");		// r0=this, r1=iDfcQ, r2=priority, r3=next, r12=0

	asm("ldr r3, [r1], #%a0" : : "i" _FOFF(TDfcQue,iQueue));			// r3=iDfcQ->iPresent, r1=&iDfcQ->iQueue[0]

	asm("str r12, [r1, r2, lsl #2] ");	// iDfcQ->iQueue[iPriority]=NULL

	asm("mov r12, #1 ");

	asm("bic r3, r3, r12, lsl r2 ");	// clear present bit

	asm("str r3, [r1, #-%a0]" : : "i" _FOFF(TDfcQue,iQueue));

	asm("1: ");

	ASM_KILL_LINK(r0,r1);

	asm("mov r3, #0 ");

	asm("strh r3, [r0, #%a0]" : : "i" _FOFF(TDfc,iOnFinalQ));			// iOnFinalQ=iQueued=FALSE - must be done last

	// R0=this != 0 here

	asm("0: ");

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

	asm("bl  " CSM_ZN5NKern6UnlockEv);			// unlock the kernel

	__POPRET("r0,");

	}

#endif

#ifdef __FAST_SEM_MACHINE_CODED__

/** Waits on a fast semaphore.

    Decrements the signal count for the semaphore and

	removes the calling thread from the ready-list if the sempahore 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 Kernel must be locked.

	@pre No fast mutex can be held.

	@post Kernel is locked.

	@see NFastSemaphore::Signal()

	@see NKern::FSWait()

	@see NKern::Unlock()

 */

EXPORT_C __NAKED__ void NFastSemaphore::Wait()

	{

	ASM_CHECK_PRECONDITIONS(MASK_KERNEL_LOCKED|MASK_NOT_ISR|MASK_NOT_IDFC|MASK_NO_FAST_MUTEX);

	asm("mov r2, r0 ");

	asm("ldr r0, __TheScheduler ");

	asm("ldr r1, [r2, #%a0]" : : "i" _FOFF(NFastSemaphore,iOwningThread));	// r1=owning thread

	asm("ldr r3, [r0, #%a0]" : : "i" _FOFF(TScheduler,iCurrentThread));		// r3=current thread

	asm("cmp r1, r3 ");

	asm("bne PanicFastSemaphoreWait ");		// if wrong thread, fault

	// wait on a NFastSemaphore pointed to by r2

	// enter with r0=&TheScheduler, r1=the current thread, already validated

	asm("ldr r3, [r2, #%a0]" : : "i" _FOFF(NFastSemaphore,iCount));

	asm("mov r12, #%a0" : : "i" (NThread::EWaitFastSemaphore));

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

	asm("str r3, [r2, #%a0]" : : "i" _FOFF(NFastSemaphore,iCount));	// decrement iCount

	__JUMP(ge,lr);							// if result>=0, finished

	asm("str r2, [r1, #%a0]" : : "i" _FOFF(NThread,iWaitObj));

	asm("strb r12, [r1, #%a0]" : : "i" _FOFF(NThread,iNState));

	asm("mov r3, #1 ");

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

	// remove thread from ready list

	asm("b unready ");

	}

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

 @pre   No fast mutex can be held.

 @pre   Kernel must be unlocked.

 @pre	Call in a thread context.

 @pre	Interrupts must be enabled.

 */

EXPORT_C __NAKED__ void NKern::WaitForAnyRequest()

	{

	ASM_CHECK_PRECONDITIONS(MASK_INTERRUPTS_ENABLED|MASK_KERNEL_UNLOCKED|MASK_NOT_ISR|MASK_NOT_IDFC|MASK_NO_FAST_MUTEX);

	asm("ldr r0, __TheScheduler ");

	asm("str lr, [sp, #-4]! ");				// save lr

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

	asm("bl wait_for_any_request2 ");

	SET_INTS(r0, MODE_SVC, INTS_ALL_ON);	// turn interrupts back on

	asm("ldr pc, [sp], #4 ");

	// Special case handler for Exec::WaitForAnyRequest() for efficiency reasons

	// Called from __ArmVectorSwi with R11=&TheScheduler, R1=current thread

	// Returns with interrupts disabled

	asm(".global wait_for_any_request ");

	asm("wait_for_any_request: ");

	ASM_DEBUG0(WaitForAnyRequest);

	asm("mov r0, r11 ");

	asm("wait_for_any_request2: ");

	SET_INTS_1(r2, MODE_SVC, INTS_ALL_OFF);

#ifdef _DEBUG

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

	asm("cmp r3, #0 ");

	asm("movne r12, #0xd8000001 ");			// FAULT - calling Exec::WaitForAnyRequest() with the kernel locked is silly

	asm("strne r12, [r12] ");

#endif

	SET_INTS_2(r2, MODE_SVC, INTS_ALL_OFF);	// turn off interrupts

	asm("ldr r2, [r1, #%a0]" : : "i" _FOFF(NThread,iRequestSemaphore.iCount));

	asm("mov r3, #1 ");

	SET_INTS_1(r12, MODE_SVC, INTS_ALL_ON);

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

	asm("str r2, [r1, #%a0]" : : "i" _FOFF(NThread,iRequestSemaphore.iCount));	// decrement iCount

	__JUMP(ge,lr);							// if result non-negative, finished

	asm("str r3, [r0, #%a0]" : : "i" _FOFF(TScheduler,iKernCSLocked));	// lock the kernel

	SET_INTS_2(r12, MODE_SVC, INTS_ALL_ON);	// reenable interrupts

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

	// r2 points to NFastSemaphore

	asm("add r2, r1, #%a0" : : "i" _FOFF(NThread,iRequestSemaphore));

	asm("str lr, [sp, #-4]! ");

	asm("str r2, [r1, #%a0]" : : "i" _FOFF(NThread,iWaitObj));

	asm("mov r3, #%a0" : : "i" (NThread::EWaitFastSemaphore));

	asm("strb r3, [r1, #%a0]" : : "i" _FOFF(NThread,iNState));	// mark thread waiting on semaphore

	asm("bl unready ");						// remove thread from ready list - DOESN'T CLOBBER R0

	asm("bl  " CSM_ZN10TScheduler10RescheduleEv);		// Reschedule

	asm("ldr lr, [sp], #4 ");

	asm("mov r3, #%a0 " : : "i" (NThread::EContextWFARCallback));

	asm("b callUserModeCallbacks ");		// exit and call callbacks

	}

/** 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_CHECK_PRECONDITIONS(MASK_KERNEL_LOCKED|MASK_NOT_ISR);

	asm("req_sem_signaln: ");

	asm("ldr r2, [r0, #%a0]" : : "i" _FOFF(NFastSemaphore,iCount));

	asm("adds r2, r2, r1 ");

	asm("str r2, [r0, #%a0]" : : "i" _FOFF(NFastSemaphore,iCount));

	__JUMP(cc,lr);							// if count did not cross 0 nothing more to do

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

	asm("mov r1, #0 ");

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

	asm("b check_suspend_then_ready ");

	}

/** @internalComponent */

__NAKED__ void NFastSemaphore::WaitCancel()

	{

	asm("ldr r3, [r0, #%a0]" : : "i" _FOFF(NFastSemaphore,iOwningThread));

	asm("mov r1, #0 ");

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

	asm("str r1, [r3, #%a0]" : : "i" _FOFF(NThread,iWaitObj));

	asm("mov r0, r3 ");

	asm("b check_suspend_then_ready ");

	}

/** Resets a fast semaphore.

	@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::Reset()

	{

	ASM_CHECK_PRECONDITIONS(MASK_KERNEL_LOCKED|MASK_NOT_ISR);

	asm("ldr r2, [r0, #%a0]" : : "i" _FOFF(NFastSemaphore,iCount));

	asm("mov r1, #0 ");

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

	asm("cmp r2, #0 ");

	__JUMP(ge,lr);					// if count was not negative, nothing to do

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

	asm("mov r1, #0 ");

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

	asm("b check_suspend_then_ready ");

	}

#endif

#ifdef __SCHEDULER_MACHINE_CODED__

__ASSERT_COMPILE(_FOFF(SDblQueLink,iNext) == 0);

__ASSERT_COMPILE(_FOFF(SDblQueLink,iPrev) == 4);

__ASSERT_COMPILE(_FOFF(TScheduler,iPresent) == 0);

__ASSERT_COMPILE(_FOFF(NFastSemaphore,iCount) == 0);

__ASSERT_COMPILE(_FOFF(NFastSemaphore,iOwningThread) == 4);

__ASSERT_COMPILE(_FOFF(TDfc,iPtr) == _FOFF(TDfc,iPriority) + 4);

__ASSERT_COMPILE(_FOFF(TDfc,iFunction) == _FOFF(TDfc,iPtr) + 4);

__NAKED__ void TScheduler::Remove(NThreadBase* /*aThread*/)

//

// Remove a thread from the ready list

//

	{

	asm("unready: ");

	asm("ldr r2, [r0, #%a0]" : : "i" _FOFF(TScheduler,iMadeUnReadyCounter)); 	// Update Made UnReady count here, 

	asm("add r2, r2, #1"); 								// ie equiv of 'iMadeUnReadyCounter++;'.

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

#ifdef _DEBUG

	asm("ldr r2, [r1, #%a0]" : : "i" _FOFF(NThread,iHeldFastMutex));

	asm("mov r12, #0xd8000003 ");

	asm("cmp r2, #0 ");

	asm("strne r12, [r12] ");				// crash if fast mutex held

#endif

	asm("ldr r12, [r1, #%a0]" : : "i" _FOFF(NThread,iTimeslice));

	asm("ldmia r1, {r2,r3} ");				// r2=next, r3=prev

	asm("str r12, [r1, #%a0]" : : "i" _FOFF(NThread,iTime));	// fresh timeslice for next time

	asm("pri_list_remove: ");

	ASM_KILL_LINK(r1,r12);

	asm("subs r12, r1, r2 ");				// check if more threads at this priority, r12=0 if not

	asm("bne unready_1 ");					// branch if there are more at same priority

	asm("ldrb r2, [r1, #%a0]" : : "i" _FOFF(NThread, iPriority));	// r2=thread priority

	asm("add r1, r0, #%a0" : : "i" _FOFF(TScheduler, iQueue));		// r1->iQueue[0]

	asm("str r12, [r1, r2, lsl #2] ");		// iQueue[priority]=NULL

	asm("ldrb r1, [r0, r2, lsr #3] ");		// r1=relevant byte in present mask

	asm("and r3, r2, #7 ");					// r3=priority & 7

	asm("mov r12, #1 ");

	asm("bic r1, r1, r12, lsl r3 ");		// clear bit in present mask

	asm("strb r1, [r0, r2, lsr #3] ");		// update relevant byte in present mask

	__JUMP(,lr);

	asm("unready_1: ");						// get here if there are other threads at same priority

	asm("ldrb r12, [r1, #%a0]" : : "i" _FOFF(NThread, iPriority));	// r12=thread priority

	asm("add r0, r0, #%a0" : : "i" _FOFF(TScheduler, iQueue));		// r0=&iQueue[0]

	asm("str r3, [r2, #4] ");				// next->prev=prev

	asm("ldr r12, [r0, r12, lsl #2]! ");	// r12=iQueue[priority], r0=&iQueue[priority]

	asm("str r2, [r3, #0] ");				// and prev->next=next

	asm("cmp r12, r1 ");					// if aThread was first...

	asm("streq r2, [r0, #0] ");				// iQueue[priority]=aThread->next

	__JUMP(,lr);							// finished

	}

/** Removes an item from a priority list.

	@param aLink A pointer to the item - this must not be NULL.

 */

EXPORT_C __NAKED__ void TPriListBase::Remove(TPriListLink* /*aLink*/)

	{

	asm("ldmia r1, {r2,r3} ");				// r2=aLink->iNext, r3=aLink->iPrev

	asm("b pri_list_remove ");

	}

/** 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_CHECK_PRECONDITIONS(MASK_KERNEL_LOCKED|MASK_NOT_ISR);

	asm("req_sem_signal: ");

	asm("ldmia r0, {r1,r2} ");				// r1=iCount, r2=iOwningThread

	asm("mov r3, #0 ");

	asm("adds r1, r1, #1 ");

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