/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "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:  

*

*/

//

// LDD for thread time profiling

//

#include <kern_priv.h>

#include <platform.h>

#include <arm.h>

#ifdef __SMP__

#include <assp/naviengine/naviengine.h> 

#include <nkernsmp/arm/arm_gic.h>

#include <nkernsmp/arm/arm_tmr.h>

#endif

#include "GeneralsDriver.h"

#include <piprofiler/PluginDriver.h>

#include <piprofiler/PluginSampler.h>

#include <piprofiler/ProfilerTraces.h>

#include "GppSamplerImpl.h"

#include "GfcSamplerImpl.h"

#include "IttSamplerImpl.h"

#include "MemSamplerImpl.h"

#include "PriSamplerImpl.h"

#ifndef __SMP__

extern TUint* IntStackPtr();

extern void UsrModLr(TUint32*);

#endif

// for security check

#define KProfilerExeSecurUid 0x2001E5AD

static _LIT_SECURITY_POLICY_PASS(KAllowAllPolicy);

static _LIT_SECURITY_POLICY_FAIL( KDenyAllPolicy );

#define SEPARATE_DFC_QUEUE

// CONSTANTS

//_LIT(DProfilerThread,"DProfilerThread");

//const TInt KDProfilerThreadPriority = 27;

#ifdef SEPARATE_DFC_QUEUE

const TInt KGeneralsDriverThreadPriority = 24;

_LIT(KGeneralsDriverThread, "PIGeneralsDriver");

#endif

// global Dfc Que

//TDynamicDfcQue* gDfcQ;

//#ifdef __SMP__

//

//enum  TNaviEngineAsspInterruptIdExtension

//{

//    KIntProfilerBase = 99      //  Sampling profiler interrupt base. 

//    //  Each CPU is assigned a sampling interrupt from this base

//    //  CPU-0's sampling interrupt is KIntIdSamplingBase + 0

//    //  CPU-n's sampling interrupt is KIntIdSamplingBase + n

//};

//#endif

/*

 *

 *

 *	Class DGfcProfilerFactory definition

 *

 *

 */

class DGeneralsProfilerFactory : public DLogicalDevice

{

	public:

		DGeneralsProfilerFactory();

		~DGeneralsProfilerFactory();

	public:

		virtual TInt Install();

		virtual void GetCaps(TDes8& aDes) const;

		virtual TInt Create(DLogicalChannelBase*& aChannel);

};

/*

 *

 *

 *	Class DGfcDriver definition

 *

 *

 */

class DPluginDriver;

class DGeneralsDriver : public DPluginDriver

{

public:

	DGeneralsDriver();

	~DGeneralsDriver();

private:

	TInt					NewStart(TInt aRate);

	static void				NewDoProfilerProfile(TAny*);

	static void				NewDoDfc(TAny*);

	// called by each core

	static void				Sample(TAny*);

	TInt					GetSampleTime(TUint32* time);

	//TInt					Test(TUint32 testCase); 

	TInt					StartSampling();

	TInt                    StopSampling();

	void					InitialiseSamplerList(); 

	DProfilerSamplerBase*	GetSamplerForId(TInt samplerId);

	TInt					GetSamplerVersion(TDes* aDes);

#ifdef __SMP__

	void                    UnbindInterrupts();

#endif

	TInt					ProcessStreamReadRequest(TBapBuf* aBuf,TRequestStatus* aStatus);

	TInt					MarkTraceActive(TInt samplerIdToActivate);

	TInt					MarkTraceInactive(TInt samplerIdToDisable);

	TInt					OutputSettingsForTrace(TInt samplerId,TInt settings);

	TInt					AdditionalTraceSettings(TInt samplerId,TInt settings);

	TInt					AdditionalTraceSettings2(TInt samplerId,TInt settings);

	TInt					SetSamplingPeriod(TInt /*samplerId*/,TInt settings);

private:

	// create the driver in EKA-2 version

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

	// receive commands and control in EKA-2 version

	void					HandleMsg(TMessageBase* aMsg);

private:

	// timer mechanism in EKA-2 version

	NTimer						iTimer;

	TDfc						iNewDfc;

	TInt						iCount;

	TInt						iLastPcVal;					

	TInt						iPeriod;

	// sync sample number property for synchronizing other samplers

	RPropertyRef 				iSampleStartTimeProp;

	TInt						iSampleStartTime;

	DProfilerGppSampler<10000> 	gppSampler;

#ifdef __SMP__

	DProfilerGppSampler<10000>  gppSampler2;

    DProfilerGppSampler<10000>  gppSampler3;

    DProfilerGppSampler<10000>  gppSampler4;

#endif

	DProfilerGfcSampler<10000> 	gfcSampler;

	DProfilerIttSampler<10000> 	ittSampler;

	DProfilerMemSampler<40000> 	memSampler;

	DProfilerPriSampler<10000> 	priSampler;

#ifdef __SMP__

//    DProfilerPriSampler<10000>  priSampler2;

//    DProfilerPriSampler<10000>  priSampler3;

//    DProfilerPriSampler<10000>  priSampler4;

#endif

#ifndef __SMP__

	static const TInt			KSamplerAmount = 5;

#else

    static const TInt           KSamplerAmount = 8;

#endif

	DProfilerSamplerBase*		iSamplers[KSamplerAmount];

    TInt                        iMaxCpus;

    TUint32                     iStartTime; 

#ifdef SEPARATE_DFC_QUEUE

	TDynamicDfcQue*             iDfcQ;

#endif

};

/*

 *

 *

 *	Class DGeneralsProfilerFactory implementation

 *

 *

 */

DECLARE_STANDARD_LDD()

    {

	return new DGeneralsProfilerFactory();

    }

TInt DGeneralsProfilerFactory::Create(DLogicalChannelBase*& aChannel)

    {

	aChannel = new DGeneralsDriver;

	return aChannel?KErrNone:KErrNoMemory;

    }

DGeneralsProfilerFactory::DGeneralsProfilerFactory()

    {

	// major, minor, and build version number

    iVersion=TVersion(1,0,1);

    }

DGeneralsProfilerFactory::~DGeneralsProfilerFactory()

    {

//    if (gDfcQ)

//        {

//        gDfcQ->Destroy();

//        }

    }

TInt DGeneralsProfilerFactory::Install()

    {

    return(SetName(&KPluginSamplerName));

    }

void DGeneralsProfilerFactory::GetCaps(TDes8& aDes) const

    {

    TCapsSamplerV01 b;

    b.iVersion=TVersion(1,0,1);

    aDes.FillZ(aDes.MaxLength());

    aDes.Copy((TUint8*)&b,Min(aDes.MaxLength(),sizeof(b)));

    }

/*

 *

 *

 *	Class DGeneralsDriver implementation

 *

 *

 */

DGeneralsDriver::DGeneralsDriver() :

	iTimer(NewDoProfilerProfile,this),

	iNewDfc(NewDoDfc,this,NULL,7),

#ifdef __SMP__

	gppSampler(0),

	gppSampler2(1),

    gppSampler3(2),

    gppSampler4(3),

#endif

	gfcSampler(gppSampler.GetExportData()),

	ittSampler(gppSampler.GetExportData()),

	memSampler(gppSampler.GetExportData(), PROFILER_MEM_SAMPLER_ID),

	priSampler(gppSampler.GetExportData(), PROFILER_PRI_SAMPLER_ID)

#ifdef __SMP__

//    ,priSampler2(gppSampler.GetExportData(), PROFILER_PRI_SAMPLER_ID),

//    priSampler3(gppSampler.GetExportData(), PROFILER_PRI_SAMPLER_ID),

//    priSampler4(gppSampler.GetExportData(), PROFILER_PRI_SAMPLER_ID)

#endif

    {

	LOGSTRING("DGeneralsDriver::DGeneralsDriver()");

	iState = EStopped;

	iEndRequestStatus = 0;

	doingDfc = 0;

	sampleRunning = 0;

	iSyncOffset = 0;

	iStartTime = 0;

	InitialiseSamplerList();

    }

/*

 *

 *	This method has to be changed for each new sampler

 *

 */ 

void DGeneralsDriver::InitialiseSamplerList()

	{

	// initialize all samplers to zero

	for(TInt i(0);i<KSamplerAmount;i++)

		{

		iSamplers[i] = 0;

		}

	TInt i(0);

	iSamplers[i] = &gppSampler;i++;

#ifdef __SMP__

	iSamplers[i] = &gppSampler2;i++;

    iSamplers[i] = &gppSampler3;i++;

    iSamplers[i] = &gppSampler4;i++;

#endif

	iSamplers[i] = &gfcSampler;i++;

	iSamplers[i] = &ittSampler;i++;

	iSamplers[i] = &memSampler;i++;

	iSamplers[i] = &priSampler;i++;

#ifdef __SMP__

    // get the number of cpus

    iMaxCpus = NKern::NumberOfCpus();

#else

    iMaxCpus = 0;

#endif

	// initialize synchronizing property

	LOGSTRING("DGeneralsDriver::InitialiseSamplerList() - initializing property");

	TInt r(iSampleStartTimeProp.Attach(KGppPropertyCat, EGppPropertySyncSampleNumber));

    if (r!=KErrNone)

        {

        LOGSTRING2("DGeneralsDriver::InitialiseSamplerList() - error in attaching counter property, error %d", r);

        }

    LOGSTRING("DGeneralsDriver::InitialiseSamplerList() - defining properties");

    r = iSampleStartTimeProp.Define(RProperty::EInt, KAllowAllPolicy, KDenyAllPolicy, 0, NULL);

    if (r!=KErrNone)

        {

        LOGSTRING2("DGeneralsDriver::InitialiseSamplerList() - error in defining counter property, error %d", r);

        }	

	}

DProfilerSamplerBase* DGeneralsDriver::GetSamplerForId(TInt samplerIdToGet)

    {

	for(TInt i(0);i<KSamplerAmount;i++)

	    {

		if(iSamplers[i]->iSamplerId == samplerIdToGet)

		    {

			return iSamplers[i];

		    }

	    }

	return (DProfilerSamplerBase*)0;

    }

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

    {

    TUint8 err(KErrNone);

    if (!Kern::QueryVersionSupported(TVersion(1,0,1),aVer))

	   	return KErrNotSupported;

    // just for testing 

#ifndef __SMP__

    LOGTEXT("Initializing the stack pointer");

    stackTop=(TUint32*)IntStackPtr();

    LOGSTRING2("Got stack pointer 0x%x",(TUint32)stackTop);

#endif

    iClient = &Kern::CurrentThread();

    err = iClient->Open();

    DProcess* clientProcess(iClient->iOwningProcess);

    if (clientProcess)

        {

        //Require Power Management and All Files to use this driver

        // Not ideal, but better than nothing

        if(!Kern::CurrentThreadHasCapability(ECapabilityPowerMgmt,__PLATSEC_DIAGNOSTIC_STRING("Checked by GeneralsDriver.ldd")))

            return KErrPermissionDenied;

        if(!Kern::CurrentThreadHasCapability(ECapabilityAllFiles,__PLATSEC_DIAGNOSTIC_STRING("Checked by GeneralsDriver.ldd")))

            return KErrPermissionDenied;  

        SSecurityInfo secureInfo = clientProcess->iS;

        if (secureInfo.iSecureId != KProfilerExeSecurUid)

            {

            return KErrPermissionDenied;

            }

        }

    // initiate sample stream ready for collecting the trace data

	iSampleStream.InsertCurrentClient(iClient);

	iTimer.Cancel();

	iNewDfc.Cancel();

	Kern::SetThreadPriority(24);

#ifdef SEPARATE_DFC_QUEUE

	err = Kern::DynamicDfcQCreate(iDfcQ, KGeneralsDriverThreadPriority, TBuf8<32>( KGeneralsDriverThread ));

	if (KErrNone == err)

        {

        SetDfcQ(iDfcQ);

        iNewDfc.SetDfcQ(iDfcQ);

        iMsgQ.Receive();

        return err;

        }

#else

	SetDfcQ(Kern::DfcQue0());

	iNewDfc.SetDfcQ(iDfcQ);

	iMsgQ.Receive();

#endif

	return err;

    }

DGeneralsDriver::~DGeneralsDriver()

    {

	if (iState!=EStopped)

	    iTimer.Cancel();

	iNewDfc.Cancel();

#ifdef SEPARATE_DFC_QUEUE

	if(iDfcQ)

	    iDfcQ->Destroy();

#endif

	iSampleStartTimeProp.Close();

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

    }

TInt DGeneralsDriver::GetSampleTime(TUint32* time)

    {

	LOGSTRING("DGeneralsDriver::GetSampleTime - entry");

	Kern::ThreadRawWrite(	iClient,(TAny*)time, 

							(TAny*)&gppSampler.GetExportData()->sampleNumber, 

							4, iClient);

	LOGSTRING("DGeneralsDriver::GetSampleTime - exit");

	return KErrNone;

    }

TInt DGeneralsDriver::GetSamplerVersion(TDes* aDes)

    {

	LOGSTRING2("DGeneralsDriver::GetSamplerVersion - 0x%x",aDes);

	TBuf8<16> aBuf;

	aBuf.Append(PROFILER_SAMPLER_VERSION);

	Kern::ThreadDesWrite(iClient,aDes,aBuf,0,KChunkShiftBy0,iClient);

	LOGSTRING("DGeneralsDriver::GetSamplerVersion - written client descriptor");

	return KErrNone;

    }

TInt DGeneralsDriver::NewStart(TInt aDelay)

    {	

	LOGSTRING("DGeneralsDriver::NewStart");

	iEndRequestStatus = 0;

	aDelay = Min(KMaxDelay, Max(KMinDelay, aDelay));

	// always use this rate

	iPeriod = aDelay;

#ifdef __SMP__

    /*

     * Bind and enable the sampling interupts associated with each core. 

     */

    TInt err(0);

    TUint32 flags = NKern::EIrqBind_Count;

//    Kern::Printf(" > Interrupt::InterruptBind KIntProfilerBase - 32=%d", KIntProfilerBase -32 );

    err = NKern::InterruptBind( KIntProfilerBase - 32 , DGeneralsDriver::Sample, this, flags, 0);

    if(err < 0)

        Kern::Printf(" InterruptBind KIntProfilerBase - 32 ret = %d", err );

//    Kern::Printf(" > Interrupt::InterruptBind KIntProfilerBase + 1 - 32=%d", KIntProfilerBase + 1-32 );

    err = NKern::InterruptBind( KIntProfilerBase + 1 - 32 , DGeneralsDriver::Sample, this, flags, 0);

    if(err < 0)

        Kern::Printf(" InterruptBind KIntProfilerBase + 1 - 32 ret = %d", err );

//    Kern::Printf(" > Interrupt::InterruptBind KIntProfilerBase + 2 - 32=%d", KIntProfilerBase + 2 - 32 );

    err = NKern::InterruptBind(KIntProfilerBase + 2 - 32 , DGeneralsDriver::Sample, this, flags, 0);

    if(err < 0)

        Kern::Printf(" InterruptBind KIntProfilerBase + 2 - 32 ret = %d", err );

//    Kern::Printf(" > Interrupt::InterruptBind KIntProfilerBase + 3 - 32=%d", KIntProfilerBase + 3 - 32 );

    err = NKern::InterruptBind(KIntProfilerBase + 3 - 32 , DGeneralsDriver::Sample, this, flags, 0);

    if(err < 0)

        Kern::Printf(" InterruptBind KIntProfilerBase + 3 - 32 ret = %d", err );

    err = NKern::InterruptEnable(KIntProfilerBase - 32);

    if(err < 0)

        Kern::Printf(" InterruptEnable KIntProfilerBase - 32 ret = %d", err );

    err = NKern::InterruptEnable(KIntProfilerBase + 1 - 32);

    if(err < 0)

        Kern::Printf(" InterruptEnable KIntProfilerBase + 1 - 32 ret = %d", err );

    err = NKern::InterruptEnable(KIntProfilerBase + 2 - 32);

    if(err < 0)

        Kern::Printf(" InterruptEnable KIntProfilerBase + 2 - 32 ret = %d", err );

    err = NKern::InterruptEnable(KIntProfilerBase + 3 - 32);

    if(err < 0)

        Kern::Printf(" InterruptEnable KIntProfilerBase + 3 - 32 ret = %d", err );

#endif

	iTimer.OneShot(aDelay);

	iState = ERunning;

	return KErrNone;

    }

/*

 *	This function is run in each interrupt

 */

// EKA-2 implementation of the sampler method

void DGeneralsDriver::NewDoProfilerProfile(TAny* aPtr)

    {

    LOGSTRING("DGeneralsDriver::NewDoProfilerProfile - entry");

#ifdef __SMP__      

    TInt currCpu(NKern::CurrentCpu());

#endif

    TInt8 postSampleNeeded(0);

    DGeneralsDriver& d=*(DGeneralsDriver*)aPtr;

	if (d.iState == ERunning && d.sampleRunning == 0)

	    {

        // start timer again

		d.iTimer.Again(d.iPeriod);

		d.sampleRunning++;

#ifdef __SMP__      

        // print out the sample tick

        if(d.gppSampler.GetExportData()->sampleNumber% 1000 == 0) 

            {