romdev-mcp 0.1.1

package/src/platforms/gba/lib/libtonc/src/asm/tonc_isr_nest.s

@@ -0,0 +1,98 @@
+//
+//  Main ISR for prioritized nested interrupts
+//
+//! \file tonc_isr_nest.s
+//! \author J Vijn
+//! \date 20060909 - 20061025
+//
+// === NOTES ===
+
+#include "tonc_asminc.h"
+
+	.file "tonc_isr_nest.s"
+	.extern	__isr_table;
+
+/*! \fn IWRAM_CODE void isr_master_nest()
+	\brief	Main ISR for using prioritized nested interrupts
+*/
+BEGIN_FUNC_ARM(isr_master_nest, CSEC_IWRAM)
+	mov		r3, #0x04000000
+	ldr		r2, [r3, #0x200]!
+	and		r2, r2, r2, lsr #16		@ irq_curr= IE & IF
+	
+	@ REG_IFBIOS |= irq_curr
+	ldr		r1, [r3, #-0x208]
+	orr		r1, r1, r2
+	str		r1, [r3, #-0x208]
+
+	@ --- Find raised irq in __isr_table ---
+	@ r0 := IRQ_REC *pir= __isr_table
+	@ r12:= irq_prio (higher priority irqs)
+	ldr		r0, =__isr_table
+	mov		r12, #0
+.Lirq_search:
+		ldr		r1, [r0], #8 
+		tst		r1, r2
+		bne		.Lirq_found		@ Found it, break off search
+		orr		r12, r12, r1
+		cmp		r1, #0
+		bne		.Lirq_search	@ Not here; try next irq_rec
+	
+	@ --- No irq or ISR: just ack and return ---
+.Lirq_none:
+	strh	r2, [r3, #2]	@ REG_IF= irq_curr (is this right?)
+	bx		lr
+
+	@ If we're here, we found the irq; check for ISR
+.Lirq_found:
+	ldr		r0, [r0, #-4]	@ isr= pir[ii-1].isr
+	cmp		r0, #0
+	streqh	r1, [r3, #2]	@ No ISR: ack and return
+	bxeq	lr
+
+	@ --- ISR found, prep for nested irqs ---
+	@ {r0,r1,r3,r12} == { isr(), irq_flag, &REG_IE, irq_prio }
+
+	@ r2 := ieif= REG_IE|(irq_flag<<16); REG_IE &= irq_prio;
+	ldrh	r2, [r3]
+	and		r12, r12, r2
+	strh	r12, [r3]
+	orr		r2, r2, r1, lsl #16
+
+	mrs		r12, spsr
+	stmfd	sp!, {r2, r12, lr}	@ sp_irq,{ieif, spsr, lr_irq}
+
+	str		r3, [r3, #8]	@ REG_IME=0 (yeah ugly, I know)
+	@ Set CPU to SYS-mode, re-enable IRQ
+	mrs		r2, cpsr
+	bic		r2, r2, #0xDF
+	orr		r2, r2, #0x1F
+	msr		cpsr, r2
+
+	stmfd	sp!, {r3, lr}	@ sp_sys, {&REG_IE, lr_sys}
+	mov		r2, #1
+	str		r2, [r3, #8]	@ REG_IME= 1
+	adr		lr, .Lpost_isr
+	bx		r0
+
+	@ --- Unroll preparation ---
+.Lpost_isr:
+	ldmfd	sp!, {r3, lr}	@ sp_sys, {&REG_IE, lr_sys}
+	ldr		r0, [r3, #8]
+	str		r3, [r3, #8]	@ REG_IME=0 again
+
+	@ Restore CPU to IRQ-mode, disable IRQ
+	mrs		r2, cpsr
+	bic		r2, r2, #0xDF
+	orr		r2, r2, #0x92
+	msr		cpsr, r2
+	
+	ldmfd	sp!, {r2, r12, lr}	@ sp_irq,{ieif, spsr, lr_irq}
+	msr		spsr, r12
+
+	str		r2, [r3]		@ REG_IE/REG_IF= ieif
+	str		r0, [r3, #8]	@ Restore REG_IME
+	bx		lr
+END_FUNC(isr_master_nest)
+
+@ EOF

package/src/platforms/gba/lib/libtonc/src/asm/tonc_memcpy.s

@@ -0,0 +1,126 @@
+//
+//  Alignment-safe and fast memcpy routines
+//
+//! \file tonc_memcpy.s
+//! \author J Vijn
+//! \date 20060508 - 20090801
+//
+// === NOTES ===
+@ * 20050924: Lower overhead for all; reduced i-count for u16 loops.
+@ * These are 16/32bit memset and memcpy. The 32bit versions are in 
+@   iwram for maximum effect and pretty much do what CpuFastSet does, 
+@   except that it'll work for non multiples of 8 words too. Speed 
+@   is as good as CpuFastSet, but with a little less overhead.
+@ * The 16bit versions call the 32bit ones if possible and/or desirable. 
+@   They are thumb/ROM functions but did them in asm anyway because 
+@   GCC goes haywire with the use of registers resulting in a much
+@   higher overhead (i.e., detrimental for low counts)
+@ * Crossover with inline while(nn--) loops (not for(ii++), which are
+@   much slower):
+@		memcpy32: ~4
+@		memcpy16: ~8
+
+#include "tonc_asminc.h"
+
+	.file "tonc_memcpy.s"
+
+@ === void memcpy32(void *dst, const void *src, u32 wdn); =============
+/*! \fn void memcpy32(void *dst, const void *src, u32 wdn) CODE_IN_IWRAM;
+    \brief Fast-copy by words.
+	\param dst Destination address.
+	\param src Source address.
+	\param wdn Number of words.
+	\note \a src and \a dst <b>must</b> be word aligned.
+	\note \a r0 and \a r1 return as \a dst + \a wdn and \a src + \a wdn.
+*/
+/* Reglist:
+  r0, r1: dst, src
+  r2: wdn, then wdn>>3
+  r3-r10: data buffer
+  r12: wdn&7
+*/
+BEGIN_FUNC_ARM(memcpy32, CSEC_IWRAM)
+	and		r12, r2, #7
+	movs	r2, r2, lsr #3
+	beq		.Lres_cpy32
+	push	{r4-r10}
+	@ copy 32byte chunks with 8fold xxmia
+.Lmain_cpy32:
+		ldmia	r1!, {r3-r10}	
+		stmia	r0!, {r3-r10}
+		subs	r2, r2, #1
+		bhi		.Lmain_cpy32
+	pop		{r4-r10}
+	@ and the residual 0-7 words
+.Lres_cpy32:
+		subs	r12, r12, #1
+		ldmcsia	r1!, {r3}
+		stmcsia	r0!, {r3}
+		bhi		.Lres_cpy32
+	bx	lr
+END_FUNC(memcpy32)
+
+@ === void memcpy16(void *dst, const void *src, u32 hwn); =============
+/*! \fn void memcpy16(void *dst, const void *src, u32 hwn);
+    \brief Copy for halfwords.
+	Uses <code>memcpy32()</code> if \a hwn>6 and 
+	  \a src and \a dst are aligned equally.
+	\param dst Destination address.
+	\param src Source address.
+	\param wdn Number of halfwords to fill.
+	\note \a dst and \a src <b>must</b> be halfword aligned.
+	\note \a r0 and \a r1 return as \a dst + \a hwn and \a src + \a hwn.
+*/
+/* Reglist:
+  r0, r1: dst, src
+  r2, r4: wdn
+  r3: tmp; and data buffer
+*/
+
+BEGIN_FUNC_THUMB(memcpy16, CSEC_TEXT)
+	push	{r4, lr}
+	@ under 5 hwords -> std cpy
+	cmp		r2, #5
+	bls		.Ltail_cpy16
+	@ unreconcilable alignment -> std cpy
+	@ if (dst^src)&2 -> alignment impossible
+	mov		r3, r0
+	eor		r3, r1
+	lsl		r3, r3, #31		@ (dst^src), bit 1 into carry
+	bcs		.Ltail_cpy16	@ (dst^src)&2 : must copy by halfword
+	@ src and dst have same alignment -> word align
+	lsl		r3, r0, #31
+	bcc		.Lmain_cpy16	@ ~src&2 : already word aligned
+	@ aligning is necessary: copy 1 hword and align
+		ldrh	r3, [r1]
+		strh	r3, [r0]
+		add		r0, #2
+		add		r1, #2
+		sub		r2, r2, #1
+	@ right, and for the REAL work, we're gonna use memcpy32
+.Lmain_cpy16:
+	lsl		r4, r2, #31
+	lsr		r2, r2, #1
+	ldr		r3, =memcpy32
+	bl		.Llong_bl
+	@ NOTE: r0,r1 are altered by memcpy32, but in exactly the right 
+	@ way, so we can use them as is.
+	lsr		r2, r4, #31
+	beq		.Lend_cpy16
+.Ltail_cpy16:
+	sub		r2, #1
+	bcc		.Lend_cpy16		@ r2 was 0, bug out
+	lsl		r2, r2, #1
+.Lres_cpy16:
+		ldrh	r3, [r1, r2]
+		strh	r3, [r0, r2]
+		sub		r2, r2, #2
+		bcs		.Lres_cpy16
+.Lend_cpy16:
+	pop		{r4}
+	pop		{r3}
+.Llong_bl:
+	bx	r3
+END_FUNC(memcpy16)
+
+@ EOF

package/src/platforms/gba/lib/libtonc/src/asm/tonc_memset.s

@@ -0,0 +1,123 @@
+//
+//  Alignment-safe and fast memset routines
+//
+//! \file tonc_memcpy.s
+//! \author J Vijn
+//! \date 20060508 - 20090801
+//
+// === NOTES ===
+@ * 20050924: Lower overhead for all; reduced i-count for u16 loops.
+@ * These are 16/32bit memset and memcpy. The 32bit versions are in 
+@   iwram for maximum effect and pretty much do what CpuFastSet does, 
+@   except that it'll work for non multiples of 8 words too. Speed 
+@   is as good as CpuFastSet, but with a little less overhead.
+@ * The 16bit versions call the 32bit ones if possible and/or desirable. 
+@   They are thumb/ROM functions but did them in asm anyway because 
+@   GCC goes haywire with the use of registers resulting in a much
+@   higher overhead (i.e., detrimental for low counts)
+@ * Crossover with inline while(nn--) loops (not for(ii++), which are
+@   much slower):
+@		memset32: ~5
+@		memset16: ~8
+
+	.file "tonc_memset.s"
+
+#include "tonc_asminc.h"
+
+@ === void memset32(void *dst, u32 src, u32 wdn); =====================
+/*! \fn void memset32(void *dst, u32 src, u32 wdn) IWRAM_CODE;
+    \brief Fast-fill by words.
+	\param dst Destination address.
+	\param src Fill word (not address).
+	\param wdn Number of words to fill.
+	\note \a dst <b>must</b> be word aligned.
+	\note \a r0 returns as \a dst + \a wdn.
+*/
+/* Reglist:
+  r0, r1: dst, src
+  r2: wdn, then wdn>>3
+  r3-r10: data buffer
+  r12: wdn&7
+*/
+BEGIN_FUNC_ARM(memset32, CSEC_IWRAM)
+	and		r12, r2, #7
+	movs	r2, r2, lsr #3
+	beq		.Lres_set32
+	push	{r4-r9}
+	@ set 32byte chunks with 8fold xxmia
+	mov		r3, r1
+	mov		r4, r1
+	mov		r5, r1
+	mov		r6, r1
+	mov		r7, r1
+	mov		r8, r1
+	mov		r9, r1
+.Lmain_set32:
+		stmia	r0!, {r1, r3-r9}
+		subs	r2, r2, #1
+		bhi		.Lmain_set32
+	pop		{r4-r9}
+	@ residual 0-7 words
+.Lres_set32:
+		subs	r12, r12, #1
+		stmhsia	r0!, {r1}
+		bhi		.Lres_set32
+	bx	lr
+END_FUNC(memset32)
+
+@ === void memset16(void *dst, u16 src, u32 hwn); =====================
+/*! \fn void memset16(void *dst, u16 src, u32 hwn);
+    \brief Fill for halfwords.
+	Uses <code>memset32()</code> if \a hwn>5
+	\param dst Destination address.
+	\param src Source halfword (not address).
+	\param wdn Number of halfwords to fill.
+	\note \a dst <b>must</b> be halfword aligned.
+	\note \a r0 returns as \a dst + \a hwn.
+*/
+/* Reglist:
+  r0, r1: dst, src
+  r2, r4: wdn
+  r3: tmp; and data buffer
+*/
+BEGIN_FUNC_THUMB(memset16, CSEC_TEXT)
+	push	{r4, lr}
+	@ under 6 hwords -> std set
+	cmp		r2, #5
+	bls		.Ltail_set16
+	@ dst not word aligned: copy 1 hword and align
+	lsl		r3, r0, #31
+	bcc		.Lmain_set16
+		strh	r1, [r0]
+		add		r0, #2
+		sub		r2, r2, #1
+	@ Again, memset32 does the real work
+.Lmain_set16:
+	lsl		r4, r1, #16
+	orr		r1, r4
+	lsl		r4, r2, #31
+	lsr		r2, r2, #1
+	ldr		r3, =memset32
+	bl		.Llong_bl
+	@ NOTE: r0 is altered by memset32, but in exactly the right 
+	@ way, so we can use is as is. r1 is now doubled though.
+	lsr		r2, r4, #31
+	beq		.Lend_set16
+	lsr		r1, #16
+.Ltail_set16:
+	sub		r2, #1
+	bcc		.Lend_set16		@ r2 was 0, bug out
+	lsl		r2, r2, #1
+.Lres_set16:
+		strh	r1, [r0, r2]
+		sub		r2, r2, #2
+		bcs		.Lres_set16
+.Lend_set16:
+	pop		{r4}
+	pop		{r3}
+.Llong_bl:
+	bx	r3
+END_FUNC(memset16)
+	
+
+@ EOF

package/src/platforms/gba/lib/libtonc/src/asm/tonc_nocash.s

@@ -0,0 +1,73 @@
+//
+//  No$gba debugger messaging
+//
+//! \file tonc_nocash.s
+//! \author J Vijn
+//! \date 20080422 - 20080422
+
+#include "tonc_asminc.h"
+
+/* DECLARATIONS:
+	int nocash_puts(const char *str);
+	EWRAM_CODE void nocash_message();
+	extern EWRAM_DATA char nocash_buffer[80];
+*/
+
+		.global nocash_puts
+		.global nocash_message
+		.global nocash_buffer
+
+BEGIN_FUNC_THUMB(nocash_puts, CSEC_TEXT)
+	push	{r4, lr}
+	ldr		r4,=nocash_message	@ Get messenger address
+	ldr 	r1,=nocash_buffer	@ Get buffer address
+
+	mov 	r2, #0
+	mov		r12, r2
+
+	@ Iterate over loop parts
+.Lmsg_loop:
+		mov 	r2, #0
+
+		@ Copy up to 80 chars and print
+.Lmsg_cpy:							@ for(ii=0; ii<80; ii++)
+			ldrb	r3, [r0, r2]	@	if((dst[ii]=src[ii]) == '\0')
+			strb	r3, [r1, r2]	@		break;
+			cmp 	r3, #0
+			beq 	.Lmsg_print
+			add		r2, #1
+			cmp		r2, #80
+			bne 	.Lmsg_cpy
+
+		@ Print message
+.Lmsg_print:
+		bl		.Lmsg_far_call
+		
+		@ If not at end, continue with next part of string
+		add		r0, r2
+		add		r12, r2
+		cmp		r3, #0
+		bne		.Lmsg_loop
+
+	@ Full string done. Set result and return
+	mov		r0, r12
+	pop		{r4}
+	pop		{r1}
+	bx		r1
+.Lmsg_far_call:
+	bx		r4
+END_FUNC(nocash_puts)
+
+BEGIN_FUNC_THUMB(nocash_message, CSEC_EWRAM)
+	mov 	r12, r12 			@ first ID
+	b		.Lmsg_end			@ skip the text section
+	.hword	0x6464				@ second ID
+	.hword	0					@ flags
+nocash_buffer:
+	.space	82	 				@ Message buffer
+
+.Lmsg_end:
+	bx		lr
+END_FUNC(nocash_message)
+
+@ EOF

package/src/platforms/gba/lib/libtonc/src/font/sys8.s

@@ -0,0 +1,46 @@
+
+@{{BLOCK(sys8)
+
+	.section .rodata
+	.align	2
+	.global	sys8Font
+sys8Font:
+	.word	sys8Glyphs, 0, 0
+	.hword	32, 96
+	.byte	8, 8
+	.byte	8, 8
+	.hword	8
+	.byte	1, 0
+
+	.section .rodata
+	.align	2
+	.global sys8Glyphs		@ 768 unsigned chars
+sys8Glyphs:
+	.word 0x00000000,0x00000000,0x18181818,0x00180018,0x00003636,0x00000000,0x367F3636,0x0036367F
+	.word 0x3C067C18,0x00183E60,0x1B356600,0x0033566C,0x6E16361C,0x00DE733B,0x000C1818,0x00000000
+	.word 0x0C0C1830,0x0030180C,0x3030180C,0x000C1830,0xFF3C6600,0x0000663C,0x7E181800,0x00001818
+	.word 0x00000000,0x0C181800,0x7E000000,0x00000000,0x00000000,0x00181800,0x183060C0,0x0003060C
+	.word 0x7E76663C,0x003C666E,0x181E1C18,0x00181818,0x3060663C,0x007E0C18,0x3860663C,0x003C6660
+	.word 0x33363C38,0x0030307F,0x603E067E,0x003C6660,0x3E060C38,0x003C6666,0x3060607E,0x00181818
+	.word 0x3C66663C,0x003C6666,0x7C66663C,0x001C3060,0x00181800,0x00181800,0x00181800,0x0C181800
+	.word 0x06186000,0x00006018,0x007E0000,0x0000007E,0x60180600,0x00000618,0x3060663C,0x00180018
+
+	.word 0x5A5A663C,0x003C067A,0x7E66663C,0x00666666,0x3E66663E,0x003E6666,0x06060C78,0x00780C06
+	.word 0x6666361E,0x001E3666,0x1E06067E,0x007E0606,0x1E06067E,0x00060606,0x7606663C,0x007C6666
+	.word 0x7E666666,0x00666666,0x1818183C,0x003C1818,0x60606060,0x003C6660,0x0F1B3363,0x0063331B
+	.word 0x06060606,0x007E0606,0x6B7F7763,0x00636363,0x7B6F6763,0x00636373,0x6666663C,0x003C6666
+	.word 0x3E66663E,0x00060606,0x3333331E,0x007E3B33,0x3E66663E,0x00666636,0x3C0E663C,0x003C6670
+	.word 0x1818187E,0x00181818,0x66666666,0x003C6666,0x66666666,0x00183C3C,0x6B636363,0x0063777F
+	.word 0x183C66C3,0x00C3663C,0x183C66C3,0x00181818,0x0C18307F,0x007F0306,0x0C0C0C3C,0x003C0C0C
+	.word 0x180C0603,0x00C06030,0x3030303C,0x003C3030,0x00663C18,0x00000000,0x00000000,0x003F0000
+
+	.word 0x00301818,0x00000000,0x603C0000,0x007C667C,0x663E0606,0x003E6666,0x063C0000,0x003C0606
+	.word 0x667C6060,0x007C6666,0x663C0000,0x003C067E,0x0C3E0C38,0x000C0C0C,0x667C0000,0x3C607C66
+	.word 0x663E0606,0x00666666,0x18180018,0x00301818,0x30300030,0x1E303030,0x36660606,0x0066361E
+	.word 0x18181818,0x00301818,0x7F370000,0x0063636B,0x663E0000,0x00666666,0x663C0000,0x003C6666
+	.word 0x663E0000,0x06063E66,0x667C0000,0x60607C66,0x663E0000,0x00060606,0x063C0000,0x003E603C
+	.word 0x0C3E0C0C,0x00380C0C,0x66660000,0x007C6666,0x66660000,0x00183C66,0x63630000,0x00367F6B
+	.word 0x36630000,0x0063361C,0x66660000,0x0C183C66,0x307E0000,0x007E0C18,0x0C181830,0x00301818
+	.word 0x18181818,0x00181818,0x3018180C,0x000C1818,0x003B6E00,0x00000000,0x00000000,0x00000000
+
+@}}BLOCK(sys8)