// Copyright (c) 2003-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\benchmark\bm_mcot_pdd.cpp
// PDD to provide OS timer services to benchmark programs
// 
//

#include <kernel/kernel.h>
#include <cotulla.h>


#include "k32bm.h"

class DBMMcotDevice : public DPhysicalDevice
	{
public:
	DBMMcotDevice();
	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 DBMMcotChannel : public DBMPChannel
	{
public:
	DBMMcotChannel();
	~DBMMcotChannel();

	// Report timing spec
	virtual TBMTicks TimerPeriod();
	// Get current OST tick time
	virtual TBMTicks TimerStamp();
	// Tick/nS conversions
	virtual TBMNs TimerTicksToNs(TBMTicks);
	virtual TBMTicks TimerNsToTicks(TBMNs);
	// Pass in client ISRs to invoke 
	virtual TInt BindInterrupt(MBMIsr*);
	virtual TInt BindInterrupt(MBMInterruptLatencyIsr*);
	// Invoke an ISR 
	virtual void RequestInterrupt();
	virtual void CancelInterrupt();

private:

	// Attach to OST interrupt
	TInt BindInterrupt();

	static const TInt		KBMMcotInterruptDelayTicks = KHwOscFreqHz / 1000;	// ie. delay ~ 1 ms timer tick!
	static const TBMTicks	KBMMcotPeriod = (((TBMTicks) 1) << 32);
	static const TBMNs		KBMMcotNsPerTick = (1000*1000*1000) / KHwOscFreqHz;
	
	// Real ISR (calls out to client)
	static void Isr(TAny*);
	
	MBMIsr*						iIsr;
	MBMInterruptLatencyIsr*		iInterruptLatencyIsr;
	};

// Standard boiler plate PDD factory object 

DECLARE_STANDARD_PDD()
//
// Create a new device
//
	{
	__ASSERT_CRITICAL;
	return new DBMMcotDevice;
	}

DBMMcotDevice::DBMMcotDevice()
//
// Constructor
//
	{
	//iUnitsMask=0;
	iVersion = TVersion(1,0,1);
	}

TInt DBMMcotDevice::Install()
//
// Install the device driver.
//
	{
	TInt r = SetName(&KBMPdName);
	return r;
	}

void DBMMcotDevice::GetCaps(TDes8& aDes) const
//
// Return the Comm capabilities.
//
	{
	}

TInt DBMMcotDevice::Create(DBase*& aChannel, TInt /*aUnit*/, const TDesC8* /*aInfo*/, const TVersion& /*aVer*/)
//
// Create a channel on the device.
//
	{
	__ASSERT_CRITICAL;
	aChannel = new DBMMcotChannel;
	return aChannel?KErrNone:KErrNoMemory;
	}

TInt DBMMcotDevice::Validate(TInt /*aUnit*/, const TDesC8* /*anInfo*/, const TVersion& aVer)
	{
	if (!Kern::QueryVersionSupported(iVersion,aVer))
		{
		return KErrNotSupported;
		}
	return KErrNone;
	}

// Actual device channel functions, called by LDD

// Clear saved ISR members
DBMMcotChannel::DBMMcotChannel()
	{
	//	iIsr = NULL;
	//	iInterruptLatencyIsr = NULL;
	}

// If we ever initialised the timers to generate ISRs, clear 
DBMMcotChannel::~DBMMcotChannel()
	{
	if (iIsr || iInterruptLatencyIsr)
		{
		TCotulla::DisableOstInterrupt(KHwOstMatchGeneral);
		TCotulla::SetOstMatchEOI(KHwOstMatchGeneral);
		Interrupt::Disable(KIntIdOstMatchGeneral);
		TCotulla::ModifyIntLevels(KHtIntsOstMatchGeneral,0);
		Interrupt::Unbind(KIntIdOstMatchGeneral);
		}
	}

TBMTicks DBMMcotChannel::TimerPeriod()
	{
	return KBMMcotPeriod;
	}

// Read OST and return tick count
TBMTicks DBMMcotChannel::TimerStamp()
	{
	return TUint(TCotulla::OstData());
	}

TBMNs DBMMcotChannel::TimerTicksToNs(TBMTicks ticks)
	{
	return ticks * KBMMcotNsPerTick;
	}

TBMTicks DBMMcotChannel::TimerNsToTicks(TBMNs ns)
	{
	return ns / KBMMcotNsPerTick;
	}

// Actual ISR called when benchmark timer fires
void DBMMcotChannel::Isr(TAny* ptr)
	{
	DBMMcotChannel* mCh = (DBMMcotChannel*) ptr;
	BM_ASSERT(mCh->iIsr || mCh->iInterruptLatencyIsr);
	if (mCh->iIsr)
		{
		// Call the handler with the current OST time
		mCh->iIsr->Isr(TUint(TCotulla::OstData()));
		}
	else
		{
		// Call the handler with the difference between NOW and the time the match timer was set for
		// ie. the latency between the timer interrupt set and when it was called.
		mCh->iInterruptLatencyIsr->InterruptLatencyIsr(TCotulla::OstData() - TCotulla::OstMatch(KHwOstMatchGeneral));
		}
	TCotulla::DisableOstInterrupt(KHwOstMatchGeneral);
	TCotulla::SetOstMatchEOI(KHwOstMatchGeneral);
	}


// Bind the OST match interrupt to a FIQ ISR - it will interrupt running IRQ service
// routines. 
TInt DBMMcotChannel::BindInterrupt()
	{
	TInt r = Interrupt::Bind(KIntIdOstMatchGeneral, Isr, this);
	if (r != KErrNone)
		{
		return r;
		}
	TCotulla::ModifyIntLevels(0, KHtIntsOstMatchGeneral);	// route new timer interrupt to FIQ
	TCotulla::SetOstMatchEOI(KHwOstMatchGeneral);
	Interrupt::Enable(KIntIdOstMatchGeneral);
	return KErrNone;
	}

// NB! Only one of these is ever used per channel opening, ie. the 
// channel must be closed and re-opened between installing client ISR
TInt DBMMcotChannel::BindInterrupt(MBMIsr* aIsr)
	{
	BM_ASSERT(!iIsr);
	BM_ASSERT(!iInterruptLatencyIsr);
	iIsr = aIsr;
	return BindInterrupt();
	}

TInt DBMMcotChannel::BindInterrupt(MBMInterruptLatencyIsr* aIsr)
	{
	BM_ASSERT(!iIsr);
	BM_ASSERT(!iInterruptLatencyIsr);
	iInterruptLatencyIsr = aIsr;
	return BindInterrupt();
	}

// Called by client to request an interrupt (ISR/latency ISR) invocation in ~1mS.
void DBMMcotChannel::RequestInterrupt()
	{
	BM_ASSERT(iIsr || iInterruptLatencyIsr);
	TCotulla::SetOstMatch(TCotulla::OstData()+KBMMcotInterruptDelayTicks,KHwOstMatchGeneral);
	TCotulla::SetOstMatchEOI(KHwOstMatchGeneral);
	TCotulla::EnableOstInterrupt(KHwOstMatchGeneral);
	}

// Called to cancel if client dies/killed after ISR scheduled ???
void DBMMcotChannel::CancelInterrupt()
	{	
	if (iIsr || iInterruptLatencyIsr)
		{
		TCotulla::DisableOstInterrupt(KHwOstMatchGeneral);
		TCotulla::SetOstMatchEOI(KHwOstMatchGeneral);
		}
	}