// Copyright (c) 1997-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\misc\d_rndtim.cpp

// LDD for generating random interrupts

// 

//

#include "platform.h"

#include <kernel/kern_priv.h>

#include "d_rndtim.h"

#include "../misc/prbs.h"

#if defined(__MAWD__)

#include <windermere.h>

#elif defined(__MISA__)

#define INT_ID KIntIdOstMatchGeneral

#include <sa1100.h>

#elif defined(__MCOT__)

#define INT_ID KIntIdOstMatchGeneral

#include <cotulla.h>

#elif defined(__MI920__) || defined(__NI1136__)

#include <integratorap.h>

#elif defined(__EPOC32__) && defined(__CPU_X86)

#include <x86.h>

#endif

#ifndef INT_ID

#error Random timer ISR not supported on this platform

#endif

const TInt KMajorVersionNumber=0;

const TInt KMinorVersionNumber=1;

const TInt KBuildVersionNumber=1;

class DRndTimFactory : public DLogicalDevice

//

// IPC copy LDD factory

//

	{

public:

	DRndTimFactory();

	virtual TInt Install();						//overriding pure virtual

	virtual void GetCaps(TDes8& aDes) const;	//overriding pure virtual

	virtual TInt Create(DLogicalChannelBase*& aChannel);	//overriding pure virtual

	};

class DRndTim : public DLogicalChannelBase

//

// Millisecond timer LDD channel

//

	{

public:

	DRndTim();

	virtual ~DRndTim();

protected:

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

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

public:

	static void TimerIsr(TAny* aPtr);

	static void IDfcFn(TAny* aPtr);

	void StartTimer();

	void StopTimer();

	TInt SetPriority(TInt aHandle, TInt aPriority);

	TInt Calibrate(TInt aMilliseconds);

public:

	TInt iIntId;

	NFastSemaphore iSem;

	volatile TUint32 iSeed[2];

	volatile TUint32 iIsrCount;

	DThread* iThread;

	TDfc iIDfc;

	};

DECLARE_STANDARD_LDD()

	{

    return new DRndTimFactory;

    }

DRndTimFactory::DRndTimFactory()

//

// Constructor

//

    {

    iVersion=TVersion(KMajorVersionNumber,KMinorVersionNumber,KBuildVersionNumber);

    //iParseMask=0;//No units, no info, no PDD

    //iUnitsMask=0;//Only one thing

    }

TInt DRndTimFactory::Create(DLogicalChannelBase*& aChannel)

//

// Create a new DRndTim on this logical device

//

    {

	aChannel=new DRndTim;

    return aChannel?KErrNone:KErrNoMemory;

    }

TInt DRndTimFactory::Install()

//

// Install the LDD - overriding pure virtual

//

    {

    return SetName(&KRndTimLddName);

    }

void DRndTimFactory::GetCaps(TDes8& aDes) const

//

// Get capabilities - overriding pure virtual

//

    {

    TCapsRndTimV01 b;

    b.iVersion=TVersion(KMajorVersionNumber,KMinorVersionNumber,KBuildVersionNumber);

    Kern::InfoCopy(aDes,(TUint8*)&b,sizeof(b));

    }

DRndTim::DRndTim()

//

// Constructor

//

	:	iIntId(-1),

		iIDfc(&IDfcFn, this)

    {

	iThread=&Kern::CurrentThread();

	iThread->Open();

	iSem.iOwningThread = &iThread->iNThread;

	iSeed[0] = 0xb504f333u;

	iSeed[1] = 0xf9de6484u;

    }

DRndTim::~DRndTim()

	{

	StopTimer();

	if (iIntId >= 0)

		Interrupt::Unbind(iIntId);

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

	}

TInt DRndTim::DoCreate(TInt /*aUnit*/, const TDesC8* /*anInfo*/, const TVersion& aVer)

//

// Create channel

//

    {

    if (!Kern::QueryVersionSupported(TVersion(KMajorVersionNumber,KMinorVersionNumber,KBuildVersionNumber),aVer))

    	return KErrNotSupported;

	StopTimer();

	TInt r = Interrupt::Bind(INT_ID, &TimerIsr, this);

	if (r == KErrNone)

		iIntId = INT_ID;

	return r;

	}

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

	{

	TInt r = KErrNotSupported;

	switch (aFunction)

		{

		case RRndTim::EControlWait:

			NKern::FSWait(&iSem);

			r = KErrNone;

			break;

		case RRndTim::EControlSetPriority:

			r = SetPriority(TInt(a1), TInt(a2));

			break;

		case RRndTim::EControlStartTimer:

			NKern::ThreadEnterCS();

			StartTimer();

			NKern::ThreadLeaveCS();

			break;

		case RRndTim::EControlStopTimer:

			NKern::ThreadEnterCS();

			StopTimer();

			NKern::ThreadLeaveCS();

			break;

		case RRndTim::EControlCalibrate:

			NKern::ThreadEnterCS();

			r = Calibrate(TInt(a1));

			NKern::ThreadLeaveCS();

			break;

		default:

			break;

		}

	return r;

	}

TInt DRndTim::SetPriority(TInt aHandle, TInt aPriority)

	{

	TInt r = KErrBadHandle;

	DThread& c = Kern::CurrentThread();

	NKern::ThreadEnterCS();

	NKern::LockSystem();

	DThread* t = (DThread*)Kern::ObjectFromHandle(&c, aHandle, EThread);

	if (t && !t->Open())

		{

		NKern::UnlockSystem();

		r = Kern::SetThreadPriority(aPriority, t);

		t->Close(NULL);

		}

	else

		NKern::UnlockSystem();

	NKern::ThreadLeaveCS();

	return r;

	}

TInt DRndTim::Calibrate(TInt aMilliseconds)

	{

	TUint32 n1, n2;

	TInt ticks = NKern::TimerTicks(aMilliseconds);

	n1 = iIsrCount;

	NKern::Sleep(ticks);

	n2 = iIsrCount;

	return (TInt)(n2-n1);

	}

void DRndTim::StartTimer()

	{

#if defined(__MISA__) 

	// for SA11x0 use OST match 0

	TSa1100::ModifyIntLevels(0,KHtIntsOstMatchGeneral);	// route new timer interrupt to FIQ

	TSa1100::SetOstMatchEOI(KHwOstMatchGeneral);

	TUint oscr=TSa1100::OstData();

	TSa1100::SetOstMatch(KHwOstMatchGeneral, oscr + 5000);

	TSa1100::EnableOstInterrupt(KHwOstMatchGeneral);

#elif defined(__MCOT__)

	// for SA11x0 use OST match 0

	TCotulla::ModifyIntLevels(0,KHtIntsOstMatchGeneral);	// route new timer interrupt to FIQ

	TCotulla::SetOstMatchEOI(KHwOstMatchGeneral);

	TUint oscr=TCotulla::OstData();

	TCotulla::SetOstMatch(KHwOstMatchGeneral, oscr + 5000);

	TCotulla::EnableOstInterrupt(KHwOstMatchGeneral);

#endif

	Interrupt::Enable(INT_ID);

	}

void DRndTim::StopTimer()

	{

#if defined(__MISA__) 

	Interrupt::Disable(KIntIdOstMatchGeneral);

	TSa1100::DisableOstInterrupt(KHwOstMatchGeneral);

	TSa1100::SetOstMatchEOI(KHwOstMatchGeneral);

#elif defined(__MCOT__)

	Interrupt::Disable(KIntIdOstMatchGeneral);

	TCotulla::DisableOstInterrupt(KHwOstMatchGeneral);

	TCotulla::SetOstMatchEOI(KHwOstMatchGeneral);

#endif

	}

void DRndTim::TimerIsr(TAny* aPtr)

	{

	DRndTim* d = (DRndTim*)aPtr;

	++d->iIsrCount;

#if defined(__MISA__) 

	TUint interval = Random((TUint*)d->iSeed);

	interval &= 0x3ff;

	interval += 256;	// 256-1279 ticks = approx 69 to 347 microseconds

	TUint oscr=TSa1100::OstData();

	TSa1100::SetOstMatch(KHwOstMatchGeneral, oscr + interval);

	TSa1100::SetOstMatchEOI(KHwOstMatchGeneral);

#elif defined(__MCOT__)

	TUint interval = Random((TUint*)d->iSeed);

	interval &= 0x3ff;

	interval += 256;	// 256-1279 ticks = approx 69 to 347 microseconds

	TUint oscr=TCotulla::OstData();

	TCotulla::SetOstMatch(KHwOstMatchGeneral, oscr + interval);

	TCotulla::SetOstMatchEOI(KHwOstMatchGeneral);

#endif

	d->iIDfc.Add();

	}

void DRndTim::IDfcFn(TAny* aPtr)

	{

	DRndTim* d = (DRndTim*)aPtr;

	d->iSem.Signal();

	}