// 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\ncsched.cpp

// 

//

// NThreadBase member data

#define __INCLUDE_NTHREADBASE_DEFINES__

#include <arm.h>

#include <arm_tmr.h>

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 __DebugMsgSendReschedIPI(int a)

	{

	__KTRACE_OPT(KSCHED2,DEBUGPRINT("@%d",a));

	}

extern "C" void __DebugMsgSendReschedIPIs(int a)

	{

	__KTRACE_OPT(KSCHED2,DEBUGPRINT("@%02x",a));

	}

extern "C" void __DebugMsgSendReschedIPIAndWait(int a)

	{

	__KTRACE_OPT(KSCHED2,DEBUGPRINT("@@%d",a));

	}

#ifdef __FAST_SEM_MACHINE_CODED__

extern "C" void PanicFastSemaphoreWait()

	{

	FAULT();

	}

#endif

#ifdef BTRACE_CPU_USAGE

extern "C" void btrace_irq_entry(TInt aVector)

	{

	BTrace4(BTrace::ECpuUsage, BTrace::EIrqStart, aVector);

	}

extern "C" void btrace_fiq_entry()

	{

	BTrace0(BTrace::ECpuUsage, BTrace::EFiqStart);

	}

extern "C" void btrace_irq_exit()

	{

	BTrace0(BTrace::ECpuUsage, BTrace::EIrqEnd);

	}

extern "C" void btrace_fiq_exit()

	{

	BTrace0(BTrace::ECpuUsage, BTrace::EFiqEnd);

	}

#endif

extern "C" void __DebugMsgIrq(TUint a)

	{

	if ((a & 0x3ffu) >= 0x20u)

		return;

	__KTRACE_OPT(KSCHED2,DEBUGPRINT("!%x",a));

	}

#ifdef _DEBUG

extern "C" void __DebugMsgFSWait(NFastSemaphore* a)

	{

	CHECK_PRECONDITIONS(MASK_KERNEL_LOCKED|MASK_NO_FAST_MUTEX,"NFastSemaphore::Wait");

	NThreadBase* pC = NCurrentThreadL();

	__ASSERT_WITH_MESSAGE_ALWAYS(pC==a->iOwningThread,"The calling thread must own the semaphore","NFastSemaphore::Wait");

	}

extern "C" void __DebugMsgNKFSWait(NFastSemaphore* a)

	{

	__KTRACE_OPT(KNKERN,DEBUGPRINT("NFSW %m",a));

	NThreadBase* pC = NCurrentThread();

	__ASSERT_WITH_MESSAGE_ALWAYS(pC==a->iOwningThread,"The calling thread must own the semaphore","NKern::FSWait");

	}

extern "C" void __DebugMsgWFAR()

	{

	CHECK_PRECONDITIONS(MASK_THREAD_STANDARD,"NKern::WaitForAnyRequest");

	__KTRACE_OPT(KNKERN,DEBUGPRINT("WfAR"));

	}

extern "C" void __DebugMsgFSSignal(NFastSemaphore* /*a*/)

	{

	CHECK_PRECONDITIONS(MASK_KERNEL_LOCKED|MASK_NOT_ISR,"NFastSemaphore::Signal");

	}

extern "C" void __DebugMsgFSSignalN(NFastSemaphore* /*a*/, TInt aCount)

	{

	CHECK_PRECONDITIONS(MASK_KERNEL_LOCKED|MASK_NOT_ISR,"NFastSemaphore::SignalN");			

	__NK_ASSERT_DEBUG(aCount>=0);

	}

extern "C" void __DebugMsgNKThreadRequestSignalN(NThread* /*aThread*/, TInt aCount)

	{

	__ASSERT_WITH_MESSAGE_DEBUG(aCount>=0, "aCount>=0", "NKern::ThreadRequestSignal");

	}

extern "C" void __DebugMsgNKThreadRequestSignal(NThread* /*aThread*/)

	{

	}

extern "C" void __DebugMsgNKFSSignal(NFastSemaphore* a)

	{

	CHECK_PRECONDITIONS(MASK_INTERRUPTS_ENABLED|MASK_NOT_ISR,"NKern::FSSignal(NFastSemaphore*)");

	__KTRACE_OPT(KNKERN,DEBUGPRINT("NFSS %m",a));

	}

extern "C" void __DebugMsgNKFSSignalN(NFastSemaphore* a, TInt aCount)

	{

	CHECK_PRECONDITIONS(MASK_INTERRUPTS_ENABLED|MASK_NOT_ISR,"NKern::FSSignalN(NFastSemaphore*, TInt)");

	__KTRACE_OPT(KNKERN,DEBUGPRINT("NFSSN %m %d",a,aCount));

	__NK_ASSERT_DEBUG(aCount>=0);

	}

extern "C" void __DebugMsgFMSignal(NFastMutex* /*a*/)

	{

	CHECK_PRECONDITIONS(MASK_KERNEL_LOCKED,"NFastMutex::Signal");

	}

extern "C" void __DebugMsgNKFMWait(NFastMutex* a)

	{

	__KTRACE_OPT(KNKERN,DEBUGPRINT("NFMW %M", a));

	CHECK_PRECONDITIONS(MASK_THREAD_STANDARD,"NKern::FMWait");

	}

extern "C" void __DebugMsgNKFMSignal(NFastMutex* a)

	{

	__KTRACE_OPT(KNKERN,DEBUGPRINT("NFMS %M", a));

	CHECK_PRECONDITIONS(MASK_KERNEL_UNLOCKED | MASK_INTERRUPTS_ENABLED | MASK_NOT_ISR | MASK_NOT_IDFC, "NKern::FMSignal");

	__ASSERT_WITH_MESSAGE_DEBUG(a->HeldByCurrentThread(),"The calling thread holds the mutex","NKern::FMSignal");

	}

extern "C" void __DebugMsgNKFMFlash(NFastMutex* a)

	{

	CHECK_PRECONDITIONS(MASK_KERNEL_UNLOCKED | MASK_INTERRUPTS_ENABLED | MASK_NOT_ISR | MASK_NOT_IDFC, "NKern::FMFlash");

	__ASSERT_WITH_MESSAGE_DEBUG(a->HeldByCurrentThread(),"The calling thread holds the mutex","NKern::FMFlash");

	}

#endif

#if !defined(__UTT_MACHINE_CODED__)

void TSubScheduler::UpdateThreadTimes(NThreadBase* aOld, NThreadBase* aNew)

	{

	/* If necessary update local timer frequency (DVFS) */

	SRatioInv* pNCF = iSSX.iNewCpuFreqRI;

	if (pNCF)

		{

		iSSX.iCpuFreqRI = *pNCF;

		__e32_atomic_store_rel_ptr(&iSSX.iNewCpuFreqRI, 0);

		}

	SRatioInv* pNTF = iSSX.iNewTimerFreqRI;

	if (pNTF)

		{

		iSSX.iTimerFreqRI = *pNTF;

		__e32_atomic_store_rel_ptr(&iSSX.iNewTimerFreqRI, 0);

		}

	if (!aOld)

		aOld = iInitialThread;

	if (!aNew)

		aNew = iInitialThread;

	if (aNew!=aOld || aNew->iTime<=0 || pNTF)

		{

		TUint32 tmrval = 0x7fffffffu;

		if (aNew->iTime > 0)

			{

			tmrval = aNew->iTime;	// this will have been computed based on the old timer frequency

			iSSX.iTimerFreqRI.iR.Mult(tmrval);

			}

//		iSSX.iLastTimerSet = tmrval;

		iSSX.iLocalTimerAddr->iTimerCount = tmrval;

		}

	if (aNew!=aOld)

		{

		TUint64 now = NKern::Timestamp();

		TUint64 delta = now - iLastTimestamp.i64;

		iLastTimestamp.i64 = now;

		aOld->iLastRunTime.i64 = now;

		aOld->iTotalCpuTime.i64 += delta;

		++iReschedCount.i64;

		++aNew->iRunCount.i64;

		if (!aOld->iActiveState)

			aOld->iTotalActiveTime.i64 += (now - aOld->iLastActivationTime.i64);

		NSchedulable* parent = aOld->iParent;

		if (parent != aOld)

			{

			parent->iLastRunTime.i64 = now;

			if (!parent->iActiveState)

				parent->iTotalActiveTime.i64 += (now - parent->iLastActivationTime.i64);

			if (parent != aNew->iParent)

				parent->iTotalCpuTime.i64 += (now - parent->iLastStartTime.i64);

			}

		NSchedulable* np = aNew->iParent;

		if (np!=aNew && np!=parent)

			np->iLastStartTime.i64 = now;

		}

	}

#endif