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

 	}