// 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::InterruptBind");
	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();
	}

