// 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();

	}