/*

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

*

*/

#include <piprofiler/ProfilerVersion.h>

#include <piprofiler/ProfilerTraces.h>

#include <kern_priv.h>

#include <arm.h>

#include "GppSamplerImpl.h"

extern TUint*		IntStackPtr();

#define	TAG(obj)	(*(TUint32*)&(obj.iAsyncDeleteNext))

// properties for ISA task parsing

const TUid KIsaPropertyCat={0x2001E5AD};

enum TIsaPropertyKeys

	{

	EIsaPropertyIsaTaskParserStatus = 1,

	EIsaPropertyIsaTaskAddressStart,

	EIsaPropertyIsaTaskAddressEnd,

	EIsaPropertyIsaTaskAddress,

	EIsaPropertyIsaOsTaskRunningAddress,

	EIsaPropertyIsaTaskParsedName

	};

DGppSamplerImpl::DGppSamplerImpl()

	{

	LOGTEXT("GppSamplerImpl::GppSamplerImpl");

	iInterruptStack = (TUint*)IntStackPtr();

	LOGTEXT("GppSamplerImpl::GppSamplerImpl - attaching to properties");

	if(err != KErrNone)

		LOGTEXT("GppSamplerImpl::GppSamplerImpl() - Property EIsaPropertyIsaTaskAddressStart not available"); 

	err = iIsaEndAddr.Attach(KIsaPropertyCat, EIsaPropertyIsaTaskAddressEnd);

	if(err != KErrNone)

		LOGTEXT("GppSamplerImpl::GppSamplerImpl() - Property EIsaPropertyIsaTaskAddressEnd not available"); 

	err = iIsaPluginStatus.Attach(KIsaPropertyCat, EIsaPropertyIsaTaskParserStatus);

	if(err != KErrNone)

		LOGTEXT("GppSamplerImpl::GppSamplerImpl() - Property EIsaPropertyIsaTaskParserStatus not available"); 

	err = iIsaOsTaskRunning.Attach(KIsaPropertyCat, EIsaPropertyIsaOsTaskRunningAddress);

	if(err != KErrNone)

		LOGTEXT("GppSamplerImpl::GppSamplerImpl() - Property EIsaPropertyIsaOsTaskRunningAddress not available"); 

	PROFILER_ISA_TASK_NAMES

	Reset();

	}

DGppSamplerImpl::~DGppSamplerImpl() 

	{

	iIsaStartAddr.Close();

	iIsaEndAddr.Close();

	iIsaPluginStatus.Close();

	iIsaOsTaskRunning.Close();

	}

void DGppSamplerImpl::Reset()

	{

	iLastPc = 0;

	iLastThread = 0xfffffffe;

	iRepeat = 0;

	iIsaStatus = 0;

	iIsaStart = 0;

	iIsaEnd = 0;

//	isaOsTaskRunningAddr = 0;

	// in SMP start time common with all CPUs, provided by DGeneralsDriver class

#ifndef __SMP__

#endif

	if(iIsaStatus > 0)

		{

		iIsaStartAddr.Get(iIsaStart);

		iIsaEndAddr.Get(iIsaEnd);

		iIsaOsTaskRunning.Get(osAddr);

		isaOsTaskRunningAddr = reinterpret_cast<TInt*>(osAddr);

		LOGSTRING2("GppSamplerImpl::Reset - got isa os_task_running address 0x%X", osAddr);

		}

	iIsaSample = false;

		knownIsaTasks[i] = -1;

	knownIsaTaskCount = 0;

	iCpuSelector = 0x3;

#ifndef __SMP__

    iMask =  0xfffffffc;

#else

    iMask =  0xfffffff0;

    switch(iCpuNumber)

        {

        case 0:

            iCpuSelector = 0x1;

            break;

        case 1:

            iCpuSelector = 0x2;

            break;

        case 2:

            iCpuSelector = 0x4;

            break;

        case 3:

            iCpuSelector = 0x8;

            break;

        }

#endif

	}

TUint8* DGppSamplerImpl::EncodeTag(TUint8* aPtr)

//

// Encode a tag and version to the trace data. This allows the offline analyser to 

// identify the sample data.

//

{	

	_LIT(KGppSamplerVersion,"Bappea_GPP_V");

	_LIT(KProfilerVersion,"#Prof#");

	_LIT(KSamplerVersion,"#Samp#");

#ifdef __SMP__

	_LIT(KCPUNumberText,"#CPU#");

#endif

	TBuf<64> buf;

	buf.Zero();

	buf.Append(KGppSamplerVersion);

	buf.Append(PROFILER_GPP_SAMPLER_VERSION);

	buf.Append(KProfilerVersion);

	buf.Append(PROFILER_VERSION_SHORT);	

	buf.Append(KSamplerVersion);

	buf.Append(PROFILER_SAMPLER_VERSION);

#ifdef __SMP__

	buf.Append(KCPUNumberText);

	buf.AppendNum(iCpuNumber);

#endif

	aPtr = EncodeText(aPtr, buf);

	return aPtr;

}

TUint8* DGppSamplerImpl::EncodeInt(TUint8* aPtr,TInt aValue)

{

	LOGSTRING2("Encoding int 0x%x",aPtr);

	LOGSTRING2("TIint = 0x%x",aValue);

	TUint byte;

	for (;;)

		{

		byte = aValue & 0x7f;

		if ((aValue >> 6) == (aValue >> 7))

			break;

		aValue >>= 7;

		*aPtr++ = byte;

		}

	*aPtr++ = byte | 0x80;

	LOGSTRING2("Encoded int 0x%x",aPtr);

	return aPtr;

}

TUint8* DGppSamplerImpl::EncodeUint(TUint8* aPtr,TUint aValue)

{

	LOGSTRING2("Encoding Uint 0x%x",aPtr);

	LOGSTRING2("TUint = 0x%x",aValue);

	TUint byte;

	for (;;)

		{

		byte = aValue & 0x7f;

		aValue >>= 7;

		if (aValue == 0)

			break;

		*aPtr++ = byte;

		}

	*aPtr++ = byte | 0x80;

	LOGSTRING2("Encoded Uint 0x%x",aPtr);

	return aPtr;

}

TUint8* DGppSamplerImpl::EncodeText(TUint8* aPtr, const TDesC& aDes)

//

// Encode a descriptor into the data stream

// This is currently limited to a descriptor that is up to 255 characters in length,

// and Unicode characters are truncated to 8 bits

//

{

	LOGSTRING2("Encoding text 0x%x",aPtr);

	*aPtr++ = TUint8(len);

	const TText* p = aDes.Ptr();

	while (--len >= 0)

		{

		*aPtr++ = TUint8(*p++);

		}

	LOGSTRING2("Encoded text 0x%x",aPtr);

	return aPtr;

}

TUint8* DGppSamplerImpl::EncodeName(TUint8* aPtr, DObject& aObject,TUint32 id)

//

// Encode the name of a kernel object

//

{

	LOGSTRING2("Encoding name 0x%x",aPtr);

	TBuf8<0x5f> name;

	aObject.TraceAppendName(name,false);

	if(id != 0xffffffff)

	{

		name.Append('[');

		name.AppendNum(id,EHex);

		name.Append(']');

	}

	else

	{

		name.Append('[');

		name.AppendNum((TUint32)((void*)&(((DThread*)&aObject)->iNThread)),EHex);

		name.Append(']');

	}

	aPtr = EncodeText(aPtr,name);

	LOGSTRING2("Encoded name 0x%x",aPtr);

	return aPtr;

}

TUint8* DGppSamplerImpl::EncodeThread(TUint8* aPtr, DThread& aThread)

//

// Encode a thread name in the data stream.

// The thread is identified by its name, and the identity of its owning process.

// If the process has not been identified in the data stream already, it's name is

// also encoded.

//

{

	LOGSTRING2("Encoding thread 0x%x",aPtr);	

	aPtr = EncodeUint(aPtr, p.iId);

#ifdef __SMP__

    // check if first time founding

    if ((TAG(p) & iMask) != iStartTime)

        {

        // mark tagged for this CPU

        TAG(p) = (iStartTime | iCpuSelector);

        // The thread is 'unknown' to this sample, so encode the thread name

        aPtr = EncodeName(aPtr, p, p.iId);     

        }

    // check if thread appeared already on this CPU

    else if((TAG(p) & iCpuSelector) != iCpuSelector)

        {

        TAG(p) = (TAG(p) | iCpuSelector);

        // The thread is 'unknown' to this sample, so encode the thread name

        aPtr = EncodeName(aPtr, p, p.iId);     

        }

#else

	if (TAG(p) != iStartTime)

	    {

		TAG(p) = iStartTime;

		// Provide the name matching this process ID

		aPtr = EncodeName(aPtr, p, p.iId);

	    }

#endif	    

	aPtr = EncodeName(aPtr, aThread,0xffffffff);

	LOGSTRING2("Encoded thread 0x%x",aPtr);	

	return aPtr;

    }

TUint8* DGppSamplerImpl::EncodeRepeat(TUint8* aPtr)

//

// Encode a repeated sequence of samples

//

{

	LOGSTRING2("Encoding repeat, 0x%x",iRepeat);	

	aPtr = EncodeInt(aPtr, 0);

	aPtr = EncodeUint(aPtr, iRepeat);

	iRepeat = 0;

	LOGSTRING2("Encoded repeat, 0x%x",iRepeat);	

	return aPtr;

}

TInt DGppSamplerImpl::CreateFirstSample()

{

	LOGTEXT("GppSamplerImpl::CreateFirstSample");

	Reset();

	w = EncodeTag(w);

	LOGSTRING2("TAG encoded, length %d",length);

	return length;

}

TBool DGppSamplerImpl::IsaTaskKnown(TUint8 task)

{

	{

		if(knownIsaTasks[i] == -1)

		{

			knownIsaTasks[i] = task;

			knownIsaTaskCount++;

			return false;

		}

		else if(knownIsaTasks[i] == task)

		{

			return true;

		}

	}

	return false;

}

TUint8* DGppSamplerImpl::EncodeIsaTask(TUint8* aPtr, TUint task)

{

	LOGSTRING2("Encoding ISA task 0x%x",aPtr);	

	aPtr = EncodeUint(aPtr,task);

	// use the task name as the process name

	aPtr = EncodeIsaName(aPtr,task,true);

	// then encode the task name

	aPtr = EncodeIsaName(aPtr,task,false);

	LOGSTRING2("Encoded ISA task 0x%x",aPtr);	

	return aPtr;

}

TUint8* DGppSamplerImpl::EncodeIsaName(TUint8* aPtr, TUint task,TBool process)

//

// Encode a descriptor into the data stream

// This is currently limited to a descriptor that is up to 255 characters in length,

// and Unicode characters are truncated to 8 bits

//

{

	TBuf8<256> aDes;

	if(iIsaStatus > 0)

		{

		// resolve the isa task name from the task name array

		if((task-100000) < PROFILER_ISA_OS_TASK_AMOUNT && process == false)

			{

			aDes.Append(isaTaskNames[(task-100000)]);

			}

		else

			{

			aDes.Append(_L8("NativeOS_Task"));

			}

		}

	else

		{

		aDes.Append(_L8("NativeOS_Task"));

		}

	aDes.Append('[');

	aDes.AppendNum((task-100000),EHex);

	aDes.Append(']');

	LOGSTRING2("Encoding ISA name 0x%x",aPtr);

	*aPtr++ = TUint8(len);

	while (--len >= 0)

		{

		*aPtr++ = TUint8(*p++);

		}

	LOGSTRING2("Encoded ISA name 0x%x",aPtr);

	return aPtr;

}

TInt DGppSamplerImpl::SampleImpl()

//

// ISR for the profile timer

// This extracts the thread and PC that was current when the interrupt went off and

// encodes it into the sample data buffer. If enough data has been generated, the

// DFC is triggered to complete a read request

//

    {