// Copyright (c) 2006-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\dfcs.cpp

// DFCs

// 

//

// NThreadBase member data

#define __INCLUDE_NTHREADBASE_DEFINES__

// TDfc member data

#define __INCLUDE_TDFC_DEFINES__

#include "nk_priv.h"

extern "C" void send_self_resched_ipi();

/** Construct an IDFC

	@param aFunction = function to call

	@param aPtr = parameter to be passed to function

 */

EXPORT_C TDfc::TDfc(TDfcFn aFunction, TAny* aPtr)

	{

	iPtr = aPtr;

	iFn = aFunction;

	iTied = 0;

	iHType = EEventHandlerIDFC;

	i8888.iHState0 = 0;

	i8888.iHState1 = 0;

	i8888.iHState2 = 0;

	iTiedLink.iNext = 0;

	}

/** Construct an IDFC tied to a thread or group

	@param aTied = pointer to thread or group to which IDFC should be tied

	@param aFunction = function to call

	@param aPtr = parameter to be passed to function

	@pre Call in thread context, interrupts enabled

 */

EXPORT_C TDfc::TDfc(NSchedulable* aTied, TDfcFn aFunction, TAny* aPtr)

	{

	iPtr = aPtr;

	iFn = aFunction;

	iTied = 0;

	iHType = EEventHandlerIDFC;

	i8888.iHState0 = 0;

	i8888.iHState1 = 0;

	i8888.iHState2 = 0;

	iTiedLink.iNext = 0;

	if (aTied)

		{

		SetTied(aTied);

		}

	}

/** Construct a DFC without specifying a DFC queue.

	The DFC queue must be set before the DFC may be queued.

	@param aFunction = function to call

	@param aPtr = parameter to be passed to function

	@param aPriority = priority of DFC within the queue (0 to 7, where 7 is highest)

 */

EXPORT_C TDfc::TDfc(TDfcFn aFunction, TAny* aPtr, TInt aPriority)

	{

	__NK_ASSERT_DEBUG((TUint)aPriority<(TUint)KNumDfcPriorities);

	iPtr = aPtr;

	iFn = aFunction;

	iTied = 0;

	iHType = TUint8(aPriority);

	i8888.iHState0 = 0;

	i8888.iHState1 = 0;

	i8888.iHState2 = 0;

	iTiedLink.iNext = 0;

	}

/** Construct a DFC specifying a DFC queue.

	@param aFunction = function to call

	@param aPtr = parameter to be passed to function

	@param aDfcQ = pointer to DFC queue which this DFC should use

	@param aPriority = priority of DFC within the queue (0-7)

 */

EXPORT_C TDfc::TDfc(TDfcFn aFunction, TAny* aPtr, TDfcQue* aDfcQ, TInt aPriority)

	{

	__NK_ASSERT_DEBUG((TUint)aPriority<(TUint)KNumDfcPriorities);

	iPtr = aPtr;

	iFn = aFunction;

	iDfcQ = aDfcQ;

	iHType = TUint8(aPriority);

	i8888.iHState0 = 0;

	i8888.iHState1 = 0;

	i8888.iHState2 = 0;

	iTiedLink.iNext = 0;

	}

/** Tie an IDFC to a thread or group

	@param	aTied = pointer to thread or group to which IDFC should be tied

	@return	KErrNone if successful

	@return	KErrDied if thread has exited or group has been destroyed.

	@pre Call in thread context, interrupts enabled

	@pre Must be IDFC not DFC

	@pre IDFC must not be queued or running

	@pre IDFC must not already be tied

 */

EXPORT_C TInt TDfc::SetTied(NSchedulable* aTied)

	{

	__NK_ASSERT_ALWAYS(IsIDFC() && i8816.iHState16==0);

	__NK_ASSERT_ALWAYS(aTied && !iTied);

	NKern::Lock();

	TInt r = aTied->AddTiedEvent(this);

	__NK_ASSERT_ALWAYS(r==KErrNone || r==KErrDied);

	NKern::Unlock();

	return r;

	}

/** Destroy a DFC or IDFC

	@pre Call from thread context with interrupts and preemption enabled

	@pre Calling thread holds no fast mutex

	@pre Calling thread in critical section

 */

EXPORT_C TDfc::~TDfc()

	{

	CHECK_PRECONDITIONS(MASK_THREAD_CRITICAL,"TDfc::~TDfc");

	NKern::Lock();

	NEventHandler::TiedLock.LockOnly();

	NSchedulable* tied = iTied;

	if (IsDFC() || (IsIDFC() && !tied))

		{

		Cancel();

		iHType = (TUint8)EEventHandlerDummy;

		}

	if (IsIDFC())

		{

		__NK_ASSERT_ALWAYS(tied!=0);

		tied->AcqSLock();

		if (iTiedLink.iNext)

			{

			iTiedLink.Deque();

			iTiedLink.iNext = 0;

			}

		tied->RelSLock();

		Cancel();

		iHType = (TUint8)EEventHandlerDummy;

		iTied = 0;

		}

	NEventHandler::TiedLock.UnlockOnly();

	NKern::Unlock();

	}

/** Construct a DFC queue

	Kern::DfcQInit() should be called on the new DFC queue before it can be used.

 */

EXPORT_C TDfcQue::TDfcQue()

	: iThread(NULL)

	{}

/** Queue an IDFC or a DFC from an ISR

	This function is the only way to queue an IDFC and is the only way to queue

	a DFC from an ISR. To queue a DFC from an IDFC or a thread either Enque()

	or DoEnque() should be used.

	This function does nothing if the IDFC/DFC is already queued.

	@pre Call only from ISR, IDFC or thread with preemption disabled.

	@pre Do not call from thread with preemption enabled.

	@return	TRUE if DFC was actually queued by this call

			FALSE if DFC was already queued on entry so this call did nothing

	@see TDfc::DoEnque()

	@see TDfc::Enque()

 */

EXPORT_C TBool TDfc::Add()

	{

	__ASSERT_DEBUG(NKern::CurrentContext()!=NKern::EThread || NKern::KernelLocked(), *(int*)0xdfcadd01=0);

	__ASSERT_DEBUG(IsIDFC() || (IsDFC() && iDfcQ), *(int*)0xdfcadd03=0);

//	__ASSERT_WITH_MESSAGE_DEBUG(  NKern::CurrentContext()!=NKern::EThread  ||  NKern::KernelLocked(),"Do not call from thread with preemption enabled","TDfc::Add");

//	__ASSERT_WITH_MESSAGE_DEBUG(  IsIDFC() || (IsDFC() && iDfcQ), "DFC queue not set", "TDfc::Add");

#ifdef __WINS__

	__NK_ASSERT_ALWAYS(Interrupt.InInterrupt() || NKern::KernelLocked());

#endif

	TInt irq = NKern::DisableAllInterrupts();

	TSubScheduler& ss = SubScheduler();

	TUint32 orig = 0xFF00;

	// Transition the state to 'on normal IDFC queue'

	// 0000->008n

	// 00Cn->00En

	// All other states unchanged

	// Return original state

	if (IsValid())	// don't add if tied and tied thread/group is being/has been destroyed

		orig = AddStateChange();

	if (orig==0)

		{

		// wasn't already queued

		i8888.iHState0 = 0;	// BeginTiedEvent() not done

		ss.iDfcs.Add(this);

		ss.iDfcPendingFlag = 1;

#ifdef _DEBUG

		TUint32 st8 = DFC_STATE(this) & 0xFF;

		if (st8 != (0x80|ss.iCpuNum))

			__crash();

#endif

		}

	NKern::RestoreInterrupts(irq);

	return (orig==0 || (orig&0xFFE0)==0x00C0);

	}

/** Queue an IDFC or a DFC from any context

	This function is identical to TDfc::Add() but no checks are performed for correct usage,

	and it contains no instrumentation code.

	@return	TRUE if DFC was actually queued by this call

			FALSE if DFC was already queued on entry so this call did nothing

	@see TDfc::DoEnque()

	@see TDfc::Enque()

	@see TDfc::Add()

 */

EXPORT_C TBool TDfc::RawAdd()

	{

	TInt irq = NKern::DisableAllInterrupts();

	TSubScheduler& ss = SubScheduler();

	TUint32 orig = 0xFF00;

	if (IsValid())	// don't add if tied and tied thread/group is being/has been destroyed

		orig = AddStateChange();

	if (orig==0)

		{

		// wasn't already queued

		i8888.iHState0 = 0;	// BeginTiedEvent() not done

		ss.iDfcs.Add(this);

		ss.iDfcPendingFlag = 1;

		send_self_resched_ipi();	// ensure current CPU runs the DFC

#ifdef _DEBUG

		TUint32 st8 = DFC_STATE(this) & 0xFF;

		if (st8 != (0x80|ss.iCpuNum))

			__crash();

#endif

		// FIXME: Need to wait to ensure IRQ is active before reenabling interrupts

		}

	NKern::RestoreInterrupts(irq);

	return (orig==0 || (orig&0xFFE0)==0x00C0);

	}

/** Queue a DFC (not an IDFC) from an IDFC or thread with preemption disabled.

	This function is the preferred way to queue a DFC from an IDFC. It should not

	be used to queue an IDFC - use TDfc::Add() for this.

	This function does nothing if the DFC is already queued.

	@pre Call only from IDFC or thread with preemption disabled.

	@pre Do not call from ISR or thread with preemption enabled.

	@return	TRUE if DFC was actually queued by this call

			FALSE if DFC was already queued on entry so this call did nothing

	@see TDfc::Add()

	@see TDfc::Enque()

 */

EXPORT_C TBool TDfc::DoEnque()

	{

	__ASSERT_WITH_MESSAGE_DEBUG(  (NKern::CurrentContext()==NKern::EIDFC )||( NKern::CurrentContext()==NKern::EThread && NKern::KernelLocked()),"Do not call from ISR or thread with preemption enabled","TDfc::DoEnque");

	__NK_ASSERT_DEBUG(IsDFC());

	__ASSERT_WITH_MESSAGE_DEBUG(iDfcQ, "DFC queue not set", "TDfc::DoEnque");

	// Check not already queued and then mark queued to prevent ISRs touching this DFC

	TDfcQue* q = iDfcQ;

	NThreadBase* t = q->iThread;

	t->AcqSLock();	// also protects DFC queue

	TUint16 expect = 0;

	TBool ok = __e32_atomic_cas_acq16(&iDfcState, &expect, 1);

	if (ok)

		{

		// wasn't already queued, now marked as on final queue, which means

		// attempts to cancel will block on the thread spin lock

		TUint present = q->iPresent[0];

		q->Add((TPriListLink*)this);

		if (!present)

			t->iWaitState.UnBlockT(NThreadBase::EWaitDfc, q, KErrNone);

		}

	t->RelSLock();	// also protects DFC queue

	return ok;

	}

void TDfcQue::ThreadFunction(TAny* aDfcQ)

	{

	TDfcQue& q = *(TDfcQue*)aDfcQ;

	NThreadBase* t = NKern::CurrentThread();

	FOREVER

		{

		NKern::Lock();

		t->AcqSLock();	// also protects DFC queue

		if (q.IsEmpty())

			{

			t->iWaitState.SetUpWait(NThreadBase::EWaitDfc, 0, &q);

			RescheduleNeeded();

			t->RelSLock();	// also protects DFC queue

			NKern::Unlock();

			}

		else

			{

			TDfc* d = q.First();

			q.Remove((TPriListLink*)d);

			TDfcFn f = d->iFn;

			TAny* p = d->iPtr;

			d->ResetState();

			t->RelSLock();	// also protects DFC queue

			NKern::Unlock();

			(*f)(p);

			}

		}

	}

void TCancelIPI::Send(TDfc* aDfc, TInt aCpu)

	{

	iDfc = aDfc;

	Queue(&Isr, 1u<<aCpu);

	}

void TCancelIPI::Isr(TGenericIPI* aIPI)

	{

	TCancelIPI* p = (TCancelIPI*)aIPI;

	TDfc* d = p->iDfc;

	if (d->iNext)

		{

		// QueueDfcs() hasn't dequeued it yet

		// just dequeue it here and reset the state - QueueDfcs() will never see it

		// Note that this means we have to release the tied thread/group if necessary

		// BeginTiedEvent() has occurred if iHState0 is set and it's actually an IDFC not an NTimer

		NSchedulable* tied = (d->iHType==NEventHandler::EEventHandlerIDFC && d->i8888.iHState0) ? d->iTied : 0;

		d->Deque();

		d->ResetState();

		if (tied)

			tied->EndTiedEvent();

		}

	else

		{

		// QueueDfcs() has already dequeued it

		// state transition:

		//		XXYY->XX00

		//		XX00->0000

		// QueueDfcs() will take care of the tied thread/group

		d->CancelFinalStateChange();

		}

	}

/** Cancels an IDFC or DFC.

	This function does nothing if the IDFC or DFC is not queued.

	For any DFC or IDFC the following identity holds:

			Number of times Add() is called and returns TRUE

		+	Number of times DoEnque() is called and returns TRUE

		+	Number of times Enque() is called and returns TRUE

		+	Number of times QueueOnIdle() is called and returns TRUE

		=	Number of times Cancel() is called and returns TRUE

		+	Number of times the DFC/IDFC function executes

	@pre IDFC or thread context. Do not call from ISRs.

	@pre If the DFC function accesses the DFC object itself, the user must ensure that

	     Cancel() cannot be called while the DFC function is running.

	@return	TRUE	if the DFC was actually dequeued by this call - i.e. an

					instance of the DFC's execution has been prevented. It

					is still possible that a previous execution is still in

					progress.

			FALSE	if the DFC was not queued on entry to the call, or was in

					the process of being executed or cancelled. In this case

					it is possible that the DFC executes after this call

					returns.

	@post	However in either case it is safe to delete the DFC object on

			return from this call provided only that the DFC function does not

			refer to the DFC object itself.

 */

EXPORT_C TBool TDfc::Cancel()

	{

	enum TAction { EDeque=1, EReset=2, EIdleUnlock=4, ESendIPI=8, EWait=16 };

	CHECK_PRECONDITIONS(MASK_NOT_ISR|MASK_INTERRUPTS_ENABLED,"TDfc::Cancel");

	if (!iDfcState)

		return FALSE;

	TUint action = EIdleUnlock;

	TBool ret = FALSE;

	TInt cpu = -1;

	NSchedulable* tied = 0;

	TDfcQue* q = 0;

	NThreadBase* t = 0;

	NKern::Lock();

	TSubScheduler& ss0 = SubScheduler();

	if (IsDFC())

		q = iDfcQ, t = q->iThread, t->AcqSLock();

	TInt irq = NKern::DisableAllInterrupts();

	TheScheduler.iIdleSpinLock.LockOnly();

	// 0000->0000, XX00->ZZ00, xxYY->zzYY

	TUint state = CancelInitialStateChange();

	TUint stt = state >> 5;

	if (state & 0xFF00)

		{

		// someone else cancelling at the same time - just wait for them to finish

		action = EWait|EIdleUnlock;

		goto end;

		}

	if (state == 0)	// DFC not active

		goto end;

	// possible states here are 0001, 002g, 006m, 008m, 00Am, 00Cm, 00Em

	ret = (stt!=6);	// if running but not pending, Cancel() will not have prevented an execution

	if (state == TUint(TheScheduler.iIdleGeneration | 0x20))

		{

		// was on idle queue, BeginTiedEvent() isn't called until QueueDfcs() runs

		action = EDeque|EReset|EIdleUnlock;

		goto end;

		}

	if (state == 1)

		{

		// was on final queue, must be DFC not IDFC

		q->Remove((TPriListLink*)this);

		action = EReset|EIdleUnlock;

		goto end;

		}

	// possible states here are 002g (spilled), 006m, 008m, 00Am, 00Cm, 00Em

	// i.e. either on IDFC queue, ExIDFC queue or running

	// For IDFCs, tied thread/group is now in play.

	cpu = state & 0x1f;	// CPU it's on for states 006m, 008m, 00Am, 00Cm, 00Em

	if (stt==3 || stt==6 || stt==7)

		{

		// It's actually running - must be IDFC. A re-queue may also be pending.

		TheScheduler.iIdleSpinLock.UnlockOnly();

		TSubScheduler* ss = TheSubSchedulers + cpu;

		TDfc* expect = this;

		TBool done = __e32_atomic_cas_acq_ptr(&ss->iCurrentIDFC, &expect, 0);

		if (done)

			{

			// We cleared iCurrentIDFC so QueueDfcs() won't touch this again - we reset the state and finish up

			// We must also release the tied thread/group

			tied = iTied;

			action = EReset;

			goto end;

			}

		// QueueDfcs() got to iCurrentIDFC before we did, so we interlock with it

		// and we can leave the EndTiedEvent to it as well

		// State transition:

		//		XXAm->XX00, wait

		//		XX00->0000, don't wait

		TUint32 orig = CancelFinalStateChange() & 0xFF;

		__NK_ASSERT_ALWAYS(orig==0 || orig==state);

		action = orig ? EWait : 0;

		goto end;

		}

	// possible states here 002g (propagated), 008m, 00Am so it's either on the endogenous or exogenous IDFC queue

	if (stt==5)

		{

		// it's on the exogenous IDFC queue

		TheScheduler.iIdleSpinLock.UnlockOnly();

		TSubScheduler* ss = TheSubSchedulers + cpu;

		ss->iExIDfcLock.LockOnly();

		if (iNext)

			{

			// we got to it before QueueDfcs() on the other CPU so we can finish up here

			// QueueDfcs() will never see it again so we must release tied thread/group

			Deque();

			tied = iTied;

			ss->iExIDfcLock.UnlockOnly();

			action = EReset;

			goto end;

			}

		// QueueDfcs() on other CPU has already dequeued it - we must now interlock with RunIDFCStateChange()

		ss->iExIDfcLock.UnlockOnly();

		// State transition:

		//		XXAm->XX00, wait

		//		XX00->0000, don't wait

		// QueueDfcs() will take care of tied thread/group

		TUint32 orig = CancelFinalStateChange() & 0xFF;

		__NK_ASSERT_ALWAYS(orig==0 || orig==state);

		action = orig ? EWait : 0;

		goto end;

		}

	// possible states here 002g (propagated idle) or 008m (IDFC or DFC on endogenous DFC queue)

	if (stt==1)	// propagated idle

		cpu = TheScheduler.iIdleSpillCpu;

	// if it's on this CPU's IDFC queue we can just remove it and reset the state here

	// otherwise we send a cancel IPI to the CPU it's on

	// We are guaranteed to dequeue the DFC before it executes since the

	// QueueDfcs() on the target CPU will notice that a cancel is in progress and

	// so will not run the DFC even if it dequeues it.

	// QueueDfcs() takes care of the tied thread/group if it sees the DFC/IDFC again, otherwise

	// we must do it here.

	if (TUint(cpu) == ss0.iCpuNum)

		{

		if (IsIDFC())