sl@0: // Copyright (c) 1998-2009 Nokia Corporation and/or its subsidiary(-ies).
sl@0: // All rights reserved.
sl@0: // This component and the accompanying materials are made available
sl@0: // under the terms of the License "Eclipse Public License v1.0"
sl@0: // which accompanies this distribution, and is available
sl@0: // at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0: //
sl@0: // Initial Contributors:
sl@0: // Nokia Corporation - initial contribution.
sl@0: //
sl@0: // Contributors:
sl@0: //
sl@0: // Description:
sl@0: // e32\nkern\nk_timer.cpp
sl@0: // Fast Millisecond Timer Implementation
sl@0: // This file is just a template - you'd be mad not to machine code this
sl@0: // 
sl@0: //
sl@0: 
sl@0: #include "nk_priv.h"
sl@0: 
sl@0: #define i_NTimer_iState			i8888.iHState1
sl@0: #define i_NTimer_iCompleteInDfc	i8888.iHState2
sl@0: 
sl@0: const TInt KTimerQDfcPriority=6;
sl@0: 
sl@0: GLDEF_D NTimerQ TheTimerQ;
sl@0: 
sl@0: extern "C" void send_irq_ipi(TSubScheduler*);
sl@0: 
sl@0: #ifndef __MSTIM_MACHINE_CODED__
sl@0: #ifdef _DEBUG
sl@0: #define __DEBUG_CALLBACK(n)	{if (iDebugFn) (*iDebugFn)(iDebugPtr,n);}
sl@0: #else
sl@0: #define __DEBUG_CALLBACK(n)
sl@0: #endif
sl@0: 
sl@0: /** Construct a nanokernel timer tied to a specified thread or group
sl@0: 	
sl@0: 
sl@0: 	@param	aTied Pointer to the thread/group to which the timer should be tied
sl@0: 	@param	aFunction Pointer to the function to call on timer expiry
sl@0: 	@param	aPtr Parameter to pass to the expiry handler
sl@0: 	
sl@0: 	@pre	Any context
sl@0: 
sl@0: 	@publishedPartner
sl@0: 	@prototype
sl@0:  */
sl@0: EXPORT_C NTimer::NTimer(NSchedulable* aTied, NTimerFn aFunction, TAny* aPtr)
sl@0: 	{
sl@0: 	iPtr = aPtr;
sl@0: 	iFn = aFunction;
sl@0: 	iHType = EEventHandlerNTimer;
sl@0: //	i8888.iHState1 = EIdle;		done by NEventHandler constructor
sl@0: 	if (aTied)
sl@0: 		{
sl@0: 		SetTied(aTied);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /** Construct a nanokernel timer which mutates into and runs as a DFC on expiry
sl@0: 	The DFC queue is not specified at object construction time, but must be set
sl@0: 	using NTimer::SetDfcQ() before the timer is used.
sl@0: 
sl@0: 	@param	aFunction	Pointer to the function to call on timer expiry
sl@0: 	@param	aPtr		Parameter to pass to the expiry handler
sl@0: 	@param	aPriority	Priority of DFC within the queue (0 to 7, where 7 is highest)
sl@0: 	
sl@0: 	@pre	Any context
sl@0: 
sl@0: 	@publishedPartner
sl@0: 	@prototype
sl@0:  */
sl@0: EXPORT_C NTimer::NTimer(TDfcFn aFunction, TAny* aPtr, TInt aPriority)
sl@0: 	{
sl@0: 	iPtr = aPtr;
sl@0: 	iFn = aFunction;
sl@0: 	iTied = 0;
sl@0: 	iHType = (TUint8)aPriority;
sl@0: //	i8888.iHState0 = 0;			done by NEventHandler constructor
sl@0: //	i8888.iHState1 = EIdle;		done by NEventHandler constructor
sl@0: //	i8888.iHState2 = 0;			done by NEventHandler constructor
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /** Construct a nanokernel timer which mutates into and runs as a DFC on expiry
sl@0: 
sl@0: 	@param	aFunction	Pointer to the function to call on timer expiry
sl@0: 	@param	aPtr		Parameter to pass to the expiry handler
sl@0: 	@param	aDfcQ		Pointer to DFC queue which this timer should use
sl@0: 	@param	aPriority	Priority of DFC within the queue (0 to 7, where 7 is highest)
sl@0: 	
sl@0: 	@pre	Any context
sl@0: 
sl@0: 	@publishedPartner
sl@0: 	@prototype
sl@0:  */
sl@0: EXPORT_C NTimer::NTimer(TDfcFn aFunction, TAny* aPtr, TDfcQue* aDfcQ, TInt aPriority)
sl@0: 	{
sl@0: 	iPtr = aPtr;
sl@0: 	iFn = aFunction;
sl@0: 	iDfcQ = aDfcQ;
sl@0: 	iHType = (TUint8)aPriority;
sl@0: //	i8888.iHState0 = 0;			done by NEventHandler constructor
sl@0: //	i8888.iHState1 = EIdle;		done by NEventHandler constructor
sl@0: //	i8888.iHState2 = 0;			done by NEventHandler constructor
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /** Set the DFC queue to be used by an NTimer constructed using a TDfcFn
sl@0: 
sl@0: 	@param	aDfcQ		Pointer to DFC queue which this timer should use
sl@0: 
sl@0: 	@pre	Timer cannot be in use
sl@0: 	@pre	Any context
sl@0: 
sl@0: 	@publishedPartner
sl@0: 	@prototype
sl@0:  */
sl@0: EXPORT_C void NTimer::SetDfcQ(TDfcQue* aDfcQ)
sl@0: 	{
sl@0: 	__NK_ASSERT_ALWAYS(aDfcQ!=0);
sl@0: 	__NK_ASSERT_ALWAYS(iHType < KNumDfcPriorities);
sl@0: 	__NK_ASSERT_ALWAYS(i8816.iHState16==EIdle);
sl@0: 	iDfcQ = aDfcQ;
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /** Tie a nanokernel timer to a thread or group
sl@0: 
sl@0: 	@param	aTied = pointer to thread or group to which IDFC should be tied
sl@0: 	@return	KErrNone if successful
sl@0: 	@return	KErrDied if thread has exited or group has been destroyed.
sl@0: 
sl@0: 	@pre Call in thread context, interrupts enabled
sl@0: 	@pre Timer must not be queued or running
sl@0: 	@pre Timer must not already be tied
sl@0: 	@pre Must not be a mutating timer (constructed with TDfcFn)
sl@0: 
sl@0: 	@publishedPartner
sl@0: 	@prototype
sl@0:  */
sl@0: EXPORT_C TInt NTimer::SetTied(NSchedulable* aTied)
sl@0: 	{
sl@0: 	__NK_ASSERT_ALWAYS(!IsMutating());
sl@0: 	__NK_ASSERT_ALWAYS(i8888.iHState1 == EIdle);
sl@0: 	__NK_ASSERT_ALWAYS(aTied && !iTied);
sl@0: 	NKern::Lock();
sl@0: 	TInt r = aTied->AddTiedEvent(this);
sl@0: 	__NK_ASSERT_ALWAYS(r==KErrNone || r==KErrDied);
sl@0: 	NKern::Unlock();
sl@0: 	return r;
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /** Destroy a nanokernel timer
sl@0: 
sl@0: 	@pre Call in thread context, interrupts enabled, preemption enabled
sl@0: 	@pre Calling thread in critical section
sl@0: 	@pre No fast mutex held
sl@0: 
sl@0: 	@publishedPartner
sl@0: 	@prototype
sl@0:  */
sl@0: EXPORT_C NTimer::~NTimer()
sl@0: 	{
sl@0: 	if (!IsMutating() && iTied)
sl@0: 		{
sl@0: 		NKern::Lock();
sl@0: 		// remove from tied thread/group
sl@0: 		NEventHandler::TiedLock.LockOnly();
sl@0: 		NSchedulable* tied = iTied;
sl@0: 		DoCancel(ECancelDestroy);
sl@0: 		if (tied)	// might have been dequeued by thread/group termination
sl@0: 			{
sl@0: 			tied->AcqSLock();
sl@0: 			if (iTiedLink.iNext)
sl@0: 				{
sl@0: 				iTiedLink.Deque();
sl@0: 				iTiedLink.iNext = 0;
sl@0: 				}
sl@0: 			iTied = 0;
sl@0: 			tied->RelSLock();
sl@0: 			}
sl@0: 		NEventHandler::TiedLock.UnlockOnly();
sl@0: 		NKern::Unlock();
sl@0: 		}
sl@0: 	else if (IsMutating() && iDfcQ)
sl@0: 		DoCancelMutating(ECancelDestroy);
sl@0: 	else
sl@0: 		DoCancel(ECancelDestroy);
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /** Starts a nanokernel timer in one-shot mode with ISR callback.
sl@0: 	
sl@0: 	Queues the timer to expire in the specified number of nanokernel ticks. The
sl@0: 	actual wait time will be at least that much and may be up to one tick more.
sl@0: 	The expiry handler will be called in ISR context.
sl@0: 	
sl@0: 	Note that NKern::TimerTicks() can be used to convert milliseconds to ticks.
sl@0: 
sl@0: 	@param	aTime Timeout in nanokernel ticks
sl@0: 	
sl@0: 	@return	KErrNone if no error; KErrInUse if timer is already active.
sl@0: 	
sl@0: 	@pre	Any context
sl@0: 	
sl@0: 	@see    NKern::TimerTicks()
sl@0:  */
sl@0: EXPORT_C TInt NTimer::OneShot(TInt aTime)
sl@0: 	{
sl@0: 	return OneShot(aTime,FALSE);
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /** Starts a nanokernel timer in one-shot mode with ISR or DFC callback.
sl@0: 	
sl@0: 	Queues the timer to expire in the specified number of nanokernel ticks. The
sl@0: 	actual wait time will be at least that much and may be up to one tick more.
sl@0: 	For normal timers (constructed with NTimerFn) the expiry handler will be
sl@0: 	called in either ISR context or in the context of the nanokernel timer
sl@0: 	thread (DfcThread1). For mutating timers (constructed with TDfcFn) the
sl@0: 	expiry handler is called in the context of the thread running the relevant
sl@0: 	TDfcQue.
sl@0: 
sl@0:     Note that NKern::TimerTicks() can be used to convert milliseconds to ticks.
sl@0: 
sl@0: 	@param	aTime Timeout in nanokernel ticks
sl@0: 	@param	aDfc TRUE if DFC callback required, FALSE if ISR callback required.
sl@0: 			Note that this parameter is ignored for mutating timers.
sl@0: 	
sl@0: 	@return	KErrNone if no error
sl@0: 	@return	KErrInUse if timer is already active.
sl@0: 	@return	KErrDied if tied thread/group has exited
sl@0: 	
sl@0: 	@pre	Any context
sl@0: 	
sl@0: 	@see    NKern::TimerTicks()
sl@0:  */
sl@0: EXPORT_C TInt NTimer::OneShot(TInt aTime, TBool aDfc)
sl@0: 	{
sl@0: 	__NK_ASSERT_DEBUG(aTime>=0);
sl@0: 	/** iFn could be set to NULL after NTimer::OneShot(TInt, TDfc&) call.
sl@0: 	Call-back mechanism cannot be changed in the life time of a timer. */
sl@0: 	__NK_ASSERT_DEBUG(iFn!=NULL);
sl@0: 
sl@0: 	TInt irq = TheTimerQ.iTimerSpinLock.LockIrqSave();
sl@0: 	if (!IsValid())
sl@0: 		{
sl@0: 		TheTimerQ.iTimerSpinLock.UnlockIrqRestore(irq);
sl@0: 		return KErrDied;
sl@0: 		}
sl@0: 	TUint16 state = i8816.iHState16;
sl@0: 	if (IsNormal())
sl@0: 		state &= 0xFF;
sl@0: 	else
sl@0: 		aDfc = FALSE;	// mutating timers start as ISR completion
sl@0: 	if (state!=EIdle)
sl@0: 		{
sl@0: 		TheTimerQ.iTimerSpinLock.UnlockIrqRestore(irq);
sl@0: 		return KErrInUse;
sl@0: 		}
sl@0: 	mb();	// ensure that if we observe an idle state all accesses to the NTimer have also been observed
sl@0: 	i_NTimer_iCompleteInDfc=TUint8(aDfc?1:0);
sl@0: 	iTriggerTime=TheTimerQ.iMsCount+(TUint32)aTime;
sl@0: 	TheTimerQ.Add(this);
sl@0: 	TheTimerQ.iTimerSpinLock.UnlockIrqRestore(irq);
sl@0: 	return KErrNone;
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /** Starts a nanokernel timer in one-shot mode with callback in dfc thread that provided DFC belongs to.
sl@0: 	
sl@0: 	Queues the timer to expire in the specified number of nanokernel ticks. The
sl@0: 	actual wait time will be at least that much and may be up to one tick more.
sl@0: 	On expiry aDfc will be queued in ISR context.
sl@0: 
sl@0:     Note that NKern::TimerTicks() can be used to convert milliseconds to ticks.
sl@0: 
sl@0: 	@param	aTime Timeout in nanokernel ticks
sl@0: 	@param	aDfc - Dfc to be queued when the timer expires.
sl@0: 	
sl@0: 	@return	KErrNone if no error
sl@0: 	@return	KErrInUse if timer is already active.
sl@0: 	@return	KErrDied if tied thread/group has exited
sl@0: 	
sl@0: 	@pre	Any context
sl@0: 	@pre	Must not be a mutating timer (constructed with TDfcFn)
sl@0: 	
sl@0: 	@see    NKern::TimerTicks()
sl@0:  */
sl@0: EXPORT_C TInt NTimer::OneShot(TInt aTime, TDfc& aDfc)
sl@0: 	{
sl@0: 	__NK_ASSERT_DEBUG(!IsMutating());
sl@0: 	__NK_ASSERT_DEBUG(aTime>=0);
sl@0: 	TInt irq = TheTimerQ.iTimerSpinLock.LockIrqSave();
sl@0: 	if (iHType != EEventHandlerNTimer)
sl@0: 		{
sl@0: 		TheTimerQ.iTimerSpinLock.UnlockIrqRestore(irq);
sl@0: 		return KErrDied;
sl@0: 		}
sl@0: 	if (i_NTimer_iState!=EIdle)
sl@0: 		{
sl@0: 		TheTimerQ.iTimerSpinLock.UnlockIrqRestore(irq);
sl@0: 		return KErrInUse;
sl@0: 		}
sl@0: 	mb();	// ensure that if we observe an idle state all accesses to the NTimer have also been observed
sl@0: 	i_NTimer_iCompleteInDfc = 0;
sl@0: 	iFn = NULL;
sl@0: 	iPtr = (TAny*) &aDfc;
sl@0: 	iTriggerTime=TheTimerQ.iMsCount+(TUint32)aTime;
sl@0: 	TheTimerQ.Add(this);
sl@0: 	TheTimerQ.iTimerSpinLock.UnlockIrqRestore(irq);
sl@0: 	return KErrNone;
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /** Starts a nanokernel timer in zero-drift periodic mode with ISR or DFC callback.
sl@0: 
sl@0: 	Queues the timer to expire in the specified number of nanokernel ticks,
sl@0: 	measured from the time at which it last expired. This allows exact periodic
sl@0: 	timers to be implemented with no drift caused by delays in requeueing the
sl@0: 	timer.
sl@0: 
sl@0: 	The expiry handler will be called in the same context as the previous timer
sl@0: 	expiry. Generally the way this is used is that NTimer::OneShot() is used to start 
sl@0: 	the first time interval and this specifies whether the callback is in ISR context 
sl@0: 	or in the context of the nanokernel timer thread (DfcThread1) or other Dfc thread.
sl@0: 	The expiry handler then uses NTimer::Again() to requeue the timer.
sl@0: 
sl@0: 	@param	aTime Timeout in nanokernel ticks
sl@0: 
sl@0: 	@return	KErrNone if no error
sl@0: 	@return	KErrInUse if timer is already active;
sl@0: 	@return	KErrArgument if the requested expiry time is in the past.
sl@0: 	@return	KErrDied if tied thread/group has exited
sl@0: 	        
sl@0: 	@pre	Any context
sl@0:  */
sl@0: EXPORT_C TInt NTimer::Again(TInt aTime)
sl@0: //
sl@0: // Wait aTime from last trigger time - used for periodic timers
sl@0: //
sl@0: 	{
sl@0: 	__NK_ASSERT_DEBUG(aTime>0);
sl@0: 	TInt irq = TheTimerQ.iTimerSpinLock.LockIrqSave();
sl@0: 	if (!IsValid())
sl@0: 		{
sl@0: 		TheTimerQ.iTimerSpinLock.UnlockIrqRestore(irq);
sl@0: 		return KErrDied;
sl@0: 		}
sl@0: 	TUint16 state = i8816.iHState16;
sl@0: 	if (IsNormal())
sl@0: 		state &= 0xFF;
sl@0: 	if (state!=EIdle)
sl@0: 		{
sl@0: 		TheTimerQ.iTimerSpinLock.UnlockIrqRestore(irq);
sl@0: 		return KErrInUse;
sl@0: 		}
sl@0: 	mb();	// ensure that if we observe an idle state all accesses to the NTimer have also been observed
sl@0: 	TUint32 nextTick=TheTimerQ.iMsCount;
sl@0: 	TUint32 trigger=iTriggerTime+(TUint32)aTime;
sl@0: 	TUint32 d=trigger-nextTick;
sl@0: 	if (d>=0x80000000)
sl@0: 		{
sl@0: 		TheTimerQ.iTimerSpinLock.UnlockIrqRestore(irq);
sl@0: 		return KErrArgument;		// requested time is in the past
sl@0: 		}
sl@0: 	iTriggerTime=trigger;
sl@0: 	TheTimerQ.Add(this);
sl@0: 	TheTimerQ.iTimerSpinLock.UnlockIrqRestore(irq);
sl@0: 	return KErrNone;
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /** Cancels a nanokernel timer.
sl@0: 
sl@0: 	Removes this timer from the nanokernel timer queue. Does nothing if the
sl@0: 	timer is inactive or has already expired.
sl@0: 	Note that if the timer was queued and DFC callback requested it is possible
sl@0: 	for the expiry handler to run even after Cancel() has been called. This will
sl@0: 	occur in the case where DfcThread1 is preempted just before calling the
sl@0: 	expiry handler for this timer and the preempting thread/ISR/IDFC calls
sl@0: 	Cancel() on the timer.
sl@0: 
sl@0: 	@pre	Any context for a non-mutating NTimer (constructed with NTimerFn)
sl@0: 	@pre	For mutating NTimer (constructed with TDfcFn), IDFC or thread context only.
sl@0: 	@return	TRUE if timer was actually cancelled
sl@0: 	@return	FALSE if timer was not cancelled - this could be because it was not
sl@0: 				active or because its expiry handler was already running on
sl@0: 				another CPU or in the timer DFC.
sl@0:  */
sl@0: EXPORT_C TBool NTimer::Cancel()
sl@0: 	{
sl@0: 	if (IsMutating() && iDfcQ)
sl@0: 		return DoCancelMutating(0);
sl@0: 	return DoCancel(0)!=EIdle;
sl@0: 	}
sl@0: 
sl@0: void NTimer::DoCancel0(TUint aState)
sl@0: 	{
sl@0: 	if (aState>ETransferring && aState<=EFinal)	// idle or transferring timers are not on a queue
sl@0: 		Deque();
sl@0: 	switch (aState)
sl@0: 		{
sl@0: 		case ETransferring:	// signal DFC to abort this iteration
sl@0: 			TheTimerQ.iTransferringCancelled=TRUE;
sl@0: 			break;
sl@0: 		case ECritical:		// signal DFC to abort this iteration
sl@0: 			TheTimerQ.iCriticalCancelled=TRUE;
sl@0: 			break;
sl@0: 		case EFinal:
sl@0: 			{
sl@0: 			// Need to clear bit in iPresent if both final queues now empty
sl@0: 			// NOTE: Timer might actually be on the completed queue rather than the final queue
sl@0: 			//		 but the check is harmless in any case.
sl@0: 			TInt i=iTriggerTime & NTimerQ::ETimerQMask;
sl@0: 			NTimerQ::STimerQ& q=TheTimerQ.iTickQ[i];
sl@0: 			if (q.iIntQ.IsEmpty() && q.iDfcQ.IsEmpty())
sl@0: 				TheTimerQ.iPresent &= ~(1<<i);
sl@0: 			break;
sl@0: 			}
sl@0: 		case EIdle:			// nothing to do
sl@0: 		case EHolding:		// just deque
sl@0: 		case EOrdered:		// just deque
sl@0: 			break;
sl@0: 		default:
sl@0: 			__NK_ASSERT_ALWAYS(0);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: TUint NTimer::DoCancel(TUint aFlags)
sl@0: 	{
sl@0: 	NSchedulable* tied = 0;
sl@0: 	TInt irq = NKern::DisableAllInterrupts();
sl@0: 	TheTimerQ.iTimerSpinLock.LockOnly();
sl@0: 	TUint state = i_NTimer_iState;
sl@0: 	mb();
sl@0: 	if (IsNormal() && state>=EEventQ)
sl@0: 		{
sl@0: 		// It's on a CPU's event handler queue
sl@0: 		TInt cpu = state - EEventQ;
sl@0: 		if (cpu < TheScheduler.iNumCpus)
sl@0: 			{
sl@0: 			TSubScheduler* ss = TheSubSchedulers + cpu;
sl@0: 			ss->iEventHandlerLock.LockOnly();
sl@0: 			state = i_NTimer_iState;
sl@0: 			if (state != EIdle)
sl@0: 				{
sl@0: 				Deque();	// we got to it first
sl@0: 				tied = iTied;
sl@0: 				i_NTimer_iState = EIdle;
sl@0: 				}
sl@0: 			ss->iEventHandlerLock.UnlockOnly();
sl@0: 			goto end;
sl@0: 			}
sl@0: 		}
sl@0: 	DoCancel0(state);
sl@0: 	if (IsMutating())
sl@0: 		i8816.iHState16 = 0;
sl@0: 	else
sl@0: 		i_NTimer_iState=EIdle;
sl@0: end:
sl@0: 	if (aFlags & ECancelDestroy)
sl@0: 		iHType = EEventHandlerDummy;
sl@0: 	TheTimerQ.iTimerSpinLock.UnlockOnly();
sl@0: 	if (tied)
sl@0: 		tied->EndTiedEvent();	// FIXME - Could be called in thread context
sl@0: 	NKern::RestoreInterrupts(irq);
sl@0: 	return state;
sl@0: 	}
sl@0: 
sl@0: TBool NTimer::DoCancelMutating(TUint aFlags)
sl@0: 	{
sl@0: 	CHECK_PRECONDITIONS(MASK_NOT_ISR,"NTimer::Cancel (mutating NTimer)");
sl@0: 	TSubScheduler& ss0 = SubScheduler();
sl@0: 	TBool wait = FALSE;
sl@0: 	TInt cpu = -1;
sl@0: 	TBool result = TRUE;
sl@0: 	TDfc* d = (TDfc*)this;
sl@0: 	NKern::Lock();
sl@0: 	TDfcQue* q = iDfcQ;
sl@0: 	NThreadBase* t = q->iThread;
sl@0: 	t->AcqSLock();
sl@0: 	TheTimerQ.iTimerSpinLock.LockIrq();
sl@0: 
sl@0: 	// 0000->0000, XX00->ZZ00, xxYY->zzYY
sl@0: 	TUint state = d->CancelInitialStateChange();
sl@0: 	if (state & 0xFF00)
sl@0: 		{
sl@0: 		// someone else cancelling at the same time - just wait for them to finish
sl@0: 		// they can only be waiting for the cancel IPI
sl@0: 		result = FALSE;
sl@0: 		wait = TRUE;
sl@0: 		goto end;
sl@0: 		}
sl@0: 	if (state == 0)	// timer was not active
sl@0: 		{
sl@0: 		result = FALSE;
sl@0: 		goto end;
sl@0: 		}
sl@0: 	if (state>=ETransferring && state<=EFinal)
sl@0: 		{
sl@0: 		DoCancel0(state);
sl@0: 		// cancel is complete
sl@0: 		goto reset;
sl@0: 		}
sl@0: 	if (state==1)
sl@0: 		{
sl@0: 		// on DFC final queue
sl@0: 		q->Remove((TPriListLink*)this);
sl@0: 		goto reset;
sl@0: 		}
sl@0: 	// must be on IDFC queue - need to send cancel IPI
sl@0: 	__NK_ASSERT_ALWAYS((state>>5)==4);
sl@0: 	cpu = state & 0x1f;
sl@0: 	if (TUint(cpu) == ss0.iCpuNum)
sl@0: 		{
sl@0: 		// it's on this CPU's IDFC queue so just dequeue it and finish
sl@0: 		Deque();
sl@0: 		cpu = -1;
sl@0: reset:
sl@0: 		d->ResetState();	// release semantics
sl@0: 		}
sl@0: end:
sl@0: 	if (aFlags & ECancelDestroy)
sl@0: 		iHType = EEventHandlerDummy;
sl@0: 	TheTimerQ.iTimerSpinLock.UnlockIrq();
sl@0: 	t->RelSLock();
sl@0: 	if (cpu>=0)
sl@0: 		{
sl@0: 		TCancelIPI ipi;
sl@0: 		ipi.Send(d, cpu);
sl@0: 		ipi.WaitCompletion();
sl@0: 		wait = TRUE;
sl@0: 		}
sl@0: 	if (wait)
sl@0: 		{
sl@0: 		TUint n = 0x01000000;
sl@0: 		while ((i8816.iHState16>>8) & ss0.iCpuMask)
sl@0: 			{
sl@0: 			__chill();
sl@0: 			if (!--n)
sl@0: 				__crash();
sl@0: 			}
sl@0: 		}
sl@0: 	NKern::Unlock();
sl@0: 	return result;
sl@0: 	}
sl@0: #endif
sl@0: 
sl@0: 
sl@0: /** Obtains the address of the nanokernel timer queue object.
sl@0: 
sl@0: 	Not intended for general use. Intended only for base ports in order to get
sl@0: 	the address used to call NTimerQ::Tick() with.
sl@0: 
sl@0: 	@return	The address of the nanokernel timer queue object
sl@0: 	@pre	Any context
sl@0:  */
sl@0: EXPORT_C TAny* NTimerQ::TimerAddress()
sl@0: 	{
sl@0: 	return &TheTimerQ;
sl@0: 	}
sl@0: 
sl@0: NTimerQ::NTimerQ()
sl@0: 	:	iDfc(NTimerQ::DfcFn,this,NULL,KTimerQDfcPriority),
sl@0: 		iDfcCompleteCount(1),
sl@0: 		iTimerSpinLock(TSpinLock::EOrderNTimerQ)
sl@0: 	{
sl@0: 	// NOTE: All other members are initialised to zero since the single instance
sl@0: 	//		 of NTimerQ resides in .bss
sl@0: 	}
sl@0: 
sl@0: void NTimerQ::Init1(TInt aTickPeriod)
sl@0: 	{
sl@0: 	TheTimerQ.iTickPeriod=aTickPeriod;
sl@0: 	__KTRACE_OPT(KBOOT,DEBUGPRINT("NTimerQ::Init1 - period %d us",aTickPeriod));
sl@0: 	__KTRACE_OPT(KMEMTRACE, DEBUGPRINT("MT:P %d",aTickPeriod));
sl@0: 	}
sl@0: 
sl@0: void NTimerQ::Init3(TDfcQue* aDfcQ)
sl@0: 	{
sl@0: 	__KTRACE_OPT(KBOOT,DEBUGPRINT("NTimerQ::Init3 DFCQ at %08x",aDfcQ));
sl@0: 	TheTimerQ.iDfc.SetDfcQ(aDfcQ);
sl@0: 	}
sl@0: 
sl@0: #ifndef __MSTIM_MACHINE_CODED__
sl@0: void NTimerQ::Add(NTimer* aTimer)
sl@0: //
sl@0: //	Internal function to add a timer to the queue.
sl@0: //	Enter and return with timer queue spin lock held.
sl@0: //
sl@0: 	{
sl@0: 	TInt t=TInt(aTimer->iTriggerTime-iMsCount);
sl@0: 	if (t<ENumTimerQueues)
sl@0: 		AddFinal(aTimer);
sl@0: 	else
sl@0: 		{
sl@0: 		// >=32ms to expiry, so put on holding queue
sl@0: 		aTimer->i_NTimer_iState=NTimer::EHolding;
sl@0: 		iHoldingQ.Add(aTimer);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: void NTimerQ::AddFinal(NTimer* aTimer)
sl@0: //
sl@0: //	Internal function to add a timer to the corresponding final queue.
sl@0: //	Enter and return with timer queue spin lock held.
sl@0: //
sl@0: 	{
sl@0: 	TInt i=aTimer->iTriggerTime & ETimerQMask;
sl@0: 	SDblQue* pQ;
sl@0: 	if (aTimer->i_NTimer_iCompleteInDfc)
sl@0: 		pQ=&iTickQ[i].iDfcQ;
sl@0: 	else
sl@0: 		pQ=&iTickQ[i].iIntQ;
sl@0: 	iPresent |= (1<<i);
sl@0: 	aTimer->i_NTimer_iState=NTimer::EFinal;
sl@0: 	pQ->Add(aTimer);
sl@0: 	}
sl@0: 
sl@0: void NTimerQ::DfcFn(TAny* aPtr)
sl@0: 	{
sl@0: 	((NTimerQ*)aPtr)->Dfc();
sl@0: 	}
sl@0: 
sl@0: void NTimerQ::Dfc()
sl@0: //
sl@0: // Do deferred timer queue processing and/or DFC completions
sl@0: //
sl@0: 	{
sl@0: 	// First transfer entries on the Ordered queue to the Final queues
sl@0: 	FOREVER
sl@0: 		{
sl@0: 		iTimerSpinLock.LockIrq();
sl@0: 		if (iOrderedQ.IsEmpty())
sl@0: 			break;
sl@0: 		NTimer* pC=(NTimer*)iOrderedQ.First();
sl@0: 		TInt remain=pC->iTriggerTime-iMsCount;
sl@0: 		if (remain>=ENumTimerQueues)
sl@0: 			break;
sl@0: 
sl@0: 		// If remaining time <32 ticks, add it to final queue;
sl@0: 		// also if remain < 0 we've 'missed it' so add to final queue.
sl@0: 		pC->Deque();
sl@0: 		AddFinal(pC);
sl@0: 		iTimerSpinLock.UnlockIrq();
sl@0: 		__DEBUG_CALLBACK(0);
sl@0: 		}
sl@0: 	iTimerSpinLock.UnlockIrq();
sl@0: 	__DEBUG_CALLBACK(1);
sl@0: 
sl@0: 	// Next transfer entries on the Holding queue to the Ordered queue or final queue
sl@0: 	FOREVER
sl@0: 		{
sl@0: 		iTimerSpinLock.LockIrq();
sl@0: 		if (iHoldingQ.IsEmpty())
sl@0: 			break;
sl@0: 		NTimer* pC=(NTimer*)iHoldingQ.First();
sl@0: 		pC->Deque();
sl@0: 		pC->i_NTimer_iState=NTimer::ETransferring;
sl@0: 		iTransferringCancelled=FALSE;
sl@0: 		TUint32 trigger=pC->iTriggerTime;
sl@0: 		if (TInt(trigger-iMsCount)<ENumTimerQueues)
sl@0: 			{
sl@0: 			// <32ms remaining so put it on final queue
sl@0: 			AddFinal(pC);
sl@0: 			}
sl@0: 		else
sl@0: 			{
sl@0: 			FOREVER
sl@0: 				{
sl@0: 				iTimerSpinLock.UnlockIrq();
sl@0: 				__DEBUG_CALLBACK(2);
sl@0: 
sl@0: 				// we now need to walk ordered queue to find correct position for pC
sl@0: 				SDblQueLink* anchor=&iOrderedQ.iA;
sl@0: 				iCriticalCancelled=FALSE;
sl@0: 				iTimerSpinLock.LockIrq();
sl@0: 				NTimer* pN=(NTimer*)iOrderedQ.First();
sl@0: 				while (pN!=anchor && !iTransferringCancelled)
sl@0: 					{
sl@0: 					if ((pN->iTriggerTime-trigger)<0x80000000u)
sl@0: 						break;	// insert before pN
sl@0: 					pN->i_NTimer_iState=NTimer::ECritical;
sl@0: 					iTimerSpinLock.UnlockIrq();
sl@0: 					__DEBUG_CALLBACK(3);
sl@0: 					iTimerSpinLock.LockIrq();
sl@0: 					if (iCriticalCancelled)
sl@0: 						break;
sl@0: 					pN->i_NTimer_iState=NTimer::EOrdered;
sl@0: 					pN=(NTimer*)pN->iNext;
sl@0: 					}
sl@0: 
sl@0: 				if (iTransferringCancelled)
sl@0: 					break;		// this one has been cancelled, go on to next one
sl@0: 				if (!iCriticalCancelled)
sl@0: 					{
sl@0: 					pC->InsertBefore(pN);
sl@0: 					pC->i_NTimer_iState=NTimer::EOrdered;
sl@0: 					break;		// done this one
sl@0: 					}
sl@0: 				}
sl@0: 			}
sl@0: 		iTimerSpinLock.UnlockIrq();
sl@0: 		__DEBUG_CALLBACK(4);
sl@0: 		}
sl@0: 	iTimerSpinLock.UnlockIrq();
sl@0: 	__DEBUG_CALLBACK(5);
sl@0: 
sl@0: 	// Finally do call backs for timers which requested DFC callback
sl@0: 	FOREVER
sl@0: 		{
sl@0: 		iTimerSpinLock.LockIrq();
sl@0: 		if (iCompletedQ.IsEmpty())
sl@0: 			break;
sl@0: 		NTimer* pC=(NTimer*)iCompletedQ.First();
sl@0: 		pC->Deque();
sl@0: 		pC->i_NTimer_iState=NTimer::EIdle;
sl@0: 		TAny* p=pC->iPtr;
sl@0: 		NTimerFn f=pC->iFn;
sl@0: 		iTimerSpinLock.UnlockIrq();
sl@0: 		__DEBUG_CALLBACK(7);
sl@0: 		(*f)(p);
sl@0: 		}
sl@0: 	iTimerSpinLock.UnlockIrq();
sl@0: 	__e32_atomic_add_rel32(&iDfcCompleteCount, 2);
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /** Tick over the nanokernel timer queue.
sl@0: 	This function should be called by the base port in the system tick timer ISR.
sl@0: 	It should not be called at any other time.
sl@0: 	The value of 'this' to pass is the value returned by NTimerQ::TimerAddress().
sl@0: 
sl@0: 	@see NTimerQ::TimerAddress()
sl@0:  */
sl@0: EXPORT_C void NTimerQ::Tick()
sl@0: 	{
sl@0: 	TInt irq = iTimerSpinLock.LockIrqSave();
sl@0: 	TInt i=iMsCount & ETimerQMask;
sl@0: 	iMsCount++;
sl@0: 	STimerQ* pQ=iTickQ+i;
sl@0: 	iPresent &= ~(1<<i);
sl@0: 	TBool doDfc=FALSE;
sl@0: 	if (!pQ->iDfcQ.IsEmpty())
sl@0: 		{
sl@0: 		// transfer DFC completions to completed queue and queue DFC
sl@0: 		iCompletedQ.MoveFrom(&pQ->iDfcQ);
sl@0: 		doDfc=TRUE;
sl@0: 		}
sl@0: 	if ((i&(ETimerQMask>>1))==0)
sl@0: 		{
sl@0: 		// Every 16 ticks we check if a DFC is required.
sl@0: 		// This allows a DFC latency of up to 16 ticks before timers are missed.
sl@0: 		if (!iHoldingQ.IsEmpty())
sl@0: 			{
sl@0: 			doDfc=TRUE;				// if holding queue nonempty, queue DFC to sort
sl@0: 			}
sl@0: 		else if (!iOrderedQ.IsEmpty())
sl@0: 			{
sl@0: 			// if first ordered queue entry expires in <32ms, queue the DFC to transfer
sl@0: 			NTimer* pC=(NTimer*)iOrderedQ.First();
sl@0: 			TUint x = pC->iTriggerTime - iMsCount;
sl@0: 			if (x < (TUint)ENumTimerQueues)
sl@0: 				{
sl@0: 				doDfc=TRUE;
sl@0: 				}
sl@0: 			}
sl@0: 		}
sl@0: 	if (!pQ->iIntQ.IsEmpty())
sl@0: 		{
sl@0: 		// transfer ISR completions to a temporary queue
sl@0: 		// careful here - other CPUs could dequeue timers!
sl@0: 		SDblQue q(&pQ->iIntQ,0);
sl@0: 		for (; !q.IsEmpty(); iTimerSpinLock.LockIrqSave())
sl@0: 			{
sl@0: 			NTimer* pC=(NTimer*)q.First();
sl@0: 			pC->Deque();
sl@0: 			if (pC->IsMutating())
sl@0: 				{
sl@0: 				pC->AddAsDFC();			//mutate NTimer into TDfc and Add() it
sl@0: 				iTimerSpinLock.UnlockIrqRestore(irq);
sl@0: 				continue;
sl@0: 				}
sl@0: 			if (!pC->iFn)
sl@0: 				{
sl@0: 				pC->i_NTimer_iState=NTimer::EIdle;
sl@0: 				iTimerSpinLock.UnlockIrqRestore(irq);
sl@0: 				((TDfc*)(pC->iPtr))->Add();
sl@0: 				continue;
sl@0: 				}
sl@0: 			NSchedulable* tied = pC->iTied;
sl@0: 			if (tied)
sl@0: 				{
sl@0: 				TInt cpu = tied->BeginTiedEvent();
sl@0: 				if (cpu != NKern::CurrentCpu())
sl@0: 					{
sl@0: 					pC->i_NTimer_iState = TUint8(NTimer::EEventQ + cpu);
sl@0: 					TSubScheduler* ss = TheSubSchedulers + cpu;
sl@0: 					TBool kick = ss->QueueEvent(pC);
sl@0: 					iTimerSpinLock.UnlockIrqRestore(irq);
sl@0: 					if (kick)
sl@0: 						send_irq_ipi(ss);
sl@0: 					continue;
sl@0: 					}
sl@0: 				}
sl@0: 			pC->i_NTimer_iState=NTimer::EIdle;
sl@0: 			TAny* p = pC->iPtr;
sl@0: 			NTimerFn f = pC->iFn;
sl@0: 			iTimerSpinLock.UnlockIrqRestore(irq);
sl@0: 			(*f)(p);
sl@0: 			if (tied)
sl@0: 				tied->EndTiedEvent();
sl@0: 			}
sl@0: 		}
sl@0: 	iTimerSpinLock.UnlockIrqRestore(irq);
sl@0: 	if (doDfc)
sl@0: 		iDfc.Add();
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /** Mutate an NTimer into a DFC and Add() it
sl@0: 
sl@0: If NTimer state is EFinal, change to DFC state 008n and add to endogenous IDFC
sl@0: queue for this CPU.
sl@0: 
sl@0: Enter and return with IRQs disabled and timer spin lock held
sl@0: No need to worry about Cancel()s since timer spin lock is held
sl@0: Don't touch iHState0
sl@0: 
sl@0: @internalComponent
sl@0: */
sl@0: void NTimer::AddAsDFC()
sl@0: 	{
sl@0: 	TSubScheduler& ss = SubScheduler();
sl@0: 	i8816.iHState16 = (TUint16)(0x80|ss.iCpuNum);
sl@0: 	ss.iDfcs.Add(this);
sl@0: 	ss.iDfcPendingFlag = 1;
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /** Check if a nanokernel timer is pending or not
sl@0: 
sl@0: 	@return	TRUE if the timer is pending (OneShot() etc. would return KErrInUse)
sl@0: 	@return FALSE if the timer is idle (OneShot() etc. would succeed)
sl@0: 	@pre	Any context
sl@0: 
sl@0: 	@publishedPartner
sl@0: 	@prototype
sl@0:  */
sl@0: EXPORT_C TBool NTimer::IsPending()
sl@0: 	{
sl@0: 	TUint16 state = i8816.iHState16;
sl@0: 	return state != EIdle;
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /** Return the number of ticks before the next nanokernel timer expiry.
sl@0: 	May on occasion return a pessimistic estimate (i.e. too low).
sl@0: 	Used by base port to disable the system tick interrupt when the system
sl@0: 	is idle.
sl@0: 
sl@0: 	@return	The number of ticks before the next nanokernel timer expiry.
sl@0: 	
sl@0: 	@pre	Interrupts must be disabled.
sl@0: 	
sl@0: 	@post	Interrupts are disabled.
sl@0:  */
sl@0: EXPORT_C TInt NTimerQ::IdleTime()
sl@0: 	{
sl@0: 	CHECK_PRECONDITIONS(MASK_INTERRUPTS_DISABLED,"NTimerQ::IdleTime");	
sl@0: 	NTimerQ& m=TheTimerQ;
sl@0: 	TUint32 next=m.iMsCount;	// number of next tick
sl@0: 	TUint32 p=m.iPresent;
sl@0: 	TInt r=KMaxTInt;
sl@0: 	if (p)
sl@0: 		{
sl@0: 		// Final queues nonempty
sl@0: 		TInt nx=next&0x1f;				// number of next tick modulo 32
sl@0: 		p=(p>>nx)|(p<<(32-nx));			// rotate p right by nx (so lsb corresponds to next tick)
sl@0: 		r=__e32_find_ls1_32(p);	// find number of zeros before LS 1
sl@0: 		}
sl@0: 	if (!m.iHoldingQ.IsEmpty())
sl@0: 		{
sl@0: 		// Sort operation required - need to process next tick divisible by 16
sl@0: 		TInt nx=next&0x0f;				// number of next tick modulo 16
sl@0: 		TInt r2=nx?(16-nx):0;			// number of ticks before next divisible by 16
sl@0: 		if (r2<r)
sl@0: 			r=r2;
sl@0: 		}
sl@0: 	if (!m.iOrderedQ.IsEmpty())
sl@0: 		{
sl@0: 		// Timers present on ordered queue
sl@0: 		NTimer* pC=(NTimer*)m.iOrderedQ.First();
sl@0: 		TUint32 tt=pC->iTriggerTime;
sl@0: 		tt=(tt&~0x0f)-16;				// time at which transfer to final queue would occur
sl@0: 		TInt r3=(TInt)(tt-next);
sl@0: 		if (r3<r)
sl@0: 			r=r3;
sl@0: 		}
sl@0: 	return r;
sl@0: 	}
sl@0: #endif
sl@0: 
sl@0: 
sl@0: /** Advance the nanokernel timer queue by the specified number of ticks.
sl@0: 	It is assumed that no timers expire as a result of this.
sl@0: 	Used by base port when system comes out of idle mode after disabling the
sl@0: 	system tick interrupt to bring the timer queue up to date.
sl@0: 
sl@0: 	@param	aTicks Number of ticks skipped due to tick suppression
sl@0: 
sl@0: 	@pre	Interrupts must be disabled.
sl@0: 
sl@0: 	@post	Interrupts are disabled.
sl@0:  */
sl@0: EXPORT_C void NTimerQ::Advance(TInt aTicks)
sl@0: 	{
sl@0: 	CHECK_PRECONDITIONS(MASK_INTERRUPTS_DISABLED,"NTimerQ::Advance");	
sl@0: 	TheTimerQ.iMsCount+=(TUint32)aTicks;
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**	Returns the period of the nanokernel timer.
sl@0: 	@return Period in microseconds
sl@0: 	@pre any context
sl@0: 	@see NTimer
sl@0:  */
sl@0: EXPORT_C TInt NKern::TickPeriod()
sl@0: 	{
sl@0: 	return TheTimerQ.iTickPeriod;
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**	Converts a time interval to timer ticks.
sl@0: 
sl@0: 	@param aMilliseconds time interval in milliseconds.
sl@0: 	@return Number of nanokernel timer ticks.  Non-integral results are rounded up.
sl@0: 
sl@0:  	@pre aMilliseconds should be <=2147483 to avoid integer overflow.
sl@0: 	@pre any context
sl@0:  */
sl@0: EXPORT_C TInt NKern::TimerTicks(TInt aMilliseconds)
sl@0: 	{
sl@0: 	__ASSERT_WITH_MESSAGE_DEBUG(aMilliseconds<=2147483,"aMilliseconds should be <=2147483","NKern::TimerTicks");
sl@0: 	TUint32 msp=TheTimerQ.iTickPeriod;
sl@0: 	if (msp==1000)	// will be true except on pathological hardware
sl@0: 		return aMilliseconds;
sl@0: 	TUint32 us=(TUint32)aMilliseconds*1000;
sl@0: 	return (us+msp-1)/msp;
sl@0: 	}
sl@0: