// Copyright (c) 2005-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:

// e32\drivers\trace\btrace.cpp

// 

//

#include <kernel/kern_priv.h>

#include "platform.h"

#include "d_btrace.h"

class DBTraceTestFactory : public DLogicalDevice

	{

public:

	virtual TInt Install();

	virtual void GetCaps(TDes8& aDes) const;

	virtual TInt Create(DLogicalChannelBase*& aChannel);

	};

class DBTraceTestChannel : public DLogicalChannelBase

	{

public:

	DBTraceTestChannel();

	virtual ~DBTraceTestChannel();

	//	Inherited from DObject

	virtual TInt RequestUserHandle(DThread* aThread, TOwnerType aType);

	// Inherited from DLogicalChannelBase

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

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

private:

	DThread* iClient;

public:

	static void TestTrace(DBTraceTestChannel* aSelf);

	static void TestUTrace(DBTraceTestChannel* aSelf);

private:

	TUint32 iTestType;

	TInt iTestDataSize;

	TUint32 iTestData[KMaxBTraceRecordSize*2/4];

	volatile TBool iTimerExpired;

	NTimer iTraceTimer;

	TDfc iTraceIDFC;

	};

//

// DBTraceTestFactory

//

TInt DBTraceTestFactory::Install()

	{

	return SetName(&RBTraceTest::Name());

	}

void DBTraceTestFactory::GetCaps(TDes8& aDes) const

	{

	Kern::InfoCopy(aDes,0,0);

	}

TInt DBTraceTestFactory::Create(DLogicalChannelBase*& aChannel)

	{

	aChannel=new DBTraceTestChannel();

	if(!aChannel)

		return KErrNoMemory;

	return KErrNone;

	}

//

// DBTraceTestChannel

//

DBTraceTestChannel::DBTraceTestChannel()

	: iTraceTimer((NTimerFn)TestTrace,this),

	iTraceIDFC((NTimerFn)TestTrace,this)

	{

	}

DBTraceTestChannel::~DBTraceTestChannel()

	{

	iTraceTimer.Cancel();

	}

TInt DBTraceTestChannel::DoCreate(TInt /*aUnit*/, const TDesC8* /*aInfo*/, const TVersion& /*aVer*/)

	{

	iClient = &Kern::CurrentThread();

	return KErrNone;

	}

TInt DBTraceTestChannel::RequestUserHandle(DThread* aThread, TOwnerType aType)

	{

	if (aType!=EOwnerThread || aThread!=iClient)

		return KErrAccessDenied;

	return KErrNone;

	}

TInt DBTraceTestChannel::Request(TInt aReqNo, TAny* a1, TAny* a2)

	{

	switch(aReqNo)

		{

	// test functions

	case RBTraceTest::ETestSpecialTrace:

	case RBTraceTest::ETestTrace:

		{

		TPtr8 data((TUint8*)&iTestData,sizeof(iTestData));

		Kern::KUDesGet(data,*(TDesC8*)a2);

		iTestDataSize = data.Size()-4;

		if(aReqNo==RBTraceTest::ETestSpecialTrace)

			{

			iTestType = (TUint)a1;

			iTimerExpired = EFalse;

			if(iTestType&RBTraceTest::EContextIsr)

				iTraceTimer.OneShot(1);

			else if(iTestType&RBTraceTest::EContextIDFC)

				{

				NKern::Lock();

				iTraceIDFC.Add();

				NKern::Unlock();

				}

			else if(iTestType&RBTraceTest::EContextIntsOff)

				{

				TInt irq = NKern::DisableAllInterrupts();

				TestTrace(this);

				NKern::RestoreInterrupts(irq);

				}

			else

				TestTrace(this);

			while(!__e32_atomic_load_acq32(&iTimerExpired)) {};

			return (TInt)NKern::CurrentThread();

			}

		else

			{

			TInt delay = (TInt)a1/NKern::TickPeriod();

			iTestType = 0;

			if(!delay)

				TestTrace(this);

			else

				{

				iTraceTimer.Cancel();

				iTraceTimer.OneShot(delay+1);

				}

			}

		}

		return KErrNone;

	case RBTraceTest::ETestBenchmark:

		{

		TInt delay = (TInt)a2/NKern::TickPeriod();

		TInt size = (TInt)a1;

		iTestDataSize = -1;

		// wait for next tick...

		iTraceTimer.Cancel();

		iTimerExpired = EFalse;

		iTraceTimer.OneShot(1);

		while(!__e32_atomic_load_acq32(&iTimerExpired)) {};

		// do benchmark...

		iTimerExpired = EFalse;

		iTraceTimer.OneShot(delay+1);

		TInt count = 0;

		if(size)

			for(;;)

				{

				TBool finished = __e32_atomic_load_acq32(&iTimerExpired);

				BTraceContextN(BTrace::ETest1,0,0,0,&iTestData,size);

				++count;

				if(!finished)

					continue;

				break;

				}

		else

			for(;;)

				{

				TBool finished = __e32_atomic_load_acq32(&iTimerExpired);

				BTrace0(BTrace::ETest1,0);

				++count;

				if(!finished)

					continue;

				break;

				}

		return count;

		}

	case RBTraceTest::ETestBenchmark2:

		{

		TInt delay = (TInt)a2/NKern::TickPeriod();

		TInt size = (TInt)a1;

		iTestDataSize = -1;

		// wait for next tick...

		iTraceTimer.Cancel();

		iTimerExpired = EFalse;

		iTraceTimer.OneShot(1);

		while(!__e32_atomic_load_acq32(&iTimerExpired)) {};

		// do benchmark...

		iTimerExpired = EFalse;

		iTraceTimer.OneShot(delay+1);

		TInt count = 0;

		if(size)

			for(;;)

				{

				TBool finished = __e32_atomic_load_acq32(&iTimerExpired);

				BTraceFilteredContextN(BTrace::ETest1,0,KBTraceFilterTestUid1,0,&iTestData,size);

				++count;

				if(!finished)

					continue;

				break;

				}

		else

			for(;;)

				{

				TBool finished = __e32_atomic_load_acq32(&iTimerExpired);

				BTraceFiltered4(BTrace::ETest1,0,KBTraceFilterTestUid1);

				++count;

				if(!finished)

					continue;

				break;

				}

		return count;

		}

	case RBTraceTest::ETestBenchmarkCheckFilter:

		{

		TInt delay = (TInt)a2/NKern::TickPeriod();

		// wait for next tick...

		iTraceTimer.Cancel();

		iTimerExpired = EFalse;

		iTraceTimer.OneShot(1);

		while(!__e32_atomic_load_acq32(&iTimerExpired)) {};

		// do benchmark...

		iTimerExpired = EFalse;

		iTraceTimer.OneShot(delay+1);

		TInt count = 0;

		if(a1)

			for(;;)

				{

				TBool finished = __e32_atomic_load_acq32(&iTimerExpired);

				BTrace::CheckFilter2(BTrace::ETest1,KBTraceFilterTestUid1);

				++count;

				if(!finished)

					continue;

				break;

				}

		else

			for(;;)

				{

				TBool finished = __e32_atomic_load_acq32(&iTimerExpired);

				BTrace::CheckFilter(BTrace::ETest1);

				++count;

				if(!finished)

					continue;

				break;

				}

		return count;

		}

	case RBTraceTest::ETestUTrace:

		{

		TPtr8 data((TUint8*)&iTestData,sizeof(iTestData));

		Kern::KUDesGet(data,*(TDesC8*)a2);

		iTestDataSize = data.Size()-4;

		TInt delay = (TInt)a1/NKern::TickPeriod();

		iTestType = 0;

		if(!delay)

			TestUTrace(this);

		else

			{

			iTraceTimer.Cancel();

			iTraceTimer.OneShot(delay+1);

			}

		return KErrNone;

		}

	default:

		break;

		}

	return KErrNotSupported;

	}

void DBTraceTestChannel::TestTrace(DBTraceTestChannel* aSelf)

	{

	TInt size = aSelf->iTestDataSize;

	if(size<0)

		{

		__e32_atomic_store_rel32(&aSelf->iTimerExpired, 1);

		return;

		}

	TUint32* data = aSelf->iTestData;

	BTrace::TCategory category = (BTrace::TCategory)((TUint8*)data)[0];

	TUint subCategory = (BTrace::TCategory)((TUint8*)data)[1];

	TUint type = aSelf->iTestType&0xff;

	TBool bigTrace = aSelf->iTestType&RBTraceTest::EBigTrace;

	TBool filter2Trace = aSelf->iTestType&RBTraceTest::EFilter2Trace;

	if(!filter2Trace)

		{

		if(type==BTrace::EPcPresent)

			{

			if(bigTrace)

				{

				BTracePcBig(category,subCategory,data[1],data+2,size-4);

				BTracePcBig(category,subCategory,data[1],data+2,size-4);

				}

			else if(size==0)

				{

				BTracePc0(category,subCategory);

				BTracePc0(category,subCategory);

				}

			else if(size<=4)

				{

				BTracePc4(category,subCategory,data[1]);

				BTracePc4(category,subCategory,data[1]);

				}

			else if(size<=8)

				{

				BTracePc8(category,subCategory,data[1],data[2]);

				BTracePc8(category,subCategory,data[1],data[2]);

				}

			else

				{

				BTracePcN(category,subCategory,data[1],data[2],data+3,size-8);

				BTracePcN(category,subCategory,data[1],data[2],data+3,size-8);

				}

			}

		else if(type==BTrace::EContextIdPresent)

			{

			if(bigTrace)

				{

				BTraceContextBig(category,subCategory,data[1],data+2,size-4);

				BTraceContextBig(category,subCategory,data[1],data+2,size-4);

				}

			else if(size==0)

				{

				BTraceContext0(category,subCategory);

				BTraceContext0(category,subCategory);

				}

			else if(size<=4)

				{

				BTraceContext4(category,subCategory,data[1]);

				BTraceContext4(category,subCategory,data[1]);

				}

			else if(size<=8)

				{

				BTraceContext8(category,subCategory,data[1],data[2]);

				BTraceContext8(category,subCategory,data[1],data[2]);

				}

			else

				{

				BTraceContextN(category,subCategory,data[1],data[2],data+3,size-8);

				BTraceContextN(category,subCategory,data[1],data[2],data+3,size-8);

				}

			}

		else if(type==BTrace::EContextIdPresent+BTrace::EPcPresent)

			{

			if(bigTrace)

				{

				BTraceContextPcBig(category,subCategory,data[1],data+2,size-4);

				BTraceContextPcBig(category,subCategory,data[1],data+2,size-4);

				}

			else if(size==0)

				{

				BTraceContextPc0(category,subCategory);

				BTraceContextPc0(category,subCategory);

				}

			else if(size<=4)

				{

				BTraceContextPc4(category,subCategory,data[1]);

				BTraceContextPc4(category,subCategory,data[1]);

				}

			else if(size<=8)

				{

				BTraceContextPc8(category,subCategory,data[1],data[2]);

				BTraceContextPc8(category,subCategory,data[1],data[2]);

				}

			else

				{

				BTraceContextPcN(category,subCategory,data[1],data[2],data+3,size-8);

				BTraceContextPcN(category,subCategory,data[1],data[2],data+3,size-8);

				}

			}

		else

			{

			if(bigTrace)

				BTraceBig(category,subCategory,data[1],data+2,size-4);

			else if(size==0)

				BTrace0(category,subCategory);

			else if(size<=4)

				BTrace4(category,subCategory,data[1]);

			else if(size<8)

				BTrace8(category,subCategory,data[1],data[2]);

			else

				BTraceN(category,subCategory,data[1],data[2],data+3,size-8);

			}

		}

	else

		{

		if(type==BTrace::EPcPresent)

			{

			if(bigTrace)

				{

				BTraceFilteredPcBig(category,subCategory,data[1],data+2,size-4);

				BTraceFilteredPcBig(category,subCategory,data[1],data+2,size-4);

				}

			else if(size<4)

				{

				// invalid

				}

			else if(size==4)

				{

				BTraceFilteredPc4(category,subCategory,data[1]);

				BTraceFilteredPc4(category,subCategory,data[1]);

				}

			else if(size<=8)

				{

				BTraceFilteredPc8(category,subCategory,data[1],data[2]);

				BTraceFilteredPc8(category,subCategory,data[1],data[2]);

				}

			else

				{

				BTraceFilteredPcN(category,subCategory,data[1],data[2],data+3,size-8);

				BTraceFilteredPcN(category,subCategory,data[1],data[2],data+3,size-8);

				}

			}

		else if(type==BTrace::EContextIdPresent)

			{

			if(bigTrace)

				{

				BTraceFilteredContextBig(category,subCategory,data[1],data+2,size-4);

				BTraceFilteredContextBig(category,subCategory,data[1],data+2,size-4);

				}

			else if(size<4)

				{

				// invalid

				}

			else if(size==4)

				{

				BTraceFilteredContext4(category,subCategory,data[1]);

				BTraceFilteredContext4(category,subCategory,data[1]);

				}

			else if(size<=8)

				{

				BTraceFilteredContext8(category,subCategory,data[1],data[2]);

				BTraceFilteredContext8(category,subCategory,data[1],data[2]);

				}

			else

				{

				BTraceFilteredContextN(category,subCategory,data[1],data[2],data+3,size-8);

				BTraceFilteredContextN(category,subCategory,data[1],data[2],data+3,size-8);

				}

			}

		else if(type==BTrace::EContextIdPresent+BTrace::EPcPresent)

			{

			if(bigTrace)

				{

				BTraceFilteredContextPcBig(category,subCategory,data[1],data+2,size-4);

				BTraceFilteredContextPcBig(category,subCategory,data[1],data+2,size-4);

				}

			else if(size<4)

				{

				// invalid

				}

			else if(size==4)

				{

				BTraceFilteredContextPc4(category,subCategory,data[1]);

				BTraceFilteredContextPc4(category,subCategory,data[1]);

				}

			else if(size<=8)

				{

				BTraceFilteredContextPc8(category,subCategory,data[1],data[2]);

				BTraceFilteredContextPc8(category,subCategory,data[1],data[2]);

				}

			else

				{

				BTraceFilteredContextPcN(category,subCategory,data[1],data[2],data+3,size-8);

				BTraceFilteredContextPcN(category,subCategory,data[1],data[2],data+3,size-8);

				}

			}

		else

			{

			if(bigTrace)

				BTraceFilteredBig(category,subCategory,data[1],data+2,size-4);

			else if(size<4)

				{

				// invalid

				}

			else if(size==4)

				BTraceFiltered4(category,subCategory,data[1]);

			else if(size<8)

				BTraceFiltered8(category,subCategory,data[1],data[2]);

			else

				BTraceFilteredN(category,subCategory,data[1],data[2],data+3,size-8);

			}

		}

	__e32_atomic_store_rel32(&aSelf->iTimerExpired, 1);

	}

void DBTraceTestChannel::TestUTrace(DBTraceTestChannel* aSelf)

	{

	aSelf->iTimerExpired = ETrue;

	TInt size = aSelf->iTestDataSize;

	if(size<0)

		return;

	TUint32* data = aSelf->iTestData;

	BTrace::TCategory category = (BTrace::TCategory)((TUint8*)data)[0];

	TUint subCategory = (BTrace::TCategory)((TUint8*)data)[1];

	#define T_UTRACE_HEADER(aSize,aClassification,aContext,aPc)																\

		((((aSize) + (aContext?4:0) + (aPc?4:0)) << BTrace::ESizeIndex*8)										\

		+(((aContext?BTrace::EContextIdPresent:0) | (aPc?BTrace::EPcPresent:0)) << BTrace::EFlagsIndex*8)			\

		+((aClassification) << BTrace::ECategoryIndex*8)																				\

		+((subCategory) << BTrace::ESubCategoryIndex*8))