// Copyright (c) 2005-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\x86\ncsched.cpp
// 
//

// NThreadBase member data
#define __INCLUDE_NTHREADBASE_DEFINES__

#include <x86.h>
#include <apic.h>


// Called by a thread which has been forced to exit
// Kernel locked on entry
extern "C" void __fastcall do_forced_exit(NThreadBase* aT)
	{
	__NK_ASSERT_ALWAYS(aT->iFastMutexDefer != 1);
	aT->iFastMutexDefer = 0;
	aT->Exit();
	}

extern "C" NThreadBase* __fastcall select_next_thread(TSubScheduler* aS)
	{
	return aS->SelectNextThread();
	}

extern "C" void __fastcall queue_dfcs(TSubScheduler* aS)
	{
	aS->QueueDfcs();
	}

extern "C" void NewThreadTrace(NThread* a)
	{
	__ACQUIRE_BTRACE_LOCK();
	BTraceData.iHandler(BTRACE_HEADER_C(4,BTrace::ECpuUsage,BTrace::ENewThreadContext),0,(TUint32)a,0,0,0,0,0);
	__RELEASE_BTRACE_LOCK();
	}

extern "C" void __fastcall send_ipi(TUint32);
extern "C" void __fastcall do_send_resched_ipis(TUint32);

extern "C" void send_resched_ipi(TInt aCpu)
	{
	TSubScheduler& ss = TheSubSchedulers[aCpu];
	__KTRACE_OPT(KSCHED2,DEBUGPRINT("@%d",aCpu));
	send_ipi((TUint32)ss.i_APICID);
	}

extern "C" void send_resched_ipis(TUint32 aMask)
	{
	__KTRACE_OPT(KSCHED2,DEBUGPRINT("@%02x",aMask));
#ifdef __USE_LOGICAL_DEST_MODE__
	do_send_resched_ipis(aMask);
#else
	TInt i=0;
	while (aMask)
		{
		if (aMask&1)
			send_resched_ipi(i);
		aMask>>=1;
		++i;
		}
#endif
	}

extern "C" void send_resched_ipi_and_wait(TInt aCpu)
	{
	TSubScheduler& ss = TheSubSchedulers[aCpu];
	__KTRACE_OPT(KSCHED2,DEBUGPRINT("@@%d",aCpu));
	volatile TUint32& irqc = (volatile TUint32&)ss.i_IrqCount;
	volatile TInt& irqn = (volatile TInt&)ss.i_IrqNestCount;
	TUint32 irqc0 = irqc;
	mb();
	send_ipi((TUint32)ss.i_APICID);
	mb();
	while (!ss.iRescheduleNeededFlag || (irqn<0 && irqc==irqc0))
		{
		__chill();
		}
	mb();	// guaranteed to observe final thread state after this
	}

void TSubScheduler::SaveTimesliceTimer(NThreadBase* aT)
	{
	if (aT->iTime>0 && !aT->i_NThread_Initial)
		{
		TUint32 remain32 = read_apic_reg(CURRCNT);
		TUint64 x(remain32);
		x *= TUint32(i_TimerMultI);
		x += 0x00800000u;
		x >>= 24;
		aT->iTime = (TInt)x;
		}
	write_apic_reg(INITCNT, 0);
	}


/*	Update aOld's execution time and set up the timer for aNew
	Update this CPU's timestamp value

	if (!aOld) aOld=iInitialThread
	if (!aNew) aNew=iInitialThread
	if new thread has a timeslice, start the timeslice timer
	update the last reschedule time
	update the run time for the old thread
	update the reschedule count for the new thread and the current CPU
 */
void TSubScheduler::UpdateThreadTimes(NThreadBase* aOld, NThreadBase* aNew)
	{
	if (!aOld)
		aOld = iInitialThread;
	if (!aNew)
		aNew = iInitialThread;
	if (aNew->iTime>0)
		{
		TUint32 remain32 = (TUint32)aNew->iTime;
		TUint64 x(remain32);
		x *= TUint32(i_TimerMultF);
		x += 0x80000000u;
		x >>= 32;
		write_apic_reg(LVTTMR, TIMESLICE_VECTOR);
		write_apic_reg(INITCNT, (TUint32)x);
		}
	if (aNew!=aOld)
		{
		TUint64 now = NKern::Timestamp();
		aOld->iTotalCpuTime64 += (now - iLastTimestamp64);
		iLastTimestamp64 = now;
		++iReschedCount64;
		++aNew->iRunCount64;
		}
	}