// 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 "drivers/btrace.h"

#if defined(__EPOC32__) && defined(__CPU_X86)

#include <x86.h>

#endif

TBTraceBufferK Buffer;

TBool ChannelOpen = EFalse;

const TUint KCopyBufferMaxSize = 0x10000;

TInt TBTraceBufferK::Create(TInt aSize)

	{

	if(aSize<=0)

		return KErrArgument;

	TUint pageSize = Kern::RoundToPageSize(1);

	aSize = (aSize+pageSize-1)&-(TInt)pageSize;

	TUint recordOffsets = aSize+pageSize;

	TUint recordOffsetsSize = Kern::RoundToPageSize(aSize>>2);

	TUint copyBuffer = recordOffsets+recordOffsetsSize+pageSize;

	TUint copyBufferSize = Kern::RoundToPageSize(aSize>>2);

	if(copyBufferSize>KCopyBufferMaxSize)

		copyBufferSize = KCopyBufferMaxSize;

	TUint chunkSize = copyBuffer+copyBufferSize+pageSize;

	// Create chunk...

    TChunkCreateInfo info;

    info.iType         = TChunkCreateInfo::ESharedKernelSingle;

    info.iMaxSize      = chunkSize;

#ifdef __EPOC32__

	// we want full caching, no execute, default sharing

	new (&info.iMapAttr) TMappingAttributes2(EMemAttNormalCached, EFalse, ETrue);

#endif

    info.iOwnsMemory   = ETrue; // Use memory from system's free pool

    info.iDestroyedDfc = NULL;

	TUint32 mapAttr;

	TInt r = Kern::ChunkCreate(info, iBufferChunk, iAddress, mapAttr);

	if(r==KErrNone)

		r = Kern::ChunkCommit(iBufferChunk, 0, aSize);

	if(r==KErrNone)

		r = Kern::ChunkCommit(iBufferChunk, recordOffsets, recordOffsetsSize);

	if(r==KErrNone)

		r = Kern::ChunkCommit(iBufferChunk, copyBuffer, copyBufferSize);

	// Check errors...

	if(r!=KErrNone)

		{

		Close();

		return r;

		}

	// Initialise state...

	iStart = sizeof(TBTraceBuffer);

	iEnd = aSize;

	iRecordOffsets = (TUint8*)(iAddress+recordOffsets);

	TBTraceBuffer* userBuffer = (TBTraceBuffer*)iAddress;

	userBuffer->iRecordOffsets = recordOffsets;

	userBuffer->iCopyBuffer = copyBuffer;

	userBuffer->iCopyBufferSize = copyBufferSize;

	Reset(0);

#ifndef __SMP__

	TInt irq = NKern::DisableAllInterrupts();

#endif

	iTimestamp2Enabled = EFalse;

	BTrace::SetHandlers(TBTraceBufferK::Trace,TBTraceBufferK::ControlFunction,iOldBTraceHandler,iOldBTraceControl);

#ifndef __SMP__

	NKern::RestoreInterrupts(irq);

#endif

	return KErrNone;

	}

void TBTraceBufferK::Close()

	{

#ifdef __SMP__

	if(iOldBTraceHandler)

		{

		BTrace::THandler handler;

		BTrace::TControlFunction control;

		BTrace::SetHandlers(iOldBTraceHandler,iOldBTraceControl,handler,control);

		iOldBTraceHandler = NULL;

		iOldBTraceControl = NULL;

		}

	TSpinLock* sl = BTrace::LockPtr();

	TInt irq = sl->LockIrqSave();	// guarantees handler can't run at the same time

	DChunk* chunk = iBufferChunk;

	iBufferChunk = NULL;

	iAddress = NULL;

	sl->UnlockIrqRestore(irq);

#else

	TInt irq = NKern::DisableAllInterrupts();

	if(iOldBTraceHandler)

		{

		BTrace::THandler handler;

		BTrace::TControlFunction control;

		BTrace::SetHandlers(iOldBTraceHandler,iOldBTraceControl,handler,control);

		iOldBTraceHandler = NULL;

		iOldBTraceControl = NULL;

		}

	DChunk* chunk = iBufferChunk;

	iBufferChunk = NULL;

	iAddress = NULL;

	NKern::RestoreInterrupts(irq);

#endif

	if(chunk)

		Kern::ChunkClose(chunk);

	}

/**

Helper functions for encoding pseudo- floating point values recoverable by:

	int exponent = (signed char)(encoded_val >> 24);

	int mantissa = encoded_val & 0xFFFFFF;

	double val = mantissa * pow(2, exponent);

*/

TUint EncodeFloatesque(TUint64 val64, TInt exponent)

	{

	// Lose precision until it fits in 24 bits

	TInt round_up = 0;

	while (val64>=0x1000000) 

		{

		round_up = (TInt)(val64&1);

		val64 >>= 1;

		exponent++;

		}

	if (round_up) 

		{

		val64++;

		if (val64>=0x1000000) 

			{

			val64 >>= 1;

			exponent++;

			}

		}

	// Return 8-bit exponent and 24-bit mantissa

	return (TUint)(val64 | (((unsigned char)exponent)<<24));

	}

TUint EncodeReciprocal(TUint val)

	{

	if (val==0) return val;

	// Get reciprocal * 2^64

	TUint64 val64 = val;

	TUint64 div = 0;

	div--;

	val64 = div / val64;

	return EncodeFloatesque(val64, -64);

	}

TUint EncodePostDiv(TUint val, TUint divisor)

	{

	TUint64 val64 = val;

	val64 <<= 32;

	val64 = val64 / divisor;

	return EncodeFloatesque(val64, -32);

	}

void BTracePrimeMetatrace()

	{

#ifdef __SMP__

	TUint period1 = EncodeReciprocal(NKern::TimestampFrequency());

	TUint period2 = period1 + (32u<<24);	// timestamp2 period is 2^32 * timestamp1 period

	BTrace12(BTrace::EMetaTrace, BTrace::EMetaTraceTimestampsInfo, period1, period2, 1);

#else

	TUint period1 = EncodeReciprocal(NKern::FastCounterFrequency());

	TUint period2 = EncodePostDiv(NKern::TickPeriod(), 1000000);

	BTrace12(BTrace::EMetaTrace, BTrace::EMetaTraceTimestampsInfo, period1, period2, 0);

#endif

	}

void TBTraceBufferK::Reset(TUint aMode)

	{

#ifdef __SMP__

	TSpinLock* sl = BTrace::LockPtr();

#endif

	TInt irq = __SPIN_LOCK_IRQSAVE(*sl);	// guarantees handler can't run at the same time

	iHead = iStart;

	TBTraceBuffer* userBuffer = (TBTraceBuffer*)iAddress;

	userBuffer->iStart = iStart;

	userBuffer->iEnd = iEnd;

	userBuffer->iHead = iHead;

	userBuffer->iTail = iHead;

	userBuffer->iGeneration = 0;

	userBuffer->iMode = aMode;

	__SPIN_UNLOCK_IRQRESTORE(*sl,irq);

	if(aMode)

		{

		if (BTrace::CheckFilter(BTrace::EMetaTrace))

			BTracePrimeMetatrace();

		BTrace::Prime();

		}

	}

TInt TBTraceBufferK::RequestData(TInt aSize, TDfc* aDfc)

	{

	if(aSize<=0)

		aSize = 1;

#ifdef __SMP__

	TSpinLock* sl = BTrace::LockPtr();

#endif

	TInt irq = __SPIN_LOCK_IRQSAVE(*sl);	// guarantees handler can't run

	TBTraceBuffer* userBuffer = (TBTraceBuffer*)iAddress;

	if(!userBuffer)

		{

		__SPIN_UNLOCK_IRQRESTORE(*sl,irq);

		return KErrNotReady;

		}

	TInt dif = userBuffer->iTail-iHead;

	if(dif>0)

		aSize = 0; // we need no more bytes because all bytes to end of buffer are available

	else

		aSize += dif; // number of bytes extra we need

	if(aSize>0)

		{

		iRequestDataSize = aSize;

		iWaitingDfc = aDfc;

		}

	__SPIN_UNLOCK_IRQRESTORE(*sl,irq);

	if(aSize<=0)

		return KErrCompletion;

	return KErrNone;

	}

#ifndef BTRACE_DRIVER_MACHINE_CODED

TBool TBTraceBufferK::Trace_Impl(TUint32 aHeader,TUint32 aHeader2,const TUint32 aContext,const TUint32 a1,const TUint32 a2,const TUint32 a3,const TUint32 aExtra, const TUint32 aPc, TBool aIncTimestamp2)

	{

#ifndef __SMP__

	TInt irq = NKern::DisableAllInterrupts();

#endif

#ifdef __SMP__

	// Header 2 always present and contains CPU number

	// If Header2 not originally there, add 4 to size

	if (!(aHeader&(BTrace::EHeader2Present<<BTrace::EFlagsIndex*8)))

		aHeader += (4<<BTrace::ESizeIndex*8) + (BTrace::EHeader2Present<<BTrace::EFlagsIndex*8), aHeader2=0;

	aHeader2 = (aHeader2 &~ BTrace::ECpuIdMask) | (NKern::CurrentCpu()<<20);

#endif

#ifdef BTRACE_INCLUDE_TIMESTAMPS

	// Add timestamp to trace...

#if defined(__SMP__)

	aHeader += 8<<BTrace::ESizeIndex*8;

	aHeader |= BTrace::ETimestampPresent<<BTrace::EFlagsIndex*8 | BTrace::ETimestamp2Present<<BTrace::EFlagsIndex*8;

	TUint64 timeStamp = NKern::Timestamp();

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

	aHeader += 8<<BTrace::ESizeIndex*8;

	aHeader |= BTrace::ETimestampPresent<<BTrace::EFlagsIndex*8 | BTrace::ETimestamp2Present<<BTrace::EFlagsIndex*8;

	TUint64 timeStamp = X86::Timestamp();

#else

	TUint32 timeStamp = NKern::FastCounter();

	TUint32 timeStamp2 = 0;

	if (aIncTimestamp2)

		{

		timeStamp2 = NKern::TickCount();

		aHeader += 8<<BTrace::ESizeIndex*8;

		aHeader |= (BTrace::ETimestampPresent | BTrace::ETimestamp2Present) << BTrace::EFlagsIndex*8;

		}

	else

		{

		aHeader += 4<<BTrace::ESizeIndex*8;

		aHeader |= BTrace::ETimestampPresent<<BTrace::EFlagsIndex*8;

		}

#endif

#endif

	TUint size = (aHeader+3)&0xfc;

	TBTraceBufferK& buffer = Buffer;

	TLinAddr address = buffer.iAddress;

	TBTraceBuffer& user_buffer = *(TBTraceBuffer*)address;

	++user_buffer.iGeneration;	// atomic not required since only driver modifies iGeneration

#ifdef __SMP__

	__e32_memory_barrier();

#endif

	TUint start = buffer.iStart;

	TUint end = buffer.iEnd;

	TUint orig_head = buffer.iHead;

	TInt requestDataSize = buffer.iRequestDataSize;

	TUint8* recordOffsets = buffer.iRecordOffsets;

	TUint32 orig_tail = user_buffer.iTail;

	TUint32 newHead, head, tail;

	if(!(user_buffer.iMode&RBTrace::EEnable))

		goto trace_off;

retry:

	head = orig_head;

	tail = orig_tail &~ 1;

	newHead = head+size;

	if(newHead>end)

		{

		requestDataSize = 0; 

		newHead = start+size;

		if(head<tail || tail<newHead+1)

			{

			if(!(user_buffer.iMode&RBTrace::EFreeRunning))

				goto trace_dropped;

			user_buffer.iWrap = head;

			head = start;

			tail = newHead+(recordOffsets[newHead>>2]<<2);

			goto overwrite;

			}

		user_buffer.iWrap = head;

		head = start;

		}

	else if(head<tail && tail<=newHead)

		{

		{

		requestDataSize = 0; 

		TUint wrap = user_buffer.iWrap;

		if(!(user_buffer.iMode&RBTrace::EFreeRunning))

			goto trace_dropped;

		if(newHead<end && newHead<wrap)

			{

			tail = newHead+(recordOffsets[newHead>>2]<<2);

			if(tail>=end || tail>=wrap)

				tail = start;

			}

		else

			tail = start;

		}

overwrite:

		*(TUint32*)(address+tail) |= BTrace::EMissingRecord<<(BTrace::EFlagsIndex*8);

		if (!__e32_atomic_cas_ord32(&user_buffer.iTail, &orig_tail, tail|1))

			goto retry;	// go round again if user side has already updated the tail pointer

		}

	buffer.iRequestDataSize = requestDataSize-size;

	{

	recordOffsets += head>>2;

	TUint32* src;

	TUint32* dst = (TUint32*)((TUint)address+head);

	size >>= 2; // we are now counting words, not bytes

	// store first word of trace...

	TUint w = aHeader;

	if(buffer.iDropped)

		{

		buffer.iDropped = 0;

		w |= BTrace::EMissingRecord<<(BTrace::EFlagsIndex*8); 

		}

	*recordOffsets++ = (TUint8)size;

	--size;

	*dst++ = w;

#ifndef __SMP__

	if(aHeader&(BTrace::EHeader2Present<<(BTrace::EFlagsIndex*8)))

#endif

		{

		w = aHeader2;

		*recordOffsets++ = (TUint8)size;

		--size;

		*dst++ = w;

		}

#ifdef BTRACE_INCLUDE_TIMESTAMPS

	// store timestamp...

#if defined(__SMP__) || (defined(__EPOC32__) && defined(__CPU_X86))

	*recordOffsets++ = (TUint8)size;

	--size;

	*dst++ = TUint32(timeStamp);

	*recordOffsets++ = (TUint8)size;

	--size;

	*dst++ = TUint32(timeStamp>>32);

#else

	*recordOffsets++ = (TUint8)size;

	--size;

	*dst++ = timeStamp;

	if (aIncTimestamp2)

		{

		*recordOffsets++ = (TUint8)size;

		--size;

		*dst++ = timeStamp2;

		}

#endif

#endif

	if(aHeader&(BTrace::EContextIdPresent<<(BTrace::EFlagsIndex*8)))

		{

		w = aContext;

		*recordOffsets++ = (TUint8)size;

		--size;

		*dst++ = w;

		}

	if(aHeader&(BTrace::EPcPresent<<(BTrace::EFlagsIndex*8)))

		{

		w = aPc;

		*recordOffsets++ = (TUint8)size;

		--size;

		*dst++ = w;

		}

	if(aHeader&(BTrace::EExtraPresent<<(BTrace::EFlagsIndex*8)))

		{

		w = aExtra;

		*recordOffsets++ = (TUint8)size;

		--size;

		*dst++ = w;

		}

	// store remainding words of trace...

	if(size)

		{

		w = a1;

		*recordOffsets++ = (TUint8)size;

		--size;

		*dst++ = w;

		if(size)

			{

			w = a2;

			*recordOffsets++ = (TUint8)size;

			--size;

			*dst++ = w;

			if(size)

				{

				if(size==1)

					{

					w = a3;

					*recordOffsets++ = (TUint8)size;

					*dst++ = w;

					}

				else

					{

					src = (TUint32*)a3;

					do

						{

						w = *src++;

						*recordOffsets++ = (TUint8)size;

						--size;

						*dst++ = w;

						}

					while(size);

					}

				}

			}

		}

	}

	buffer.iHead = newHead;

#ifdef __SMP__

	__e32_memory_barrier();	// make sure written data is observed before head pointer update

#endif

	user_buffer.iHead = newHead;

	{

	TDfc* dfc = (TDfc*)buffer.iWaitingDfc;

	if(dfc && buffer.iRequestDataSize<=0)

		{

		buffer.iWaitingDfc = NULL;

		dfc->RawAdd();

		}

	}

#ifdef __SMP__

	__e32_memory_barrier();

#endif

	++user_buffer.iGeneration;	// atomic not required since only driver modifies iGeneration

#ifndef __SMP__

	NKern::RestoreInterrupts(irq);

#endif

	return ETrue;

trace_dropped:

	buffer.iRequestDataSize = 0; 

	buffer.iDropped = ETrue;

#ifdef __SMP__

	__e32_memory_barrier();

#endif

	++user_buffer.iGeneration;	// atomic not required since only driver modifies iGeneration

#ifndef __SMP__

	NKern::RestoreInterrupts(irq);

#endif

	return ETrue;

trace_off:

#ifdef __SMP__

	__e32_memory_barrier();

#endif

	++user_buffer.iGeneration;	// atomic not required since only driver modifies iGeneration

#ifndef __SMP__

	NKern::RestoreInterrupts(irq);

#endif

	return EFalse;

	}

TBool TBTraceBufferK::TraceWithTimestamp2(TUint32 aHeader,TUint32 aHeader2,const TUint32 aContext,const TUint32 a1,const TUint32 a2,const TUint32 a3,const TUint32 aExtra,const TUint32 aPc)

	{

	return Trace_Impl(aHeader, aHeader2, aContext, a1, a2, a3, aExtra, aPc, ETrue);

	}

TBool TBTraceBufferK::Trace(TUint32 aHeader,TUint32 aHeader2,const TUint32 aContext,const TUint32 a1,const TUint32 a2,const TUint32 a3,const TUint32 aExtra,const TUint32 aPc)

	{

	return Trace_Impl(aHeader, aHeader2, aContext, a1, a2, a3, aExtra, aPc, EFalse);

	}