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