// Copyright (c) 2007-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\arm\btracex_impl.cia
// 
//

	// adjust a0 for timestamp(s) 
#ifdef BTRACE_INCLUDE_TIMESTAMPS
#ifdef USE_TIMESTAMP2
	asm("add	r0, r0, #8 ");
	asm("orr	r0, r0, #%a0" : : "i" ((TInt)((BTrace::ETimestampPresent | BTrace::ETimestamp2Present)<<BTrace::EFlagsIndex*8)));
#else
	asm("add	r0, r0, #4 ");
	asm("orr	r0, r0, #%a0" : : "i" ((TInt)(BTrace::ETimestampPresent<<BTrace::EFlagsIndex*8)));
#endif
#endif
#ifdef __SMP__
	// add in CPU ID field to Header2
	asm("tst r0, #%a0" : : "i" ((TInt)(BTrace::EHeader2Present<<BTrace::EFlagsIndex*8)));
	asm("movne r12, r1, lsl #12 ");		// if Header2 already present, r12=Header2<<12
	asm("mrc p15, 0, r1, c0, c0, 5 ");	// r1 = CPU ID
	asm("orr r0, r0, #%a0" : : "i" ((TInt)(BTrace::EHeader2Present<<BTrace::EFlagsIndex*8)));	// Header2 is there
	asm("addeq r0, r0, #%a0" : : "i" ((TInt)(4<<BTrace::ESizeIndex*8)));	// if Header2 was not there, add 4 to size
	asm("mov r1, r1, lsl #20 ");		// CPU ID into top 12 bits of Header2
	asm("orrne r1, r1, r12, lsr #12 ");	// if Header2 was already there, keep bottom 20 bits of it
	asm("stmdb	sp!,{r0-r12,lr} ");		// save first 4 args, callee-save registers, CPSR and return address (14 words)
#else
	asm("mrs	r12, cpsr ");			// r12 = save interrupt status
	asm("stmdb	sp!,{r0-r12,lr} ");		// save first 4 args, callee-save registers, CPSR and return address (14 words)
	INTS_OFF(r14, r12, INTS_ALL_OFF);	// disable interrupts
#endif
	asm("ldr	r10, __Buffer ");		// r10 = our buffer structure
	asm("add	r4, r0, #3 ");
	asm("and	r4, r4, #0xfc ");		// r4 = size of trace record rounded up to whole word size
	asm("ldmia	r10, {r5-r7} ");		// r5 = Buffer.iAddress
										// r6 = Buffer.iStart
										// r7 = Buffer.iEnd
	asm("ldr	r14, [r5, #%a0]" : : "i" _FOFF(TBTraceBuffer,iGeneration));
	asm("ldr	r9, [r10, #%a0]" : : "i" _FOFF(TBTraceBufferK,iRequestDataSize));
	asm("ldr	r12, [r10, #%a0]" : : "i" _FOFF(TBTraceBufferK,iRecordOffsets));
	asm("add	r14, r14, #1 ");
	asm("str	r14, [r5, #%a0]" : : "i" _FOFF(TBTraceBuffer,iGeneration));
#ifdef __SMP__
	__DATA_MEMORY_BARRIER_Z__(r8);
#endif
	asm("ldr	r2, [r5, #%a0]" : : "i" _FOFF(TBTraceBuffer,iTail));
										// r2 = original iTail (might have bit 0 set)
	asm("ldr	r14, [r5, #%a0]" : : "i" _FOFF(TBTraceBuffer,iMode));
										// r14 = iMode

	asm("8: ");
	asm("ldr	r8, [r10, #%a0]" : : "i" _FOFF(TBTraceBufferK,iHead));
	asm("bic	r1, r2, #1 ");			// r1 = tail (bit 0 cleared)
	asm("add	r3, r8, r4 ");			// r3 = head+size = newHead (always multiple of 4)

	/* Registers: R0=spare, R1=tail, R2=orig_tail, R3=newHead, R4=size, R5=&user_buffer, R6=iStart, R7=iEnd
		R8=head, R9=requestDataSize, R10=&Buffer, R11=unused, R12=iRecordOffsets, R14=iMode
	 */

	asm("tst	r14, #%a0" : : "i" ((TInt)RBTrace::EEnable));
	asm("beq	trace_off ");			// end now if tracing is disabled

	asm("cmp	r3, r7 ");				// cmp newHead,end
	asm("bls	1f "); // 1f==no_wrap
	asm("mov	r9, #0 ");				// iRequestDataSize=0
	asm("add	r3, r6, r4 ");			// newHead = start+size
	asm("add	r0, r3, #1 ");			// r0 = newHead+1
	asm("cmp	r8, r1 ");				// cmp head,tail
	asm("cmphs	r1, r0 ");				// cmp tail,newHead+1
	asm("strhs	r8, [r5, #%a0]" : : "i" _FOFF(TBTraceBuffer,iWrap));
	asm("movhs	r8, r6 ");				// head = start
	asm("bhs	3f ");					// ... done (3f==update_offsets)
	// new trace would be overwriting tail pointer...
	asm("tst	r14, #%a0" : : "i" ((TInt)RBTrace::EFreeRunning));
	asm("beq	trace_dropped ");		// if we aren't in freerunning mode, drop the trace
	asm("ldrb	r1, [r12, r3, lsr #2] ");// r1 = word offset to next record after newHead
	asm("str	r8, [r5, #%a0]" : : "i" _FOFF(TBTraceBuffer,iWrap));
	asm("mov	r8, r6 ");				// head = start
	asm("add	r1, r3, r1, lsl #2 ");	// tail = newHead + offset to next record
	asm("b		2f ");					// 2f==overwrite

	asm("1: "); // no_wrap
	asm("cmp	r8, r1 ");				// cmp head,tail
	asm("bhs	3f ");					// if >= then done (3f==update_offsets)
	asm("cmp	r1, r3 ");				// cmp tail,newHead
	asm("bhi	3f ");					// if > the done (3f==update_offsets)
	asm("ldr	r0, [r5, #%a0]" : : "i" _FOFF(TBTraceBuffer,iWrap)); // r0 = wrap
	asm("tst	r14, #%a0" : : "i" ((TInt)RBTrace::EFreeRunning));
	asm("beq	trace_dropped ");		// if we aren't in freerunning mode, drop the trace
	asm("cmp	r3, r7 ");				// cmp newHead,end
	asm("cmplo	r3, r0 ");				// cmp newHead,wrap
	asm("ldrlob	r1, [r12, r3, lsr #2] ");// r1 = word offset to next record after newHead
	asm("mov	r9, #0 ");				// iRequestDataSize=0
	asm("addlo	r1, r3, r1, lsl #2 ");	// tail = newHead + offset to next record
	asm("cmplo	r1, r7 ");				// cmp tail,end
	asm("cmplo	r1, r0 ");				// cmp tail,wrap
	asm("movhs	r1, r6 ");				// tail = start

	asm("2: "); // overwrite
	asm("ldr	r0, [r5, r1] ");			// r1 = first word of record at new tail
#ifndef __SMP__
	// On single processor iTail can't have been updated since interrupts are off here
	asm("orr	r1, r1, #1 ");
	asm("str	r1,	[r5, #%a0]" : : "i" _FOFF(TBTraceBuffer,iTail)); // update tail
	asm("bic	r1, r1, #1 ");
#endif
	asm("orr	r0, r0, #%a0" : : "i" ((TInt)(BTrace::EMissingRecord<<(BTrace::EFlagsIndex*8))));
	asm("str	r0, [r5, r1] ");			// set 'missing record' flag in next record to be read
#ifdef __SMP__
	// attempt to atomically update iTail
	asm("9: ");
	asm("add	r5,	r5, #%a0" : : "i" _FOFF(TBTraceBuffer,iTail)); // r5=&user_buffer.iTail
	asm("orr	r1, r1, #1 ");
	LDREX(0,5);
	asm("cmp r0, r2 ");		// iTail = orig_tail ?
	asm("movne r2, r0 ");	// if not, orig_tail = iTail
	asm("bne 8b ");			// and go round again
	STREX(0,1,5);			// else try to update iTail with tail|1
	asm("cmp r0, #0 ");
	asm("bne 9b ");
	__DATA_MEMORY_BARRIER__(r0);	// ensure update to iTail observed before overwrites
	asm("sub	r5,	r5, #%a0" : : "i" _FOFF(TBTraceBuffer,iTail)); // r5=&user_buffer.iTail
#endif

	asm("3: "); // update_offsets
	asm("sub	r9, r9, r4 ");			// iRequestDataSize -= size
	asm("str	r3, [r10, #%a0]" : : "i" _FOFF(TBTraceBufferK,iHead));	// OK to do this here since only used kernel side
	asm("str	r9, [r10, #%a0]" : : "i" _FOFF(TBTraceBufferK,iRequestDataSize));

	asm("add	r5, r5, r8 ");			// r5 = address+head = destination to store trace
	asm("mov	r4, r4, asr #2 ");		// r4 = size/4 = number of words in trace record
	asm("add	r11, r12, r8, asr #2 ");	// r11 = address to store record sizes
	// unused regs are now r0 r1 r2 r3 r6 r7 r8 r9 r12 r14

	asm("ldr	r14, [r10,#%a0]" : : "i" _FOFF(TBTraceBufferK,iDropped));
	asm("ldmia	sp, {r6-r9} ");			// r6 = aHeader, r7 = aHeader2, r8 = aContext, r9 = a1
	asm("cmp	r14, #0 ");
	asm("movne	r14, #0 ");
	asm("strne	r14, [r10,#%a0]" : : "i" _FOFF(TBTraceBufferK,iDropped));
	asm("orrne	r6, r6, #%a0" : : "i" ((TInt)(BTrace::EMissingRecord<<BTrace::EFlagsIndex*8)));

	asm("str	r6, [r5], #4 ");			// store aHeader
	asm("strb	r4, [r11], #1 ");
	asm("sub	r4, r4, #1 ");

	asm("tst	r6, #%a0" : : "i" ((TInt)(BTrace::EHeader2Present<<BTrace::EFlagsIndex*8)));
	asm("strne	r7, [r5], #4 ");			// store aHeader2 ?
	asm("strneb	r4, [r11], #1 ");
	asm("subne	r4, r4, #1 ");

#ifdef BTRACE_INCLUDE_TIMESTAMPS
#ifdef __SMP__
	asm("bl		Timestamp__5NKern ");
	asm("str	r0, [r5], #4 ");		// store timestamp low word
#ifdef USE_TIMESTAMP2
	asm("str	r1, [r5], #4 ");		// store timestamp high word
#endif
#else	// __SMP__
#ifdef HAS_HIGH_RES_TIMER
	GET_HIGH_RES_TICK_COUNT(r0);		// r0 = timestamp
#else
	asm("bl " CSM_ZN5NKern11FastCounterEv);
#endif
	asm("str	r0, [r5], #4 ");		// store timestamp
	asm("strb	r4, [r11], #1 ");
	asm("subs	r4, r4, #1 ");
#ifdef USE_TIMESTAMP2
	asm("bl " CSM_ZN5NKern9TickCountEv );
	asm("str	r0, [r5], #4 ");		// store timestamp2
	asm("strb	r4, [r11], #1 ");
	asm("subs	r4, r4, #1 ");
#endif
#endif	// __SMP__
#endif	// BTRACE_INCLUDE_TIMESTAMPS

	asm("add	r0, sp, #14*4 ");
	asm("ldmia	r0, {r0-r3} ");			// r0 = a2, r1 = a3, r2 = aExtra, r3 = aPc

	asm("tst	r6, #%a0" : : "i" ((TInt)(BTrace::EContextIdPresent<<BTrace::EFlagsIndex*8)));
	asm("strne	r8, [r5], #4 ");			// store aContext ?
	asm("strneb	r4, [r11], #1 ");
	asm("subne	r4, r4, #1 ");

	asm("tst	r6, #%a0" : : "i" ((TInt)(BTrace::EPcPresent<<BTrace::EFlagsIndex*8)));
	asm("strne	r3, [r5], #4 ");			// store aPc ?
	asm("strneb	r4, [r11], #1 ");
	asm("subne	r4, r4, #1 ");

	asm("tst	r6, #%a0" : : "i" ((TInt)(BTrace::EExtraPresent<<BTrace::EFlagsIndex*8)));
	asm("strne	r2, [r5], #4 ");			// store aExtra ?
	asm("strneb	r4, [r11], #1 ");
	asm("subne	r4, r4, #1 ");

	asm("cmp	r4, #0 ");				// done?
	asm("ble	6f ");					// 6f==trace_stored

	asm("str	r9, [r5], #4 ");			// store a1
	asm("strb	r4, [r11], #1 ");
	asm("subs	r4, r4, #1 ");
	asm("ble	6f ");					// 6f==trace_stored

	asm("str	r0, [r5], #4 ");			// store a2
	asm("strb	r4, [r11], #1 ");
	asm("subs	r4, r4, #1 ");
	asm("ble	6f ");					// 6f==trace_stored

	asm("cmp	r4, #1 ");
	asm("streq	r1, [r5], #4 ");			// store a3 ?
	asm("streqb	r4, [r11], #1 ");
	asm("beq	6f ");					// 6f==trace_stored

	// r9 = pointer to rest of data to store...
	asm("mov	r9, r1 ");

	asm("cmp	r4, #7 ");
	asm("blo	5f "); // store_loop_last

	asm("ldr	r14, __03020100 ");
	asm("add	r4, r4, r4, asl #8 ");
	asm("add	r4, r4, r4, asl #16 ");
	asm("sub	r4, r4, r14 ");
	asm("ldr	r8, __04040404 ");

	// align destination to 4 words...
	asm("movs	r14, r5, asl #28 ");
	asm("beq	4f "); // 4f==block_copy_loop
	asm("rsb	r14, r14, #0 ");
	asm("msr	cpsr_f, r14 ");

	asm("ldmeqia	r9!, {r0} ");
	asm("streqb		r4, [r11], #1 ");
	asm("subeq		r4, r4, r8, lsr #2 ");
	asm("stmeqia	r5!, {r0} ");

	asm("ldmmiia	r9!, {r2,r3} ");
	asm("strmih		r4, [r11], #2 ");
	asm("submi		r4, r4, r8, lsr #1 ");
	asm("stmmiia	r5!, {r2,r3} ");

	asm("4: "); // block_copy_loop
	asm("ldmia	r9!, {r0-r3} ");
	asm("stmia	r5!, {r0-r3} ");
	asm("str	r4, [r11], #4 ");
	asm("subs	r4, r4, r8 ");
	asm("cmphs	r4, #0x01000000 ");
	asm("bhs	4b ");					// 4b==block_copy_loop

	asm("ands	r4, r4, #3 ");
	asm("beq	6f ");					// 6f==trace_stored

	asm("5: "); // store_loop_last
	asm("ldr	r0, [r9], #4 ");			// get next word for record
	asm("strb	r4, [r11], #1 ");		// store size offset
	asm("subs	r4, r4, #1 ");
	asm("str	r0, [r5], #4 ");			// store word of trace record
	asm("bhi	5b "); // 5b==store_loop_last

	asm("6: "); // trace_stored
	asm("ldr	r5, [r10, #%a0]" : : "i" _FOFF(TBTraceBufferK,iAddress));
	asm("ldr	r6, [r10, #%a0]" : : "i" _FOFF(TBTraceBufferK,iHead));
#ifdef __SMP__
	__DATA_MEMORY_BARRIER_Z__(r8);		// make sure all buffer writes observed before head pointer update
#endif
	asm("ldr	r4, [r10, #%a0]" : : "i" _FOFF(TBTraceBufferK,iWaitingDfc));
	asm("ldr	r7, [r5, #%a0]" : : "i" _FOFF(TBTraceBuffer,iGeneration));
	asm("ldr	r0, [r10, #%a0]" : : "i" _FOFF(TBTraceBufferK,iRequestDataSize));
	asm("str	r6, [r5, #%a0]" : : "i" _FOFF(TBTraceBuffer,iHead));	// update user-visible head pointer
	asm("add	r7, r7, #1 ");
#ifdef __SMP__
	__DATA_MEMORY_BARRIER__(r8);		// make sure head pointer update seen before generation update
#endif
	asm("str	r7, [r5, #%a0]" : : "i" _FOFF(TBTraceBuffer,iGeneration));
	asm("cmp	r4, #0 ");
	asm("beq	done ");
	asm("cmp	r0, #0 ");
	asm("bgt	done ");

	// iWaitingDfc exists and iRequestDataSize<=0 so we need to trigger the DFC...
	asm("mov	r0, #0 ");
	asm("str	r0, [r10, #%a0]" : : "i" _FOFF(TBTraceBufferK,iWaitingDfc)); // iWaitingDfc=0

	asm("mov	r0, r4 ");
	asm("bl	"	CSM_ZN4TDfc6RawAddEv);
	asm("b		done ");

