// Copyright (c) 1994-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\kernel\stimer.cpp

// Note that timer handles are always thread relative

// 

//

#include <kernel/kern_priv.h>

#include "execs.h"

_LIT(KTimerThreadName,"TimerThread");

_LIT(KLitTimerMutex,"TimerMutex");

DMutex* TTickQ::Mutex;

const TInt KTimerThreadPriority=27;

const TInt KDaysFrom0ADTo2000AD=730497;		// See US_TIME.CPP to verify this

const TInt KSecondsPerDay=86400;

const TInt KMaxSkippedTicks=65536;

const TInt KMsDeltaLimit=2000000;

#define __CHECK_LAST_DELTA	if (TUint32(iLastDelta)>TUint32(KMaxSkippedTicks)) {NKern::Lock(); *(TInt*)0xfeedface=iLastDelta;}

/** Gets the address of the tick timer DFC queue.

	@return The tick timer DFC queue.

*/

EXPORT_C TDfcQue* Kern::TimerDfcQ()

	{

	return K::TimerDfcQ;

	}

TInt K::StartTickQueue()

	{

	TInt r=Kern::MutexCreate(TTickQ::Mutex, KLitTimerMutex, KMutexOrdTimer);

	if (r!=KErrNone)

		return r;

	r=Kern::DfcQCreate(K::TimerDfcQ,KTimerThreadPriority,&KTimerThreadName);

	if (r!=KErrNone)

		return r;

	DThread* pT = _LOFF(K::TimerDfcQ->iThread, DThread, iNThread);

	pT->iFlags |= KThreadFlagSystemPermanent;

	K::SecondQ=new TSecondQ;

	if (!K::SecondQ)

		return KErrNoMemory;

	K::InactivityQ=new TInactivityQ;

	if (!K::InactivityQ)

		return KErrNoMemory;

	r=TTickQ::Init();

	if (r!=KErrNone)

		return r;

	return KErrNone;

	}

void AbortTimers(TBool aAbortAbsolute)

	{

	DObjectCon& timers=*K::Containers[ETimer];

	DObjectCon& threads=*K::Containers[EThread];

	timers.Wait();

	TInt c=timers.Count();

	TInt i;

	for (i=0; i<c; i++)

		{

		DTimer* pT=(DTimer*)timers[i];

		pT->Abort(aAbortAbsolute);

		}

	timers.Signal();

	threads.Wait();

	c=threads.Count();

	for (i=0; i<c; i++)

		{

		DThread* pT=(DThread*)threads[i];

		pT->AbortTimer(aAbortAbsolute);

		}

	threads.Signal();

	}

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

 * Tick-based relative timer queue

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

void msCallBack(TAny* aPtr)

	{

//	__KTRACE_OPT(KTIMING,Kern::Printf("!"));

	TTickQ& q=*(TTickQ*)aPtr;

	q.iTickDfc.Add();

	}

void tickDfc(TAny* aPtr)

	{

	TTickQ& q=*(TTickQ*)aPtr;

	__ASSERT_DEBUG(q.iMsTimer.i_NTimer_iState==NTimer::EIdle, *(TInt*)0xdfc01bad=0);

	__ASSERT_DEBUG(!q.iTickDfc.Queued(), *(TInt*)0xdfc02bad=0);

	__ASSERT_DEBUG(NTickCount()-q.iMsTimer.iTriggerTime<0x80000000u, *(TInt*)0xdfc03bad=0);

	q.Tick();

	}

TTickQ::TTickQ()

	:	iLastDelta(0), iLastTicks(0), iRtc(0), iInTick(0),

		iRounding(0),

		iPrevRounding(0),

		iLastMs(0),

		iTickDfc(tickDfc,this,1),

		iMsTimer(msCallBack,this)

	{

	// Careful with the constants here or GCC will get it wrong

	K::Year2000InSeconds=Int64(KDaysFrom0ADTo2000AD)*Int64(KSecondsPerDay);

	}

#ifdef _DEBUG

void TTickQ::Check()

	{

	__ASSERT_DEBUG(iMsTimer.i_NTimer_iState==NTimer::EIdle, *(TInt*)0xdfc03bad=0);

	__ASSERT_DEBUG(!iTickDfc.Queued(), *(TInt*)0xdfc04bad=0);

	}

#endif

TInt TTickQ::Init()

	{

	TTickQ* pQ=new TTickQ;

	if (!pQ)

		return KErrNoMemory;

	K::TickQ=pQ;

	pQ->iTickDfc.SetDfcQ(K::TimerDfcQ);

	pQ->iMsTickPeriod=NTickPeriod();

	_LOFF(K::TimerDfcQ->iThread,DThread,iNThread)->iDebugMask=0x80000000;

	// These lines are tick-period dependent

	// Assume we can always set the tick period to 64Hz

	pQ->iTickPeriod=15625;

	pQ->iNominalTickPeriod=15625;

	pQ->iTicksPerSecond=64;

	K::SecondQ->iTicksPerDay=86400*64;

	TInt s2000=P::InitSystemTime();

	__KTRACE_OPT(KBOOT,Kern::Printf("s2000=%d",s2000));

	pQ->iMsTimer.iTriggerTime=NTickCount();

	pQ->iLastMs=pQ->iMsTimer.iTriggerTime;

	TUint temp = 0;

	K::SetSystemTime(s2000,0,temp,ETimeSetTime|ETimeSetAllowTimeReversal);

//	Int64 now=s2000;

//	now*=1000000;

//	now+=K::Year2000;

//	now/=pQ->iNominalTickPeriod;

//	pQ->iRtc=now;

//	TInt seconds=s2000%86400;

//	__KTRACE_OPT(KBOOT,Kern::Printf("seconds=%d",seconds));

//	now+=(86400-seconds)*pQ->iTicksPerSecond;

//	K::SecondQ->iMidnight=now;

	pQ->iMsTimer.i_NTimer_iUserFlags = ETrue;	// used as start flag

	TTickQ::Wait();

	K::SecondQ->Tick();		// start the second queue

	K::TickQ->Tick();		// start the tick queue

	TTickQ::Signal();

	return KErrNone;

	}

void TTickQ::Wait()

	{

	if (Mutex)

		Kern::MutexWait(*Mutex);

	}

void TTickQ::Signal()

	{

	if (Mutex)

		Kern::MutexSignal(*Mutex);

	}

void TTickQ::Tick()

	{

	Wait();

	__KTRACE_OPT(KTIMING,Kern::Printf("Tick!: l%d e%d",iLastDelta,IsEmpty()));

	// Make sure this DFC hasn't been queued again - this can happen if someone calls Add()

	// between this DFC being dispatched and executing the Wait() above; priority inheritance

	// can make this happen more often than you might expect.

	if (iTickDfc.Queued())

		iTickDfc.Cancel();

	if (K::SecondQ->iWakeUpDfc.Queued())

		{

		Signal();

		return;

		}

	iInTick=ETrue;

	Update();

	if (!IsEmpty() && CountDown(iLastDelta)) // Anything ready to be completed ?

		{

		__KTRACE_OPT(KTIMING,Kern::Printf("Tick!: f%d",FirstDelta()));

		TTickLink* pT;

		while (!IsEmpty() && (pT=(TTickLink*)RemoveFirst())!=NULL)

			{

			pT->iNext=NULL;					// In case Complete() calls TTickLink::Cancel()

			(*pT->iCallBack)(pT->iPtr);		// Dispatch the timer completion

#ifdef _DEBUG

			Check();

#endif

			if (pT->iNext==NULL && pT->iPeriod!=0)		// Periodic timer

				Add(pT,pT->iPeriod);

#ifdef _DEBUG

			Check();

#endif

			}

		}

	StartTimer();

	iInTick=EFalse;

	Signal();

	}

void TTickQ::Update()

	{

	TInt irq = __SPIN_LOCK_IRQSAVE(TheTimerQ.iTimerSpinLock);

	iLastMs=iMsTimer.iTriggerTime;

	iLastTicks+=iLastDelta;

	iRtc+=iLastDelta;

	__SPIN_UNLOCK_IRQRESTORE(TheTimerQ.iTimerSpinLock,irq);

	iPrevRounding=iRounding;

	}

void TTickQ::StartTimer()

	{

	TInt delta=KMaxTInt;

	if (!IsEmpty())

		delta=FirstDelta();

	if (delta>KMaxSkippedTicks)			// so that microseconds don't overflow

		delta=KMaxSkippedTicks;

	TInt delta_us=delta*iTickPeriod;	// number of microseconds to next timer expiry

	__KTRACE_OPT(KTIMING,Kern::Printf("Tick:delta_us=%d, prdg=%d",delta_us,iPrevRounding));

	delta_us-=iPrevRounding;			// subtract rounding error on last completed ms timer

	TInt msp=iMsTickPeriod;

	TInt delta_ms=(delta_us+(msp>>1))/msp;	// round to milliseconds

	iRounding=msp*delta_ms-delta_us;	// save rounding error on this timer

	iLastDelta=delta;					// save number of ticks

	__CHECK_LAST_DELTA;

	__ASSERT_DEBUG(!iTickDfc.Queued(), *(TInt*)0xdfc00bad=0);

	TInt r=KErrNone;

	if (iMsTimer.i_NTimer_iUserFlags)

		{

		iMsTimer.i_NTimer_iUserFlags = EFalse;

		iMsTimer.OneShot(delta_ms);		// start timer for the first time

		}

	else

		r=iMsTimer.Again(delta_ms);	// start timer

	__KTRACE_OPT(KTIMING,Kern::Printf("Tick:delta=%d, r=%d, lastdelta=%d, rdg=%d",delta_ms,r,iLastDelta,iRounding));

	if (r!=KErrNone)

		{

		__ASSERT_ALWAYS(r==KErrArgument, *(TInt*)0xbad0beef=r);

		// requested time has already passed so manually requeue the DFC

		iMsTimer.iTriggerTime+=delta_ms;

		iTickDfc.Enque();

		}

	}

// Wait on mutex before calling this

void TTickQ::Add(TTickLink* aLink, TInt aPeriod)

	{

	__KTRACE_OPT(KTIMING,Kern::Printf("Tick:Add p%d i%d ld%d",aPeriod, iInTick, iLastDelta));

	SDeltaQue::Add(aLink,aPeriod);

	if (!iInTick && aPeriod<iLastDelta)

		{

		// need to reset millisecond timer

		if (iMsTimer.Cancel())

			{

			// the timer was actually cancelled - so it hadn't expired

			iMsTimer.iTriggerTime=iLastMs;

			StartTimer();

			}

		}

	}

void TTickQ::Synchronise()

//

// Update everything as if a tick had just occurred

// Call with system unlocked and timer mutex held

//

	{

	TInt ms_delta=(TInt)(NTickCount()-iLastMs-1);

	__ASSERT_ALWAYS(ms_delta<KMsDeltaLimit,K::Fault(K::ESynchroniseMsDeltaTooBig));

	TInt msp=iMsTickPeriod;

	TInt us_delta=ms_delta*msp+iPrevRounding;

	TInt tick_delta=us_delta/iTickPeriod;

	if (tick_delta>iLastDelta)

		tick_delta=iLastDelta;

	us_delta=tick_delta*iTickPeriod-iPrevRounding;

	ms_delta=(us_delta+(msp>>1))/msp;

	iPrevRounding=msp*ms_delta-us_delta;

	iLastDelta-=tick_delta;

	TInt irq = __SPIN_LOCK_IRQSAVE(TheTimerQ.iTimerSpinLock);

	iRtc+=tick_delta;

	iLastTicks+=tick_delta;

	iLastMs+=ms_delta;

	__SPIN_UNLOCK_IRQRESTORE(TheTimerQ.iTimerSpinLock,irq);

	__CHECK_LAST_DELTA;

	if (!IsEmpty())

		{

		CountDown(tick_delta);

		__ASSERT_ALWAYS(FirstDelta()>=0, *(TInt*)0xfacefeed=FirstDelta());

		}

	}

/**

Rounds up microseconds into the number of Kernel Ticks(1/64Hz). 

@param a	if >=0, the number of microseconds;

			if < 0, ABS(a) is the number of Kernel Ticks.

@par aAdjust if true, the elapsed time from the last Kernel Tick is also taken into account.

*/

TInt MicroSecondsToTicks(TInt a, TBool aAdjust)

	{

	TUint32 p=K::TickQ->iTickPeriod;

	if (a<0)

		{

		TUint32 b=(TUint32)(-a);

		if (aAdjust)

   			b+=((NTickCount()-K::TickQ->iLastMs-1)* K::TickQ->iMsTickPeriod + p - 1)/p;

		if (b>(TUint32)KMaxTInt) b=KMaxTInt;

		return b;

		}

	if (a==0)

		a=1;

	TUint32 b=(TUint32)a;

	if (aAdjust)

		b += (TInt)(NTickCount()-K::TickQ->iLastMs-1)*K::TickQ->iMsTickPeriod;

	return (TInt)((b+p-1)/p);

	}

/**

Constructor for a tick timer.

@pre Calling thread must be in a critical section.

@pre Call in a thread context.

@pre Kernel must be unlocked

@pre interrupts enabled

*/

EXPORT_C TTickLink::TTickLink()

	{

	CHECK_PRECONDITIONS(MASK_KERNEL_UNLOCKED|MASK_INTERRUPTS_ENABLED|MASK_NOT_ISR|MASK_NOT_IDFC|MASK_CRITICAL,"TTickLink::TTickLink");

	iNext=NULL;

	iLastLock=-1;

	}

/** @internalComponent */

void TTickLink::DoCancel()

	{

	iPeriod=0;

	if (iNext)

		{

		K::TickQ->Remove(this);

		iNext=NULL;

		}

	}

/**

Adds this periodic tick timer to the tick timer queue.

On expiry, the timer is put back onto the tick timer queue.

@param aPeriod   The timer interval in microseconds.

@param aCallBack The callback function that is called every time

                 this periodic timer expires.

@param aPtr      An argument that is passed to the callback function.

@pre Calling thread must be in a critical section.

@pre No fast mutex can be held.

@pre Call in a thread context.

@pre Kernel must be unlocked

@pre interrupts enabled

*/

EXPORT_C void TTickLink::Periodic(TInt aPeriod, TTickCallBack aCallBack, TAny* aPtr)

	{

	CHECK_PRECONDITIONS(MASK_THREAD_CRITICAL,"TTickLink::Periodic");

	TTickQ::Wait();

	DoCancel();

	iPeriod=MicroSecondsToTicks(aPeriod, EFalse);

	iCallBack=aCallBack;

	iPtr=aPtr;

	K::TickQ->Add(this,MicroSecondsToTicks(aPeriod, ETrue));

	TTickQ::Signal();

	}

/**

Adds this one-off tick timer to the tick timer queue.

@param aTime     The timer interval in microseconds.

@param aCallBack The callback function that is called when this timer expires.

@param aPtr      An argument that is passed to the callback function.

@pre Calling thread must be in a critical section.

@pre No fast mutex can be held.

@pre Call in a thread context.

@pre Kernel must be unlocked

@pre interrupts enabled

*/

EXPORT_C void TTickLink::OneShot(TInt aTime, TTickCallBack aCallBack, TAny* aPtr)

	{

	CHECK_PRECONDITIONS(MASK_THREAD_CRITICAL,"TTickLink::OneShot");

	TTickQ::Wait();

	DoCancel();

	iCallBack=aCallBack;

	iPtr=aPtr;

	K::TickQ->Add(this,MicroSecondsToTicks(aTime, ETrue));

	TTickQ::Signal();

	}

/**

Cancels this tick timer.

This timer object is removed from the tick timer queue.

@pre Calling thread must be in a critical section.

@pre No fast mutex can be held.

@pre Call in a thread context.

@pre Kernel must be unlocked

@pre interrupts enabled

*/

EXPORT_C void TTickLink::Cancel()

	{

	CHECK_PRECONDITIONS(MASK_THREAD_CRITICAL,"TTickLink::Cancel");

	TTickQ::Wait();

	DoCancel();

	TTickQ::Signal();

	}

/**

Adds this tick timer to the tick timer queue.

@param aTicks    The timer interval in ticks. This is expected to be

                 the tick count for the next lock.

@param aCallBack The callback function that is called when this timer expires.

@param aPtr      An argument that is passed to the callback function.

@pre Calling thread must be in a critical section.

@pre No fast mutex can be held.

@pre Call in a thread context.

@pre Kernel must be unlocked

@pre interrupts enabled

*/

EXPORT_C void TTickLink::Lock(TInt aTicks, TTickCallBack aCallBack, TAny* aPtr)

	{

	CHECK_PRECONDITIONS(MASK_THREAD_CRITICAL,"TTickLink::Lock");

	TTickQ::Wait();

	DoCancel();

	iCallBack=aCallBack;

	iPtr=aPtr;

	K::TickQ->Add(this, aTicks);

	TTickQ::Signal();

	}

/**

	Get the tick count for the next lock.

	THIS FUNCTION ASSUMES 64 TICKS PER SECOND

	@return KErrGeneral with aTickCount = number of ticks until ETwelveOClock if the

			requested lock is more than 1 second from the last completed lock.

			KErrNone with aTickCount = number of ticks until the next aMark otherwise.

	@pre	Wait on TimerMutex before calling this.

	@internalComponent

*/

TInt TTickLink::GetNextLock(TTimerLockSpec aLock, TInt& aTickCount) const

	{

	__ASSERT_WITH_MESSAGE_MUTEX(TTickQ::Mutex,"Wait on TimerMutex before calling this","TTickLink::GetNextLock");

	TTickQ& tq=*K::TickQ;

	tq.Synchronise();

	TUint odd_ticks=TUint(tq.iRtc)&63;

	TUint lock_ticks=((aLock+1)*64+6)/12;

	Int64 second=tq.iRtc-odd_ticks;

	Int64 next_lock=second+lock_ticks;

	if (next_lock<=tq.iRtc)

		next_lock+=64;

	if (next_lock-iLastLock>64)

		{

		// Lock on ETwelveOClock

		aTickCount=64-odd_ticks;

		__KTRACE_OPT(KTIMING,Kern::Printf("GS%x",aTickCount));

		return KErrGeneral;

		}

	// Lock on aMark

	aTickCount=TInt(next_lock-tq.iRtc);

	__KTRACE_OPT(KTIMING,Kern::Printf("GL%x",aTickCount));

	return KErrNone;

	}

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

 * Absolute timer queue

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

void TSecondQ::TickCallBack(TAny* aPtr)

	{

	((TSecondQ*)aPtr)->Tick();

	}

void TSecondQ::WakeUpDfc(TAny* aPtr)

	{