// Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

 // All rights reserved.

 // This component and the accompanying materials are made available

 // under the terms of the License "Eclipse Public License v1.0"

 // which accompanies this distribution, and is available

 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

 //

 // Initial Contributors:

 // Nokia Corporation - initial contribution.

 //

 // Contributors:

 //

 // Description:

 // e32\nkernsmp\nk_irq.cpp

 // 

 //

 /**

  @file

  @internalTechnology

 */

 #include <e32cmn.h>

 #include <e32cmn_private.h>

 #include "nk_priv.h"

 #include <nk_irq.h>

 NIrq		Irq[NK_MAX_IRQS];

 NIrqHandler	Handlers[NK_MAX_IRQ_HANDLERS];

 NIrqHandler* NIrqHandler::FirstFree;

 extern "C" void send_irq_ipi(TSubScheduler*);

 void StepCookie(volatile TUint16& p, TInt n)

 	{

 	TUint32 x = p<<17;

 	while(n--)

 		{

 		TUint32 y = x;

 		x<<=1;

 		y^=x;

 		x |= ((y>>31)<<17);

 		}

 	p = (TUint16)(x>>17);

 	}

 NIrq::NIrq()

 	:	iNIrqLock(TSpinLock::EOrderNIrq)

 	{

 	iIState = EWait;

 	iEventsPending = 0;

 	iEnabledEvents = 0;

 	iHwId = 0;

 	iX = 0;

 	}

 TInt NIrq::BindRaw(NIsr aIsr, TAny* aPtr)

 	{

 	// Call only from thread context

 	TInt r = KErrNone;

 	Wait();

 	iNIrqLock.LockOnly();

 	if (iStaticFlags & EShared)

 		{

 		r = KErrAccessDenied;

 		goto error;

 		}

 	if ( (iIState & ERaw) || !iHandlers.IsEmpty())

 		{

 		r = KErrInUse;

 		goto error;

 		}

 	iHandlers.iA.iNext = (SDblQueLink*)aIsr;

 	iHandlers.iA.iPrev = (SDblQueLink*)aPtr;

 	__e32_atomic_ior_rel32(&iIState, ERaw);

 error:

 	iNIrqLock.UnlockOnly();

 	Done();

 	return r;

 	}

 TInt NIrq::UnbindRaw()

 	{

 	// Call only from thread context

 	TInt r = DisableRaw(TRUE);

 	if (r != KErrNone)

 		return r;

 	Wait();

 	iNIrqLock.LockOnly();

 	if (iIState & ERaw)

 		{

 		iHandlers.iA.iNext = 0;

 		iHandlers.iA.iPrev = 0;

 		++iGeneration;	// release anyone still waiting in Disable()

 		__e32_atomic_and_rel32(&iIState, ~(ERaw|EUnbind));

 		}

 	iNIrqLock.UnlockOnly();

 	Done();

 	return r;

 	}

 TInt NIrq::DisableRaw(TBool aUnbind)

 	{

 	TBool wait = FALSE;

 	TInt r = KErrNone;

 	TInt irq = __SPIN_LOCK_IRQSAVE(iNIrqLock);

 	if (!(iIState & ERaw))

 		r = KErrGeneral;

 	else

 		{

 		wait = TRUE;

 		if (aUnbind)

 			__e32_atomic_ior_acq32(&iIState, EUnbind);

 		if (!(iEnabledEvents & 1))

 			{

 			iEnabledEvents |= 1;

 			HwDisable();

 //			wait = TRUE;

 			}

 		}

 	__SPIN_UNLOCK_IRQRESTORE(iNIrqLock,irq);

 	TInt c = NKern::CurrentContext();

 	if (wait && c!=NKern::EInterrupt)

 		{

 		// wait for currently running handler to finish or interrupt to be reenabled

 		if (c==NKern::EThread)

 			NKern::ThreadEnterCS();

 		HwWaitCpus();	// ensure other CPUs have had a chance to accept any outstanding interrupts

 		TUint32 g = iGeneration;

 		while ( ((iIState >> 16) || HwPending()) && (iGeneration == g))

 			{

 			__chill();

 			}

 		if (c==NKern::EThread)

 			NKern::ThreadLeaveCS();

 		}

 	return r;

 	}

 TInt NIrq::EnableRaw()

 	{

 	TInt r = KErrNone;

 	TInt irq = __SPIN_LOCK_IRQSAVE(iNIrqLock);

 	if (!(iIState & ERaw))

 		r = KErrGeneral;

 	else if (iIState & EUnbind)

 		r = KErrNotReady;

 	else if (iEnabledEvents & 1)

 		{

 		iEnabledEvents = 0;

 		HwEnable();

 		++iGeneration;

 		}

 	__SPIN_UNLOCK_IRQRESTORE(iNIrqLock,irq);

 	return r;

 	}

 TInt NIrq::Bind(NIrqHandler* aH)

 	{

 	// Call only from thread context

 	TInt r = KErrInUse;

 	Wait();

 	if (!(iIState & ERaw))

 		{

 		r = KErrNone;

 		TBool empty = iHandlers.IsEmpty();

 		TBool shared = iStaticFlags & EShared;

 		TBool exclusive = iIState & NIrqHandler::EExclusive;

 		if (!empty)

 			{

 			if (!shared || exclusive)

 				{

 				r = KErrAccessDenied;

 				goto error;

 				}

 			NIrqHandler* h = _LOFF(iHandlers.First(), NIrqHandler, iIrqLink);

 			if (h->iHState & NIrqHandler::EExclusive)

 				{

 				r = KErrAccessDenied;

 				goto error;

 				}

 			}

 		aH->iIrq = this;

 		iHandlers.Add(&aH->iIrqLink);

 		}

 error:

 	Done();

 	return r;

 	}

 void NIrq::HwIsr()

 	{

 	TRACE_IRQ12(16, this, iVector, iIState);

 	TBool eoi_done = FALSE;

 	TUint32 rcf0 = EnterIsr();		// for initial run count

 	TUint32 rcf1 = iIState;			// might have changed while we were waiting in EnterIsr()

 	if (rcf1 & ERaw)

 		{

 		if (!(rcf1 & EUnbind))

 			{

 			NIsr f = (NIsr)iHandlers.iA.iNext;

 			TAny* p = iHandlers.iA.iPrev;

 			(*f)(p);

 			}

 		HwEoi();

 		IsrDone();

 		return;

 		}

 	if (rcf0 >> 16)

 		{

 		HwEoi();

 		return;

 		}

 	if (!(iStaticFlags & ELevel))

 		{

 		eoi_done = TRUE;

 		HwEoi();

 		}

 	do	{

 		// Handler list can't be touched now

 		SDblQueLink* anchor = &iHandlers.iA;

 		SDblQueLink* p = anchor->iNext;

 		while (p != anchor)

 			{

 			NIrqHandler* h = _LOFF(p, NIrqHandler, iIrqLink);

 			h->Activate(1);

 			p = p->iNext;

 			}

 		if (!eoi_done)

 			{

 			eoi_done = TRUE;

 			HwEoi();

 			}

 		if ((iStaticFlags & ELevel) && iEventsPending)

 			{

 			// For a level triggered interrupt make sure interrupt is disabled until

 			// all pending event handlers have run, to avoid a continuous interrupt.

 			TInt irq = __SPIN_LOCK_IRQSAVE(iNIrqLock);

 			if (iEventsPending)

 				{

 				iEnabledEvents |= 1;

 				HwDisable();

 				}

 			__SPIN_UNLOCK_IRQRESTORE(iNIrqLock,irq);

 			}

 		} while (IsrDone());

 	}

 void NIrqHandler::Activate(TInt aCount)

 	{

 	TUint32 orig = DoActivate(aCount);

 	TRACE_IRQ12(17, this, orig, aCount);

 	if (orig & (EDisable|EUnbind|EActive))

 		return;	// disabled or already active

 	if (iTied)

 		{

 		// we need to enforce mutual exclusion between the event handler

 		// and the tied thread or thread group, so the event handler must

 		// run on the CPU to which the thread or group is currently attached

 		// once the event has been attached to that CPU, the thread/group

 		// can't be migrated until the event handler completes.

 		// need a pending event count for the tied thread/group

 		// so we know when the thread/group can be migrated

 		TInt tied_cpu = iTied->BeginTiedEvent();

 		TInt this_cpu = NKern::CurrentCpu();

 		if (tied_cpu != this_cpu)

 			{

 			__e32_atomic_add_acq32(&iIrq->iEventsPending, 1);

 			TheSubSchedulers[tied_cpu].QueueEventAndKick(this);

 			// FIXME: move IRQ over to tied CPU if this is the only handler for that IRQ

 			//			what to do about shared IRQs?

 			return;

 			}

 		}

 	// event can run on this CPU so run it now

 	if (aCount)

 		{

 		orig = EventBegin();

 		TRACE_IRQ8(18, this, orig);

 		(*iFn)(iPtr);

 		orig = EventDone();

 		TRACE_IRQ8(19, this, orig);

 		if (!(orig & EActive))

 			{

 			if (iTied)

 				iTied->EndTiedEvent();

 			return;	// that was last occurrence or event now disabled

 			}

 		}

 	__e32_atomic_add_ord32(&iIrq->iEventsPending, 1);

 //	add event to this cpu

 	SubScheduler().QueueEventAndKick(this);

 	}

 NIrqHandler::NIrqHandler()

 	{

 	iIrqLink.iNext = 0;

 	iIrq = 0;

 	iTied = 0;

 	iHState = EDisable|EBind|ENotReady|EEventHandlerIrq;

 	iFn = 0;

 	iPtr = 0;

 	memclr(iNIrqHandlerSpare, sizeof(iNIrqHandlerSpare));

 	}

 void NIrqHandler::Free()

 	{

 	NKern::Lock();

 	NEventHandler::TiedLock.LockOnly();

 	if (!iTied)	// Only free if iTied has been cleared

 		{

 		iIrqLink.iNext = FirstFree;

 		FirstFree = this;

 		}

 	NEventHandler::TiedLock.UnlockOnly();

 	NKern::Unlock();

 	}

 NIrqHandler* NIrqHandler::Alloc()

 	{

 	NKern::Lock();

 	NEventHandler::TiedLock.LockOnly();

 	NIrqHandler* p = FirstFree;

 	if (p)

 		FirstFree = (NIrqHandler*)p->iIrqLink.iNext;

 	NEventHandler::TiedLock.UnlockOnly();

 	NKern::Unlock();

 	if (p)

 		new (p) NIrqHandler();

 	return p;

 	}

 TInt NIrqHandler::Enable(TInt aHandle)

 	{

 	// call from any context

 	TBool reactivate = FALSE;

 	TInt r = KErrNotReady;

 	NIrq* pI = iIrq;

 	if (!pI)

 		return KErrNotReady;

 	TInt irq = __SPIN_LOCK_IRQSAVE(pI->iNIrqLock);	// OK since NIrq's are never deleted

 	if (iIrq==pI && TUint(aHandle)==iHandle)	// check handler not unbound

 		{

 		TUint32 orig = DoSetEnabled();	// clear EDisable and EBind provided neither EUnbind nor ENotReady set

 		if (!(orig & (EUnbind|ENotReady)))

 			{

 			r = KErrNone;

 			if (orig & EDisable)	// check not already enabled

 				{

 				++iGeneration;

 				TUint32 n = pI->iEnabledEvents;

 				pI->iEnabledEvents += 2;

 				if (n==0)

 					pI->HwEnable();	// enable HW interrupt if this is first handler to be enabled

 				if ((orig >> 16) && !(orig & EActive))

 					// replay remembered interrupt(s)

 					reactivate = TRUE;

 				}

 			}

 		}

 	if (reactivate)

 		{

 		pI->iNIrqLock.UnlockOnly();

 		Activate(0);

 		pI->iNIrqLock.LockOnly();

 		}

 	__SPIN_UNLOCK_IRQRESTORE(pI->iNIrqLock,irq);

 	return r;

 	}

 TInt NIrqHandler::Disable(TBool aUnbind, TInt aHandle)

 	{

 	// call from any context

 	NIrq* pI = iIrq;

 	if (!pI)

 		return KErrGeneral;

 	TInt irq = __SPIN_LOCK_IRQSAVE(pI->iNIrqLock);	// OK since NIrq's are never deleted

 	if (iIrq != pI || TUint(aHandle)!=iHandle)	// check handler not unbound

 		{

 		__SPIN_UNLOCK_IRQRESTORE(pI->iNIrqLock,irq);

 		return KErrGeneral;

 		}

 	TInt r = aUnbind ? KErrGeneral : KErrNone;

 	TUint32 f = aUnbind ? EUnbind|EDisable : EDisable;

 	TUint32 orig = __e32_atomic_ior_acq32(&iHState, f);

 	TUint32 g = iGeneration;

 	if (!(orig & EDisable))	// check not already disabled

 		{

 		pI->iEnabledEvents -= 2;

 		if (!pI->iEnabledEvents)

 			pI->HwDisable();	// disable HW interrupt if no more enabled handlers

 		}

 	if (aUnbind && !(orig & EUnbind))

 		{

 		volatile TUint16& cookie = *(volatile TUint16*)(((TUint8*)&iHandle)+2);

 		StepCookie(cookie, 1);

 		r = KErrNone;

 		}

 	__SPIN_UNLOCK_IRQRESTORE(pI->iNIrqLock,irq);

 	if (NKern::CurrentContext() != NKern::EInterrupt)

 		{

 		// wait for currently running handler to finish or interrupt to be reenabled

  		while ((iHState & EActive) && (iGeneration == g))

 			{

 			__chill();

 			}

 		}

 	return r;

 	}

 TInt NIrqHandler::Unbind(TInt aId, NSchedulable* aTied)

 	{

 	TInt r = Disable(TRUE, aId);	// waits for any current activation of ISR to finish

 	if (r==KErrNone || aTied)	// returns KErrGeneral if someone else already unbound this interrupt handler

 		{

 		// Possible race condition here between tied thread termination and interrupt unbind.

 		// We need to be sure that the iTied field must be NULL before the tied thread/group

 		// is destroyed.

 		NKern::Lock();

 		NEventHandler::TiedLock.LockOnly();	// this guarantees pH->iTied cannot change

 		NSchedulable* t = iTied;

 		if (t)

 			{

 			// We need to guarantee the object pointed to by t cannot be deleted until we

 			// have finished with it.

 			t->AcqSLock();

 			if (iTiedLink.iNext)

 				{

 				iTiedLink.Deque();

 				iTiedLink.iNext = 0;

 				iTied = 0;

 				}

 			if (aTied && aTied==t)

 				iTied = 0;

 			t->RelSLock();

 			}

 		NEventHandler::TiedLock.UnlockOnly();

 		NKern::Unlock();

 		}

 	if (r==KErrNone)

 		{

 		DoUnbind();

 		Free();

 		}

 	return r;

 	}

 void NIrqHandler::DoUnbind()

 	{

 	// Call only from thread context

 	NIrq* pI = iIrq;

 	pI->Wait();

 	iIrqLink.Deque();

 	iIrq = 0;

 	pI->Done();

 	}

 TBool TSubScheduler::QueueEvent(NEventHandler* aEvent)

 	{

 	TInt irq = __SPIN_LOCK_IRQSAVE(iEventHandlerLock);

 	TBool pending = iEventHandlersPending;

 	iEventHandlersPending = TRUE;

 	iEventHandlers.Add(aEvent);

 	__SPIN_UNLOCK_IRQRESTORE(iEventHandlerLock,irq);

 	return !pending;

 	}

 void TSubScheduler::QueueEventAndKick(NEventHandler* aEvent)

 	{

 	if (QueueEvent(aEvent))

 		{

 		// extra barrier ?

 		send_irq_ipi(this);

 		}

 	}

 extern "C" void run_event_handlers(TSubScheduler* aS)

 	{

 	while (aS->iEventHandlersPending)

 		{

 		TInt irq = __SPIN_LOCK_IRQSAVE(aS->iEventHandlerLock);

 		if (aS->iEventHandlers.IsEmpty())

 			{

 			aS->iEventHandlersPending = FALSE;

 			__SPIN_UNLOCK_IRQRESTORE(aS->iEventHandlerLock, irq);

 			break;

 			}

 		NIrqHandler* h = (NIrqHandler*)aS->iEventHandlers.First()->Deque();

 		if (aS->iEventHandlers.IsEmpty())

 			aS->iEventHandlersPending = FALSE;

 		TInt type = h->iHType;

 		NSchedulable* tied = h->iTied;

 		if (type == NEventHandler::EEventHandlerNTimer)

 			{

 			NEventFn f = h->iFn;

 			TAny* p = h->iPtr;

 			mb();	// make sure dequeue observed and iFn,iPtr,iTied sampled before state change observed

 			h->i8888.iHState1 = NTimer::EIdle; // can't touch timer again after this

 			__SPIN_UNLOCK_IRQRESTORE(aS->iEventHandlerLock, irq);

 			(*f)(p);

 			if (tied)

 				tied->EndTiedEvent();

 			continue;

 			}

 		__SPIN_UNLOCK_IRQRESTORE(aS->iEventHandlerLock, irq);

 		TBool requeue = TRUE;

 		switch (h->iHType)

 			{

 			case NEventHandler::EEventHandlerIrq:

 				{

 				TUint32 orig;

 				// event can run on this CPU so run it now

 				// if event tied, migration of tied thread/group will have been blocked

 				orig = h->EventBegin();

 				TRACE_IRQ8(20, h, orig);

 				(*h->iFn)(h->iPtr);

 				TRACE_IRQ4(21, h);

 				if (!(h->iHState & NIrqHandler::ERunCountMask))	// if run count still nonzero, definitely still active

 					{

 					NIrq* pI = h->iIrq;

 					irq = __SPIN_LOCK_IRQSAVE(pI->iNIrqLock);

 					orig = h->EventDone();

 					TRACE_IRQ8(22, h, orig);

 					if (!(orig & NIrqHandler::EActive))

 						{

 						// handler is no longer active - can't touch it again

 						// pI is OK since NIrq's are never deleted/reused

 						requeue = FALSE;

 						if (__e32_atomic_add_rel32(&pI->iEventsPending, TUint32(-1)) == 1)

 							{

 							if (pI->iEnabledEvents & 1)

 								{

 								pI->iEnabledEvents &= ~1;

 								if (pI->iEnabledEvents)

 									pI->HwEnable();

 								}

 							}

 						}

 					__SPIN_UNLOCK_IRQRESTORE(pI->iNIrqLock,irq);

 					}

 				break;

 				}

 			default:

 				__KTRACE_OPT(KPANIC,DEBUGPRINT("h=%08x",h));

 				__NK_ASSERT_ALWAYS(0);

 			}

 		if (tied && !requeue)

 			{

 			// If the tied thread/group has no more tied events outstanding

 			// and has a migration pending, trigger the migration now.

 			// Atomically change the tied_cpu to the target CPU here. An IDFC

 			// can then effect the migration.

 			// Note that the tied code can't run in parallel with us until

 			// the tied_cpu is changed. However it could run as soon as the

 			// tied_cpu is changed (e.g. if added to ready list after change)

 			tied->EndTiedEvent();

 			}

 		if (requeue)

 			{

 			// still pending so put it back on the queue

 			// leave interrupt disabled (if so) and migration of tied thread/group blocked

 			aS->QueueEvent(h);

 			}

 		}

 	}

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

  * Public interrupt management functions

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

 void NKern::InterruptInit0()

 	 {

 	 TInt i;

 	 TUint16 cookie = 1;

 	 NIrqHandler::FirstFree = 0;

 	 for (i=NK_MAX_IRQ_HANDLERS-1; i>=0; --i)

 		 {

 		 StepCookie(cookie, 61);

 		 NIrqHandler* h = &::Handlers[i];

 		__KTRACE_OPT(KBOOT,DEBUGPRINT("NIrqHandler[%d] at %08x", i, h));

 		 h->iGeneration = 0;

 		 h->iHandle = (cookie << 16) | i;

 		 h->iIrqLink.iNext = NIrqHandler::FirstFree;

 		 NIrqHandler::FirstFree = h;

 		 }

 	 NIrq::HwInit0();

 	 }

 EXPORT_C TInt NKern::InterruptInit(TInt aId, TUint32 aFlags, TInt aVector, TUint32 aHwId, TAny* aExt)

 	{

 	__KTRACE_OPT(KBOOT,DEBUGPRINT("NKII: ID=%02x F=%08x V=%03x HWID=%08x X=%08x", aId, aFlags, aVector, aHwId, aExt));

 	TRACE_IRQ12(0, (aId|(aVector<<16)), aFlags, aHwId);

 	if (TUint(aId) >= TUint(NK_MAX_IRQS))

   		return KErrArgument;

 	NIrq* pI = &Irq[aId];

 	__KTRACE_OPT(KBOOT,DEBUGPRINT("NIrq[%02x] at %08x", aId, pI));

 	TRACE_IRQ8(1, aId, pI);

 	new (pI) NIrq;

 	pI->iX = (NIrqX*)aExt;

 	pI->iIndex = (TUint16)aId;

 	pI->iHwId = aHwId;

 	pI->iVector = aVector;

 	pI->iStaticFlags = (TUint16)(aFlags & 0x13);

 	if (aFlags & NKern::EIrqInit_Count)

 		pI->iIState |= NIrq::ECount;

 	pI->HwInit();

 	__e32_atomic_and_rel32(&pI->iIState, ~NIrq::EWait);

 	return KErrNone;

 	}

 EXPORT_C TInt NKern::InterruptBind(TInt aId, NIsr aIsr, TAny* aPtr, TUint32 aFlags, NSchedulable* aTied)

 	{

 	__KTRACE_OPT(KNKERN,DEBUGPRINT(">NKIB: ID=%02x ISR=%08x(%08x) F=%08x T=%T", aId, aIsr, aPtr, aFlags, aTied));

 	TRACE_IRQ12(2, aId, aIsr, aPtr);

 	TRACE_IRQ12(3, aId, aFlags, aTied);

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

 	if (TUint(aId) >= TUint(NK_MAX_IRQS))

 		{

 		TRACE_IRQ8(4, aId, KErrArgument);

 		return KErrArgument;

 		}

 	NIrq* pI = &Irq[aId];

 	NIrqHandler* pH = 0;

 	NSchedulable* pT = 0;

 	if (aFlags & NKern::EIrqBind_Tied)

 		{

 		if (!aTied)

 			aTied = NKern::CurrentThread();

 		pT = aTied;

 		}

 	TInt r = KErrNoMemory;

 	TInt handle = 0;

 	NKern::ThreadEnterCS();

 	if (!(aFlags & NKern::EIrqBind_Raw))

 		{

 		pH = NIrqHandler::Alloc();

 		if (!pH)

 			goto out;

 		pH->iFn = aIsr;

 		pH->iPtr = aPtr;

 		__e32_atomic_add_ord32(&pH->iGeneration, 1);

 		if (aFlags & EIrqBind_Exclusive)

 			pH->iHState |= NIrqHandler::EExclusive;

 		if (aFlags & EIrqBind_Count)

 			pH->iHState |= NIrqHandler::ECount;

 		r = pI->Bind(pH);

 		if (r==KErrNone)

 			{

 			handle = pH->iHandle;

 			// We assume that aTied cannot disappear entirely before we return

 			if (pT)

 				{

 				NKern::Lock();

 				r = pT->AddTiedEvent(pH);

 				NKern::Unlock();

 				}

 			if (r!=KErrNone)

 				{

 				// unbind

 				pH->DoUnbind();

 				}

 			}

 		if (r!=KErrNone)

 			pH->Free();

 		}

 	else

 		{

 		if (aFlags & NKern::EIrqBind_Tied)

 			r = KErrNotSupported;

 		else

 			r = pI->BindRaw(aIsr, aPtr);

 		}

 out:

 	if (r==KErrNone)

 		{

 		// clear ENotReady so handler can be enabled

 		__e32_atomic_and_rel32(&pH->iHState, ~NIrqHandler::ENotReady);

 		r = handle;

 		}

 	NKern::ThreadLeaveCS();

 	__KTRACE_OPT(KNKERN,DEBUGPRINT("<NKIB: %08x", r));

 	TRACE_IRQ8(4, aId, r);

 	return r;

 	}

 TInt NIrq::FromHandle(TInt& aHandle, NIrq*& aIrq, NIrqHandler*& aHandler)

 	{

 	TRACE_IRQ4(5, aHandle);

 	aIrq = 0;

 	aHandler = 0;

 	NIrqHandler* pH = 0;

 	NIrqHandler* pH2 = 0;

 	NIrq* pI = 0;

 	SDblQueLink* anchor = 0;

 	TUint32 i;

 	TInt r = KErrArgument;

 	if (aHandle & NKern::EIrqCookieMask)

 		{

 		i = aHandle & NKern::EIrqIndexMask;

 		if (i>=NK_MAX_IRQ_HANDLERS)

 			goto out;

 		pH = &::Handlers[i];

 		if (pH->iHandle != TUint(aHandle))

 			goto out;

 		aHandler = pH;

 		aIrq = pH->iIrq;

 		r = KErrNone;

 		goto out;

 		}

 	if (TUint32(aHandle)>=NK_MAX_IRQS)

 		goto out;

 	pI = &::Irq[aHandle];

 	if (pI->iIState & NIrq::ERaw)

 		{

 		aIrq = pI;

 		r = KErrNone;

 		goto out;

 		}

 	if (pI->iStaticFlags & NIrq::EShared)

 		goto out;

 	anchor = &pI->iHandlers.iA;

 	pH = _LOFF(anchor->iNext, NIrqHandler, iIrqLink);

 	i = pH - ::Handlers;

 	if (i>=NK_MAX_IRQ_HANDLERS)

 		goto out;

 	pH2 = &::Handlers[i];

 	if (pH2 != pH)

 		goto out;

 	if (pH->iIrq != pI || anchor->iPrev != anchor->iNext)

 		goto out;

 	aHandle = pH->iHandle;

 	aHandler = pH;

 	aIrq = pI;

 	r = KErrNone;

 out:

 	TRACE_IRQ4(6, r);

 	TRACE_IRQ12(7, aHandle, aIrq, aHandler);

 	return r;

 	}

 EXPORT_C TInt NKern::InterruptUnbind(TInt aId)

 	{

 	TRACE_IRQ4(8, aId);

 	__KTRACE_OPT(KNKERN,DEBUGPRINT(">NKIU: ID=%08x", aId));

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

 	NIrq* pI;

 	NIrqHandler* pH;

 	TInt r = NIrq::FromHandle(aId, pI, pH);

 	if (r!=KErrNone)

 		return r;

 	NKern::ThreadEnterCS();

 	if (!pH)

 		{

 		// raw ISR

 		r = pI->UnbindRaw();

 		}

 	else

 		{

 		r = pH->Unbind(aId, 0);

 		}

 	NKern::ThreadLeaveCS();

 	TRACE_IRQ4(9, r);

 	return r;

 	}

 EXPORT_C TInt NKern::InterruptEnable(TInt aId)

 	{

 	__KTRACE_OPT(KNKERN,DEBUGPRINT(">NKIE: ID=%08x", aId));

 	TRACE_IRQ4(10, aId);

 	NIrq* pI;

 	NIrqHandler* pH;

 	TInt r = NIrq::FromHandle(aId, pI, pH);

 	if (r==KErrNone)

 		r = pH ? pH->Enable(aId) : pI->EnableRaw();

 	TRACE_IRQ4(11, r);

 	return r;

 	}

 EXPORT_C TInt NKern::InterruptDisable(TInt aId)

 	{

 	__KTRACE_OPT(KNKERN,DEBUGPRINT(">NKID: ID=%08x", aId));

 	TRACE_IRQ4(12, aId);

 	NIrq* pI;

 	NIrqHandler* pH;

 	TInt r = NIrq::FromHandle(aId, pI, pH);

 	if (r==KErrNone)

 		r = pH ? pH->Disable(FALSE, aId) : pI->DisableRaw(FALSE);

 	TRACE_IRQ4(13, r);

 	return r;

 	}

 EXPORT_C TInt NKern::InterruptClear(TInt aId)

 	{

 	__KTRACE_OPT(KNKERN,DEBUGPRINT(">NKIC: ID=%08x", aId));

 	return KErrNotSupported;

 	}

 EXPORT_C TInt NKern::InterruptSetPriority(TInt aId, TInt aPri)

 	{

 	__KTRACE_OPT(KNKERN,DEBUGPRINT(">NKIS: ID=%08x PRI=%08x", aId, aPri));

 	return KErrNotSupported;

 	}

 EXPORT_C TInt NKern::InterruptSetCpuMask(TInt aId, TUint32 aMask)

 	{

 	__KTRACE_OPT(KNKERN,DEBUGPRINT(">NKIM: ID=%08x M=%08x", aId, aMask));

 	return KErrNotSupported;

 	}

 EXPORT_C void NKern::Interrupt(TInt aId)

 	{

 	__NK_ASSERT_ALWAYS(TUint(aId) < TUint(NK_MAX_IRQS));

 	NIrq* pI = &Irq[aId];

 	pI->HwIsr();

 	}