// 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:
// e32test\nkernsa\testipi.cpp
// 
//

#include <nktest/nkutils.h>

#ifdef __SMP__

class TTestIPI : public TGenericIPI
	{
public:
	TTestIPI();
	static TTestIPI* New();
	static void Isr(TGenericIPI*);
	void Inc(TInt aCpu, TInt aInc=1) {iExpected[aCpu] += aInc;}
	void IncM(TUint32 aMask);
	void Check();
public:
	TInt iCount[KMaxCpus];
	TInt iExpected[KMaxCpus];
	};

TTestIPI::TTestIPI()
	{
	memclr(iCount, sizeof(iCount));
	memclr(iExpected, sizeof(iExpected));
	}

TTestIPI* TTestIPI::New()
	{
	TTestIPI* p = new TTestIPI;
	TEST_OOM(p);
	return p;
	}

void TTestIPI::Isr(TGenericIPI* a)
	{
	TTestIPI& ipi = *(TTestIPI*)a;
	TInt cpu = NKern::CurrentCpu();
	++ipi.iCount[cpu];
	}

void TTestIPI::IncM(TUint32 aMask)
	{
	TInt i;
	for(i=0; i<KMaxCpus; ++i)
		{
		if (aMask & (1<<i))
			++iExpected[i];
		}
	}

void TTestIPI::Check()
	{
	TInt i;
	for(i=0; i<KMaxCpus; ++i)
		{
		TEST_RESULT3(iCount[i]==iExpected[i], "CPU %d Count %d Expected %d", i, iCount[i], iExpected[i]);
		}
	}

void IPITestThread1(TAny*)
	{
	TInt cpu;
	TUint32 all_cpus = ~(0xffffffffu << NKern::NumberOfCpus());

	for_each_cpu(cpu)
		{
		TEST_PRINT("ipi1");
		TTestIPI ipi;
		ipi.Queue(&TTestIPI::Isr, 1u<<cpu);
		ipi.WaitCompletion();
		ipi.Inc(cpu);
		ipi.Check();

		TEST_PRINT("ipi2");
		TTestIPI ipi2;
		TUint32 m = all_cpus & ~(1u<<cpu);
		ipi2.Queue(&TTestIPI::Isr, m);
		ipi2.WaitCompletion();
		ipi2.IncM(m);
		ipi2.Check();
		}

	TEST_PRINT("ipi3");
	TTestIPI ipi3;
	ipi3.QueueAll(&TTestIPI::Isr);
	ipi3.WaitCompletion();
	ipi3.IncM(all_cpus);
	ipi3.Check();

	TEST_PRINT("ipi4");
	TTestIPI ipi4;
	ipi4.QueueAllOther(&TTestIPI::Isr);
	ipi4.WaitCompletion();
	ipi4.IncM(all_cpus & ~(1u<<NKern::CurrentCpu()) );
	ipi4.Check();
	}

void DoIPITest1()
	{
	TInt cpu;
	for_each_cpu(cpu)
		{
		CreateThreadAndWaitForExit("IPITest1", &IPITestThread1, 12, 0, 0, -1, cpu);
		}
	}


class TTestIPI2 : public TGenericIPI
	{
public:
	TTestIPI2(TInt aId);
	static TTestIPI2* New(TInt aId);
	static void Isr(TGenericIPI*);
	static void Thread(TAny*);
public:
	TInt iId;
public:
	enum {EMaxIPI=32};
	enum {EBufSize=256};
	static volatile TInt NextPos;
	static volatile TUint32 Buffer[EBufSize];
	static volatile TUint32 PauseHere;
	};

volatile TInt TTestIPI2::NextPos;
volatile TUint32 TTestIPI2::Buffer[TTestIPI2::EBufSize];
volatile TUint32 TTestIPI2::PauseHere;

__ASSERT_COMPILE(TTestIPI2::EBufSize >= TTestIPI2::EMaxIPI*KMaxCpus);

TTestIPI2::TTestIPI2(TInt aId)
	: iId(aId)
	{
	}

TTestIPI2* TTestIPI2::New(TInt aId)
	{
	TTestIPI2* p = new TTestIPI2(aId);
	TEST_OOM(p);
	return p;
	}

void TTestIPI2::Isr(TGenericIPI* a)
	{
	TTestIPI2& ipi = *(TTestIPI2*)a;
	TUint32 cpu = NKern::CurrentCpu();
	TUint32 x = (cpu<<16) | ipi.iId;
	TInt pos = __e32_atomic_tas_ord32(&NextPos, EBufSize, 0, 1);
	if (pos < EBufSize)
		Buffer[pos] = x;
	while (PauseHere == x)
		{}
	}

void TTestIPI2::Thread(TAny*)
	{
	TTestIPI2* ipi[EMaxIPI];
	TUint32 all_cpus = ~(0xffffffffu << NKern::NumberOfCpus());
	TInt this_cpu = NKern::CurrentCpu();
	TInt pause_cpu = this_cpu + 1;
	if (pause_cpu >= NKern::NumberOfCpus())
		pause_cpu = 0;
	if (pause_cpu == this_cpu)
		pause_cpu = -1;
	TUint32 this_cpu_mask = 1u<<this_cpu;
	TUint32 pause_cpu_mask = (pause_cpu>=0) ? (1u<<pause_cpu) : 0;
	TUint32 other_cpus = all_cpus & ~(this_cpu_mask | pause_cpu_mask);
	TInt num_other_cpus = __e32_bit_count_32(other_cpus);
	TInt i;
	for(i=0; i<EMaxIPI; ++i)
		ipi[i] = New(i+1);

	NextPos = 0;
	PauseHere = 0;
	if (pause_cpu >= 0)
		PauseHere = (pause_cpu<<16) | (EMaxIPI/2);

	TEST_PRINT3("this_cpu=%d pause_cpu=%d PauseHere=%x", this_cpu, pause_cpu, PauseHere);

	TInt irq = NKern::DisableAllInterrupts();
	for (i=0; i<EMaxIPI; ++i)
		ipi[i]->QueueAll(&Isr);

	TInt expected1 = num_other_cpus*EMaxIPI + EMaxIPI/2;
	while (NextPos != expected1)
		{}

	PauseHere = 0;
	TInt expected2 = num_other_cpus*EMaxIPI + EMaxIPI;
	while (NextPos != expected2)
		{}
	NKern::RestoreInterrupts(irq);
	ipi[EMaxIPI-1]->WaitCompletion();

	for(i=0; i<NextPos; ++i)
		{
		TEST_PRINT1("%08x", Buffer[i]);
		}

	for(i=0; i<EMaxIPI; ++i)
		delete ipi[i];
	}

void DoIPITest2()
	{
	TInt cpu;
	for_each_cpu(cpu)
		{
		CreateThreadAndWaitForExit("IPITest2", &TTestIPI2::Thread, 12, 0, 0, -1, cpu);
		}
	}


void TestIPI()
	{
	TEST_PRINT("Testing generic IPIs...");

	DoIPITest1();
	DoIPITest2();
	}

#else	// __SMP__
void TestIPI()
	{
	}
#endif	// __SMP__