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

		}

	}