// 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();
	}