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

// e32test\nkernsa\testdfc.cpp

// 

//

#include <nktest/nkutils.h>

#ifndef __SMP__

#define iNThreadBaseSpare7 iSpare7

class NSchedulable;

#endif

extern "C" TUint32 set_bit0_if_nonnull(TUint32&);

extern "C" void flip_bit0(TUint32&);

extern "C" TUint32 swap_out_if_bit0_clear(TUint32&);

#ifdef __SMP__

class TAddDfc : public TGenericIPI

#else

class TAddDfc : public NTimer

#endif

	{

public:

	TAddDfc();

	TDfc* Add(TDfc* aDfc, TUint32 aCpuMask);

	static TAddDfc* New();

#ifdef __SMP__

	static void Isr(TGenericIPI*);

#else

	static void TimerCallBack(TAny*);

	void WaitCompletion();

#endif

public:

	TDfc* iDfc;

	};

TAddDfc::TAddDfc()

#ifdef __SMP__

	:	iDfc(0)

#else

	:	NTimer(&TimerCallBack, this),

		iDfc(0)

#endif

	{

	}

TAddDfc* TAddDfc::New()

	{

	TAddDfc* p = new TAddDfc;

	TEST_OOM(p);

	return p;

	}

#ifdef __SMP__

void TAddDfc::Isr(TGenericIPI* a)

#else

void TAddDfc::TimerCallBack(TAny* a)

#endif

	{

	TAddDfc& adder = *(TAddDfc*)a;

	TDfc* dfc = (TDfc*)__e32_atomic_swp_ord_ptr(&adder.iDfc, 0);

	if (dfc)

		dfc->Add();

	}

TDfc* TAddDfc::Add(TDfc* aDfc, TUint32 aCpuMask)

	{

	TDfc* old = (TDfc*)__e32_atomic_swp_ord_ptr(&iDfc, aDfc);

#ifdef __SMP__

	Queue(&Isr, aCpuMask);

#else

	(void)aCpuMask;

	OneShot(1);

#endif

	return old;

	}

#ifndef __SMP__

void TAddDfc::WaitCompletion()

	{

	while (iDfc)

		{}

	}

#endif

class TTestDfc : public TDfc

	{

public:

	TTestDfc(TUint aId);

	TTestDfc(TUint aId, TDfcQue* aQ, TInt aPri);

	static void Run(TAny* aPtr);

	static void CheckEmpty(TInt aLine);

	static void CheckFirstEntry(TInt aLine, TUint32 aCpu, TUint32 aContext, TDfcQue* aQ, TUint32 aId);

	static CircBuf* Buffer;

	static volatile TBool Full;

	static volatile TUint32 Last;

	enum {EBufferSlots=1024};

	};

#define CHECK_EMPTY()	TTestDfc::CheckEmpty(__LINE__)

#define CHECK_FIRST_ENTRY(cpu, ctx, q, id)	TTestDfc::CheckFirstEntry(__LINE__, cpu, ctx, q, id)

CircBuf* TTestDfc::Buffer;

volatile TBool TTestDfc::Full = FALSE;

volatile TUint32 TTestDfc::Last;

TTestDfc::TTestDfc(TUint aId)

	:	TDfc(&Run, (TAny*)aId)

	{

	}

TTestDfc::TTestDfc(TUint aId, TDfcQue* aQ, TInt aPri)

	:	TDfc(&Run, (TAny*)aId, aQ, aPri)

	{

	}

void TTestDfc::Run(TAny* aPtr)

	{

	TUint32 id = (TUint32)aPtr;

	TUint32 tid = 0;

	TUint32 ctx = NKern::CurrentContext();

	TUint32 cpu = NKern::CurrentCpu();

	if (ctx == NKern::EThread)

		{

		NThread* t = NKern::CurrentThread();

		tid = t->iNThreadBaseSpare7;

		}

	TUint32 x = (cpu<<24) | (ctx<<16) | (tid<<8) | id;

	TInt r = Buffer->TryPut(x);

	if (r != KErrNone)

		Full = TRUE;

	Last = id;

	}

void TTestDfc::CheckEmpty(TInt aLine)

	{

	TInt c = Buffer->Count();

	TUint32 x;

	Buffer->TryGet(x);

	if (c!=0)

		{

		TEST_PRINT3("Line %d Buffer not empty C:%d X:%08x", aLine, c, x);

		}

	}

void TTestDfc::CheckFirstEntry(TInt aLine, TUint32 aCpu, TUint32 aContext, TDfcQue* aQ, TUint32 aId)

	{

	TUint32 tid = aQ ? aQ->iThread->iNThreadBaseSpare7 : 0;

	TUint32 expected = (aCpu<<24) | (aContext<<16) | (tid << 8) | aId;

	TUint32 x;

	TInt r = Buffer->TryGet(x);

	if (r!=KErrNone)

		{

		TEST_PRINT2("Line %d Buffer empty, Expected %08x", aLine, expected);

		}

	else if (x != expected)

		{

		TEST_PRINT3("Line %d Got %08x Expected %08x", aLine, x, expected);

		}

	}

class TPauseIDFC : public TDfc

	{

public:

	TPauseIDFC();

	void Pause(TInt aCpu);

	void Release();

	static void Run(TAny*);

public:

	volatile TInt iFlag;

	};

TPauseIDFC::TPauseIDFC()

	:	TDfc(&Run, this),

		iFlag(-1)

	{

	}

void TPauseIDFC::Pause(TInt aCpu)

	{

	TAddDfc adder;

	iFlag = -1;

	__e32_memory_barrier();

	adder.Add(this, 1u<<aCpu);

	adder.WaitCompletion();

	while (iFlag == -1)

		{}

	}

void TPauseIDFC::Release()

	{

	__e32_atomic_store_ord32(&iFlag, 1);

	}

void TPauseIDFC::Run(TAny* aPtr)

	{

	TPauseIDFC* p = (TPauseIDFC*)aPtr;

	__e32_atomic_store_ord32(&p->iFlag, 0);

	while (__e32_atomic_load_acq32(&p->iFlag) == 0)

		{}

	}

class TPauseDFC : public TDfc

	{

public:

	TPauseDFC(TDfcQue* aQ);

	void Pause(TInt aWait=0);

	void BusyPause();

	void Release();

	static void Run(TAny*);

public:

	NFastSemaphore* volatile iSem;

	volatile TInt iWait;

	};

TPauseDFC::TPauseDFC(TDfcQue* aQ)

	:	TDfc(&Run, this, aQ, 0),

		iSem(0)

	{

	}

void TPauseDFC::Pause(TInt aWait)

	{

	iWait = aWait;

	NFastSemaphore entrySem(0);

	iSem = &entrySem;

	Enque();

	NKern::FSWait(&entrySem);

	}

void TPauseDFC::BusyPause()

	{

	volatile TInt& flag = (volatile TInt&)iSem;

	__e32_atomic_store_ord32(&flag, 0xfffffffe);

	Enque();

	while (__e32_atomic_load_acq32(&flag) == 0xfffffffe)

		{}

	}

void TPauseDFC::Release()

	{

	NFastSemaphore* s = (NFastSemaphore*)__e32_atomic_swp_ord_ptr(&iSem, 0);

	if (((TInt)s)==-1)

		{

		volatile TInt& flag = (volatile TInt&)iSem;

		__e32_atomic_store_ord32(&flag, 0);

		}

	else

		NKern::FSSignal(s);

	}

void TPauseDFC::Run(TAny* aPtr)

	{

	TPauseDFC* p = (TPauseDFC*)aPtr;

	volatile TInt& flag = (volatile TInt&)p->iSem;

	if (flag == -2)

		{

		flag = -1;

		__e32_memory_barrier();

		while (flag == -1)

			{}

		}

	else

		{

		NFastSemaphore exitSem(0);

		NFastSemaphore* s = (NFastSemaphore*)__e32_atomic_swp_ord_ptr(&p->iSem, &exitSem);

		if (p->iWait)

			{

			nfcfspin(__microseconds_to_norm_fast_counter(10000));

			NKern::Sleep(p->iWait);

			}

		NKern::FSSignal(s);

		NKern::FSWait(&exitSem);

		}

	}

void DoDFCTest1()

	{

	TEST_PRINT("DFCTest1");

	TInt cpu;

	for_each_cpu(cpu)

		{

		TDfcQue* q = CreateDfcQ("DfcQ0", 1, cpu);

		DestroyDfcQ(q);

		q = CreateDfcQ("DfcQ1", 32, cpu);

		DestroyDfcQ(q);

		}

	}

TBool QueueDfc(TDfc* aDfc, TInt aMode, TBool aExRet)

	{

	if (aMode==0)

		return !aExRet == !aDfc->Enque();

	else if (aMode>0)

		{

		TAddDfc adder;

		TInt cpu = aMode - 1;

		adder.Add(aDfc, 1u<<cpu);

		adder.WaitCompletion();

		nfcfspin(__microseconds_to_norm_fast_counter(10000));

		return TRUE;

		}

	else if (aMode==-1)

		{

		NKern::Lock();

		TBool ret = aDfc->Add();

		NKern::Unlock();

		return !aExRet == !ret;

		}

	return FALSE;

	}

#define QUEUE_DFC(dfc, mode, exret)	TEST_RESULT(QueueDfc(dfc,mode,exret),"")

void DoDFCTest2()

	{

	TEST_PRINT("DFCTest2");

	TInt num_cpus = NKern::NumberOfCpus();

	TInt this_cpu = NKern::CurrentCpu();

	TDfcQue* q;

	q = CreateDfcQ("DfcQ2", 1, this_cpu);

	TEST_OOM(q);

	q->iThread->iNThreadBaseSpare7 = 1;

	TTestDfc* d1 = new TTestDfc(1, q, 1);

	TEST_OOM(d1);

	TEST_RESULT(!d1->IsIDFC(), "");

	TTestDfc* d2 = new TTestDfc(2, q, 2);

	TEST_OOM(d2);

	TEST_RESULT(!d2->IsIDFC(), "");

	TTestDfc* d3 = new TTestDfc(3, q, 2);

	TEST_OOM(d3);

	TEST_RESULT(!d3->IsIDFC(), "");

	TTestDfc* d4 = new TTestDfc(4, q, 3);

	TEST_OOM(d4);

	TEST_RESULT(!d4->IsIDFC(), "");

	TInt mode;

	for (mode=-1; mode<=num_cpus; ++mode)

		{

		TEST_PRINT1("Mode %d", mode);

		CHECK_EMPTY();

		TEST_RESULT(!d1->Queued(), "");

		QUEUE_DFC(d1, mode, TRUE);

		TEST_RESULT(d1->Queued(), "");

		QUEUE_DFC(d1, mode, FALSE);

		TEST_RESULT(d1->Queued(), "");

		QUEUE_DFC(d2, mode, TRUE);

		QUEUE_DFC(d3, mode, TRUE);

		QUEUE_DFC(d4, mode, TRUE);

		CHECK_EMPTY();

		NKern::Sleep(30);

		CHECK_FIRST_ENTRY(this_cpu, NKern::EThread, q, 4);

		CHECK_FIRST_ENTRY(this_cpu, NKern::EThread, q, 2);

		CHECK_FIRST_ENTRY(this_cpu, NKern::EThread, q, 3);

		CHECK_FIRST_ENTRY(this_cpu, NKern::EThread, q, 1);

		CHECK_EMPTY();

		QUEUE_DFC(d4, mode, TRUE);

		QUEUE_DFC(d3, mode, TRUE);

		QUEUE_DFC(d2, mode, TRUE);

		QUEUE_DFC(d1, mode, TRUE);

		CHECK_EMPTY();

		NKern::Sleep(30);

		CHECK_FIRST_ENTRY(this_cpu, NKern::EThread, q, 4);

		CHECK_FIRST_ENTRY(this_cpu, NKern::EThread, q, 3);

		CHECK_FIRST_ENTRY(this_cpu, NKern::EThread, q, 2);

		CHECK_FIRST_ENTRY(this_cpu, NKern::EThread, q, 1);

		CHECK_EMPTY();

		QUEUE_DFC(d4, mode, TRUE);

		QUEUE_DFC(d3, mode, TRUE);

		QUEUE_DFC(d2, mode, TRUE);

		QUEUE_DFC(d1, mode, TRUE);

		TEST_RESULT(d4->Queued(), "");

		TEST_RESULT(d4->Cancel(), "");

		TEST_RESULT(!d4->Cancel(), "");

		TEST_RESULT(!d4->Queued(), "");

		CHECK_EMPTY();

		NKern::Sleep(30);

		CHECK_FIRST_ENTRY(this_cpu, NKern::EThread, q, 3);

		CHECK_FIRST_ENTRY(this_cpu, NKern::EThread, q, 2);

		CHECK_FIRST_ENTRY(this_cpu, NKern::EThread, q, 1);

		CHECK_EMPTY();

		QUEUE_DFC(d4, mode, TRUE);

		QUEUE_DFC(d3, mode, TRUE);

		QUEUE_DFC(d2, mode, TRUE);

		QUEUE_DFC(d1, mode, TRUE);

		TEST_RESULT(d3->Queued(), "");

		TEST_RESULT(d3->Cancel(), "");

		TEST_RESULT(!d3->Queued(), "");

		CHECK_EMPTY();

		NKern::Sleep(30);

		CHECK_FIRST_ENTRY(this_cpu, NKern::EThread, q, 4);

		CHECK_FIRST_ENTRY(this_cpu, NKern::EThread, q, 2);

		CHECK_FIRST_ENTRY(this_cpu, NKern::EThread, q, 1);

		CHECK_EMPTY();

		QUEUE_DFC(d4, mode, TRUE);

		QUEUE_DFC(d3, mode, TRUE);

		QUEUE_DFC(d2, mode, TRUE);

		QUEUE_DFC(d1, mode, TRUE);

		TEST_RESULT(d3->Queued(), "");

		TEST_RESULT(d2->Queued(), "");

		TEST_RESULT(d3->Cancel(), "");

		TEST_RESULT(d2->Cancel(), "");

		TEST_RESULT(!d3->Queued(), "");

		TEST_RESULT(!d2->Queued(), "");

		CHECK_EMPTY();

		NKern::Sleep(30);

		CHECK_FIRST_ENTRY(this_cpu, NKern::EThread, q, 4);

		CHECK_FIRST_ENTRY(this_cpu, NKern::EThread, q, 1);

		CHECK_EMPTY();

		QUEUE_DFC(d4, mode, TRUE);

		QUEUE_DFC(d3, mode, TRUE);

		QUEUE_DFC(d2, mode, TRUE);

		QUEUE_DFC(d1, mode, TRUE);

		TEST_RESULT(d3->Cancel(), "");

		TEST_RESULT(d2->Cancel(), "");

		TEST_RESULT(d4->Cancel(), "");

		TEST_RESULT(d1->Cancel(), "");

		CHECK_EMPTY();

		NKern::Sleep(30);

		CHECK_EMPTY();

		QUEUE_DFC(d4, mode, TRUE);

		QUEUE_DFC(d3, mode, TRUE);

		QUEUE_DFC(d2, mode, TRUE);

		QUEUE_DFC(d1, mode, TRUE);

		TEST_RESULT(d1->Queued(), "");

		TEST_RESULT(d3->Cancel(), "");

		TEST_RESULT(d2->Cancel(), "");

		TEST_RESULT(d4->Cancel(), "");

		TEST_RESULT(d1->Cancel(), "");

		TEST_RESULT(!d1->Queued(), "");

		QUEUE_DFC(d1, mode, TRUE);

		TEST_RESULT(d1->Queued(), "");

		QUEUE_DFC(d1, mode, FALSE);

		TEST_RESULT(d1->Queued(), "");

		CHECK_EMPTY();

		NKern::Sleep(30);

		CHECK_FIRST_ENTRY(this_cpu, NKern::EThread, q, 1);

		CHECK_EMPTY();

		}

	delete d4;

	delete d3;

	delete d2;

	delete d1;

	DestroyDfcQ(q);

	}

void DoDFCTest3(TInt aCpu)

	{

	TEST_PRINT1("DFCTest3 CPU %d", aCpu);

	TInt num_cpus = NKern::NumberOfCpus();

	TInt this_cpu = NKern::CurrentCpu();

	TBool same_cpu = (aCpu==this_cpu);

	TDfcQue* q;

	q = CreateDfcQ("DfcQ2", 32, aCpu);

	TEST_OOM(q);

	q->iThread->iNThreadBaseSpare7 = 1;

	TPauseDFC pauser(q);

	TTestDfc* d1 = new TTestDfc(1, q, 1);

	TEST_OOM(d1);

	TEST_RESULT(!d1->IsIDFC(), "");

	TTestDfc* d2 = new TTestDfc(2, q, 2);

	TEST_OOM(d2);

	TEST_RESULT(!d2->IsIDFC(), "");

	TTestDfc* d3 = new TTestDfc(3, q, 2);

	TEST_OOM(d3);

	TEST_RESULT(!d3->IsIDFC(), "");

	TTestDfc* d4 = new TTestDfc(4, q, 3);

	TEST_OOM(d4);

	TEST_RESULT(!d4->IsIDFC(), "");

	TInt mode;

	for (mode=-1; mode<=num_cpus; ++mode)

		{

		TEST_PRINT1("Mode %d", mode);

		CHECK_EMPTY();

		TEST_RESULT(!d1->Queued(), "");

		QUEUE_DFC(d1, mode, TRUE);

		if (!same_cpu)

			while (d1->Queued()) {}

		TEST_RESULT(!d1->Queued(), "");

		QUEUE_DFC(d1, mode, TRUE);

		if (!same_cpu)

			while (d1->Queued()) {}

		TEST_RESULT(!d1->Queued(), "");

		QUEUE_DFC(d2, mode, TRUE);

		if (!same_cpu)

			while (d2->Queued()) {}

		QUEUE_DFC(d3, mode, TRUE);

		if (!same_cpu)

			while (d3->Queued()) {}

		QUEUE_DFC(d4, mode, TRUE);

		if (!same_cpu)

			while (d4->Queued()) {}

		CHECK_FIRST_ENTRY(aCpu, NKern::EThread, q, 1);

		CHECK_FIRST_ENTRY(aCpu, NKern::EThread, q, 1);

		CHECK_FIRST_ENTRY(aCpu, NKern::EThread, q, 2);

		CHECK_FIRST_ENTRY(aCpu, NKern::EThread, q, 3);

		CHECK_FIRST_ENTRY(aCpu, NKern::EThread, q, 4);

		CHECK_EMPTY();

		QUEUE_DFC(d4, mode, TRUE);

		QUEUE_DFC(d3, mode, TRUE);

		QUEUE_DFC(d2, mode, TRUE);

		QUEUE_DFC(d1, mode, TRUE);

		if (!same_cpu)

			while (d1->Queued()) {}

		CHECK_FIRST_ENTRY(aCpu, NKern::EThread, q, 4);

		CHECK_FIRST_ENTRY(aCpu, NKern::EThread, q, 3);

		CHECK_FIRST_ENTRY(aCpu, NKern::EThread, q, 2);

		CHECK_FIRST_ENTRY(aCpu, NKern::EThread, q, 1);

		CHECK_EMPTY();