// 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 <kernel/kernel.h>

 #include <integratorap.h>

 #include <iolines.h>

 //	NOTE:

 //	We use 2 different timers on this test:

 //		1) the Core module FRC - 32-bit clocked at 24MHz, non-interruptible, for the time stamps

 //		2) IntegratorAP Timer 1 - 16-bit, clocked at 1.5MHz , interruptible, for the Interrupts latency measurements

 //

 #define KHwFrcFreqHz	24000000			// uses the core module FRC clocked at 24MHz

 #define KHwApFreqHz		24000000			// uses the IntegratorAP Timer 1 clocked at 24MHz

 #include "k32bm.h"

 class DBMMi920Device : public DPhysicalDevice

 	{

 public:

 	DBMMi920Device();

 	virtual TInt Install();

 	virtual void GetCaps(TDes8& aDes) const;

 	virtual TInt Create(DBase*& aChannel, TInt aUnit, const TDesC8* anInfo, const TVersion& aVer);

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

 	};

 class DBMMi920Channel : public DBMPChannel

 	{

 public:

 	DBMMi920Channel();

 	~DBMMi920Channel();

 	TInt InitialiseTimer();

 	virtual TBMTicks TimerPeriod();

 	virtual TBMTicks TimerStamp();

 	virtual TBMNs TimerTicksToNs(TBMTicks);

 	virtual TBMTicks TimerNsToTicks(TBMNs);

 	virtual TInt BindInterrupt(MBMIsr*);

 	virtual TInt BindInterrupt(MBMInterruptLatencyIsr*);

 	virtual void RequestInterrupt();

 	virtual void CancelInterrupt();

 private:

 	static void ClearAp1TimerInt();

 	TInt BindInterrupt();

 	static const TBMTicks	KBMMi920FrcPeriod = (((TBMTicks) 1) << 32);				// FRC

 	static const TUint		KBMMi920ApPeriod = (((TBMTicks) 1) << 16);				// FRC

 	static const TBMNs		KBMMi920NsPerTick = (1000*1000*1000) / KHwFrcFreqHz;	// FRC

 	static const TUint		KBMMi920InterruptDelayTicks = KHwApFreqHz / 1000;		// 1ms in AP Timer 1 ticks

 	static void Isr(TAny*);

 	MBMIsr*						iIsr;

 	MBMInterruptLatencyIsr*		iInterruptLatencyIsr;

 	TInt				iInterruptId;

 	};

 DECLARE_STANDARD_PDD()

 //

 // Create a new device

 //

 	{

 	__ASSERT_CRITICAL;

 	return new DBMMi920Device;

 	}

 DBMMi920Device::DBMMi920Device()

 //

 // Constructor

 //

 	{

 	//iUnitsMask=0;

 	iVersion = TVersion(1,0,1);

 	}

 TInt DBMMi920Device::Install()

 //

 // Install the device driver.

 //

 	{

 	TInt r = SetName(&KBMPdName);

 	return r;

 	}

 void DBMMi920Device::GetCaps(TDes8& aDes) const

 //

 // Return the Comm capabilities.

 //

 	{

 	}

 TInt DBMMi920Device::Create(DBase*& aChannel, TInt /*aUnit*/, const TDesC8* /*aInfo*/, const TVersion& /*aVer*/)

 //

 // Create a channel on the device.

 //

 	{

 	__ASSERT_CRITICAL;

 	DBMMi920Channel* pD= new DBMMi920Channel;

 	aChannel = pD;

 	TInt r=KErrNoMemory;

 	if (pD)

 		r=pD->InitialiseTimer();

 	return r;

 	}

 TInt DBMMi920Device::Validate(TInt /*aUnit*/, const TDesC8* /*anInfo*/, const TVersion& aVer)

 	{

 	if (!Kern::QueryVersionSupported(iVersion,aVer))

 		{

 		return KErrNotSupported;

 		}

 	return KErrNone;

 	}

 void DBMMi920Channel::ClearAp1TimerInt()

 	{

 	do

 		TIntegratorAP::ClearTimerInt(TIntegratorAP::ECounterTimer1);

 		// WARNING: Integrator bug! The timer interrupts are not always cleared the first time round

 		// so keep on clearing them until they are no longer active.

 	while (*(volatile TUint*)(KHwIrqBaseSet0) & KHtIntTimer1);

 	}

 DBMMi920Channel::DBMMi920Channel()

 	{

 	//	iIsr = NULL;

 	//	iInterruptLatencyIsr = NULL;

 	iInterruptId = KIntIdMatchGeneral2;

 	}

 DBMMi920Channel::~DBMMi920Channel()

 	{

 	// Disable the IntegratorAP Timer 1 and associated interrupt

 	if (iIsr || iInterruptLatencyIsr)

 		{

 		ClearAp1TimerInt();

 		Interrupt::Disable(iInterruptId);

 		Interrupt::Unbind(iInterruptId);

 		}

 	TIntegratorAP::EnableTimer(TIntegratorAP::ECounterTimer1, TIntegratorAP::EDisable);

 	}

 TInt DBMMi920Channel::InitialiseTimer()

 	{

 	// Set up the IntegratorAP Timer 1 to run at 1.5MHz, free-running mode, and enable it

     TIntegratorAP::SetTimerMode(TIntegratorAP::ECounterTimer1, TIntegratorAP::ETimerModeFreeRunning);

 	TIntegratorAP::SetTimerPreScale(TIntegratorAP::ECounterTimer1, TIntegratorAP::ETimerPreScaleNone);	// 24MHz

     TIntegratorAP::EnableTimer(TIntegratorAP::ECounterTimer1, TIntegratorAP::EEnable);

 	return KErrNone;

 	}

 TBMTicks DBMMi920Channel::TimerPeriod()

 	{

 	return KBMMi920FrcPeriod;

 	}

 TBMTicks DBMMi920Channel::TimerStamp()

 	{

 	return (*(volatile TUint*)(KHwRwCoreClkCounter));		// FRC

 	}

 TBMNs DBMMi920Channel::TimerTicksToNs(TBMTicks ticks)

 	{

 	return ticks * KBMMi920NsPerTick;						// FRC

 	}

 TBMTicks DBMMi920Channel::TimerNsToTicks(TBMNs ns)

 	{

 	return ns / KBMMi920NsPerTick;							// FRC

 	}

 void DBMMi920Channel::Isr(TAny* ptr)

 	{

 	DBMMi920Channel* mCh = (DBMMi920Channel*) ptr;

 	BM_ASSERT(mCh->iIsr || mCh->iInterruptLatencyIsr);

 	if (mCh->iIsr)

 		{

 		mCh->iIsr->Isr(*(volatile TUint*)(KHwRwCoreClkCounter));	// read timestamp off FRC

 		}

 	else

 		{ // calculate time elapsed between the interrupt going off and now in FRC ticks

 		TUint value = TIntegratorAP::TimerValue(TIntegratorAP::ECounterTimer1);

 		BM_ASSERT(((KHwFrcFreqHz/KHwApFreqHz)*KHwApFreqHz) == KHwFrcFreqHz);

 		mCh->iInterruptLatencyIsr->InterruptLatencyIsr((KBMMi920ApPeriod - value) * (KHwFrcFreqHz/KHwApFreqHz));

 		}

 	ClearAp1TimerInt();

 	Interrupt::Disable(mCh->iInterruptId);

 	}

 TInt DBMMi920Channel::BindInterrupt()

 	{

 	BM_ASSERT(iInterruptId==KIntIdMatchGeneral2);

 	TInt r=Interrupt::Bind(iInterruptId, Isr, this);

 	if (r<0)

 		{

 		return r;

 		}

 	iInterruptId = r;

 	return KErrNone;

 	}

 TInt DBMMi920Channel::BindInterrupt(MBMIsr* aIsr)

 	{

 	BM_ASSERT(!iIsr);

 	BM_ASSERT(!iInterruptLatencyIsr);

 	iIsr = aIsr;

 	return BindInterrupt();

 	}

 TInt DBMMi920Channel::BindInterrupt(MBMInterruptLatencyIsr* aIsr)

 	{

 	BM_ASSERT(!iIsr);

 	BM_ASSERT(!iInterruptLatencyIsr);

 	iInterruptLatencyIsr = aIsr;

 	return BindInterrupt();

 	}

 void DBMMi920Channel::RequestInterrupt()

 	{

 	BM_ASSERT(iIsr || iInterruptLatencyIsr);

 	TIntegratorAP::SetTimerLoad(TIntegratorAP::ECounterTimer1, KBMMi920InterruptDelayTicks);

 	ClearAp1TimerInt();

 	Interrupt::Enable(iInterruptId);					// Timer interrupts on Integrator are always enabled!

 	}

 void DBMMi920Channel::CancelInterrupt()

 	{	

 	if (iIsr || iInterruptLatencyIsr)

 		{

 		TIntegratorAP::EnableTimer(TIntegratorAP::ECounterTimer1, TIntegratorAP::EDisable);

 		}

 	}