// 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");
	}