// Copyright (c) 2002-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:

 //

 #include "k32bm.h"

 const TUint8 KMutexOrder = 0xf0;

 class DBMLDevice : public DLogicalDevice

 	{

 public:

 	DBMLDevice();

 	virtual TInt Install();

 	virtual void GetCaps(TDes8& aDes) const;

 	virtual TInt Create(DLogicalChannelBase*& aChannel);

 	};

 class DBMLChannel : public DLogicalChannelBase, public MBMIsr, public MBMInterruptLatencyIsr

 	{

 public:

 	DBMLChannel();

 	~DBMLChannel();

 	virtual TInt DoCreate(TInt aUnit, const TDesC8* anInfo, const TVersion& aVer);

 	virtual TInt Request(TInt aFunction, TAny* a1, TAny* a2);

 	DBMPChannel* PChannel() { return (DBMPChannel*) iPdd; }

 private:

 	static const TInt	KBMDfcQThreadPriority;	

 	static const TInt	KBMKernelThreadPriority;	

 	static void Dfc(TAny*);

 	virtual void Isr(TBMTicks now);

 	TInt (DBMLChannel::*iRequestInterrupt)();	// Measurement specific RBMChannel::RequestInterrupt() implmentation 

 	TInt RequestInterrupt();					// Default iRequestInterrupt() implementation

 	TBMTicks (DBMLChannel::*iResult)();			// Measurement specific RBMChannel::Result() implmentation

 	TBMTicks Result();							// Default iResult() implementation

 	TInt Start(RBMChannel::TMode);

 	TInt StartInterruptLatency();

 	virtual void InterruptLatencyIsr(TBMTicks latency);

 	TInt StartKernelPreemptionLatency();

 	static TInt KernelPreemptionLatencyThreadEntry(TAny* ptr);

 	void KernelPreemptionLatencyThread();

 	TInt StartUserPreemptionLatency();

 	TBMTicks UserPreemptionLatencyResult();		// iResult() implementation

 	TInt StartNTimerJitter();

 	TInt RequestNTimerJitterInterrupt();		// iRequestInterrupt() implementation

 	static void NTimerJitterCallBack(TAny*);

 	TInt StartTimerStampOverhead();

 	TInt RequestTimerStampOverhead();			// iRequestInterrupt() implementation

 	TInt SetAbsPrioirty(TInt aThreadHandle, TInt aNewPrio, TInt* aOldPrio);

 	DMutex*			iLock;	// Shall be acquired by anyone who access the object's writable state.

 	TBool			iStarted;					// ETrue when a particular sequence of measurements has been started

 	TBool			iPendingInterruptRequest;	// ETrue when an interrupt has been requested

 	TDynamicDfcQue*	iDfcQ;

 	TDfc			iDfc;

 	DThread*		iKernelThread;		// the kernel thread created by some benchmarks

 	DThread*		iUserThread;		// the user-side thread

 	DThread*		iInterruptThread;	// the thread signaled by DFC; if non-NULL either iKernelThread or iUserThread

 	NTimer			iNTimer;			// the timer used in "NTimer jitter" benchmark

 	TBMTicks		iOneNTimerTick;		// number of high-resolution timer ticks in one NKern tick.

 	TInt			iNTimerShotCount;	// used in "NTimer jitter" to distinguish between the first and the second shots 

 	TBMTicks		iTime;

 	TBMTicks		iTimerPeriod;		// period of high-resolution timer in ticks

 	NFastSemaphore*	iKernelThreadExitSemaphore;

 	void Lock()

 		{

 		NKern::ThreadEnterCS();

 		Kern::MutexWait(*iLock);

 		}

 	void Unlock()

 		{

 		Kern::MutexSignal(*iLock);

 		NKern::ThreadLeaveCS();

 		}

 	TBMTicks Delta(TBMTicks aT0, TBMTicks aT1)

 		{

 		return (aT0 <= aT1) ? (aT1 - aT0) : iTimerPeriod - (aT0 - aT1);

 		}

 	};

 _LIT(KBMLChannelLit, "BMLChannel");

 const TInt	DBMLChannel::KBMDfcQThreadPriority = KBMLDDHighPriority;

 const TInt	DBMLChannel::KBMKernelThreadPriority = KBMLDDMidPriority;

 DECLARE_STANDARD_LDD()

 //

 // Create a new device

 //

 	{

 	__ASSERT_CRITICAL;

 	return new DBMLDevice;

 	}

 DBMLDevice::DBMLDevice()

 //

 // Constructor

 //

 	{

 	//iUnitsMask=0;

 	iVersion = TVersion(1,0,1);

 	iParseMask = KDeviceAllowPhysicalDevice;

 	}

 TInt DBMLDevice::Install()

 //

 // Install the device driver.

 //

 	{

 	TInt r = SetName(&KBMLdName);

 	return r;

 	}

 void DBMLDevice::GetCaps(TDes8&) const

 //

 // Return the Comm capabilities.

 //

 	{

 	}

 TInt DBMLDevice::Create(DLogicalChannelBase*& aChannel)

 //

 // Create a channel on the device.

 //

 	{

 	__ASSERT_CRITICAL;

 	aChannel = new DBMLChannel;

 	return aChannel ? KErrNone : KErrNoMemory;

 	}

 DBMLChannel::DBMLChannel() : 

 		iDfc(0, this, 0, 0),

 		iNTimer(NULL, this)

 	{

 	// iDfcQueue = NULL;

 	// iStarted = EFalse;

 	// iPendingInterruptRequest = EFalse;

 	// iKernelThread = NULL;

 	}

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

 //

 // Create the channel from the passed info.

 //

 	{

 	__ASSERT_CRITICAL;

 	if (!Kern::QueryVersionSupported(TVersion(1,0,1),aVer))

 		return KErrNotSupported;

 	TInt r = Kern::MutexCreate(iLock, KBMLChannelLit, KMutexOrder);

 	if (r != KErrNone)

 		{

 		return r;

 		}

 	iTimerPeriod = PChannel()->TimerPeriod();

 		// Calculate the number of high-resolution timer ticks in one NKern tick

 		// deviding the number of high-resolution timer ticks in one second by the

 		// number of NKern ticks in one second.

 		//

 	iOneNTimerTick = PChannel()->TimerNsToTicks(BMSecondsToNs(1))/NKern::TimerTicks(1000);

 	return KErrNone;

 	}

 DBMLChannel::~DBMLChannel()

 // Called on a channel close. Note that if the PDD channel create failed 

 // then the DoCreate() call will not have been made so don't assume anything 

 // about non-ctor initialisation of members.

 	{

 	if (iLock) 

 		iLock->Close(0);

 	if (iPendingInterruptRequest)

 		{

 		PChannel()->CancelInterrupt();

 		iDfc.Cancel();

 		}

 	if (iDfcQ)

 		{

 		iDfcQ->Destroy();

 		}

 	if (iKernelThread)

 		{

 		NFastSemaphore exitSemaphore;

 		exitSemaphore.iOwningThread = NKern::CurrentThread();

 		iKernelThreadExitSemaphore = &exitSemaphore;

 		NKern::ThreadRequestSignal(&iKernelThread->iNThread);

 		NKern::FSWait(&exitSemaphore);

 		}

 	}

 void DBMLChannel::Dfc(TAny* ptr)

 	{	

 	DBMLChannel* lCh = (DBMLChannel*) ptr;

 	BM_ASSERT(lCh->iPendingInterruptRequest);

 	BM_ASSERT(lCh->iInterruptThread);

 	NKern::ThreadRequestSignal(&lCh->iInterruptThread->iNThread);

 	lCh->iPendingInterruptRequest = EFalse;

 	}

 //

 // Default DBMLChannel::iRequestInterrupt implementation

 //

 TInt DBMLChannel::RequestInterrupt()

 	{

 	if (!iStarted)

 		{

 		return KErrNotReady;

 		}

 	if (iPendingInterruptRequest) 

 		{

 		return KErrInUse;

 		}

 	iPendingInterruptRequest = ETrue;

 	PChannel()->RequestInterrupt();

 	return KErrNone;

 	}

 //

 // Default DBMLChannel::iResult implementation

 //

 TBMTicks DBMLChannel::Result()

 	{

 	return iTime;

 	}

 void DBMLChannel::Isr(TBMTicks aNow)

 	{

 	//

 	// Store the ISR entry time and queue a DFC.

 	//

 	iTime = aNow;

 	iDfc.Add();

 	}

 //

 // "INTERRUPT LATENCY"

 // 

 // SCENARIO:

 //

 //		A user thread requests an interrupt (RBMChannel::RequestInterrupt()) and waits at User::WaitForAnyRequest()

 //		(RBMChannel::Result()).

 //		When the interrupt occurs DBMLChannel::InterruptLatencyIsr() stores the interrupt latency 

 //		provided by LDD, in DBMLChannel::iTime and queues a DFC (DBMLChannel::iDfc, DBMLChannel::Dfc())

 //		which in its turn signals the user thread.

 //

 TInt DBMLChannel::StartInterruptLatency()

 	{

 	if (iStarted)

 		{

 		return KErrInUse;

 		}

 	TInt r = PChannel()->BindInterrupt((MBMInterruptLatencyIsr*) this);

 	if (r != KErrNone)

 		{

 		return r;

 		}

 		// Use the default iRequestInterrupt() implmentation

 	iRequestInterrupt = &DBMLChannel::RequestInterrupt;

 		// Use the default iResult() implmentation

 	iResult = &DBMLChannel::Result;

 	iInterruptThread = &Kern::CurrentThread();

 	iStarted = ETrue;

 	return KErrNone;

 	}

 void DBMLChannel::InterruptLatencyIsr(TBMTicks aLatency)

 	{

 	iTime = aLatency;

 	iDfc.Add();

 	}

 //

 // "KERNEL THREAD PREEMPTION LATENCY"

 // 

 // SCENARIO:

 //

 //		A new kernel thread is created at the beginning of a sequence of measurements 

 //		(DBMLChannel::StartKernelPreemptionLatency()). The kernel thread waits at Kern::WaitForAnyRequest()

 //		(DBMLChannel::KernelPreemptionLatencyThread()).

 //		The user thread requests an interrupt (RBMChannel::RequestInterrupt()) and waits at User::WaitForAnyRequest()

 //		(RBMChannel::Result()).

 //		When the interrupt occurs DBMLChannel::Isr() stores the ISR entry time, provided by LDD 

 //		in DBMLChannel::iTime and queues a DFC (DBMLChannel::iDfc, DBMLChannel::Dfc()) which, in its turn,

 //		signals the kernel thread.

 //		The kernel thread, when awaken, calculates the latency as the difference between the ISR entry time 

 //		and the current time and finally signals the user thread.

 //

 TInt DBMLChannel::StartKernelPreemptionLatency()

 	{

 	if (iStarted)

 		{

 		return KErrInUse;

 		}

 	TInt r = PChannel()->BindInterrupt((MBMIsr*) this);

 	if (r != KErrNone)

 		{

 		return r;

 		}

 	{

 	SThreadCreateInfo info;

 	info.iType = EThreadSupervisor;

 	info.iFunction = DBMLChannel::KernelPreemptionLatencyThreadEntry;

 	info.iPtr = this;

 	info.iSupervisorStack = NULL;

 	info.iSupervisorStackSize = 0;

 	info.iInitialThreadPriority = KBMKernelThreadPriority;

 	info.iName.Set(KBMLChannelLit);

 	info.iTotalSize = sizeof(info);

 	r = Kern::ThreadCreate(info);

 	if (r != KErrNone)

 		{

 		return r;

 		}

 	iKernelThread = (DThread*) info.iHandle;

 	}

 	iUserThread = &Kern::CurrentThread();

 		// Use the default iRequestInterrupt() implmentation

 	iRequestInterrupt = &DBMLChannel::RequestInterrupt;

 		// Use the default iResult() implmentation

 	iResult = &DBMLChannel::Result;

 	iInterruptThread = iKernelThread;

 	iStarted = ETrue;

 	Kern::ThreadResume(*iKernelThread);

 	return KErrNone;

 	}

 TInt DBMLChannel::KernelPreemptionLatencyThreadEntry(TAny* ptr)

 	{

 	DBMLChannel* lCh = (DBMLChannel*) ptr;

 	lCh->KernelPreemptionLatencyThread();

 	BM_ASSERT(0);

 	return 0;

 	}

 void DBMLChannel::KernelPreemptionLatencyThread()

 	{

 	for(;;)

 		{

 		NKern::WaitForAnyRequest();

 		if(iKernelThreadExitSemaphore)

 			break;

 		TBMTicks now = PChannel()->TimerStamp();

 		iTime = Delta(iTime, now);

 		BM_ASSERT(iUserThread);

 		NKern::ThreadRequestSignal(&iUserThread->iNThread);

 		}

 	NKern::FSSignal(iKernelThreadExitSemaphore);

 	Kern::Exit(0); 

 	}

 //

 // "USER THREAD PREEMPTION LATENCY"

 // 

 // SCENARIO:

 //

 //		A user thread requests an interrupt (RBMChannel::RequestInterrupt()) and waits at User::WaitForAnyRequest()

 //		(RBMChannel::Result()).

 //		When the interrupt occurs DBMLChannel::Isr() stores the ISR entry time provided by LDD, 

 //		in DBMLChannel::iTime and queues a DFC (DBMLChannel::iDfc, DBMLChannel::Dfc()) which in its turn

 //		signals the user thread.

 //		The user thread, when awaken, immediately re-enters in the LDD, and calculates the latency as 

 //		the difference between the ISR entry time and the current time.

 //

 TInt DBMLChannel::StartUserPreemptionLatency()

 	{

 	if (iStarted)

 		{

 		return KErrInUse;

 		}

 	TInt r = PChannel()->BindInterrupt((MBMIsr*) this);

 	if (r != KErrNone)

 		{

 		return r;

 		}

 		// Default iRequestInterrupt() implmentation

 	iRequestInterrupt = &DBMLChannel::RequestInterrupt;

 	iResult = &DBMLChannel::UserPreemptionLatencyResult;

 	iInterruptThread = &Kern::CurrentThread();

 	iStarted = ETrue;

 	return KErrNone;

 	}

 TBMTicks DBMLChannel::UserPreemptionLatencyResult()

 	{

 	TBMTicks now = PChannel()->TimerStamp();

 	return Delta(iTime, now);

 	}

 //

 // "NTimer PERIOD JITTER"

 // 

 // SCENARIO:

 //

 //		One measuremnt is done by two consecutive NTimer callbacks. 

 //		The first callback stores the current time and the second one calculate the actual period as 

 //		the difference between its own current time and the time stored by the first callback.

 //		The difference between this actual period and the theoretical period is considered as the jitter.

 //

 TInt DBMLChannel::StartNTimerJitter()

 	{

 	if (iStarted)

 		{

 		return KErrInUse;

 		}

 	new (&iNTimer) NTimer(&NTimerJitterCallBack, this);

 	iRequestInterrupt = &DBMLChannel::RequestNTimerJitterInterrupt;

 		// Use the default iResult() implmentation

 	iResult = &DBMLChannel::Result;

 	iInterruptThread = &Kern::CurrentThread();

 	iStarted = ETrue;

 	return KErrNone;

 	}

 TInt DBMLChannel::RequestNTimerJitterInterrupt()

 	{

 	if (!iStarted)

 		{

 		return KErrNotReady;

 		}

 	if (iPendingInterruptRequest) 

 		{

 		return KErrInUse;

 		}

 	iPendingInterruptRequest = ETrue;

 	iNTimerShotCount = 0;

 	iNTimer.OneShot(1);

 	return KErrNone;

 	}

 void DBMLChannel::NTimerJitterCallBack(TAny* ptr)

 	{

 	DBMLChannel* lCh = (DBMLChannel*) ptr;

 	TBMTicks now = lCh->PChannel()->TimerStamp();

 	if (lCh->iNTimerShotCount++ == 0)

 		{

 		//

 		// This is the first callback: store the time and request another one.

 		//

 		lCh->iTime = now;

 		lCh->iNTimer.Again(1);

 		}

 	else 

 		{

 		//

 		// This is the second callback: measure the jitter and schedule a DFC

 		// which in its turn will signal the user thread.

 		//

 		lCh->iTime = lCh->Delta(lCh->iTime, now);

 		lCh->iDfc.Add();

 		}

 	}

 //

 // "TIMER OVERHEAD"

 // 

 // SCENARIO:

 //		To measure the overhead of the high-precision timer read operation we get

 //		two consecutive timestamps through DBMPChannel::TimerStamp() interface.

 //		The difference beween this two values is considered as the measured overhead.

 //

 TInt DBMLChannel::StartTimerStampOverhead()

 	{

 	if (iStarted)

 		{

 		return KErrInUse;

 		}

 	iRequestInterrupt = &DBMLChannel::RequestTimerStampOverhead;

 		// Use the default iResult() implmentation

 	iResult = &DBMLChannel::Result;

 	iInterruptThread = &Kern::CurrentThread();

 	iStarted = ETrue;

 	return KErrNone;

 	}

 TInt DBMLChannel::RequestTimerStampOverhead()

 	{

 	TBMTicks t1 = PChannel()->TimerStamp();

 	TBMTicks t2 = PChannel()->TimerStamp();

 	iTime = Delta(t1, t2);

 	NKern::ThreadRequestSignal(&iInterruptThread->iNThread);

 	return KErrNone;

 	}

 //

 // END OF "GETTING TIMER OVERHEAD"

 //

 //

 // The implmentation of RBMDriver::SetAbsPrioirty() call.

 //

 TInt DBMLChannel::SetAbsPrioirty(TInt aThreadHandle, TInt aNewPrio, TInt* aOldPrio)

 	{

 	NKern::LockSystem();

 	//

 	// Under the system lock find the DThread object and increment its ref-count (i.e Open()) 

 	//

 	DThread* thr = (DThread*) Kern::ObjectFromHandle(&Kern::CurrentThread(), aThreadHandle, EThread);

 	TInt r;

 	if (!thr)

 		{

 		r = EBadHandle;

 		}

 	else

 		{

 		r = thr->Open();

 		}

 	//

 	// Now it's safe to release the system lock and to work with the object.

 	//

 	NKern::ThreadEnterCS();

 	NKern::UnlockSystem();

 	if (r != KErrNone)

 		{

 		NKern::ThreadLeaveCS();

 		return r;

 		}

 	*aOldPrio = thr->iDefaultPriority;

 	Kern::SetThreadPriority(aNewPrio, thr);

 	//

 	// Work is done - close the object.

 	//	

 	thr->Close(NULL);

 	NKern::ThreadLeaveCS();

 	return KErrNone;

 	}

 _LIT(KBmDfcQName, "BmDfcQ");

 //

 // Starts a new sequence of measurements.

 //

 // Only one sequence can be started for any particular DBMLChannel object during its life. 

 // If more than one sequence is required a new DBMLChannel object must be created.

 //

 TInt DBMLChannel::Start(RBMChannel::TMode aMode)

 	{

 	TInt r;

 	if (iDfcQ == NULL)

 		{

 		r = Kern::DynamicDfcQCreate(iDfcQ, KBMDfcQThreadPriority, KBmDfcQName);

 		if (r != KErrNone)

 			return r;

 		iDfc.SetDfcQ(iDfcQ);

 		iDfc.SetFunction(Dfc);

 		}

 	switch (aMode)

 		{

 	case RBMChannel::EInterruptLatency:

 		r = StartInterruptLatency();

 		break;

 	case RBMChannel::EKernelPreemptionLatency:

 		r = StartKernelPreemptionLatency();

 		break;

 	case RBMChannel::EUserPreemptionLatency:

 		r = StartUserPreemptionLatency();

 		break;

 	case RBMChannel::ENTimerJitter:

 		r = StartNTimerJitter();

 		break;

 	case RBMChannel::ETimerStampOverhead:

 		r = StartTimerStampOverhead();

 		break;

 	default:

 		r = KErrNotSupported;

 		break;

 		}

 	return r;

 	}

 //

 // Client requests.

 //

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

 	{

 	TInt r = KErrNone;

 	switch (aFunction)

 		{

 		case RBMChannel::EStart:

 			{

 			RBMChannel::TMode mode = (RBMChannel::TMode) (TInt) a1;

 			Lock();

 			r = Start(mode);

 			Unlock();

 			break;

 			}

 		case RBMChannel::ERequestInterrupt:

 			{

 			Lock();

 			r = (this->*iRequestInterrupt)();

 			Unlock();

 			break;

 			}

 		case RBMChannel::EResult:

 			{

 			//

 			// We don't acquire the lock because:

 			//	(1) iResult() typically reads iTime which was written BEFORE to signal the current thread 

 			//      and therefore BEFORE the current thread comes here. 

 			//  (2) we really want if possible (i.e. correct!) to avoid the lock acquisition because it can

 			//		increase the measurement overhead in the case when we are in a measured path (e.g. user

 			//		preemption latency benchmark).

 			//

 			TBMTicks ticks = (this->*iResult)();

 			umemput(a1, &ticks, sizeof(ticks));

 			break;

 			}

 		//

 		// All below requests do not access writable DBMChannel state and therefore do not require the lock

 		//

 		case RBMChannel::ETimerStamp:

 			{

 			TBMTicks ticks = PChannel()->TimerStamp();

 			umemput(a1, &ticks, sizeof(ticks));

 			break;

 			}

 		case RBMChannel::ETimerPeriod:

 			{

 			TBMTicks ticks = iTimerPeriod;

 			umemput(a1, &ticks, sizeof(ticks));

 			break;

 			}

 		case RBMChannel::ETimerTicksToNs:

 			{

 			TBMTicks ticks;

 			umemget(&ticks, a1, sizeof(ticks));

 			TBMNs ns = PChannel()->TimerTicksToNs(ticks);

 			umemput(a2, &ns, sizeof(ns));

 			break;

 			}

 		case RBMChannel::ETimerNsToTicks:

 			{

 			TBMNs ns;

 			umemget(&ns, a1, sizeof(ns));

 			TBMTicks ticks = PChannel()->TimerNsToTicks(ns);

 			umemput(a2, &ticks, sizeof(ticks));

 			break;

 			}

 		case RBMChannel::ESetAbsPriority:

 			{

 			TInt newPrio;

 			TInt oldPrio;

 			umemget(&newPrio, a2, sizeof(newPrio));

 			r = SetAbsPrioirty((TInt) a1, newPrio, &oldPrio);

 			umemput(a2, &oldPrio, sizeof(oldPrio));

 			break;

 			}

 		default:

 			r = KErrNotSupported;

 			break;

 		}

 	return r;

 	}