// Copyright (c) 2008-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\nkern\d_crazyints.cpp

//

// Overview:

// kernel-side test (driver) for Crazy-Interrupts functionality

//

#include <platform.h>

#include <nk_priv.h>

#include <kernel/kern_priv.h>

#include "d_crazyints.h"

const TInt KMaxNumChannels = 1; // we only support one client at the time

_LIT(KLddRootName,"d_crazyints");

_LIT(KIntTestThreadName,"InterruptsTest");

// Constructor

DDeviceIntsTest::DDeviceIntsTest()

	{

	iParseMask = 0;

	iUnitsMask = 0;  // No info, no PDD, no Units

	iVersion = TVersion(KIntTestMajorVersionNumber,

	        KIntTestMinorVersionNumber, KIntTestBuildVersionNumber);

	}

DDeviceIntsTest::~DDeviceIntsTest()

	{

	}

// Install the device driver.

TInt DDeviceIntsTest::Install()

	{

	return (SetName(&KLddRootName));

	}

void DDeviceIntsTest::GetCaps(TDes8& aDes) const

	{

	TPckgBuf<TCapsProxyClient> b;

	b().version = TVersion(KIntTestMajorVersionNumber, KIntTestMinorVersionNumber, KIntTestBuildVersionNumber);

	Kern::InfoCopy(aDes, b);

	}

// Create a channel on the device.

TInt DDeviceIntsTest::Create(DLogicalChannelBase*& aChannel)

	{

	if (iOpenChannels >= KMaxNumChannels)

		return KErrOverflow;

	aChannel = new DChannIntsTest;

	return aChannel ? KErrNone : KErrNoMemory;

	}

DChannIntsTest::DChannIntsTest()

#ifdef __SMP__

	: iTimer(Handler, this)

#endif

	{

	iClient = &Kern::CurrentThread();

	// Increase the DThread's ref count so that it does not close without us

	((DObject*)iClient)->Open();

	}

DChannIntsTest::~DChannIntsTest()

	{

	iDfcQue->Destroy();

	// decrement the DThread's reference count

	Kern::SafeClose((DObject*&) iClient, NULL);

	}

TInt DChannIntsTest::DoCreate(TInt aUnit, const TDesC8* /*aInfo*/, const TVersion& /*aVer*/)

	{

	TInt r = Kern::DynamicDfcQCreate(iDfcQue, KIntTestThreadPriority, KIntTestThreadName);

	if(r == KErrNone)

		{

		SetDfcQ(iDfcQue);

		iMsgQ.Receive();

		}

#ifdef __SMP__

	return r;

#else

	return KErrNotSupported;

#endif

	}

void DChannIntsTest::HandleMsg(TMessageBase* aMsg)

	{

	TThreadMessage& m = *(TThreadMessage*) aMsg;

	TInt id = m.iValue;

	if (id == ECloseMsg)

		{

		iMsgQ.iMessage->Complete(KErrNone, EFalse);

		return;

		}

	else if (id == KMaxTInt)

		{

		m.Complete(KErrNone, ETrue);

		return;

		}

	if (id < 0)

		{

		TRequestStatus* pS = (TRequestStatus*) m.Ptr0();

		TInt r = DoRequest(~id, pS, m.Ptr1(), m.Ptr2());

		if (r != KErrNone)

			{

			Kern::RequestComplete(iClient, pS, r);

			}

		m.Complete(KErrNone, ETrue);

		}

	else

		{

		TInt r = DoControl(id, m.Ptr0(), m.Ptr1());

		m.Complete(r, ETrue);

		}

	}

#ifdef __SMP__

TBool DChannIntsTest::CrazyInterruptsEnabled()

	{

	// check, if crazy-interrupts are enabled..

	TSuperPage& sp = Kern::SuperPage();

	return (sp.KernelConfigFlags() & EKernelConfigSMPCrazyInterrupts);

	}

// Isr handler - it will check, if previously was run on the same core..

void DChannIntsTest::Handler (TAny *aParam)

	{

	__KTRACE_OPT(KTESTFAST,Kern::Printf("Handler\n"));

	DChannIntsTest *a = (DChannIntsTest*) aParam;

	// clear the flag for the core that we're now executing..

	TUint curr_core = NKern::CurrentCpu();

	a->iStatus &= ~(1u << curr_core);

	// decrement the counter..and kick the timer again - as required..

	TInt cnt = __e32_atomic_add_acq32(&a->iRunCount, ~(0u));

	if(cnt >= 1)

		a->iTimer.Again(KTimerWaitValue);

	}

// This test checks if the timer handler run in ISR context executes on all available

// CPU cores when crazy interrupts are enabled.

TInt DChannIntsTest::TestCrazyInts()

	{

	__KTRACE_OPT(KTESTFAST,Kern::Printf("TestCrazyInts"));

	if(!CrazyInterruptsEnabled())

		return KErrNotSupported;

	// Check how many CPUs we have in the system -and set corresponding flags in

	// iStatus. As an indication, that ISRs are run on a different cores all these flags

	// should be cleared in the Handler.

	TUint status = 0;

	for(TInt i = 0; i < NKern::NumberOfCpus(); ++i)

		{

		status |= 1u << i;

		}

	iStatus = status;

	// Kick-off a Timer to run it's handler in a ISR context..

	iRunCount = KNumOfTimes;

	iTimer.OneShot(KTimerWaitValue);

	//busy wait until it all completes..

	while (__e32_atomic_load_acq32(&iRunCount) > 0)

		NKern::Sleep(1);

	if(iStatus)

		{

		if((iStatus ^ status) == 1)

			{

			// we must be running on the single core version, whilst the kernel flag is set

			// this might happen, if the Kernel (nkern) was not compiled with SMP_CRAZY_INTERRUPTS defined

			// check, if variant.mmh for this platform contains:  macro SMP_CRAZY_INTERRUPTS

			Kern::Printf("Interrupts running only on CPU0 and EKernelConfigSMPCrazyInterrupts flag is set \n\r is this - wrong configuration? ", iStatus);

			}

		else

			Kern::Printf("ISR was not executed on all CPUs..(%x)", iStatus);

		return KErrGeneral;

		}

	return KErrNone;

	}

#endif

// to handle synchronous requests from the client

TInt DChannIntsTest::DoControl(TInt aId, TAny* a1, TAny* a2)

	{

	TInt r = KErrNone;

	switch (aId)

		{

		case RBusIntTestClient::ETestCrazyInts:

			{

#ifdef __SMP__

			r = TestCrazyInts();

#else

			r = KErrNotSupported;

#endif

			break;

			}

		default:

			{

			__KTRACE_OPT(KTESTFAST,Kern::Printf("DChannIntsTest::DoControl():Unrecognized value for aId=0x%x\n", aId));

			r = KErrArgument;

			break;

			}

		}

	return r;

	}

// to handle asynchronous requests from the client

TInt DChannIntsTest::DoRequest(TInt aId, TRequestStatus* aStatus, TAny* a1, TAny* a2)

	{

	__KTRACE_OPT(KTESTFAST,Kern::Printf("DChannIntsTest::DoRequest(aId=0x%x, aStatus=0x%x, a1=0x%x, a2=0x%x\n",

					aId, aStatus, a1, a2));

	TInt r = KErrNone;

	switch (aId)

		{

		default:

			{

			__KTRACE_OPT(KTESTFAST,Kern::Printf("DChannIntsTest::DoRequest(): unrecognized value for aId=0x%x\n", aId));

			r = KErrArgument;

			break;

			}

		}

	return r;

	}

// LDD entry point

DECLARE_STANDARD_LDD()

	{

	return new DDeviceIntsTest;

	}