// Copyright (c) 2005-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\emi\d_emitest.cpp

 // 

 //

 #include <kernel/kern_priv.h>

 #include "d_emitest.h"

 #include "d_emitest_dev.h"

 #include <kernel/emi.h>

 //

 // DEMITestFactory

 //

 /*

   Standard export function for LDDs. This creates a DLogicalDevice derived object,

   in this case, our DEMITestFactory

 */

 DECLARE_STANDARD_LDD()

 	{

 	return new DEMITestFactory;

 	}

 DEMITestFactory::DEMITestFactory()

 	{

 	}

 DEMITestFactory::~DEMITestFactory()

 	{

 	}

 /*

   Second stage constructor for DEMITestFactory.

   This must at least set a name for the driver object.

   @return KErrNone or standard error code.

 */

 TInt DEMITestFactory::Install()

 	{

 	return SetName(&KEMITestName);

 	}

 /*

   Return the drivers capabilities.

   Called in the response to an RDevice::GetCaps() request.

   The thread is in a critical section.

   @param aDes Descriptor to write capabilities information into

 */

 void DEMITestFactory::GetCaps(TDes8&) const

 	{

 	}

 /*

   Called by the kernel's device driver framework to create a Logical Channel.

   This is called in the context of the user thread (client) which requested the creation of a Logical Channel

   (E.g. through a call to RBusLogicalChannel::DoCreate)

   The thread is in a critical section.

   @param aChannel Set to point to the created Logical Channel

   @return KErrNone or standard error code.

 */

 TInt DEMITestFactory::Create(DLogicalChannelBase*& aChannel)

 	{

 	aChannel=new DEMITestChannel;

 	if(!aChannel)

 		return KErrNoMemory;

 	return KErrNone;

 	}

 //

 // Logical Channel

 //

 DEMITestChannel::DEMITestChannel()

 : iTagMaskDFC(TagMaskDFC,NULL,1)

 	{

 	// Get pointer to client threads DThread object

 	iClient=&Kern::CurrentThread();

 	// Open a reference on client thread so it's control block can't dissapear until

 	// this driver has finished with it.

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

 	}

 DEMITestChannel::~DEMITestChannel()

 	{

 	// Stop EMI, incase it wannt stopped manually.

   	EMI::TaskEventLogging(EFalse,0,NULL,NULL);

   	EMI::SetMask(0);

 	// Close our reference on the client thread

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

 	}

 /*

   Second stage constructor called by the kernel's device driver framework.

   This is called in the context of the user thread (client) which requested the creation of a Logical Channel

   (E.g. through a call to RBusLogicalChannel::DoCreate)

   The thread is in a critical section.

   @param aUnit The unit argument supplied by the client to RBusLogicalChannel::DoCreate

   @param aInfo The info argument supplied by the client to RBusLogicalChannel::DoCreate

   @param aVer The version argument supplied by the client to RBusLogicalChannel::DoCreate

   @return KErrNone or standard error code.

 */

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

 	{

 	iTagMaskDFC.SetDfcQ(Kern::DfcQue0());

 	return KErrNone;

 	}

 /* 

   Normal test monitors

 */

 TInt MyThreadStartMonitor(NThread* aNThread)

 	{

 	TTaskEventRecord rec;

 	rec.iType=128;

 	rec.iPrevious=((TInt*) aNThread)+1;	// This stops the event getting killed on thread exit.

 						// This means there is no garantee the thread will still exist when

 						// the record is read. This is only safe here as the test code never 

 						// attempts to derefrance this pointer.

 	EMI::AddTaskEvent(rec);

 	return 0;

 	}

 void MyThreadExitMonitor(NThread* aNThread)

 	{

 	TTaskEventRecord rec;

 	rec.iType=129;

 	rec.iPrevious=aNThread;

 	EMI::AddTaskEvent(rec);

 	}

 /* 

   Stress test monitors

   Vems =	 1: Passed.

   			 0: No monitors called.

   			-1: Wrong Exit monitor callled.

   			-2: Exit call before StartMonitor

   			-3: Jibberish VEMs value. (or anything ending 5-9)

   			-4: Exit called multiple times, 1st time ok.

   			<-9: Exit called multiple times.  See last digit for status 1st time.

   			Stops couting after -1000, where its clearly very sick!

 */

 TInt SoakStartMonitor1(NThread* aNThread)

 	{

  	EMI::SetThreadVemsData(aNThread,(TAny*)1000);

  	return 0;

 	}

 TInt SoakStartMonitor2(NThread* aNThread)

 	{

  	EMI::SetThreadVemsData(aNThread,(TAny*)2000);

  	return 0;

 	}

 inline void SoakExitMonitor(NThread* aNThread, TInt aOwner)

 	{

 	TInt val = (TInt) EMI::GetThreadVemsData(aNThread);

 	if (val>-1)

 		{

 		TInt notOwner = (aOwner==1000?2000:1000);

 		if (val==aOwner)

 			EMI::SetThreadVemsData(aNThread,(TAny*)1);

 		else if (val==notOwner)

 			EMI::SetThreadVemsData(aNThread,(TAny*)-1);

 		else if (val==0)

 			EMI::SetThreadVemsData(aNThread,(TAny*)-2);

 		else if (val==1)

 			EMI::SetThreadVemsData(aNThread,(TAny*)-4);

 		else

 			EMI::SetThreadVemsData(aNThread,(TAny*)-3);

 		}

 	else

 		{

 		if (val>-1000)

 			EMI::SetThreadVemsData(aNThread,(TAny*)(val-10));

 		else

 			EMI::SetThreadVemsData(aNThread,(TAny*)val);

 		}

 	}

 void SoakExitMonitor1(NThread* aNThread)

 	{

 	SoakExitMonitor(aNThread,1000);

 	}

 void SoakExitMonitor2(NThread* aNThread)

 	{

 	SoakExitMonitor(aNThread,2000);

 	}

 /*

   Process synchronous requests

 */

 TInt DEMITestChannel::Request(TInt aFunction, TAny* a1, TAny* a2)

 	{

 	TInt r=KErrNotSupported; 

 	TTaskEventRecord rec;

 	switch (aFunction)

 		{

 		case REMITest::ETaskEventLogging:

 			{

 			NKern::ThreadEnterCS();

 			TMonitors mon = (TMonitors) ((TInt)a1 >> 1);

 			TBool logging = (TBool) ((TInt)a1 & 1);

 			switch (mon)

 				{

 				case ENone: r = EMI::TaskEventLogging(logging,(TInt) a2,NULL,NULL);

 				break;

 				case ENormal: r = EMI::TaskEventLogging(logging,(TInt) a2,&MyThreadStartMonitor,&MyThreadExitMonitor);

 				break;

 				case EStressFirst:r = EMI::TaskEventLogging(logging,(TInt) a2,SoakStartMonitor1,SoakExitMonitor1);

 				break;

 				case EStressSecond:r = EMI::TaskEventLogging(logging,(TInt) a2,SoakStartMonitor2,SoakExitMonitor2);

 				}

 			NKern::ThreadLeaveCS();	

 			return r;

 			}

 		case REMITest::EGetTaskEvent:

 			r = (TInt) EMI::GetTaskEvent(rec);

 			if (r)

 				kumemput(a1,&rec,sizeof(TTaskEventRecord));

 			return r;

 		case REMITest::EAddTaskEvent:

 			kumemget(&rec,a1,sizeof(TTaskEventRecord));

 			return (TInt) EMI::AddTaskEvent(rec);

 		case REMITest::EGetIdleThread:

 			return (TInt) EMI::GetIdleThread(); 

 		case REMITest::EGetSigmaThread:

 			return (TInt) EMI::GetSigmaThread(); 

 		case REMITest::ESetVEMSData:

 			EMI::SetThreadVemsData((NThread*) a1,a2);

 			return KErrNone;

 		case REMITest::EGetVEMSData:

 			return (TInt) EMI::GetThreadVemsData((NThread*) a1);

 		case REMITest::ESetThreadLoggable:

 			EMI::SetThreadLoggable((NThread*) a1,(TBool) a2);

 			return KErrNone;

 		case REMITest::EGetThreadLoggable:

 			return (TInt) EMI::GetThreadLoggable((NThread*) a1);

 		case REMITest::ESetThreadTag:

 			EMI::SetThreadTag((NThread*) a1,(TUint32) a2);

 			return KErrNone;

 		case REMITest::EGetThreadTag:

 			return (TInt) EMI::GetThreadTag((NThread*) a1);

 		case REMITest::ESetMask:

 			EMI::SetMask((TInt) a1);

 			return KErrNone;

 		case REMITest::EGetMask:

 			return EMI::GetMask();			

 		case REMITest::ESetDFC:

 			EMI::SetDfc(&iTagMaskDFC, 0);

 			return KErrNone;

 		case REMITest::ESetState:

 			EMI::SetState((TInt) a1);

 			return KErrNone;

 		case REMITest::EGetState:

 			return EMI::GetState();

 		case REMITest::EGetNThread:

 			{

 			DThread* myThread;

 			TInt myNThread;

 			NKern::LockSystem();

 			myThread = (DThread* ) Kern::CurrentThread().ObjectFromHandle((TInt)a1,EThread);

 			myNThread=  (TInt) (myThread==NULL?NULL:&myThread->iNThread);

 			NKern::UnlockSystem();

 			return myNThread;

 			}

 		case REMITest::EAfterIdle:

 			EMI::AfterIdle((TInt) a1);			

 			return KErrNone;

 		default:

 			return KErrNotSupported;

 		}

 	}

 /*

   DFC callback which gets triggered when the EMI tag anded with thread mask is true.

   Sets EMI state to be the value returned from GetDfcTriggerTag.

 */

 void DEMITestChannel::TagMaskDFC(TAny*)

 	{

 	EMI::SetState(EMI::GetDfcTriggerTag());

 	EMI::SetMask(0);

 	}