// Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// e32\nkern\x86\ncsched.cia

// 

//

#include <x86.h>

#if defined(KSCHED)

extern "C" void __DebugMsgWaitForAnyRequest();

extern "C" void __DebugMsgResched(int a);

extern "C" void __DebugMsgInitSelection(int a);

extern "C" void __DebugMsgRR(int a);

extern "C" void __DebugMsgBlockedFM(int a);

extern "C" void __DebugMsgImpSysHeld(int a);

#endif

const TLinAddr TScheduler_Reschedule = (TLinAddr)&TScheduler::Reschedule;

const TLinAddr TheScheduler_iRescheduleNeededFlag = (TLinAddr)&TheScheduler.iRescheduleNeededFlag;

const TLinAddr NKern_FastCounter = (TLinAddr)&NKern::FastCounter;

__NAKED__ void TScheduler::YieldTo(NThreadBase*)

	{

	//

	// Enter with kernel locked, interrupts can be on or off

	// Exit with kernel unlocked, interrupts off

	//

	asm("mov byte ptr [%a0], 1" : : "i"(&TheScheduler.iRescheduleNeededFlag));

	asm("call %a0" : : "i"(TScheduler_Reschedule));

	asm("ret");

	}

const TUint32 new_thread_trace_header = ((8<<BTrace::ESizeIndex) + (BTrace::EContextIdPresent<<BTrace::EFlagsIndex*8) + (BTrace::ECpuUsage<<BTrace::ECategoryIndex*8) + (BTrace::ENewThreadContext<<BTrace::ESubCategoryIndex*8));

/***************************************************************************

* Reschedule

* Enter with:

*		Kernel locked, interrupts enabled or disabled

* Return with:

*		Kernel unlocked, interrupts disabled

*		EAX=0 if no reschedule occurred, 1 if it did

***************************************************************************/

__NAKED__ void TScheduler::Reschedule()

	{

	asm("push 0");

	asm("cli");

	asm("start_resched:");

	asm("cmp byte ptr [%a0], 0" : : "i"(&TheScheduler.iDfcPendingFlag));

	asm("jz resched_no_dfcs");

	asm("mov ecx, %0": :"i"(&TheScheduler)); 

#ifdef __GCC32__

	asm("push ecx");

	asm("call __ZN10TScheduler9QueueDfcsEv");

	asm("add esp,4"); 

#else

	TheScheduler.QueueDfcs();

#endif

	asm("resched_no_dfcs:");

	asm("cmp byte ptr [%a0], 0" : : "i"(&TheScheduler.iRescheduleNeededFlag));

	asm("jz resched_not_needed");

	asm("mov byte ptr [esp], 1");

	asm("sti");

	asm("push fs");

	asm("push gs");

	asm("push ebp");

	asm("push edi");

	asm("lea edi, %a0": : "i"(&TheScheduler));

	asm("push esi");

	asm("push ebx");

	asm("mov eax, cr0");

	asm("push eax");

	asm("mov eax, [edi+4]");

	asm("test eax, eax");

	asm("jz resched_pri_lt_32");

	asm("bsr ecx, eax");

	asm("add cl, 32");

	asm("jmp resched_1");

	asm("resched_pri_lt_32:");

	asm("mov eax, [edi]");

	asm("bsr ecx, eax");

	asm("resched_1:");						// ecx=highest ready priority

	asm("mov byte ptr [edi+%0], 0" : : "i"_FOFF(TScheduler,iRescheduleNeededFlag)); // mov byte ptr [edi]TScheduler.iRescheduleNeededFlag, 0

	asm("lea esi, [edi+ecx*4+8]");			// esi points to corresponding queue

	asm("mov ebx, [esi]");					// ebx points to highest priority thread

	ASM_DEBUG1(InitSelection,ebx)

	asm("cmp dword ptr [ebx+%0], 0" : :"i"_FOFF(NThreadBase,iTime));	// check if timeslice expired

	asm("jnz no_other");					// skip if not

	asm("cmp ebx, [ebx]");					// else check for other threads at this priority

	asm("jnz round_robin");					// branch if there are

	asm("no_other:");

	asm("mov eax, [ebx+%0]" : : "i"_FOFF(NThreadBase,iHeldFastMutex));

	asm("test eax, eax");					// does this thread hold a fast mutex?

	asm("jnz holds_fast_mutex");			// branch if it does

	asm("mov eax, [ebx+%0]" : : "i"_FOFF(NThreadBase,iWaitFastMutex));

	asm("test eax, eax");					// is thread blocked on a fast mutex?

	asm("jnz resched_blocked");				// branch if it is

	asm("resched_not_blocked:");

	asm("test byte ptr [ebx+10], 1");		// test for implicit system lock

	asm("jz resched_no_imp_sys");

#ifdef __GCC32__

	asm("mov eax, [edi+%0]" : : "i"(_FOFF(TScheduler,iLock) + _FOFF(NFastMutex,iHoldingThread)));

#else

	_asm mov eax, [edi]TheScheduler.iLock.iHoldingThread

#endif

	asm("test eax, eax");

	asm("jz resched_imp_sys_ok");

	asm("mov ebx, eax");					// system lock held so switch to holding thread

#ifdef __GCC32__

	asm("mov eax,1");

	asm("mov [edi+%0],eax" : : "i"(_FOFF(TScheduler, iLock) + _FOFF(NFastMutex,iWaiting)));

#else

	_asm mov [edi]TheScheduler.iLock.iWaiting, 1

#endif

	ASM_DEBUG1(ImpSysHeld,ebx)

	asm("resched_no_imp_sys:");

	asm("resched_imp_sys_ok:");

	asm("resched_do_thread_switch:");

	// EBX->new thread, EDI->TheScheduler

	ASM_DEBUG1(Resched,ebx)

#ifdef MONITOR_THREAD_CPU_TIME

	asm("call %a0" : :"i"(NKern_FastCounter));

	asm("mov ecx, [edi+%0]" : : "i"_FOFF(TScheduler,iCurrentThread));

	asm("mov edx, [ecx+%0]" : : "i"_FOFF(NThreadBase,iLastStartTime));

	asm("mov [ebx+%0], eax" : : "i"_FOFF(NThreadBase,iLastStartTime));

	asm("sub eax, edx");

	asm("add dword ptr ([ecx+%0]), eax" : : "i"_FOFF(NThreadBase,iTotalCpuTime));

	asm("adc dword ptr ([ecx+4+%0]), 0" : : "i"_FOFF(NThreadBase,iTotalCpuTime));

#endif

#ifdef BTRACE_CPU_USAGE

	asm("cmp byte ptr [%a0], 0": : "i"(&TheScheduler.iCpuUsageFilter));

	asm("jz no_trace");

	asm("push [%a0]": : "i"(&TheScheduler.iCurrentThread));

	asm("push 0");

	asm("push %0": : "i"(new_thread_trace_header));

	asm("call dword ptr [%a0]": : "i"(&TheScheduler.iBTraceHandler));

	asm("pop eax");

	asm("pop eax");

	asm("pop eax");

	asm("no_trace:");

#endif

	asm("mov esi, [edi+%0]": :"i"_FOFF(TScheduler,iCurrentThread)); // ESI -> original thread

	asm("mov [esi+%0], esp": :"i"_FOFF(NThreadBase,iSavedSP));		// Save original thread stack pointer

	asm("mov [edi+%0], ebx": :"i"_FOFF(TScheduler,iCurrentThread));	// EBX -> new thread, update current thread

	asm("cmp ebx, esi");

	asm("je same_thread");

	asm("test byte ptr [esp], 8");									// test thread's TS flag

	asm("jnz no_fpu");												// if set, thread did not use FPU

	asm("clts");

	asm("fnsave [esi+%0]": :"i"_FOFF(NThread,iCoprocessorState));	// else thread did use FPU - save its state

	asm("or byte ptr [esp], 8");									// set TS flag so thread aborts next time it uses FPU

	asm("fwait");

	asm("no_fpu:");

	asm("same_thread:");

	asm("mov esp, [ebx+%0]": :"i"_FOFF(NThreadBase,iSavedSP));		// Load new thread stack pointer

	asm("mov eax, [ebx+%0]": :"i"_FOFF(NThreadBase,iStackBase));

	asm("add eax, [ebx+%0]": :"i"_FOFF(NThreadBase,iStackSize));

	asm("mov ecx, dword ptr [%a0]": :"i"(&X86_TSS_Ptr));

	asm("mov [ecx+%0], eax": :"i"_FOFF(TX86Tss,iEsp0));				// set ESP0 to top of new thread supervisor stack

	asm("test byte ptr [ebx+%0], 2": :"i"_FOFF(TPriListLink,iSpare2)); // test for address space switch

	asm("jz resched_no_as_switch");

	asm("call [edi+%0]": :"i"_FOFF(TScheduler,iProcessHandler));	// call handler with

																	// EBX=pointer to new thread, EDI->scheduler, preserves ESI, EDI

	asm("resched_no_as_switch:");

	asm("pop eax");

	asm("mov cr0, eax");

	asm("pop ebx");

	asm("pop esi");

	asm("pop edi");

	asm("pop ebp");

	asm("pop gs");

	asm("pop fs");

	asm("cli");

	asm("lea eax, %a0": : "i"(&TheScheduler.iRescheduleNeededFlag));

	asm("cmp dword ptr [eax], 0");

	asm("jnz start_resched");

	asm("mov eax,0");

	asm("mov [%a0], eax": : "i"(&TheScheduler.iKernCSLocked));

	asm("pop eax");

	asm("ret");

	asm("round_robin:");

	asm("mov eax, [ebx+%0]": : "i"_FOFF(NThreadBase,iHeldFastMutex));

	asm("test eax, eax");					// does this thread hold a fast mutex?

	asm("jnz rr_holds_fast_mutex");			// branch if it does

	asm("mov eax, [ebx+%0]": : "i"_FOFF(NThreadBase,iTimeslice));

	asm("mov [ebx+%0], eax": : "i"_FOFF(NThreadBase,iTime)); // else new timeslice for this thread next time

	asm("mov ebx, [ebx]");					// candidate thread = next thread in round-robin order

	asm("mov [esi], ebx");					// the latter is now the first at this priority

	ASM_DEBUG1(RR,ebx);

	asm("jmp no_other");

	asm("resched_blocked:");

	ASM_DEBUG1(BlockedFM,eax)

	asm("mov edx, [eax+%0]": : "i"_FOFF(NFastMutex,iHoldingThread));

	asm("test edx, edx");

	asm("jz resched_not_blocked");

	asm("mov ebx, edx");

	asm("jmp resched_do_thread_switch");

	asm("holds_fast_mutex:");

#ifdef __GCC32__

	asm("lea ecx, [edi+%0]": : "i"_FOFF(TScheduler,iLock));

#else

	_asm lea ecx, [edi]TheScheduler.iLock

#endif

	asm("cmp eax, ecx");

	asm("je resched_do_thread_switch");

	asm("test byte ptr [ebx+10], 1");		// test for implicit system lock

	asm("jz resched_do_thread_switch");

#ifdef __GCC32__

	asm("cmp dword ptr [edi+%0], 0": : "i"(_FOFF(TScheduler,iLock) + _FOFF(NFastMutex,iHoldingThread)));

#else

	_asm cmp [edi]TheScheduler.iLock.iHoldingThread, 0

#endif

	asm("jz resched_do_thread_switch");

	asm("rr_holds_fast_mutex:");

#ifdef __GCC32__

	asm("push edx");		// storing an immediate value to an C-offset address appears to be 

	asm("mov edx,1");		// impossible in GCC, so we use edx instead

	asm("mov [eax+%0], edx": : "i"_FOFF(NFastMutex,iWaiting));

	asm("pop edx");

#else

	_asm mov [eax]NFastMutex.iWaiting, 1

#endif

	asm("jmp resched_do_thread_switch");

	asm("resched_not_needed:");

	asm("xor eax, eax");

	asm("mov [%a0], eax": : "i"(&TheScheduler.iKernCSLocked));

	asm("pop eax");

	asm("ret");

	}

/** Disable interrupts to the specified level

If aLevel = 0 does not affect interrupt state

If aLevel <>0 disables all maskable interrupts.

@param	aLevel level to which to disable

@return	Cookie to pass into RestoreInterrupts()

*/

EXPORT_C __NAKED__ TInt NKern::DisableInterrupts(TInt /*aLevel*/)

	{

	asm("pushfd");

	asm("mov ecx, [esp+4]");

	asm("pop eax");

	asm("and eax, 0x200");

	asm("test ecx, ecx");

	asm("jz disable_ints_0");

	asm("cli");

	asm("disable_ints_0:");

	asm("ret");

	}

/** Disable all maskable interrupts

@return	Cookie to pass into RestoreInterrupts()

*/

EXPORT_C __NAKED__ TInt NKern::DisableAllInterrupts()

	{

	asm("pushfd");

	asm("pop eax");

	asm("and eax, 0x200");

	asm("cli");

	asm("ret");

	}

/** Restore interrupt mask to state preceding a DisableInterrupts() call

@param	aLevel Cookie returned by Disable(All)Interrupts()

*/

EXPORT_C __NAKED__ void NKern::RestoreInterrupts(TInt aLevel)

	{

	asm("test byte ptr [esp+5], 2");	// test saved I flag

	asm("jz restore_irq_off");			// jump if clear

	asm("sti");							// else reenable interrupts

	asm("ret");

	asm("restore_irq_off:");

	asm("cli");

	asm("ret");

	}

/** Enable all maskable interrupts

@internalComponent

*/

EXPORT_C __NAKED__ void NKern::EnableAllInterrupts()

	{

	asm("sti");

	asm("ret");

	}

/**	Unlocks the kernel

Decrements iKernCSLocked; if it becomes zero and IDFCs or a reschedule are

pending, calls the scheduler to process them.

@pre	Thread or IDFC context. Don't call from ISRs.

*/

EXPORT_C __NAKED__ void NKern::Unlock()

	{

	asm("xor eax, eax");

	asm("dec dword ptr [%a0]": : "i"(&TheScheduler.iKernCSLocked));

	asm("lea edx, %a0": : "i"(&TheScheduler.iRescheduleNeededFlag));

	asm("jnz unlock_no_resched");

	asm("cmp eax, [edx]");

	asm("jz unlock_no_resched");

	asm("inc eax");

	asm("mov dword ptr [%a0], eax": : "i"(&TheScheduler.iKernCSLocked));

	asm("call %a0" : : "i"(TScheduler_Reschedule));

	asm("sti");

	asm("unlock_no_resched:");

	asm("ret");

	}

/**	Locks the kernel

Increments iKernCSLocked, thereby deferring IDFCs and preemption.

@pre	Thread or IDFC context. Don't call from ISRs.

*/

EXPORT_C __NAKED__ void NKern::Lock()

	{

	asm("inc dword ptr [%a0]": : "i"(&TheScheduler.iKernCSLocked));

	asm("ret");

	}

/**	Locks the kernel and returns a pointer to the current thread

Increments iKernCSLocked, thereby deferring IDFCs and preemption.

@pre	Thread or IDFC context. Don't call from ISRs.

*/

EXPORT_C __NAKED__ NThread* NKern::LockC()

	{

	asm("inc dword ptr [%a0]": :"i"(&TheScheduler.iKernCSLocked));

	asm("mov eax, [%a0]": :"i"(&TheScheduler.iCurrentThread));

	asm("ret");

	}

/**	Allows IDFCs and rescheduling if they are pending.

If IDFCs or a reschedule are pending and iKernCSLocked is exactly equal to 1

calls the scheduler to process the IDFCs and possibly reschedule.

@return	Nonzero if a reschedule actually occurred, zero if not.

@pre	Thread or IDFC context. Don't call from ISRs.

*/

EXPORT_C __NAKED__ TInt NKern::PreemptionPoint()

	{

	asm("mov ecx, %0": : "i"(TheScheduler_iRescheduleNeededFlag));

	asm("xor eax, eax");

	asm("cmp eax, [ecx]");

	asm("jz preemption_point_no_resched");

	asm("cmp dword ptr [%a0], 1": : "i"(&TheScheduler.iKernCSLocked));

	asm("jne preemption_point_no_resched");

	asm("call %a0" : : "i"(TScheduler_Reschedule));

	asm("mov dword ptr [%a0], 1": : "i"(&TheScheduler.iKernCSLocked));

	asm("sti");

	asm("preemption_point_no_resched:");

	asm("ret");

	}