// 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