// 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)
	{
	TSecondQ& sq=*(TSecondQ*)aPtr;
	TTickQ& tq=*K::TickQ;
	TTickQ::Wait();
	__ASSERT_ALWAYS(tq.iInTick,K::Fault(K::ETickQNotLocked));
	sq.iTimer.DoCancel();	// make sure second queue timer is stopped
	sq.Tick();				// call back any timers which have already expired and restart second queue
	if (!tq.IsEmpty() && tq.FirstDelta()<=0) // Anything ready to be completed now?
		tq.Tick();				// restart tick queue
	else
		{
		tq.StartTimer();		// restart tick queue
		tq.iInTick=EFalse;
		}
	TTickQ::Signal();
	}

TSecondQ::TSecondQ()
:	iInTick(0), iWakeUpDfc(WakeUpDfc,this,K::TimerDfcQ,2)
	{
	iTimer.iPtr=this;
	iTimer.iCallBack=TickCallBack;
	}

void TSecondQ::Tick()
	{
	// Called in tick timer callback, so mutex already held
	// RTC value already incremented
	Int64 rtc=K::TickQ->iRtc;
	iInTick=ETrue;
	if (rtc==iMidnight)
		{
		iMidnight+=iTicksPerDay;
		Kern::AsyncNotifyChanges(EChangesMidnightCrossover);
		}
	while (!IsEmpty())
		{
		TSecondLink* pS=(TSecondLink*)First();
		if (pS->iTime>rtc)
			break;
		if (K::PowerModel)
			K::PowerModel->AbsoluteTimerExpired();
		pS->Deque();
		pS->iNext=NULL;
		(*pS->iCallBack)(pS->iPtr);
		}
	StartTimer();
	iInTick=EFalse;
	}

void TSecondQ::StartTimer()
	{
	TSecondLink* pS=(TSecondLink*)First();
	Int64 rtc=K::TickQ->iRtc;
	TInt delta=(TInt)(iMidnight-rtc);		// ticks before midnight
	if (pS!=&iA)
		{
		Int64 delta64=pS->iTime-rtc;		// ticks before next timer
		if (delta64<delta)
			delta=(TInt)delta64;
		}
	iNextTrigger=rtc+delta;
	K::TickQ->Add(&iTimer, delta);
	}

// Wait on mutex before calling this
void TSecondQ::Add(TSecondLink* aLink)
	{
	Int64 time=aLink->iTime;
	TSecondLink* pS=(TSecondLink*)First();
	SDblQueLink* anchor=&iA;
	while(pS!=anchor && pS->iTime<=time)
		pS=(TSecondLink*)pS->iNext;
	aLink->InsertBefore(pS);
	if (!iInTick && time<iNextTrigger)
		{
		iTimer.DoCancel();
		StartTimer();
		}
	}

TInt TSecondQ::FirstDelta()
	{
	if (IsEmpty())
		return KMaxTInt;
	TSecondLink* pS=(TSecondLink*)First();
	TTimeK first=pS->iTime*K::TickQ->iNominalTickPeriod;
	TTimeK now=Kern::SystemTime();
	Int64 delta=first-now;
	delta/=1000000;
	if (delta>KMaxTInt)
		return KMaxTInt;
	return (TInt)delta;
	}

TTimeK TSecondQ::WakeupTime()
//
// Called machine goes to standby
// Timer mutex is already held
//
	{
	if (IsEmpty())
		return 0;
	TSecondLink* pS=(TSecondLink*)First();
	return pS->iTime*K::TickQ->iNominalTickPeriod;
	}

void TSecondQ::WakeUp()
//
// Called after machine wakes up
// Timer mutex is already held
//
	{
    TInt secs;
	AbortTimers(EFalse);							// abort any locked timers
	TInt r=A::SystemTimeInSecondsFrom2000(secs);	// get hardware RTC value
	TUint changes = 0;
	if (r==KErrNone)
		{
		// Apply nonsecure offset if secure clock in use
		if (K::SecureClockStatus == ESecureClockOk)		
			{
			secs += K::NonSecureOffsetSeconds;
			}
		K::TickQ->Synchronise();
		r=K::SetSystemTime(secs,0,changes,ETimeSetTime);		// update K::SecondQ->iRtc, don't allow it to go backwards
		__KTRACE_OPT(KPOWER,Kern::Printf("new time=%d, r=%d",secs,r));
		}
	K::InactivityQ->Reset();
	if (r<0)
		return;									// time has not changed

	if (!K::TickQ->iInTick)						// if iInTick is already set, wake up DFC is already queued
		{
		K::TickQ->iInTick=ETrue;				// stop anyone else restarting timer queues
		iWakeUpDfc.Enque();						// this will restart the timer queues
		}
	if (changes & EChangesMidnightCrossover)
		Kern::AsyncNotifyChanges(EChangesMidnightCrossover);
	}




/**
Constructor for a second 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 TSecondLink::TSecondLink()
	{
	CHECK_PRECONDITIONS(MASK_KERNEL_UNLOCKED|MASK_INTERRUPTS_ENABLED|MASK_NOT_ISR|MASK_NOT_IDFC|MASK_CRITICAL,"TSecondLink::TSecondLink");
	iNext=NULL;
	}




/**
Adds this timer to the second timer queue.

@param aUTCTime The absolute date and time when the timer is to expire, in UTC.
@param aCallBack The callback function that is called when this timer expires.
@param aPtr      An argument that is passed to the callback function.

@return KErrNone, if successful;
        KErrUnderflow, if the specified time is earlier than the system time.
        KErrOverflow, if the specified time is too big.

@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 TInt TSecondLink::At(const TTimeK& aUTCTime, TSecondCallBack aCallBack, TAny* aPtr)
	{
	CHECK_PRECONDITIONS(MASK_THREAD_CRITICAL,"TSecondLink::At");
	TTickQ::Wait();
	iTime=aUTCTime;
	iCallBack=aCallBack;
	iPtr=aPtr;
	if (iTime<=Kern::SystemTime())
		{
		TTickQ::Signal();
		return KErrUnderflow;
		}
	iTime=(iTime+999999)/1000000;		// seconds from 00:00:00 01-01-0000 UTC, rounded up
	Int64 y2k=Int64(KDaysFrom0ADTo2000AD)*Int64(KSecondsPerDay);
	Int64 delta2k=iTime-y2k;
	if (delta2k>KMaxTInt)
		{
		TTickQ::Signal();
		return KErrOverflow;
		}
	iTime*=K::TickQ->iTicksPerSecond;
	K::SecondQ->Add(this);
	TTickQ::Signal();
	return KErrNone;
	}




/**
Cancels this timer.

This timer object is removed from the second 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 TSecondLink::Cancel()
//
// Cancel a pending timer.
//
	{
	CHECK_PRECONDITIONS(MASK_THREAD_CRITICAL,"TSecondLink::Cancel");
	TTickQ::Wait();
	if (iNext)
		{
		Deque();
		iNext=NULL;
		}
	TTickQ::Signal();
	}

/********************************************
 * Inactivity timer queue
 ********************************************/
/**
Constructor for an inactivity 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 TInactivityLink::TInactivityLink()
	{
	CHECK_PRECONDITIONS(MASK_KERNEL_UNLOCKED|MASK_INTERRUPTS_ENABLED|MASK_NOT_ISR|MASK_NOT_IDFC|MASK_CRITICAL,"TInactivityLink::TInactivityLink");
	iNext=NULL;
	}




/**
Adds this inactivity timer to the inactivity timer queue.

@param aSeconds  The period of inactivity needed to trigger this timer, in seconds.
@param aCallBack The callback function that is called when this timer expires.
@param aPtr      An argument that is passed to the callback function.

@return KErrNone, if successful;
        KErrArgument, if aSeconds is negative;
        KErrOverflow, if the number of ticks corresponding to aSeconds
        overflows a 32 bit signed integer.

@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 TInt TInactivityLink::Start(TInt aSeconds, TInactivityCallBack aCallBack, TAny* aPtr)
	{
	CHECK_PRECONDITIONS(MASK_THREAD_CRITICAL,"TInactivityLink::Start");
	// Time period can't be more than 2^31 ticks (just over 1 year at 64Hz)
	TTickQ& tq=*K::TickQ;
	TInactivityQ& iq=*K::InactivityQ;
	if (aSeconds<0)
		return KErrArgument;
	Int64 ticks(aSeconds);
	ticks*=Int64(tq.iTicksPerSecond);
	if (ticks>KMaxTInt)
		return KErrOverflow;
	TTickQ::Wait();
	if (iNext)
		{
		Deque();
		iNext=NULL;
		}
	iTime=(TUint32)ticks;
	iPtr=aPtr;
	iCallBack=aCallBack;
	TUint32 tc=Kern::TickCount();
	NKern::LockSystem();
	TUint32 lev = iq.iLastEventTime;
	SDblQue* pQ=&iq;
	if (tc-lev>=iTime)
		{
		pQ=&iq.iPending;
		if (pQ->IsEmpty())
			{
			// adding to empty pending queue, do with system lock held
			// to prevent race with AddEvent
			pQ->Add(this);
			pQ=NULL;
			}
		}
	NKern::UnlockSystem();
	if (pQ)
		{
		TInactivityLink* pL=(TInactivityLink*)pQ->First();
		while (pL!=&pQ->iA && pL->iTime<=iTime)
			pL=(TInactivityLink*)pL->iNext;
		InsertBefore(pL);
		if (pQ==&iq && iq.First()==this && !iq.iInTick)
			{
			// need to restart tick timer
			iq.iTimer.DoCancel();
			tq.Add(&iq.iTimer, iTime+lev-tq.iLastTicks);
			}
		}
	TTickQ::Signal();
	return KErrNone;
	}




/**
Cancels this inactivity timer.

This timer object is removed from the inactivity 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 TInactivityLink::Cancel()
	{
	CHECK_PRECONDITIONS(MASK_THREAD_CRITICAL,"TInactivityLink::Cancel");
	TTickQ::Wait();
	if (iNext)
		{
		NKern::LockSystem();
		Deque();
		NKern::UnlockSystem();
		iNext=NULL;
		}
	TTickQ::Signal();
	}

void TInactivityQ::TimerCallBack(TAny* aPtr)
	{
	((TInactivityQ*)aPtr)->Expired(ETrue);
	}

void TInactivityQ::EventDfcFn(TAny* aPtr)
	{
	((TInactivityQ*)aPtr)->EventDfc();
	}

TInactivityQ::TInactivityQ()
	:	iLastEventTime(0),
		iInTick(EFalse),
		iEventDfc(EventDfcFn,this,K::TimerDfcQ,1)
	{
	iTimer.iPtr=this;
	iTimer.iCallBack=TimerCallBack;
	}

void TInactivityQ::Reset()
	{
	TUint32 tc=Kern::TickCount();
	NKern::LockSystem();
	iLastEventTime=tc;
	if (!iPending.IsEmpty())
		iEventDfc.Enque(SYSTEM_LOCK);
	else
		NKern::UnlockSystem();
	}

TInt TInactivityQ::InactiveTime()
	{
	TUint32 lev=iLastEventTime;
	TUint32 tc=Kern::TickCount();
	tc-=lev;
	if (tc>0x80000000u)
		tc=0x80000000u;
	tc/=K::TickQ->iTicksPerSecond;
	return (TInt)tc;
	}

void TInactivityQ::Expired(TBool aTicksUpdated)
	{
	// called in tick timer call back, so timer mutex held
	TTickQ& tq=*K::TickQ;
	TUint32 tc;
	if (aTicksUpdated)
		tc=tq.iLastTicks-iLastEventTime;
	else
		tc=Kern::TickCount()-iLastEventTime;
	iInTick=ETrue;
	while (!IsEmpty())
		{
		TInactivityLink* pI=(TInactivityLink*)First();
		if (tc<pI->iTime)
			{
			tq.Add(&iTimer, pI->iTime-tc);
			break;
			}
		pI->Deque();
		pI->iNext=NULL;
		(*pI->iCallBack)(pI->iPtr);
		}
	iInTick=EFalse;
	}

void TInactivityQ::EventDfc()
	{
	// called after an event to transfer pending timers to active queue
	TTickQ::Wait();

	SDblQueLink* anchor=&iA;
	TInactivityLink* pActL=(TInactivityLink*)iA.iNext;	// first active timer
	TInactivityLink* pOldFirstActive=pActL;

	while (!iPending.IsEmpty())
		{
		TInactivityLink* pPendL=(TInactivityLink*)iPending.First();
		pPendL->Deque();
		TUint32 pending_time=pPendL->iTime;
		while (pActL!=anchor && pending_time>=pActL->iTime)
			pActL=(TInactivityLink*)pActL->iNext;	// loop until pActL expires after pPendL
		pPendL->InsertBefore(pActL);				// add pending one before first later one
		// leave pActL where it is - OK since pending Q is ordered
		}

	// prevent double calling of this DFC
	// pending queue can only become nonempty by adding a TInactivityLink
	// which would require TTickQ::Wait() to be called
	iEventDfc.Cancel();

	pActL=(TInactivityLink*)iA.iNext;	// first active timer
	if (pActL!=pOldFirstActive)
		{
		// need to restart tick timer
		iTimer.DoCancel();
		Expired(EFalse);
		}

	TTickQ::Signal();
	}

/********************************************
 * DTimer class
 ********************************************/
DTimer::DTimer()
	{}

DTimer::~DTimer()
	{
	// cancel timer before destroying
	Cancel();
	}

TInt DTimer::Create(DThread *aThread)
//
// Create a Timer. Always owned by a thread.
//
	{
	__KTRACE_OPT(KTHREAD,Kern::Printf("DTimer::Create thread %O",aThread));
	SetOwner(aThread);
	return iTimer.Create();
	}

TInt DTimer::RequestUserHandle(DThread* aThread, TOwnerType aType)
	{
	if (aThread!=Owner() || aType!=EOwnerThread)
		return KErrPermissionDenied;
	return KErrNone;
	}

void DTimer::TimerComplete(TAny* aPtr)
//
// Called when the relative timer completes.
//
	{
	DTimer* pT=FromPtr(aPtr);
	if (pT->iTimer.iState == TTimer::EWaiting)
		{
		Kern::QueueRequestComplete(pT->Owner(),pT->iTimer.iRequest,KErrNone);
		pT->iTimer.iState = (TUint8)TTimer::EIdle;
		}
	}

void DTimer::SecondComplete(TAny* aPtr)
//
// Called when the absolute timer completes.
//
	{
	DTimer* pT=FromPtr(aPtr);
	if (pT->iTimer.iState == TTimer::EWaiting)
		{
		Kern::QueueRequestComplete(pT->Owner(),pT->iTimer.iRequest,KErrNone);
		pT->iTimer.iState = (TUint8)TTimer::EIdle;
		}
	}

void DTimer::LockComplete(TAny* aPtr)
//
// Called when the locked timer completes.
//
	{
	DTimer* pT=(DTimer*)aPtr;
	if (pT->iTimer.iState == TTimer::EWaiting)
		{
		pT->iTimer.TickLink().iLastLock=K::TickQ->iRtc;
		__KTRACE_OPT(KTIMING,Kern::Printf("LC%lx",pT->iTimer.TickLink().iLastLock));
		Kern::QueueRequestComplete(pT->Owner(),pT->iTimer.iRequest,KErrNone);
		pT->iTimer.iState = (TUint8)TTimer::EIdle;
		}
	}

void DTimer::LockSynchronize(TAny* aPtr)
//
// Called when the locked timer synchronises
//
	{
	DTimer* pT=(DTimer*)aPtr;
	if (pT->iTimer.iState == TTimer::EWaiting)
		{
		pT->iTimer.TickLink().iLastLock=K::TickQ->iRtc;
		__KTRACE_OPT(KTIMING,Kern::Printf("LS%lx",pT->iTimer.TickLink().iLastLock));
		Kern::QueueRequestComplete(pT->Owner(),pT->iTimer.iRequest,KErrGeneral);
		pT->iTimer.iState = (TUint8)TTimer::EIdle;
		}
	}

void DTimer::MsComplete(TAny* aTimer)
	{
	// called in DFC, system unlocked
	DTimer* pT=FromPtr(aTimer);
	NKern::LockSystem();
	pT->iTimer.iState = (TUint8)TTimer::EIdle;
	Kern::QueueRequestComplete(pT->Owner(), pT->iTimer.iRequest,KErrNone);
	NKern::UnlockSystem();
	}

void DTimer::HighRes(TRequestStatus& aStatus, TInt anInterval)
	{
	// enter and return with system locked
	TInt r=iTimer.AfterHighRes(anInterval,MsComplete,aStatus);
	if (r!=KErrNone)
		K::PanicCurrentThread(ETimerAlreadyPending);
	}

void DTimer::Cancel()
//
// Cancel an outstanding request.
// system unlocked here
//
	{
	iTimer.Cancel(Owner());
	}

void DTimer::Abort(TBool aAbortAbsolute)
//
// Abort an outstanding request.
// TimerMutex is already held here.
//
	{
	TInt typeMask=aAbortAbsolute?(TTimer::ELocked|TTimer::EAbsolute):(TTimer::ELocked);
	iTimer.Abort(Owner(),typeMask);
	}

TInt DTimer::After(TRequestStatus& aStatus, TInt anInterval)
//
// Request a relative time.
// System is unlocked here
//
	{
	return iTimer.After(anInterval,TimerComplete,aStatus);
	}

TInt DTimer::At(TRequestStatus& aStatus, const TTimeK& aTime)
//
// Request an absolute time.
//
	{
	return iTimer.At(aTime,SecondComplete,aStatus);
	}

TInt DTimer::Inactivity(TRequestStatus& aStatus, TInt aSeconds)
//
// Request an inactivity time.
//
	{
	return iTimer.Inactivity(aSeconds,TimerComplete,aStatus);
	}

TInt DTimer::Lock(TRequestStatus& aStatus, TTimerLockSpec aLock)
//
// Request a synchronisation lock to a fraction of a second.
//
	{
	TTickQ::Wait();
	NKern::LockSystem();
	if (iTimer.iState != TTimer::EIdle || iTimer.iRequest->SetStatus(&aStatus) != KErrNone)
		{
		NKern::UnlockSystem();
		TTickQ::Signal();
		return KErrInUse;
		}
	iTimer.iState = (TUint8)TTimer::EWaiting;
	if (iTimer.Type()!=TTimer::ELocked)
		iTimer.SetType(TTimer::ELocked);
	NKern::UnlockSystem();
	TInt ticks;
	TInt r=iTimer.TickLink().GetNextLock(aLock, ticks);
	if (r==KErrNone)
		iTimer.TickLink().Lock(ticks,LockComplete,this);
	else
		iTimer.TickLink().Lock(ticks,LockSynchronize,this);
	TTickQ::Signal();
	return KErrNone;
	}


/********************************************
 * Multipurpose timer
 ********************************************/

TInt TTimer::Create()
	{
	return Kern::CreateClientRequest(iRequest);
	}

TTimer::~TTimer()
	{
	Kern::DestroyClientRequest(iRequest);
	}

void TTimer::SetType(TTimerType aType)
	{
	switch (aType)
		{
		case ERelative:
		case ELocked:
			new (&TickLink()) TTickLink;
			break;
		case EAbsolute:
			new (&SecondLink()) TSecondLink;
			break;
		case EHighRes:
			break;
		case EInactivity:
			new (&Inact()) TInactivityLink;
			break;
		default:
			K::Fault(K::EBadTimerType);
		}
	iType=(TUint8)aType;
	}

TInt TTimer::AfterHighRes(TInt anInterval, NTimerFn aFunction, TRequestStatus& aStatus)
	{
	// enter and return with system locked
	if (iState!=EIdle || iRequest->SetStatus(&aStatus) != KErrNone)
		return KErrInUse;
	iState = (TUint8)EWaitHighRes;
	SetType(EHighRes);
	TInt msp=NTickPeriod();
	TInt t=(TInt)(((TUint)anInterval+msp-1)/msp);	// convert microseconds to milliseconds, rounding up
	new (&Ms()) NTimer(aFunction,this);
	Ms().OneShot(t,ETrue);			// start millisecond timer, complete in DFC
	return KErrNone;
	}

void TTimer::Cancel(DThread* aThread)
//
// Cancel an outstanding request.
// Enter and return with system unlocked
//
	{
	NKern::LockSystem();
	TTimerState s = (TTimerState)iState;
	if (s==EWaitHighRes)
		{
		Ms().Cancel();
		iState=(TUint8)EIdle;
		s=EIdle;
		if (aThread)
			Kern::QueueRequestComplete(aThread, iRequest,KErrCancel);
		NKern::UnlockSystem();
		}
	else
		NKern::UnlockSystem();
	if (s==EIdle)
		return;
	TTickQ::Wait();
	if (iState==EWaiting)
		{
		if (iType==EAbsolute)
			SecondLink().Cancel();
		else if (iType==EInactivity)
			Inact().Cancel();
		else
			TickLink().Cancel();
		if (aThread)
			Kern::QueueRequestComplete(aThread,iRequest,KErrCancel);
		iState=(TUint8)EIdle;
		}
	TTickQ::Signal();
	}

TInt TTimer::After(TInt anInterval, TTickCallBack aFunction, TRequestStatus& aStatus)
//
// Request a relative time.
// Enter and return with system unlocked
//
	{
	TTickQ::Wait();
	NKern::LockSystem();
	if (iState!=EIdle || iRequest->SetStatus(&aStatus) != KErrNone)
		{
		NKern::UnlockSystem();
		TTickQ::Signal();
		return KErrInUse;
		}
	iState=(TUint8)EWaiting;
	SetType(ERelative);
	NKern::UnlockSystem();
	TickLink().OneShot(anInterval,aFunction,this);
	TTickQ::Signal();
	return KErrNone;
	}

TInt TTimer::At(const TTimeK& aTime, TSecondCallBack aFunction, TRequestStatus& aStatus)
//
// Request an absolute time.
// Enter and return with system unlocked
//
	{
	TTickQ::Wait();
	NKern::LockSystem();
	if (iState!=EIdle || iRequest->SetStatus(&aStatus) != KErrNone)
		{
		NKern::UnlockSystem();
		TTickQ::Signal();
		return KErrInUse;
		}
	iState=(TUint8)EWaiting;
	SetType(EAbsolute);
	NKern::UnlockSystem();
	TInt r=SecondLink().At(aTime,aFunction,this);
	if (r!=KErrNone)
		{
		iState=(TUint8)EIdle;
		iRequest->Reset();
		}
	TTickQ::Signal();
	return r;
	}

TInt TTimer::Inactivity(TInt aSeconds, TInactivityCallBack aFunction, TRequestStatus& aStatus)
//
// Request an inactivity time.
// Enter and return with system unlocked
//
	{
	TTickQ::Wait();
	NKern::LockSystem();
	if (iState!=EIdle || iRequest->SetStatus(&aStatus) != KErrNone)
		{
		NKern::UnlockSystem();
		TTickQ::Signal();
		return KErrInUse;
		}
	iState=(TUint8)EWaiting;
	SetType(EInactivity);
	NKern::UnlockSystem();
	TInt r=Inact().Start(aSeconds,aFunction,this);
	if (r!=KErrNone)
		{
		iState=(TUint8)EIdle;
		iRequest->Reset();
		}
	TTickQ::Signal();
	return r;
	}

void TTimer::Abort(DThread* aThread, TInt aTypeMask)
//
// Abort an outstanding request.
// TimerMutex is already held here.
//
	{
	NKern::LockSystem();
	if (iState!=EWaiting || (iType&aTypeMask)==0)
		{
		NKern::UnlockSystem();
		return;
		}
	NKern::UnlockSystem();
	if (iType==EAbsolute)
		SecondLink().Cancel();
	else
		TickLink().Cancel();
	if (iType==ELocked)
		TickLink().iLastLock=-1;
	if (aThread)
		Kern::QueueRequestComplete(aThread,iRequest,KErrAbort);
	iState=(TUint8)EIdle;
	}


/********************************************
 * Timer utilities
 ********************************************/
TInt ExecHandler::TimerCreate()
//
// Create a Timer.
//
	{
	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::TimerCreate"));
	NKern::ThreadEnterCS();
	DTimer *pT=new DTimer;
	TInt r=KErrNoMemory;
	if (pT)
		{
		r=pT->Create(TheCurrentThread);
		if (r==KErrNone)
			r=K::AddObject(pT,ETimer);
		if (r==KErrNone)
			r=K::MakeHandle(EOwnerThread,pT);
		}
	if (pT && r<KErrNone)
		pT->Close(NULL);
	NKern::ThreadLeaveCS();
	return r;
	}

void ExecHandler::TimerCancel(DTimer* aTimer)
	{
	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::TimerCancel"));
	K::ThreadEnterCS();
	aTimer->Cancel();			// OK since timer handles always thread relative
	K::ThreadLeaveCS();
	}

void ExecHandler::TimerAfter(DTimer* aTimer, TRequestStatus& aStatus, TInt aTime)
	{
	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::TimerAfter"));
	K::ThreadEnterCS();
	TInt r=aTimer->After(aStatus,aTime);	// OK since timer handles always thread relative
	K::ThreadLeaveCS();
	if (r!=KErrNone)
		K::PanicCurrentThread(ETimerAlreadyPending);
	}

void ExecHandler::TimerHighRes(DTimer* aTimer, TRequestStatus& aStatus, TInt aTime)
	{
	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::TimerHighRes"));
	aTimer->HighRes(aStatus,aTime);
	}

void ExecHandler::TimerAt(DTimer* aTimer, TRequestStatus& aStatus, TUint32 aTimeLo, TUint32 aTimeHi)
	{
	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::TimerAt"));
	TTimeK time = MAKE_TINT64(aTimeHi,aTimeLo);
	K::ThreadEnterCS();
	TInt r=aTimer->At(aStatus,time);		// OK since timer handles always thread relative
	K::ThreadLeaveCS();
	if (r==KErrInUse)
		K::PanicCurrentThread(ETimerAlreadyPending);
	else if (r!=KErrNone)
		{
		TRequestStatus* status = &aStatus;
		Kern::RequestComplete(status, r);
		}
	}

void ExecHandler::TimerLock(DTimer* aTimer, TRequestStatus& aStatus, TTimerLockSpec aLock)
	{
	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::TimerLock"));
	K::ThreadEnterCS();
	TInt r=aTimer->Lock(aStatus,aLock);		// OK since timer handles always thread relative
	K::ThreadLeaveCS();
	if (r!=KErrNone)
		K::PanicCurrentThread(ETimerAlreadyPending);
	}

void ExecHandler::TimerInactivity(DTimer* aTimer, TRequestStatus& aStatus, TInt aSeconds)
	{
	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::TimerInactivity"));
	K::ThreadEnterCS();
	TInt r=aTimer->Inactivity(aStatus,aSeconds);	// OK since timer handles always thread relative
	K::ThreadLeaveCS();
	if (r==KErrInUse)
		K::PanicCurrentThread(ETimerAlreadyPending);
	else if (r!=KErrNone)
		{
		TRequestStatus* status = &aStatus;
		Kern::RequestComplete(status, r);
		}
	}

/********************************************
 * Miscellaneous
 ********************************************/
TInt ExecHandler::UserInactivityTime()
	{
	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::UserInactivityTime"));
	return K::InactivityQ->InactiveTime();
	}

void ExecHandler::ResetInactivityTime()
	{
	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ResetInactivityTime"));
	NKern::ThreadEnterCS();
	K::InactivityQ->Reset();
	NKern::ThreadLeaveCS();
	}

EXPORT_C TUint32 Kern::TickCount()
/**
	Returns the number of system ticks since boot.
*/
	{
	TTickQ& q=*K::TickQ;
	TInt irq = __SPIN_LOCK_IRQSAVE(TheTimerQ.iTimerSpinLock);
	TUint32 last_ticks=q.iLastTicks;
	TUint32 lastms=q.iLastMs;
	TUint32 ms=NTickCount();
	TUint32 p=(TUint32)q.iTickPeriod;
	__SPIN_UNLOCK_IRQRESTORE(TheTimerQ.iTimerSpinLock,irq);
	return last_ticks+((ms-lastms-1)*q.iMsTickPeriod)/p;
	}

TInt K::SecondsFrom2000(const TTimeK& aTime, TInt& aSeconds)
	{
	TInt64 diff=aTime/1000000; // convert microseconds to seconds
	diff-=K::Year2000InSeconds;
	if (diff>KMaxTInt || diff<KMinTInt)
		return KErrOverflow;
	aSeconds=(TInt)diff;
	return KErrNone;
	}

EXPORT_C TTimeK Kern::SystemTimeSecure()
/**
	Gets the current system time.

	@return The current time as the number of microseconds since midnight, January 1st, 0 AD nominal Gregorian.
*/
	{
	TTimeK r = Kern::SystemTime();
	if (K::SecureClockStatus==ESecureClockOk)
		{
		/*
		NB: We read the software clock and unapply the nonsecure offset, rather than
		reading the hardware rtc directly, for two reasons:
			1. The software clock ticks at 64Hz, whereas the variant API 
			   for reading the rtc is a measly 1Hz.
			2. Less code.
		*/
		TInt64 nonsecure_offset=K::NonSecureOffsetSeconds;
		nonsecure_offset *= 1000000;
		r -= nonsecure_offset;
		}
	else 
		{
		// Driver/variant code mustn't try to read the secure system time before the HAL has 
		// loaded (i.e. the nonsecure offset has been read from permanent storage). If you hit the 
		// assert below you need to change your code to use the nonsecure time API.
		__ASSERT_DEBUG(K::SecureClockStatus!=ESecureClockPresent, Kern::Printf("Secure clock read but no nonsecure offset is present"));
		}
	return r;
	}

EXPORT_C TTimeK Kern::SystemTime()
/**
	Gets the current nonsecure (user-settable) system time.

	@return The current time as the number of microseconds since midnight, January 1st, 0 AD nominal Gregorian.
*/
	{
	TTickQ& q=*K::TickQ;
	TInt irq = __SPIN_LOCK_IRQSAVE(TheTimerQ.iTimerSpinLock);
	Int64 rtc = q.iRtc;
	TUint32 lastms=q.iLastMs;
	TUint32 ms=NTickCount();
	__SPIN_UNLOCK_IRQRESTORE(TheTimerQ.iTimerSpinLock,irq);
	return rtc*q.iNominalTickPeriod+TInt(ms-lastms-1)*q.iMsTickPeriod;
	}


static TInt ExecTimeNowImpl(TTimeK& aUniversalTime, TInt& aUniversalTimeOffset, TBool aSecure)
{
	if (aSecure && K::SecureClockStatus != ESecureClockOk) 
		return KErrNoSecureTime;

	TInt off=K::HomeTimeOffsetSeconds;
	TTimeK time = aSecure ? Kern::SystemTimeSecure() : Kern::SystemTime();
	kumemput32(&aUniversalTime,&time,sizeof(time));
	kumemput32(&aUniversalTimeOffset,&off,sizeof(off));
	return KErrNone;
}

TInt ExecHandler::TimeNowSecure(TTimeK& aUniversalTime, TInt& aUniversalTimeOffset)
//
// Get the secure system time and universal time offset.
//
    {
	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::TimeNowSecure"));
	return ExecTimeNowImpl(aUniversalTime, aUniversalTimeOffset, ETrue);
	}

TInt ExecHandler::TimeNow(TTimeK& aUniversalTime, TInt& aUniversalTimeOffset)
//
// Get the nonsecure system time and universal time offset.
//
    {
	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::TimeNow"));
	return ExecTimeNowImpl(aUniversalTime, aUniversalTimeOffset, EFalse);
	}

TInt ExecHandler::UTCOffset()
//
// Get the universal time offset in seconds.
//
	{
	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::UTCOffset"));
	return K::HomeTimeOffsetSeconds;
	}

// Call with system unlocked and timer mutex held
TInt K::SetSystemTime(TInt aSecondsFrom2000, TInt aUTCOffset, TUint& aChanges, TUint aMode)
	{
	__KTRACE_OPT(KEXEC,Kern::Printf("K::SetSystemTime %d %d %d",aSecondsFrom2000,aUTCOffset,aMode));

	TTickQ& tq=*K::TickQ;
	TSecondQ& sq=*(TSecondQ*)K::SecondQ;

	// get current midnight time and UTC offset
	Int64 mnt = sq.iMidnight;
	TInt old_offset = K::HomeTimeOffsetSeconds;

	// set up new offset and tweak midnight for offset change
	if (aMode & ETimeSetOffset)
		{
		aUTCOffset %= 86400;	// stop silly offsets crashing the system
		mnt += (old_offset - aUTCOffset) * tq.iTicksPerSecond;
		}
	else
		aUTCOffset = old_offset;

	// set up new time and check for time reversal
	Int64 c;
	if (aMode & ETimeSetTime)
		{
		c=aSecondsFrom2000;
		c+=K::Year2000InSeconds;
		c*=tq.iTicksPerSecond;
		if (c<tq.iRtc && (aMode & ETimeSetAllowTimeReversal) == 0)
			return KErrArgument;
		}
	else
		c = tq.iRtc;

	// check if we've crossed midnight	
	if (c>=mnt || c<mnt-sq.iTicksPerDay)
		aChanges |= EChangesMidnightCrossover;
		
	// work out local time and round to the next midnight, then back to utc
	mnt=(c + aUTCOffset*tq.iTicksPerSecond + sq.iTicksPerDay) / sq.iTicksPerDay * sq.iTicksPerDay - aUTCOffset*tq.iTicksPerSecond;
	
	// update time, next midnight, and offset atomically
	TInt irq = __SPIN_LOCK_IRQSAVE(TheTimerQ.iTimerSpinLock);
	tq.iRtc=c;
	sq.iMidnight=mnt;
	K::HomeTimeOffsetSeconds = aUTCOffset;
	__SPIN_UNLOCK_IRQRESTORE(TheTimerQ.iTimerSpinLock,irq);
	
	// Cancel timers and note time change
	if (aMode & ETimeSetTime)
		{
		tq.iMsTimer.Cancel();
		tq.iMsTimer.iTriggerTime=tq.iLastMs;
		tq.iTickDfc.Cancel();
		}
	if ((aMode & ETimeSetTime) || (old_offset != aUTCOffset && (aMode & ETimeSetNoTimeUpdate) == 0))
		{
		aChanges |= EChangesSystemTime;
		sq.iTimer.DoCancel();
		}
	
	return KErrNone;
	}


TInt ExecHandler::SetUTCTimeAndOffset(const TTimeK& aHomeTime, TInt aOffsetInSeconds, TUint aMode, TUint aChanges)
	{
	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::SetUTCTimeAndOffset"));

	if(aChanges != EChangesLocale && !Kern::CurrentThreadHasCapability(ECapabilityWriteDeviceData,__PLATSEC_DIAGNOSTIC_STRING("Checked by User time set function")))
		K::UnlockedPlatformSecurityPanic();
	
	// If caller wants to set the secure (hardware) clock then check the process has permission to do that. Also
	// check that the nonsecure offset HAL attribute is present, or a secure time cannot be set.
	TUint flags = Kern::ETimeSet_SetHwRtc; // all user-mode clock setting APIs need to use this flag. It's only optional for drivers calling Kern::SetSystemTime
	if (aMode & ETimeSetSecure) 
		{
		if(!Kern::CurrentThreadHasCapability(ECapabilityTCB,__PLATSEC_DIAGNOSTIC_STRING("Checked by User time set function")))
			return KErrPermissionDenied;
		if (0 == (K::SecureClockStatus & ESecureClockOffsetPresent))
			return KErrNoSecureTime;
		aMode &= ~ETimeSetSecure;
		flags |= Kern::ETimeSet_Secure;
		}


	TTimeK hometime;
  	kumemget32(&hometime, &aHomeTime, sizeof(hometime));

	if (aMode & ETimeSetOffset)
		{
		SLocaleData& ld = TheMachineConfig().iLocale;
		NKern::LockSystem();
		ld.iUniversalTimeOffset = aOffsetInSeconds;
		ld.iDaylightSaving = EDstNone;
		NKern::ThreadEnterCS();
		NKern::UnlockSystem();
		}
	else
		NKern::ThreadEnterCS();
	TUint changes = 0;
	TInt r = K::SetSystemTimeAndOffset(hometime, aOffsetInSeconds, flags, changes, aMode);
	if (changes & EChangesSystemTime)
		{
		if (aMode & ETimeSetOffset || aChanges & EChangesLocale)
			changes |= EChangesLocale;
		__KTRACE_OPT(KEXEC,Kern::Printf("changes=%x",changes));
		Kern::NotifyChanges(changes);
		}
	else if(aChanges & EChangesLocale)
			Kern::NotifyChanges(EChangesLocale);
	NKern::ThreadLeaveCS();
	return r;
	}

/**
Updates the software RTC and possibly the hardware RTC.

@param aTime The new time to set, either universal or local
@param aMode	Flags as follows (from enum Kern::TTimeSetMode):
				ETimeSet_SetHwRtc - set HW as well as SW RTC
				ETimeSet_LocalTime - aTime is local time rather than UTC
				ETimeSet_SyncNotify - synchronously trigger change notifiers
				ETimeSet_AsyncNotify - asynchronously trigger change notifiers
				ETimeSet_Secure	- set the secure clock

@pre Calling thread must be in a critical section.
@pre Interrupts must be enabled.
@pre Kernel must be unlocked.
@pre No fast mutex can be held.
@pre Call in a thread context.
@pre Can be used in a device driver.

@return KErrNone, if successful;
        KErrOverflow, if aTime it outside the representable range, which is
		-2^31 to +2^31-1 seconds relative to 00:00:00 01-01-2000
*/
EXPORT_C TInt Kern::SetSystemTime(const TTimeK& aTime, TUint aMode)
	{
	CHECK_PRECONDITIONS(MASK_THREAD_CRITICAL,"Kern::SetSystemTime");			
	TUint dummy = 0;
	return K::SetSystemTimeAndOffset(aTime, 0, aMode, dummy, ETimeSetTime);
	}


	
TInt K::SetSystemTimeAndOffset(const TTimeK& aTime, TInt aOffset, TUint aTimeSetMode, TUint& aChanges, TUint aMode)
	{
	TSecondQ& sq = *K::SecondQ;
	TTickQ& tq = *K::TickQ;
	TTickQ::Wait();
	tq.Synchronise();
	TInt s = 0;
	TInt old = 0;

	if (aMode & ETimeSetTime)
		{

		// Convert the new time parameter to UTC seconds
		Int64 oldrtc = tq.iRtc;
		TTimeK newTime = aTime;
		if ((aTimeSetMode & Kern::ETimeSet_LocalTime) || (aMode & ETimeSetLocalTime))
			{
			if (aMode & ETimeSetOffset)
				newTime -= TTimeK(aOffset)*1000000;
			else
				newTime -= TTimeK(K::HomeTimeOffsetSeconds)*1000000;
			}
		K::SecondsFrom2000(oldrtc*tq.iNominalTickPeriod, old);
	    TInt r = K::SecondsFrom2000(newTime, s);
		if (r!=KErrNone)
			{
			TTickQ::Signal();
			return r;
			}


		// Update secure clock
		if (aTimeSetMode & Kern::ETimeSet_Secure)
			{
			if (aTimeSetMode & Kern::ETimeSet_SetHwRtc) 
				{
				r = A::SetSystemTimeInSecondsFrom2000(s);		// Update hardware RTC whether or not secure clock OK (HAL setting present)
				if (r!=KErrNone)
					{
					TTickQ::Signal();
					return r;
					}
				}
			K::SecureClockStatus |= ESecureClockPresent;	// Flag that a secure time has/is going to be set.

			if (K::SecureClockStatus == ESecureClockOk)		// i.e. if Nonsecure offset present (if secure clock in use)
				{
				TInt64 tmp = old;
				tmp -= s;
				K::NonSecureOffsetSeconds = static_cast<TInt32>(tmp); // i.e. Nonsecure time remains unchanged
				s = old;											  // so the software RTC (set below) remains unchanged nonsecure time
				}
			}
		// Update nonsecure clock
		else 
			// If the secure clock is in working order (i.e. both a secure time source and the
			// nonsecure offset are present) then all we have to do is update the nonsecure 
			// offset. Otherwise (i.e. either secure clock attribute is missing) all we can do 
			// is update the hardware clock.
			if (K::SecureClockStatus == ESecureClockOk)
			{
				TInt64 tmp = K::NonSecureOffsetSeconds;
				tmp += s;
				tmp -= old;
				K::NonSecureOffsetSeconds = static_cast<TInt32>(tmp);
			}
			else
			{
				if (aTimeSetMode & Kern::ETimeSet_SetHwRtc)
					{
					r = A::SetSystemTimeInSecondsFrom2000(s);
					if (r!=KErrNone)
						{
						TTickQ::Signal();
						return r;
						}
					}
			}
		}

	// Update the software RTC and offset
	K::SetSystemTime(s, aOffset, aChanges, aMode|ETimeSetAllowTimeReversal);

	// abort locked and absolute timers if the nonsecure time changed
	if (aChanges & EChangesSystemTime && !(aTimeSetMode & Kern::ETimeSet_Secure))
		AbortTimers(ETrue);

	if (aMode & ETimeSetTime)
		{
		// queue wakeup DFC to restart the timer queues
		// if iInTick is already set, wake up DFC is already queued
		if (!tq.iInTick)
			{
			tq.iInTick = ETrue;
			sq.iWakeUpDfc.Enque();
			}

		// tell the power manager
		if (K::PowerModel)
			K::PowerModel->SystemTimeChanged(old, s);
		}
	else if (aChanges & EChangesSystemTime)
		sq.StartTimer();
	
	TTickQ::Signal();

	if (aChanges)
		{
		if (aTimeSetMode & Kern::ETimeSet_SyncNotify)
			Kern::NotifyChanges(aChanges);
		else if (aTimeSetMode & Kern::ETimeSet_AsyncNotify)
			Kern::AsyncNotifyChanges(aChanges);
		}
	return KErrNone;
	}


TTimerLockSpec ExecHandler::LockPeriod()
	{
	// NO ONE USES THIS, SO KILL IT
	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::LockPeriod"));
	return ETwelveOClock;
	}

/** Returns the period of the Symbian OS tick timer.  

	@return Period in microseconds.
	
	@pre Call in any context.
	
	@see TTickLink
*/

EXPORT_C TInt Kern::TickPeriod()
	{
	return K::TickQ->iNominalTickPeriod;
	}
