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

//

/*

Change History:

VERSION     : 2     26-01-2010     Ruixing Yang

REASON      : 

REFERENCE   : 

DESCRIPTION : The timer resolution is modified for better interrupt latency calculation

Change History:

VERSION     : 1     25-01-2010     Ruixing Yang

REASON      : 

REFERENCE   : 

DESCRIPTION : Initial implementation of BM_SUITE PDD for Rapu platform

*/

#include <kernel/kernel.h>

#include <internal/rap_hw.h>

#include <internal/rap.h>

#include "k32bm.h"

class DBMRapuDevice : public DPhysicalDevice

	{

public:

	DBMRapuDevice();

	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 DBMRapuChannel : public DBMPChannel

	{

public:

	DBMRapuChannel();

	~DBMRapuChannel();

	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 const TBMTicks	KBMRapuPeriod = (((TBMTicks) 1) << 32);

	// Ticks at 1000Hz, input clock to timer @ 32.768 MHz.

	static const TInt KHighResTimerFrequency = 32768000;   // 32.768 MHz

	static const TBMNs		KBMRapuNsPerTick = (1000*1000*1000) / KHighResTimerFrequency;	

	static const TInt KRTC_Freq = 32768;

	static const TInt KRTC_Ratio = 1172;

	static void Isr(TAny*);

	MBMIsr*								iIsr;

	MBMInterruptLatencyIsr*		iInterruptLatencyIsr;	

	TUint									iTmpStartCount;

	TUint									iTmpLongCount;	

	NTimer								iTimer;

	volatile TUint				iStartCount;

	volatile TUint				iRunCount;

	volatile TUint				iCancelCount;

	};

	RTC001_STR& RTC001 = *reinterpret_cast<RTC001_STR*>(KRapRegRTC001);

	GPT003_STR& GPT003 = *reinterpret_cast<GPT003_STR*>(KRapRegGPT003A0);

DECLARE_STANDARD_PDD()

//

// Create a new device

//

	{

	__ASSERT_CRITICAL;

	return new DBMRapuDevice;

	}

DBMRapuDevice::DBMRapuDevice()

//

// Constructor

//

	{

	iVersion = TVersion(1,0,1);

	}

TInt DBMRapuDevice::Install()

//

// Install the device driver.

//

	{

	TInt r = SetName(&KBMPdName);

	return r;

	}

void DBMRapuDevice::GetCaps(TDes8& aDes) const

//

// Return the Comm capabilities.

//

	{

	}

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

//

// Create a channel on the device.

//

	{

	__ASSERT_CRITICAL;

	aChannel = new DBMRapuChannel;

	return aChannel?KErrNone:KErrNoMemory;

	}

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

	{

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

		{

		return KErrNotSupported;

		}

	return KErrNone;

	}

DBMRapuChannel::DBMRapuChannel()

	: iTimer(&Isr, this)

	{

	iTmpStartCount = 0;

	iTmpLongCount = 0;

	}

DBMRapuChannel::~DBMRapuChannel()

	{

	//Kern::Printf(("DBMRapuChannel::~DBMRapuChannel()"));	

	CancelInterrupt();

	}

TBMTicks DBMRapuChannel::TimerPeriod()

	{

		//Kern::Printf(("DBMRapuChannel::TimerPeriod()"));

	return KBMRapuPeriod;

	}

TBMTicks DBMRapuChannel::TimerStamp()

	{

	//Kern::Printf(("DBMRapuChannel::TimerStamp(), iTimerCount = %u"), RPTimer1::Timer().iTimerCount);	

	TUint tmpTimeStamp;

	RTC001.TRIGGER = 0;	

	tmpTimeStamp = RTC001.LONGCOUNT;

	tmpTimeStamp *= KRTC_Ratio;

	tmpTimeStamp += RTC001.SHORTCOUNT;		

	return tmpTimeStamp;	

	}	

TBMNs DBMRapuChannel::TimerTicksToNs(TBMTicks ticks)

	{

	//Kern::Printf(("DBMRapuChannel::TimerTIcksToNs(), iNsPerTick = %u"), (TBMTicks)iNsPerTick);

	return ticks * KBMRapuNsPerTick;

	}

TBMTicks DBMRapuChannel::TimerNsToTicks(TBMNs ns)

	{

	//Kern::Printf(("DBMRapuChannel::TimerNsToTicks()"));

	return ns / KBMRapuNsPerTick;	

	}

void DBMRapuChannel::Isr(TAny* ptr)

	{

	//Kern::Printf(("DBMRapuChannel::Isr()"));

	// Read RTC001	

	RTC001.TRIGGER = 0;

	TUint x = RTC001.LONGCOUNT;

	x *= KRTC_Ratio;

	x += RTC001.SHORTCOUNT;

	TUint wasteTime = 1000000/KBMRapuNsPerTick; //NTimer's resolution is 1 ms = 1000000 ns	

	DBMRapuChannel* mCh = (DBMRapuChannel*) ptr;

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

	if (mCh->iIsr)

		{				

		mCh->iIsr->Isr( x);	

		}

	else

		{				

		TUint y = (TUint)( x - mCh->iTmpLongCount - wasteTime);

		//Kern::Printf(("DBMRapuChannel::Isr(), latency = %u"), y);	

		mCh->iInterruptLatencyIsr->InterruptLatencyIsr(y);

		}

	__e32_atomic_add_ord32(&mCh->iRunCount, 1);

	}	

TInt DBMRapuChannel::BindInterrupt(MBMIsr* aIsr)

	{

	//Kern::Printf(("DBMRapuChannel::BindInterrupt(MBMIsr* aIsr)"));

	BM_ASSERT(!iIsr);

	BM_ASSERT(!iInterruptLatencyIsr);

	iIsr = aIsr;

	return KErrNone;

	}

TInt DBMRapuChannel::BindInterrupt(MBMInterruptLatencyIsr* aIsr)

	{

	//Kern::Printf(("DBMRapuChannel::BindInterrupt(MBMInterruptLatencyIsr* aIsr)"));

	BM_ASSERT(!iIsr);

	BM_ASSERT(!iInterruptLatencyIsr);

	iInterruptLatencyIsr = aIsr;

	return KErrNone;

	}

void DBMRapuChannel::RequestInterrupt()

	{

	//Kern::Printf(("DBMRapuChannel::RequestInterrupt()"));	

	BM_ASSERT(iIsr || iInterruptLatencyIsr);		

	// Read RTC001

	RTC001.TRIGGER = 0;	

	iTmpLongCount = RTC001.LONGCOUNT;

	iTmpLongCount *= KRTC_Ratio;

	iTmpLongCount += RTC001.SHORTCOUNT;					

	if (iTimer.OneShot(1)==KErrNone)

		__e32_atomic_add_ord32(&iStartCount, 1);

	}

void DBMRapuChannel::CancelInterrupt()

	{

	iTmpStartCount = 0;

	//Kern::Printf(("DBMRapuChannel::CancelInterrupt()"));		

	if (iTimer.Cancel())

		__e32_atomic_add_ord32(&iCancelCount, 1);

	while (iStartCount != iCancelCount + iRunCount)

		{}

	}