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