sl@0: // Copyright (c) 2007-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\include\nkernsmp\nkern.h
sl@0: // 
sl@0: // WARNING: This file contains some APIs which are internal and are subject
sl@0: //          to change without notice. Such APIs should therefore not be used
sl@0: //          outside the Kernel and Hardware Services package.
sl@0: //
sl@0: 
sl@0: #ifndef __NKERN_H__
sl@0: #define __NKERN_H__
sl@0: 
sl@0: #ifdef	__STANDALONE_NANOKERNEL__
sl@0: #undef	__IN_KERNEL__
sl@0: #define	__IN_KERNEL__
sl@0: #endif
sl@0: 
sl@0: #include <e32const.h>
sl@0: #include <nklib.h>
sl@0: #include <nk_event.h>
sl@0: #include <dfcs.h>
sl@0: #include <nk_trace.h>
sl@0: #include <e32atomics.h>
sl@0: 
sl@0: extern "C" {
sl@0: /** @internalComponent */
sl@0: IMPORT_C void NKFault(const char* file, TInt line);
sl@0: /** @internalComponent */
sl@0: void NKIdle(TInt aStage);
sl@0: }
sl@0: 
sl@0: /**
sl@0: @publishedPartner
sl@0: @released
sl@0: */
sl@0: #define FAULT()		NKFault(__FILE__,__LINE__)
sl@0: 
sl@0: #ifdef _DEBUG
sl@0: 
sl@0: /**
sl@0: @publishedPartner
sl@0: @released
sl@0: */
sl@0: #define __NK_ASSERT_DEBUG(c)	((void) ((c)||(FAULT(),0)) )
sl@0: 
sl@0: #else
sl@0: 
sl@0: #define __NK_ASSERT_DEBUG(c)
sl@0: 
sl@0: #endif
sl@0: 
sl@0: /**
sl@0: @publishedPartner
sl@0: @released
sl@0: */
sl@0: #define __NK_ASSERT_ALWAYS(c)	((void) ((c)||(FAULT(),0)) )
sl@0: 
sl@0: /**
sl@0: 	@publishedPartner
sl@0: 	@released
sl@0: */
sl@0: const TInt KNumPriorities=64;
sl@0: 
sl@0: const TInt KMaxCpus=8;
sl@0: 
sl@0: class NSchedulable;
sl@0: class NThread;
sl@0: class NThreadGroup;
sl@0: 
sl@0: 
sl@0: /** Spin lock
sl@0: 
sl@0: 	Used for protecting a code fragment against both interrupts and concurrent
sl@0: 	execution on another processor.
sl@0: 
sl@0: 	List of spin locks in the nanokernel, in deadlock-prevention order:
sl@0: 	A	NEventHandler::TiedLock (preemption)
sl@0: 	B	NFastMutex spin locks (preemption)
sl@0: 	C	Thread spin locks (preemption)
sl@0: 	D	Thread group spin locks (preemption)
sl@0: 	E	Per-CPU ready list lock (preemption)
sl@0: 
sl@0: 	a	Idle DFC list lock (interrupts)
sl@0: 	b	Per-CPU exogenous IDFC queue lock (interrupts)
sl@0: 	c	NTimerQ spin lock (interrupts)
sl@0: 	d	Generic IPI list locks (interrupts)
sl@0: 	e	NIrq spin locks (interrupts)
sl@0: 	f	Per-CPU event handler list lock (interrupts)
sl@0: 	z	BTrace lock (interrupts)
sl@0: 
sl@0: 	z must be minimum since BTrace can appear anywhere
sl@0: 
sl@0: 	interrupt-disabling spinlocks must be lower than preemption-disabling ones
sl@0: 
sl@0: 	Nestings which actually occur are:
sl@0: 		A > C
sl@0: 		B > C > D > E
sl@0: 		c > f
sl@0: 		Nothing (except possibly z) nested inside a, b, d, f
sl@0: 		e is held while calling HW-poking functions (which might use other spinlocks)
sl@0: 
sl@0: @publishedPartner
sl@0: @prototype
sl@0: */
sl@0: class TSpinLock
sl@0: 	{
sl@0: public:
sl@0: 	enum TOrder
sl@0: 		{
sl@0: 		// Bit 7 of order clear for locks used with interrupts disabled
sl@0: 		EOrderGenericIrqLow0	=0x00u,		// Device driver spin locks, low range
sl@0: 		EOrderGenericIrqLow1	=0x01u,		// Device driver spin locks, low range
sl@0: 		EOrderGenericIrqLow2	=0x02u,		// Device driver spin locks, low range
sl@0: 		EOrderGenericIrqLow3	=0x03u,		// Device driver spin locks, low range
sl@0: 		EOrderBTrace			=0x04u,		// BTrace lock
sl@0: 		EOrderEventHandlerList	=0x07u,		// Per-CPU event handler list lock
sl@0: 		EOrderCacheMaintenance  =0x08u,		// CacheMaintenance (for PL310)
sl@0: 		EOrderNIrq				=0x0Au,		// NIrq lock
sl@0: 		EOrderGenericIPIList	=0x0Du,		// Generic IPI list lock
sl@0: 		EOrderNTimerQ			=0x10u,		// Nanokernel timer queue lock
sl@0: 		EOrderExIDfcQ			=0x13u,		// Per-CPU exogenous IDFC queue list lock
sl@0: 		EOrderIdleDFCList		=0x16u,		// Idle DFC list lock
sl@0: 		EOrderGenericIrqHigh0	=0x18u,		// Device driver spin locks, high range
sl@0: 		EOrderGenericIrqHigh1	=0x19u,		// Device driver spin locks, high range
sl@0: 		EOrderGenericIrqHigh2	=0x1Au,		// Device driver spin locks, high range
sl@0: 		EOrderGenericIrqHigh3	=0x1Bu,		// Device driver spin locks, high range
sl@0: 
sl@0: 		// Bit 7 of order set for locks used with interrupts enabled, preemption disabled
sl@0: 		EOrderGenericPreLow0	=0x80u,		// Device driver spin locks, low range
sl@0: 		EOrderGenericPreLow1	=0x81u,		// Device driver spin locks, low range
sl@0: 		EOrderReadyList			=0x88u,		// Per-CPU ready list lock
sl@0: 		EOrderThreadGroup		=0x90u,		// Thread group locks
sl@0: 		EOrderThread			=0x91u,		// Thread locks
sl@0: 		EOrderFastMutex			=0x98u,		// Fast mutex locks
sl@0: 		EOrderEventHandlerTied	=0x9Cu,		// Event handler tied lock
sl@0: 		EOrderGenericPreHigh0	=0x9Eu,		// Device driver spin locks, high range
sl@0: 		EOrderGenericPreHigh1	=0x9Fu,		// Device driver spin locks, high range
sl@0: 
sl@0: 		EOrderNone				=0xFFu		// No order check required (e.g. for dynamic ordering)
sl@0: 		};
sl@0: public:
sl@0: 	IMPORT_C TSpinLock(TUint aOrder);
sl@0: 	IMPORT_C void LockIrq();				/**< @internalComponent disable interrupts and acquire the lock */
sl@0: 	IMPORT_C void UnlockIrq();				/**< @internalComponent release the lock and enable interrupts */
sl@0: 	IMPORT_C TBool FlashIrq();				/**< @internalComponent if someone else is waiting for the lock, UnlockIrq() then LockIrq() */
sl@0: 	IMPORT_C void LockOnly();				/**< @internalComponent acquire the lock, assuming interrupts/preemption already disabled */
sl@0: 	IMPORT_C void UnlockOnly();				/**< @internalComponent release the lock, don't change interrupt/preemption state */
sl@0: 	IMPORT_C TBool FlashOnly();				/**< @internalComponent if someone else is waiting for the lock, UnlockOnly() then LockOnly() */
sl@0: 	IMPORT_C TInt LockIrqSave();			/**< @internalComponent remember original interrupt state then disable interrupts and acquire the lock */
sl@0: 	IMPORT_C void UnlockIrqRestore(TInt);	/**< @internalComponent release the lock then restore original interrupt state */
sl@0: 	IMPORT_C TBool FlashIrqRestore(TInt);	/**< @internalComponent if someone else is waiting for the lock, UnlockIrqRestore() then LockIrq() */
sl@0: 	IMPORT_C TBool FlashPreempt();			/**< @internalComponent if someone else is waiting for the lock, UnlockOnly(); NKern::PreemptionPoint(); LockOnly(); */
sl@0: private:
sl@0: 	volatile TUint64 iLock;
sl@0: 	};
sl@0: 
sl@0: 
sl@0: /** Macro to disable interrupts and acquire the lock.
sl@0: 
sl@0: @publishedPartner
sl@0: @prototype
sl@0: */
sl@0: #define __SPIN_LOCK_IRQ(lock)				((lock).LockIrq())
sl@0: 
sl@0: /** Macro to release the lock and enable interrupts.
sl@0: 
sl@0: @publishedPartner
sl@0: @prototype
sl@0: */
sl@0: #define __SPIN_UNLOCK_IRQ(lock)				(lock).UnlockIrq()
sl@0: 
sl@0: /** Macro to see if someone else is waiting for the lock, enabling IRQs 
sl@0:     then disabling IRQs again.
sl@0: 
sl@0: @publishedPartner
sl@0: @prototype
sl@0: */
sl@0: #define __SPIN_FLASH_IRQ(lock)				(lock).FlashIrq()
sl@0: 
sl@0: /** Macro to remember original interrupt state then disable interrupts 
sl@0:     and acquire the lock.
sl@0:     
sl@0: @publishedPartner
sl@0: @prototype
sl@0: */
sl@0: #define __SPIN_LOCK_IRQSAVE(lock)			((lock).LockIrqSave())
sl@0: 
sl@0: /** Macro to release the lock then restore original interrupt state to that 
sl@0: 	supplied.
sl@0: 	
sl@0: @publishedPartner
sl@0: @prototype
sl@0: */
sl@0: #define __SPIN_UNLOCK_IRQRESTORE(lock,irq)	(lock).UnlockIrqRestore(irq)
sl@0: 
sl@0: /** Macro to see if someone else is waiting for the lock, enabling IRQs to
sl@0: 	the original state supplied then disabling IRQs again.
sl@0:     
sl@0: @publishedPartner
sl@0: @prototype
sl@0: */
sl@0: #define __SPIN_FLASH_IRQRESTORE(lock,irq)	(lock).FlashIrqRestore(irq)
sl@0: 
sl@0: /** Macro to acquire the lock. This assumes the caller has already disabled 
sl@0:     interrupts/preemption. 
sl@0: 	
sl@0: 	If interrupts/preemption is not disabled a run-time assert will occur
sl@0: 	This is to protect against unsafe code that might lead to same core 
sl@0: 	deadlock.
sl@0: 	
sl@0:     In device driver code it is safer to use __SPIN_LOCK_IRQSAVE() instead, 
sl@0: 	although not as efficient should interrupts aleady be disabled for the 
sl@0: 	duration the lock is held.
sl@0:     
sl@0: @publishedPartner
sl@0: @prototype
sl@0: */
sl@0: #define __SPIN_LOCK(lock)					((lock).LockOnly())
sl@0: 
sl@0: /** Macro to release the lock, don't change interrupt/preemption state.
sl@0: 
sl@0: @publishedPartner
sl@0: @prototype
sl@0: */
sl@0: #define __SPIN_UNLOCK(lock)					(lock).UnlockOnly()
sl@0: 
sl@0: /**
sl@0: @internalComponent
sl@0: */
sl@0: #define __SPIN_FLASH(lock)					(lock).FlashOnly()
sl@0: 
sl@0: /** Macro to see if someone else is waiting for the lock, enabling preemption 
sl@0:     then disabling it again.
sl@0: 
sl@0: @publishedPartner
sl@0: @prototype
sl@0: */
sl@0: #define __SPIN_FLASH_PREEMPT(lock)			(lock).FlashPreempt()
sl@0: 
sl@0: 
sl@0: /** Read/Write Spin lock
sl@0: 
sl@0: @publishedPartner
sl@0: @prototype
sl@0: */
sl@0: class TRWSpinLock
sl@0: 	{
sl@0: public:
sl@0: 	IMPORT_C TRWSpinLock(TUint aOrder);		// Uses same order space as TSpinLock
sl@0: 
sl@0: 	IMPORT_C void LockIrqR();				/**< @internalComponent disable interrupts and acquire read lock */
sl@0: 	IMPORT_C void UnlockIrqR();				/**< @internalComponent release read lock and enable interrupts */
sl@0: 	IMPORT_C TBool FlashIrqR();				/**< @internalComponent if someone else is waiting for write lock, UnlockIrqR() then LockIrqR() */
sl@0: 	IMPORT_C void LockIrqW();				/**< @internalComponent disable interrupts and acquire write lock */
sl@0: 	IMPORT_C void UnlockIrqW();				/**< @internalComponent release write lock and enable interrupts */
sl@0: 	IMPORT_C TBool FlashIrqW();				/**< @internalComponent if someone else is waiting for the lock, UnlockIrqW() then LockIrqW() */
sl@0: 	IMPORT_C void LockOnlyR();				/**< @internalComponent acquire read lock, assuming interrupts/preemption already disabled */
sl@0: 	IMPORT_C void UnlockOnlyR();			/**< @internalComponent release read lock, don't change interrupt/preemption state */
sl@0: 	IMPORT_C TBool FlashOnlyR();			/**< @internalComponent if someone else is waiting for write lock, UnlockOnlyR() then LockOnlyR() */
sl@0: 	IMPORT_C void LockOnlyW();				/**< @internalComponent acquire write lock, assuming interrupts/preemption already disabled */
sl@0: 	IMPORT_C void UnlockOnlyW();			/**< @internalComponent release write lock, don't change interrupt/preemption state */
sl@0: 	IMPORT_C TBool FlashOnlyW();			/**< @internalComponent if someone else is waiting for the lock, UnlockOnlyW() then LockOnlyW() */
sl@0: 	IMPORT_C TInt LockIrqSaveR();			/**< @internalComponent disable interrupts and acquire read lock, return original interrupt state */
sl@0: 	IMPORT_C void UnlockIrqRestoreR(TInt);	/**< @internalComponent release read lock and reset original interrupt state */
sl@0: 	IMPORT_C TBool FlashIrqRestoreR(TInt);	/**< @internalComponent if someone else is waiting for write lock, UnlockIrqRestoreR() then LockIrqR() */
sl@0: 	IMPORT_C TInt LockIrqSaveW();			/**< @internalComponent disable interrupts and acquire write lock, return original interrupt state */
sl@0: 	IMPORT_C void UnlockIrqRestoreW(TInt);	/**< @internalComponent release write lock and reset original interrupt state */
sl@0: 	IMPORT_C TBool FlashIrqRestoreW(TInt);	/**< @internalComponent if someone else is waiting for the lock, UnlockIrqRestoreW() then LockIrqW() */
sl@0: 	IMPORT_C TBool FlashPreemptR();			/**< @internalComponent if someone else is waiting for write lock, UnlockOnlyR(); NKern::PreemptionPoint(); LockOnlyR(); */
sl@0: 	IMPORT_C TBool FlashPreemptW();			/**< @internalComponent if someone else is waiting for the lock, UnlockOnlyW(); NKern::PreemptionPoint(); LockOnlyW(); */
sl@0: private:
sl@0: 	volatile TUint64 iLock;
sl@0: 	};
sl@0: 
sl@0: 
sl@0: /**
sl@0: @publishedPartner
sl@0: @prototype
sl@0: */
sl@0: #define __SPIN_LOCK_IRQ_R(lock)					(lock).LockIrqR()
sl@0: 
sl@0: /**
sl@0: @publishedPartner
sl@0: @prototype
sl@0: */
sl@0: #define __SPIN_UNLOCK_IRQ_R(lock)				(lock).UnlockIrqR()
sl@0: 
sl@0: /**
sl@0: @publishedPartner
sl@0: @prototype
sl@0: */
sl@0: #define __SPIN_FLASH_IRQ_R(lock)				((lock).FlashIrqR())
sl@0: 
sl@0: /**
sl@0: @publishedPartner
sl@0: @prototype
sl@0: */
sl@0: #define __SPIN_LOCK_IRQ_W(lock)					(lock).LockIrqW()
sl@0: 
sl@0: /**
sl@0: @publishedPartner
sl@0: @prototype
sl@0: */
sl@0: #define __SPIN_UNLOCK_IRQ_W(lock)				(lock).UnlockIrqW()
sl@0: 
sl@0: /**
sl@0: @publishedPartner
sl@0: @prototype
sl@0: */
sl@0: #define __SPIN_FLASH_IRQ_W(lock)				((lock).FlashIrqW())
sl@0: 
sl@0: 
sl@0: /**
sl@0: @publishedPartner
sl@0: @prototype
sl@0: */
sl@0: #define __SPIN_LOCK_R(lock)						(lock).LockOnlyR()
sl@0: 
sl@0: /**
sl@0: @publishedPartner
sl@0: @prototype
sl@0: */
sl@0: #define __SPIN_UNLOCK_R(lock)					(lock).UnlockOnlyR()
sl@0: 
sl@0: /**
sl@0: @internalComponent
sl@0: */
sl@0: #define __SPIN_FLASH_R(lock)					((lock).FlashOnlyR())
sl@0: 
sl@0: /**
sl@0: @publishedPartner
sl@0: @prototype
sl@0: */
sl@0: #define __SPIN_LOCK_W(lock)						(lock).LockOnlyW()
sl@0: 
sl@0: /**
sl@0: @publishedPartner
sl@0: @prototype
sl@0: */
sl@0: #define __SPIN_UNLOCK_W(lock)					(lock).UnlockOnlyW()
sl@0: 
sl@0: /**
sl@0: @internalComponent
sl@0: */
sl@0: #define __SPIN_FLASH_W(lock)					((lock).FlashOnlyW())
sl@0: 
sl@0: 
sl@0: /**
sl@0: @publishedPartner
sl@0: @prototype
sl@0: */
sl@0: #define __SPIN_LOCK_IRQSAVE_R(lock)				(lock).LockIrqSaveR()
sl@0: 
sl@0: /**
sl@0: @publishedPartner
sl@0: @prototype
sl@0: */
sl@0: #define __SPIN_UNLOCK_IRQRESTORE_R(lock,irq)	(lock).UnlockIrqRestoreR(irq)
sl@0: 
sl@0: /**
sl@0: @publishedPartner
sl@0: @prototype
sl@0: */
sl@0: #define __SPIN_FLASH_IRQRESTORE_R(lock,irq)		((lock).FlashIrqRestoreR(irq))
sl@0: 
sl@0: /**
sl@0: @publishedPartner
sl@0: @prototype
sl@0: */
sl@0: #define __SPIN_LOCK_IRQSAVE_W(lock)				(lock).LockIrqSaveW()
sl@0: 
sl@0: /**
sl@0: @publishedPartner
sl@0: @prototype
sl@0: */
sl@0: #define __SPIN_UNLOCK_IRQRESTORE_W(lock,irq)	(lock).UnlockIrqRestoreW(irq)
sl@0: 
sl@0: /**
sl@0: @publishedPartner
sl@0: @prototype
sl@0: */
sl@0: #define __SPIN_FLASH_IRQRESTORE_W(lock,irq)		((lock).FlashIrqRestoreW(irq))
sl@0: 
sl@0: 
sl@0: /**
sl@0: @publishedPartner
sl@0: @prototype
sl@0: */
sl@0: #define __SPIN_FLASH_PREEMPT_R(lock)			((lock).FlashPreemptR())
sl@0: 
sl@0: /**
sl@0: @publishedPartner
sl@0: @prototype
sl@0: */
sl@0: #define __SPIN_FLASH_PREEMPT_W(lock)			((lock).FlashPreemptW())
sl@0: 
sl@0: 
sl@0: #ifdef _DEBUG
sl@0: #define __INCLUDE_SPIN_LOCK_CHECKS__
sl@0: #endif
sl@0: 
sl@0: 
sl@0: /** Nanokernel fast semaphore
sl@0: 
sl@0: 	A light-weight semaphore class that only supports a single waiting thread,
sl@0: 	suitable for the Symbian OS thread I/O semaphore.
sl@0: 	
sl@0: 	Initialising a NFastSemaphore involves two steps:
sl@0: 	
sl@0: 	- Constructing the semaphore
sl@0: 	- Setting the semaphore owning thread (the one allowed to wait on it)
sl@0: 	
sl@0: 	For example, creating one for the current thread to wait on:
sl@0: 	
sl@0: 	@code
sl@0: 	NFastSemaphore sem;
sl@0: 	sem.iOwningThread = NKern::CurrentThread();
sl@0: 	@endcode
sl@0: 	
sl@0: 	@publishedPartner
sl@0: 	@prototype
sl@0: */
sl@0: class NFastSemaphore
sl@0: 	{
sl@0: public:
sl@0: 	inline NFastSemaphore();
sl@0: 	inline NFastSemaphore(NThreadBase* aThread);
sl@0: 	IMPORT_C void SetOwner(NThreadBase* aThread);
sl@0: 	IMPORT_C void Wait();
sl@0: 	IMPORT_C void Signal();
sl@0: 	IMPORT_C void SignalN(TInt aCount);
sl@0: 	IMPORT_C void Reset();
sl@0: 	void WaitCancel();
sl@0: 
sl@0: 	TInt Dec(NThreadBase* aThread);	// does mb() if >0
sl@0: 	NThreadBase* Inc(TInt aCount);	// does mb()
sl@0: 	NThreadBase* DoReset();	// does mb()
sl@0: public:
sl@0: 	/** If >=0 the semaphore count
sl@0: 		If <0, (thread>>2)|0x80000000
sl@0: 		@internalComponent
sl@0: 	*/
sl@0: 	TInt iCount;
sl@0: 
sl@0: 	/** The thread allowed to wait on the semaphore
sl@0: 		@internalComponent
sl@0: 	*/
sl@0: 	NThreadBase* iOwningThread;	
sl@0: 	};
sl@0: 
sl@0: /** Create a fast semaphore
sl@0: 
sl@0: 	@publishedPartner
sl@0: 	@prototype
sl@0: */
sl@0: inline NFastSemaphore::NFastSemaphore()
sl@0: 	: iCount(0), iOwningThread(NULL)
sl@0: 	{}
sl@0: 
sl@0: /** Nanokernel fast mutex
sl@0: 
sl@0: 	A light-weight priority-inheritance mutex that can be used if the following
sl@0: 	conditions apply:
sl@0: 	
sl@0: 	- Threads that hold the mutex never block.
sl@0: 	- The mutex is never acquired in a nested fashion
sl@0: 	
sl@0: 	If either of these conditions is not met, a DMutex object is more appropriate.
sl@0: 	
sl@0: 	@publishedPartner
sl@0: 	@prototype
sl@0: */
sl@0: class NFastMutex
sl@0: 	{
sl@0: public:
sl@0: 	IMPORT_C NFastMutex();
sl@0: 	IMPORT_C void Wait();
sl@0: 	IMPORT_C void Signal();
sl@0: 	IMPORT_C TBool HeldByCurrentThread();
sl@0: private:
sl@0: 	void DoWaitL();
sl@0: 	void DoSignalL();
sl@0: 
sl@0: 	friend class NKern;
sl@0: public:
sl@0: 	/** @internalComponent
sl@0: 
sl@0: 	If mutex is free and no-one is waiting, iHoldingThread=0
sl@0: 	If mutex is held and no-one is waiting, iHoldingThread points to holding thread
sl@0: 	If mutex is free but threads are waiting, iHoldingThread=1
sl@0: 	If mutex is held and threads are waiting, iHoldingThread points to holding thread but with bit 0 set
sl@0: 	*/
sl@0: 	NThreadBase* iHoldingThread;
sl@0: 
sl@0: 	TUint32 i_NFastMutex_Pad1;	/**< @internalComponent */
sl@0: 
sl@0: 	/** @internalComponent
sl@0: 
sl@0: 	Spin lock to protect mutex
sl@0: 	*/
sl@0: 	TSpinLock iMutexLock;
sl@0: 
sl@0: 	/** @internalComponent
sl@0: 
sl@0: 	List of NThreads which are waiting for the mutex. The threads are linked via
sl@0: 	their iWaitLink members.
sl@0: 	*/
sl@0: 	TPriList<NThreadBase, KNumPriorities> iWaitQ;
sl@0: 	};
sl@0: 
sl@0: __ASSERT_COMPILE(!(_FOFF(NFastMutex,iMutexLock)&7));
sl@0: 
sl@0: 
sl@0: /**
sl@0: @publishedPartner
sl@0: @prototype
sl@0: 
sl@0: The type of the callback function used by the nanokernel timer. 
sl@0: 
sl@0: @see NTimer
sl@0: */
sl@0: typedef NEventFn NTimerFn;
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: /**
sl@0: @publishedPartner
sl@0: @prototype
sl@0: 
sl@0: A basic relative timer provided by the nanokernel.
sl@0: 
sl@0: It can generate either a one-shot interrupt or periodic interrupts.
sl@0: 
sl@0: A timeout handler is called when the timer expires, either:
sl@0: - from the timer ISR - if the timer is queued via OneShot(TInt aTime) or OneShot(TInt aTime, TBool EFalse), or
sl@0: - from the nanokernel timer dfc1 thread - if the timer is queued via OneShot(TInt aTime, TBool ETrue) call, or
sl@0: - from any other dfc thread that provided DFC belongs to - if the timer is queued via OneShot(TInt aTime, TDfc& aDfc) call.
sl@0: Call-back mechanism cannot be changed in the life time of a timer.
sl@0: 
sl@0: These timer objects may be manipulated from any context.
sl@0: The timers are driven from a periodic system tick interrupt,
sl@0: usually a 1ms period.
sl@0: 
sl@0: @see NTimerFn
sl@0: */
sl@0: class NTimerQ;
sl@0: class NTimer : public NEventHandler
sl@0: 	{
sl@0: public:
sl@0: 	/**
sl@0: 	Default constructor.
sl@0: 	*/
sl@0: 	inline NTimer()
sl@0: 		{
sl@0: 		iHType = EEventHandlerNTimer;
sl@0: 		i8888.iHState1 = EIdle;
sl@0: 		}
sl@0: 	/**
sl@0: 	Constructor taking a callback function and a pointer to be passed
sl@0: 	to the callback function.
sl@0: 	
sl@0: 	@param aFunction The callback function.
sl@0: 	@param aPtr      A pointer to be passed to the callback function 
sl@0: 	                 when called.
sl@0: 	*/
sl@0: 	inline NTimer(NTimerFn aFunction, TAny* aPtr)
sl@0: 		{
sl@0: 		iPtr = aPtr;
sl@0: 		iFn = aFunction;
sl@0: 		iHType = EEventHandlerNTimer;
sl@0: 		i8888.iHState1 = EIdle;
sl@0: 		}
sl@0: 	IMPORT_C NTimer(NSchedulable* aTied, NTimerFn aFunction, TAny* aPtr);
sl@0: 	IMPORT_C NTimer(TDfcFn aFunction, TAny* aPtr, TInt aPriority);					// create DFC, queue to be set later
sl@0: 	IMPORT_C NTimer(TDfcFn aFunction, TAny* aPtr, TDfcQue* aDfcQ, TInt aPriority);	// create DFC
sl@0: 	IMPORT_C void SetDfcQ(TDfcQue* aDfcQ);
sl@0: 	IMPORT_C ~NTimer();
sl@0: 	IMPORT_C TInt SetTied(NSchedulable* aTied);
sl@0: 	IMPORT_C TInt OneShot(TInt aTime);
sl@0: 	IMPORT_C TInt OneShot(TInt aTime, TBool aDfc);
sl@0: 	IMPORT_C TInt OneShot(TInt aTime, TDfc& aDfc);
sl@0: 	IMPORT_C TInt Again(TInt aTime);
sl@0: 	IMPORT_C TBool Cancel();
sl@0: 	IMPORT_C TBool IsPending();
sl@0: private:
sl@0: 	enum { ECancelDestroy=1 };
sl@0: private:
sl@0: 	inline TBool IsNormal()
sl@0: 		{ return iHType==EEventHandlerNTimer; }
sl@0: 	inline TBool IsMutating()
sl@0: 		{ return iHType<KNumDfcPriorities; }
sl@0: 	inline TBool IsValid()
sl@0: 		{ return iHType<KNumDfcPriorities || iHType==EEventHandlerNTimer; }
sl@0: 	void AddAsDFC();
sl@0: 	TUint DoCancel(TUint aFlags);
sl@0: 	void DoCancel0(TUint aState);
sl@0: 	TBool DoCancelMutating(TUint aFlags);
sl@0: public:
sl@0: /**
sl@0: 	@internalComponent
sl@0: */
sl@0: 	enum TState
sl@0: 		{
sl@0: 		EIdle=0,			// not queued
sl@0: 							// 1 skipped so as not to clash with DFC states
sl@0: 		ETransferring=2,	// being transferred from holding to ordered queue
sl@0: 		EHolding=3,			// on holding queue
sl@0: 		EOrdered=4,			// on ordered queue
sl@0: 		ECritical=5,		// on ordered queue and in use by queue walk routine
sl@0: 		EFinal=6,			// on final queue
sl@0: 		EEventQ=32,			// 32+n = on event queue of CPU n (for tied timers)
sl@0: 		};
sl@0: public:
sl@0: 	TUint32 iTriggerTime;	/**< @internalComponent */
sl@0: 	TUint32	iNTimerSpare1;	/**< @internalComponent */
sl@0: 
sl@0: 	/** This field is available for use by the timer client provided that
sl@0: 		the timer isn't a mutating-into-DFC timer.
sl@0: 		@internalTechnology */
sl@0: //	TUint8 iUserFlags;									// i8888.iHState0
sl@0: //	TUint8 iState;			/**< @internalComponent */	// i8888.iHState1
sl@0: //	TUint8 iCompleteInDfc;	/**< @internalComponent */	// i8888.iHState2
sl@0: 
sl@0: 
sl@0: 	friend class NTimerQ;
sl@0: 	friend class NSchedulable;
sl@0: 	};
sl@0: 
sl@0: /**
sl@0: @internalTechnology
sl@0: */
sl@0: #define	i_NTimer_iUserFlags	i8888.iHState0
sl@0: 
sl@0: /**
sl@0: @internalComponent
sl@0: */
sl@0: #define	i_NTimer_iState		i8888.iHState1
sl@0: 
sl@0: /**
sl@0: 	@publishedPartner
sl@0: 	@released
sl@0: */
sl@0: typedef void (*NThreadFunction)(TAny*);
sl@0: 
sl@0: /**
sl@0: 	@publishedPartner
sl@0: 	@released
sl@0: */
sl@0: typedef TDfc* (*NThreadExitHandler)(NThread*);
sl@0: 
sl@0: /**
sl@0: 	@publishedPartner
sl@0: 	@prototype
sl@0: */
sl@0: typedef void (*NThreadStateHandler)(NThread*,TInt,TInt);
sl@0: 
sl@0: /**
sl@0: 	@publishedPartner
sl@0: 	@prototype
sl@0: */
sl@0: typedef void (*NThreadExceptionHandler)(TAny*,NThread*);
sl@0: 
sl@0: /**
sl@0: 	@publishedPartner
sl@0: 	@prototype
sl@0: */
sl@0: typedef void (*NThreadTimeoutHandler)(NThread*,TInt);
sl@0: 
sl@0: /**
sl@0: 	@publishedPartner
sl@0: 	@prototype
sl@0: */
sl@0: struct SNThreadHandlers
sl@0: 	{
sl@0: 	NThreadExitHandler iExitHandler;
sl@0: 	NThreadStateHandler iStateHandler;
sl@0: 	NThreadExceptionHandler iExceptionHandler;
sl@0: 	NThreadTimeoutHandler iTimeoutHandler;
sl@0: 	};
sl@0: 
sl@0: /** @internalComponent */
sl@0: extern void NThread_Default_State_Handler(NThread*, TInt, TInt);
sl@0: 
sl@0: /** @internalComponent */
sl@0: extern void NThread_Default_Exception_Handler(TAny*, NThread*);
sl@0: 
sl@0: /** @internalComponent */
sl@0: #define NTHREAD_DEFAULT_EXIT_HANDLER		((NThreadExitHandler)0)
sl@0: 
sl@0: /** @internalComponent */
sl@0: #define	NTHREAD_DEFAULT_STATE_HANDLER		(&NThread_Default_State_Handler)
sl@0: 
sl@0: /** @internalComponent */
sl@0: #define	NTHREAD_DEFAULT_EXCEPTION_HANDLER	(&NThread_Default_Exception_Handler)
sl@0: 
sl@0: /** @internalComponent */
sl@0: #define	NTHREAD_DEFAULT_TIMEOUT_HANDLER		((NThreadTimeoutHandler)0)
sl@0: 
sl@0: 
sl@0: /**
sl@0: 	@publishedPartner
sl@0: 	@prototype
sl@0: */
sl@0: struct SFastExecTable
sl@0: 	{
sl@0: 	TInt iFastExecCount;			// includes implicit function#0
sl@0: 	TLinAddr iFunction[1];			// first entry is for call number 1
sl@0: 	};
sl@0: 
sl@0: /**
sl@0: 	@publishedPartner
sl@0: 	@prototype
sl@0: */
sl@0: const TUint32 KExecFlagClaim=0x80000000;		// claim system lock
sl@0: 
sl@0: /**
sl@0: 	@publishedPartner
sl@0: 	@prototype
sl@0: */
sl@0: const TUint32 KExecFlagRelease=0x40000000;		// release system lock
sl@0: 
sl@0: /**
sl@0: 	@publishedPartner
sl@0: 	@prototype
sl@0: */
sl@0: const TUint32 KExecFlagPreprocess=0x20000000;	// preprocess
sl@0: 
sl@0: /**
sl@0: 	@publishedPartner
sl@0: 	@prototype
sl@0: */
sl@0: const TUint32 KExecFlagExtraArgMask=0x1C000000;	// 3 bits indicating additional arguments
sl@0: 
sl@0: /**
sl@0: 	@publishedPartner
sl@0: 	@prototype
sl@0: */
sl@0: const TUint32 KExecFlagExtraArgs2=0x04000000;	// 2 additional arguments
sl@0: 
sl@0: /**
sl@0: 	@publishedPartner
sl@0: 	@prototype
sl@0: */
sl@0: const TUint32 KExecFlagExtraArgs3=0x08000000;	// 3 additional arguments
sl@0: 
sl@0: /**
sl@0: 	@publishedPartner
sl@0: 	@prototype
sl@0: */
sl@0: const TUint32 KExecFlagExtraArgs4=0x0C000000;	// 4 additional arguments
sl@0: 
sl@0: /**
sl@0: 	@publishedPartner
sl@0: 	@prototype
sl@0: */
sl@0: const TUint32 KExecFlagExtraArgs5=0x10000000;	// 5 additional arguments
sl@0: 
sl@0: /**
sl@0: 	@publishedPartner
sl@0: 	@prototype
sl@0: */
sl@0: const TUint32 KExecFlagExtraArgs6=0x14000000;	// 6 additional arguments
sl@0: 
sl@0: /**
sl@0: 	@publishedPartner
sl@0: 	@prototype
sl@0: */
sl@0: const TUint32 KExecFlagExtraArgs7=0x18000000;	// 7 additional arguments
sl@0: 
sl@0: /**
sl@0: 	@publishedPartner
sl@0: 	@prototype
sl@0: */
sl@0: const TUint32 KExecFlagExtraArgs8=0x1C000000;	// 8 additional arguments
sl@0: 
sl@0: 
sl@0: /**
sl@0: 	@publishedPartner
sl@0: 	@prototype
sl@0: */
sl@0: struct SSlowExecEntry
sl@0: 	{
sl@0: 	TUint32 iFlags;					// information about call
sl@0: 	TLinAddr iFunction;				// address of function to be called
sl@0: 	};
sl@0: 
sl@0: 
sl@0: /**
sl@0: 	@publishedPartner
sl@0: 	@prototype
sl@0: */
sl@0: struct SSlowExecTable
sl@0: 	{
sl@0: 	TInt iSlowExecCount;
sl@0: 	TLinAddr iInvalidExecHandler;	// used if call number invalid
sl@0: 	TLinAddr iPreprocessHandler;	// used for handle lookups
sl@0: 	SSlowExecEntry iEntries[1];		// first entry is for call number 0
sl@0: 	};
sl@0: 
sl@0: // Thread iAttributes Constants
sl@0: const TUint8 KThreadAttImplicitSystemLock=1;	/**< @internalComponent */
sl@0: const TUint8 KThreadAttAddressSpace=2;			/**< @internalComponent */
sl@0: const TUint8 KThreadAttLoggable=4;				/**< @internalComponent */
sl@0: 
sl@0: 
sl@0: // Thread CPU
sl@0: const TUint32 KCpuAffinityAny=0xffffffffu;		/**< @internalComponent */
sl@0: 
sl@0: /** Information needed for creating a nanothread.
sl@0: 
sl@0: 	@publishedPartner
sl@0: 	@prototype
sl@0: */
sl@0: struct SNThreadCreateInfo
sl@0: 	{
sl@0: 	NThreadFunction iFunction;
sl@0: 	TAny* iStackBase;
sl@0: 	TInt iStackSize;
sl@0: 	TInt iPriority;
sl@0: 	TInt iTimeslice;
sl@0: 	TUint8 iAttributes;
sl@0: 	TUint32 iCpuAffinity;
sl@0: 	const SNThreadHandlers* iHandlers;
sl@0: 	const SFastExecTable* iFastExecTable;
sl@0: 	const SSlowExecTable* iSlowExecTable;
sl@0: 	const TUint32* iParameterBlock;
sl@0: 	TInt iParameterBlockSize;		// if zero, iParameterBlock _is_ the initial data
sl@0: 									// otherwise it points to n bytes of initial data
sl@0: 	NThreadGroup* iGroup;			// NULL for lone thread
sl@0: 	};
sl@0: 
sl@0: /** Information needed for creating a nanothread group.
sl@0: 
sl@0: 	@publishedPartner
sl@0: 	@prototype
sl@0: */
sl@0: struct SNThreadGroupCreateInfo
sl@0: 	{
sl@0: 	TUint32 iCpuAffinity;
sl@0: 	};
sl@0: 
sl@0: /**	Constant for use with NKern:: functions which release a fast mutex as well
sl@0: 	as performing some other operations.
sl@0: 
sl@0: 	@publishedPartner
sl@0: 	@released
sl@0: */
sl@0: #define	SYSTEM_LOCK		(NFastMutex*)0
sl@0: 
sl@0: 
sl@0: /** Idle handler function
sl@0: 	Pointer to a function which is called whenever a CPU goes idle
sl@0: 
sl@0: 	@param	aPtr	The iPtr stored in the SCpuIdleHandler structure
sl@0: 	@param	aStage	If positive, the number of processors still active
sl@0: 					If zero, indicates all processors are now idle
sl@0: 					-1 indicates that postamble processing is required after waking up
sl@0: 
sl@0: 	@publishedPartner
sl@0: 	@prototype
sl@0: */
sl@0: typedef void (*TCpuIdleHandlerFn)(TAny* aPtr, TInt aStage);
sl@0: 
sl@0: /** Idle handler structure
sl@0: 
sl@0: 	@publishedPartner
sl@0: 	@prototype
sl@0: */
sl@0: struct SCpuIdleHandler
sl@0: 	{
sl@0: 	TCpuIdleHandlerFn	iHandler;
sl@0: 	TAny*				iPtr;
sl@0: 	volatile TBool		iPostambleRequired;
sl@0: 	};
sl@0: 
sl@0: 
sl@0: /**
sl@0: @internalComponent
sl@0: */
sl@0: enum TUserModeCallbackReason
sl@0: 	{
sl@0: 	EUserModeCallbackRun,
sl@0: 	EUserModeCallbackCancel,
sl@0: 	};
sl@0: 
sl@0: 
sl@0: /**
sl@0: A callback function executed when a thread returns to user mode.
sl@0: 
sl@0: @internalComponent
sl@0: */
sl@0: typedef void (*TUserModeCallbackFunc)(TAny* aThisPtr, TUserModeCallbackReason aReasonCode);
sl@0: 
sl@0: 
sl@0: /**
sl@0: An object representing a queued callback to be executed when a thread returns to user mode.
sl@0: 
sl@0: @internalComponent
sl@0: */
sl@0: class TUserModeCallback
sl@0: 	{
sl@0: public:
sl@0: 	TUserModeCallback(TUserModeCallbackFunc);
sl@0: 	~TUserModeCallback();
sl@0: 
sl@0: public:
sl@0: 	TUserModeCallback* volatile iNext;
sl@0: 	TUserModeCallbackFunc iFunc;
sl@0: 	};
sl@0: 
sl@0: TUserModeCallback* const KUserModeCallbackUnqueued = ((TUserModeCallback*)1);
sl@0: 
sl@0: 
sl@0: /** Main function for AP
sl@0: 
sl@0: @internalTechnology
sl@0: */
sl@0: struct SAPBootInfo;
sl@0: typedef void (*TAPBootFunc)(volatile SAPBootInfo*);
sl@0: 
sl@0: 
sl@0: /** Information needed to boot an AP
sl@0: 
sl@0: @internalTechnology
sl@0: */
sl@0: struct SAPBootInfo
sl@0: 	{
sl@0: 	TUint32				iCpu;				// Hardware CPU ID
sl@0: 	TUint32				iInitStackSize;		// Size of initial stack
sl@0: 	TLinAddr			iInitStackBase;		// Base of initial stack
sl@0: 	TAPBootFunc			iMain;				// Address of initial function to call
sl@0: 	TAny*				iArgs[4];
sl@0: 	};
sl@0: 
sl@0: typedef void (*NIsr)(TAny*);
sl@0: 
sl@0: /** Nanokernel functions
sl@0: 
sl@0: 	@publishedPartner
sl@0: 	@prototype
sl@0: */
sl@0: class NKern
sl@0: 	{
sl@0: public:
sl@0: 	/** Bitmask values used when blocking a nanothread.
sl@0: 		@see NKern::Block()
sl@0: 	 */
sl@0: 	enum TBlockMode 
sl@0: 		{
sl@0: 		EEnterCS=1,		/**< Enter thread critical section before blocking */
sl@0: 		ERelease=2,		/**< Release specified fast mutex before blocking */
sl@0: 		EClaim=4,		/**< Re-acquire specified fast mutex when unblocked */
sl@0: 		EObstruct=8,	/**< Signifies obstruction of thread rather than lack of work to do */
sl@0: 		};
sl@0: 
sl@0: 	/** Values that specify the context of the processor.
sl@0: 		@see NKern::CurrentContext()
sl@0: 	*/
sl@0: 	enum TContext
sl@0: 		{
sl@0: 		EThread=0,			/**< The processor is in a thread context*/
sl@0: 		EIDFC=1,			/**< The processor is in an IDFC context*/
sl@0: 		EInterrupt=2,		/**< The processor is in an interrupt context*/
sl@0: 		EEscaped=KMaxTInt	/**< Not valid a process context on target hardware*/
sl@0: 		};
sl@0: 
sl@0: public:
sl@0: 	// Threads
sl@0: 	IMPORT_C static TInt ThreadCreate(NThread* aThread, SNThreadCreateInfo& aInfo);
sl@0: 	IMPORT_C static TBool ThreadSuspend(NThread* aThread, TInt aCount);
sl@0: 	IMPORT_C static TBool ThreadResume(NThread* aThread);
sl@0: 	IMPORT_C static TBool ThreadResume(NThread* aThread, NFastMutex* aMutex);
sl@0: 	IMPORT_C static TBool ThreadForceResume(NThread* aThread);
sl@0: 	IMPORT_C static TBool ThreadForceResume(NThread* aThread, NFastMutex* aMutex);
sl@0: 	IMPORT_C static void ThreadRelease(NThread* aThread, TInt aReturnValue);
sl@0: 	IMPORT_C static void ThreadRelease(NThread* aThread, TInt aReturnValue, NFastMutex* aMutex);
sl@0: 	IMPORT_C static void ThreadSetPriority(NThread* aThread, TInt aPriority);
sl@0: 	IMPORT_C static void ThreadSetPriority(NThread* aThread, TInt aPriority, NFastMutex* aMutex);
sl@0: 	IMPORT_C static void ThreadRequestSignal(NThread* aThread);
sl@0: 	IMPORT_C static void ThreadRequestSignal(NThread* aThread, NFastMutex* aMutex);
sl@0: 	IMPORT_C static void ThreadRequestSignal(NThread* aThread, TInt aCount);
sl@0: 	IMPORT_C static void ThreadKill(NThread* aThread);
sl@0: 	IMPORT_C static void ThreadKill(NThread* aThread, NFastMutex* aMutex);
sl@0: 	IMPORT_C static void ThreadEnterCS();
sl@0: 	IMPORT_C static void ThreadLeaveCS();
sl@0: 	static NThread* _ThreadEnterCS();		/**< @internalComponent */
sl@0: 	static void _ThreadLeaveCS();			/**< @internalComponent */
sl@0: 	IMPORT_C static TInt Block(TUint32 aTimeout, TUint aMode, NFastMutex* aMutex);
sl@0: 	IMPORT_C static TInt Block(TUint32 aTimeout, TUint aMode);
sl@0: 	IMPORT_C static void NanoBlock(TUint32 aTimeout, TUint aState, TAny* aWaitObj);
sl@0: 	IMPORT_C static void ThreadGetUserContext(NThread* aThread, TAny* aContext, TUint32& aAvailRegistersMask);
sl@0: 	IMPORT_C static void ThreadSetUserContext(NThread* aThread, TAny* aContext);
sl@0: 	IMPORT_C static void ThreadGetSystemContext(NThread* aThread, TAny* aContext, TUint32& aAvailRegistersMask);
sl@0: 	static void ThreadModifyUsp(NThread* aThread, TLinAddr aUsp);
sl@0: 	IMPORT_C static TInt FreezeCpu();													/**< @internalComponent */
sl@0: 	IMPORT_C static void EndFreezeCpu(TInt aCookie);									/**< @internalComponent */
sl@0: 	IMPORT_C static TUint32 ThreadSetCpuAffinity(NThread* aThread, TUint32 aAffinity);	/**< @internalComponent */
sl@0: 	IMPORT_C static void ThreadSetTimeslice(NThread* aThread, TInt aTimeslice);			/**< @internalComponent */
sl@0: 	IMPORT_C static TUint64 ThreadCpuTime(NThread* aThread);							/**< @internalComponent */
sl@0: 	IMPORT_C static TUint32 CpuTimeMeasFreq();											/**< @internalComponent */
sl@0: 	static TInt QueueUserModeCallback(NThreadBase* aThread, TUserModeCallback* aCallback);	/**< @internalComponent */
sl@0: 	static void MoveUserModeCallbacks(NThreadBase* aSrcThread, NThreadBase* aDestThread);	/**< @internalComponent */
sl@0: 	static void CancelUserModeCallbacks();												/**< @internalComponent */
sl@0: 
sl@0: 	// Thread Groups
sl@0: 	IMPORT_C static TInt GroupCreate(NThreadGroup* aGroup, SNThreadGroupCreateInfo& aInfo);
sl@0: 	IMPORT_C static void GroupDestroy(NThreadGroup* aGroup);
sl@0: 	IMPORT_C static NThreadGroup* CurrentGroup();
sl@0: 	IMPORT_C static NThreadGroup* LeaveGroup();
sl@0: 	IMPORT_C static void JoinGroup(NThreadGroup* aGroup);
sl@0: 	IMPORT_C static TUint32 GroupSetCpuAffinity(NThreadGroup* aGroup, TUint32 aAffinity);
sl@0: 
sl@0: 	// Fast semaphores
sl@0: 	IMPORT_C static void FSSetOwner(NFastSemaphore* aSem,NThreadBase* aThread);
sl@0: 	IMPORT_C static void FSWait(NFastSemaphore* aSem);
sl@0: 	IMPORT_C static void FSSignal(NFastSemaphore* aSem);
sl@0: 	IMPORT_C static void FSSignal(NFastSemaphore* aSem, NFastMutex* aMutex);
sl@0: 	IMPORT_C static void FSSignalN(NFastSemaphore* aSem, TInt aCount);
sl@0: 	IMPORT_C static void FSSignalN(NFastSemaphore* aSem, TInt aCount, NFastMutex* aMutex);
sl@0: 
sl@0: 	// Fast mutexes
sl@0: 	IMPORT_C static void FMWait(NFastMutex* aMutex);
sl@0: 	IMPORT_C static void FMSignal(NFastMutex* aMutex);
sl@0: 	IMPORT_C static TBool FMFlash(NFastMutex* aMutex);
sl@0: 
sl@0: 	// Scheduler
sl@0: 	IMPORT_C static void Lock();
sl@0: 	IMPORT_C static NThread* LockC();
sl@0: 	IMPORT_C static void Unlock();
sl@0: 	IMPORT_C static TInt PreemptionPoint();
sl@0: 
sl@0: 	// Interrupts
sl@0: 	IMPORT_C static TInt DisableAllInterrupts();
sl@0: 	IMPORT_C static TInt DisableInterrupts(TInt aLevel);
sl@0: 	IMPORT_C static void RestoreInterrupts(TInt aRestoreData);
sl@0: 	IMPORT_C static void EnableAllInterrupts();
sl@0: 
sl@0: 	// Read-modify-write
sl@0: 	inline static TInt LockedInc(TInt& aCount)
sl@0: 		{ return __e32_atomic_add_ord32(&aCount,1); }
sl@0: 	inline static TInt LockedDec(TInt& aCount)
sl@0: 		{ return __e32_atomic_add_ord32(&aCount,0xffffffff); }
sl@0: 	inline static TInt LockedAdd(TInt& aDest, TInt aSrc)
sl@0: 		{ return __e32_atomic_add_ord32(&aDest,aSrc); }
sl@0: 	inline static TInt64 LockedInc(TInt64& aCount)
sl@0: 		{ return __e32_atomic_add_ord64(&aCount,1); }
sl@0: 	inline static TInt64 LockedDec(TInt64& aCount)
sl@0: 		{ return __e32_atomic_add_ord64(&aCount,TUint64(TInt64(-1))); }
sl@0: 	inline static TInt64 LockedAdd(TInt64& aDest, TInt64 aSrc)		/**< @internalComponent */
sl@0: 		{ return __e32_atomic_add_ord64(&aDest,aSrc); }
sl@0: 	inline static TUint32 LockedSetClear(TUint32& aDest, TUint32 aClearMask, TUint32 aSetMask)
sl@0: 		{ return __e32_atomic_axo_ord32(&aDest,~(aClearMask|aSetMask),aSetMask); }
sl@0: 	inline static TUint16 LockedSetClear16(TUint16& aDest, TUint16 aClearMask, TUint16 aSetMask)	/**< @internalComponent */
sl@0: 		{ return __e32_atomic_axo_ord16(&aDest,TUint16(~(aClearMask|aSetMask)),aSetMask); }
sl@0: 	inline static TUint8 LockedSetClear8(TUint8& aDest, TUint8 aClearMask, TUint8 aSetMask)
sl@0: 		{ return __e32_atomic_axo_ord8(&aDest,TUint8(~(aClearMask|aSetMask)),aSetMask); }
sl@0: 	inline static TInt SafeInc(TInt& aCount)
sl@0: 		{ return __e32_atomic_tas_ord32(&aCount,1,1,0); }
sl@0: 	inline static TInt SafeDec(TInt& aCount)
sl@0: 		{ return __e32_atomic_tas_ord32(&aCount,1,-1,0); }
sl@0: 	inline static TInt AddIfGe(TInt& aCount, TInt aLimit, TInt aInc)	/**< @internalComponent */
sl@0: 		{ return __e32_atomic_tas_ord32(&aCount,aLimit,aInc,0); }
sl@0: 	inline static TInt AddIfLt(TInt& aCount, TInt aLimit, TInt aInc)	/**< @internalComponent */
sl@0: 		{ return __e32_atomic_tas_ord32(&aCount,aLimit,0,aInc); }
sl@0: 	inline static TAny* SafeSwap(TAny* aNewValue, TAny*& aPtr)
sl@0: 		{ return __e32_atomic_swp_ord_ptr(&aPtr, aNewValue); }
sl@0: 	inline static TUint8 SafeSwap8(TUint8 aNewValue, TUint8& aPtr)
sl@0: 		{ return __e32_atomic_swp_ord8(&aPtr, aNewValue); }
sl@0: 	inline static TUint16 SafeSwap16(TUint16 aNewValue, TUint16& aPtr)						/**< @internalComponent */
sl@0: 		{ return __e32_atomic_swp_ord16(&aPtr, aNewValue); }
sl@0: 	inline static TBool CompareAndSwap(TAny*& aPtr, TAny* aExpected, TAny* aNew)			/**< @internalComponent */
sl@0: 		{ return __e32_atomic_cas_ord_ptr(&aPtr, &aExpected, aNew); }
sl@0: 	inline static TBool CompareAndSwap8(TUint8& aPtr, TUint8 aExpected, TUint8 aNew)		/**< @internalComponent */
sl@0: 		{ return __e32_atomic_cas_ord8(&aPtr, (TUint8*)&aExpected, (TUint8)aNew); }
sl@0: 	inline static TBool CompareAndSwap16(TUint16& aPtr, TUint16 aExpected, TUint16 aNew)	/**< @internalComponent */
sl@0: 		{ return __e32_atomic_cas_ord16(&aPtr, (TUint16*)&aExpected, (TUint16)aNew); }
sl@0: 	inline static TUint32 SafeSwap(TUint32 aNewValue, TUint32& aPtr)						/**< @internalComponent */
sl@0: 		{ return __e32_atomic_swp_ord32(&aPtr, aNewValue); }
sl@0: 	inline static TUint SafeSwap(TUint aNewValue, TUint& aPtr)								/**< @internalComponent */
sl@0: 		{ return __e32_atomic_swp_ord32(&aPtr, aNewValue); }
sl@0: 	inline static TInt SafeSwap(TInt aNewValue, TInt& aPtr)									/**< @internalComponent */
sl@0: 		{ return __e32_atomic_swp_ord32(&aPtr, aNewValue); }
sl@0: 	inline static TBool CompareAndSwap(TUint32& aPtr, TUint32 aExpected, TUint32 aNew)		/**< @internalComponent */
sl@0: 		{ return __e32_atomic_cas_ord32(&aPtr, &aExpected, aNew); }
sl@0: 	inline static TBool CompareAndSwap(TUint& aPtr, TUint aExpected, TUint aNew)			/**< @internalComponent */
sl@0: 		{ return __e32_atomic_cas_ord32(&aPtr, (TUint32*)&aExpected, (TUint32)aNew); }
sl@0: 	inline static TBool CompareAndSwap(TInt& aPtr, TInt aExpected, TInt aNew)				/**< @internalComponent */
sl@0: 		{ return __e32_atomic_cas_ord32(&aPtr, (TUint32*)&aExpected, (TUint32)aNew); }
sl@0: 
sl@0: 
sl@0: 	// Miscellaneous
sl@0: 	IMPORT_C static NThread* CurrentThread();
sl@0: 	IMPORT_C static TInt CurrentCpu();										/**< @internalComponent */
sl@0: 	IMPORT_C static TInt NumberOfCpus();									/**< @internalComponent */
sl@0: 	IMPORT_C static void LockSystem();
sl@0: 	IMPORT_C static void UnlockSystem();
sl@0: 	IMPORT_C static TBool FlashSystem();
sl@0: 	IMPORT_C static void WaitForAnyRequest();
sl@0: 	IMPORT_C static void Sleep(TUint32 aTime);
sl@0: 	IMPORT_C static void Exit();
sl@0: 	IMPORT_C static void DeferredExit();
sl@0: 	IMPORT_C static void YieldTimeslice();									/**< @internalComponent */
sl@0: 	IMPORT_C static void RotateReadyList(TInt aPriority);					
sl@0: 	IMPORT_C static void RotateReadyList(TInt aPriority, TInt aCpu);		/**< @internalTechnology */
sl@0: 	IMPORT_C static void RecordIntLatency(TInt aLatency, TInt aIntMask);	/**< @internalTechnology */
sl@0: 	IMPORT_C static void RecordThreadLatency(TInt aLatency);				/**< @internalTechnology */
sl@0: 	IMPORT_C static TUint32 TickCount();
sl@0: 	IMPORT_C static TInt TickPeriod();
sl@0: 	IMPORT_C static TInt TimerTicks(TInt aMilliseconds);
sl@0: 	IMPORT_C static TInt TimesliceTicks(TUint32 aMicroseconds);				/**< @internalTechnology */
sl@0: 	IMPORT_C static TInt CurrentContext();
sl@0: 	IMPORT_C static TUint32 FastCounter();
sl@0: 	IMPORT_C static TInt FastCounterFrequency();
sl@0: 	IMPORT_C static TUint64 Timestamp();
sl@0: 	IMPORT_C static TUint32 TimestampFrequency();
sl@0: 	static void Init0(TAny* aVariantData);
sl@0: 	static void Init(NThread* aThread, SNThreadCreateInfo& aInfo);
sl@0: 	static TInt BootAP(volatile SAPBootInfo* aInfo);
sl@0: 	IMPORT_C static TBool KernelLocked(TInt aCount=0);						/**< @internalTechnology */
sl@0: 	IMPORT_C static NFastMutex* HeldFastMutex();							/**< @internalTechnology */
sl@0: 	static void Idle();	
sl@0: 	IMPORT_C static SCpuIdleHandler* CpuIdleHandler();						/**< @internalTechnology */
sl@0: 	static void NotifyCrash(const TAny* a0, TInt a1);						/**< @internalTechnology */
sl@0: 	IMPORT_C static TBool Crashed();
sl@0: 	static TUint32 IdleGenerationCount();
sl@0: 
sl@0: 	// Debugger support
sl@0: 	typedef void (*TRescheduleCallback)(NThread*);
sl@0: 	IMPORT_C static void SchedulerHooks(TLinAddr& aStart, TLinAddr& aEnd);
sl@0: 	IMPORT_C static void InsertSchedulerHooks();
sl@0: 	IMPORT_C static void RemoveSchedulerHooks();
sl@0: 	IMPORT_C static void SetRescheduleCallback(TRescheduleCallback aCallback);
sl@0: 
sl@0: 	// Interrupts
sl@0: 	enum TIrqInitFlags
sl@0: 		{
sl@0: 		EIrqInit_FallingEdge=0,
sl@0: 		EIrqInit_RisingEdge=2,
sl@0: 		EIrqInit_LevelLow=1,
sl@0: 		EIrqInit_LevelHigh=3,
sl@0: 		EIrqInit_Shared=0x10,
sl@0: 		EIrqInit_Count=0x20,
sl@0: 		};
sl@0: 
sl@0: 	enum TIrqBindFlags
sl@0: 		{
sl@0: 		EIrqBind_Raw=1,
sl@0: 		EIrqBind_Count=2,
sl@0: 		EIrqBind_Exclusive=4,
sl@0: 		EIrqBind_Tied=8
sl@0: 		};
sl@0: 
sl@0: 	enum TIrqIdBits
sl@0: 		{
sl@0: 		EIrqIndexMask = 0x0000ffff,	// bottom 16 bits is IRQ number if top 16 bits all zero
sl@0: 									// otherwise is IRQ handler index
sl@0: 		EIrqCookieMask = 0x7fff0000,
sl@0: 		EIrqCookieShift = 16
sl@0: 		};
sl@0: 
sl@0: 	static void InterruptInit0();
sl@0: 	IMPORT_C static TInt InterruptInit(TInt aId, TUint32 aFlags, TInt aVector, TUint32 aHwId, TAny* aExt=0);
sl@0: 	IMPORT_C static TInt InterruptBind(TInt aId, NIsr aIsr, TAny* aPtr, TUint32 aFlags, NSchedulable* aTied);
sl@0: 	IMPORT_C static TInt InterruptUnbind(TInt aId);
sl@0: 	IMPORT_C static TInt InterruptEnable(TInt aId);
sl@0: 	IMPORT_C static TInt InterruptDisable(TInt aId);
sl@0: 	IMPORT_C static TInt InterruptClear(TInt aId);
sl@0: 	IMPORT_C static TInt InterruptSetPriority(TInt aId, TInt aPri);
sl@0: 	IMPORT_C static TInt InterruptSetCpuMask(TInt aId, TUint32 aMask);
sl@0: 	IMPORT_C static void Interrupt(TInt aIrqNo);
sl@0: 	};
sl@0: 
sl@0: 
sl@0: /** Create a fast semaphore
sl@0: 
sl@0: 	@publishedPartner
sl@0: 	@prototype
sl@0: */
sl@0: inline NFastSemaphore::NFastSemaphore(NThreadBase* aThread)
sl@0: 	:	iCount(0),
sl@0: 		iOwningThread(aThread ? aThread : (NThreadBase*)NKern::CurrentThread())
sl@0: 	{
sl@0: 	}
sl@0: 
sl@0: 
sl@0: class TGenericIPI;
sl@0: 
sl@0: /**
sl@0: @internalComponent
sl@0: */
sl@0: typedef void (*TGenericIPIFn)(TGenericIPI*);
sl@0: 
sl@0: /**
sl@0: @internalComponent
sl@0: */
sl@0: class TGenericIPI : public SDblQueLink
sl@0: 	{
sl@0: public:
sl@0: 	void Queue(TGenericIPIFn aFunc, TUint32 aCpuMask);
sl@0: 	void QueueAll(TGenericIPIFn aFunc);
sl@0: 	void QueueAllOther(TGenericIPIFn aFunc);
sl@0: 	void WaitEntry();
sl@0: 	void WaitCompletion();
sl@0: public:
sl@0: 	TGenericIPIFn			iFunc;
sl@0: 	volatile TUint32		iCpusIn;
sl@0: 	volatile TUint32		iCpusOut;
sl@0: 	};
sl@0: 
sl@0: /**
sl@0: @internalComponent
sl@0: */
sl@0: class TStopIPI : public TGenericIPI
sl@0: 	{
sl@0: public:
sl@0: 	void StopCPUs();
sl@0: 	void ReleaseCPUs();
sl@0: 	static void Isr(TGenericIPI*);
sl@0: public:
sl@0: 	volatile TInt iFlag;
sl@0: 	};
sl@0: 
sl@0: #include <ncern.h>
sl@0: #endif