/****************************************************************************************************
	crt.s						STARTUP  ASSEMBLY  CODE 
								-----------------------
	Module includes the interrupt vectors and start-up code.
 ****************************************************************************************************/

/* Stack Sizes */
.set  UND_STACK_SIZE, 64	/* stack size for "undef" exceptions is 64 bytes (16 registers) 	*/
.set  ABT_STACK_SIZE, 64	/* stack size for "abort" exceptions is 64 bytes (16 registers)		*/
.set  FIQ_STACK_SIZE, 32	/* stack size for "FIQ" interrupts  is 32 bytes (8 registers) 		*/
.set  IRQ_STACK_SIZE, 64	/* stack size for "IRQ" normal interrupts is 64 bytes (16 registers)*/
.set  SVC_STACK_SIZE, 64	/* stack size for "SVC" supervisor (SWI) is 64 bytes (16 registers) */

/* Standard definitions of Mode bits and Interrupt (I & F) flags in PSRs (program status registers) */
.set  MODE_USR, 0x10		/* Normal User Mode 											*/
.set  MODE_FIQ, 0x11		/* FIQ Processing Fast Interrupts Mode 							*/
.set  MODE_IRQ, 0x12		/* IRQ Processing Standard Interrupts Mode						*/
.set  MODE_SVC, 0x13		/* Supervisor Processing Software Interrupts Mode 				*/
.set  MODE_ABT, 0x17		/* Abort Processing memory Faults Mode							*/
.set  MODE_UND, 0x1B		/* Undefined Processing Undefined Instructions Mode 			*/
.set  MODE_SYS, 0x1F		/* System Running Priviledged Operating System Tasks  Mode		*/
.set  I_BIT, 0x80			/* when I bit is set, IRQ is disabled (program status registers)*/
.set  F_BIT, 0x40			/* when F bit is set, FIQ is disabled (program status registers)*/

.text
.arm

/**********************************************************************/
/***************    Vector Table & related constants     **************/
/**********************************************************************/

_vectors:       ldr     PC, Reset_Addr         
                ldr     PC, Undef_Addr
                ldr     PC, SWI_Addr
                ldr     PC, PAbt_Addr
                ldr     PC, DAbt_Addr
                nop							/* Reserved Vector (changed to Philips ISP checksum)    */
                ldr     PC, [PC,#-0xFF0]	/* LPC21xx vectored interrupt (see VIC in users manual) */
                ldr     PC, FIQ_Addr
/*---------------------------------------------------------------------------*/
Reset_Addr:     .word   Reset_Code		
Undef_Addr:     .word   UNDEF_Routine		
SWI_Addr:       .word   SWI_Routine			
PAbt_Addr:      .word   PABORT_Routine		
DAbt_Addr:      .word   DABORT_Routine		
FIQ_Addr:       .word   FIQ_Routine		


        .align 6	// skip the rest of the vector block (64 bytes total)
/****************************************/
/*			Exception handling			*/
/****************************************/
UNDEF_Routine:
		adr		r9,UNDtxt
		b		exception_exit
SWI_Routine:
		adr		r9,SWItxt
		b		exception_exit
PABORT_Routine:
		adr		r9,PABtxt
		b		exception_exit
DABORT_Routine:
		adr		r9,DABtxt
		b		exception_exit
FIQ_Routine:
        adr     r9,FIQtxt
exception_exit:
		ldr     r8,=0xE000C000      /* UART0 THR */
50:     ldrb    r10,[r8,#0x14]      /* UART0 LSR  */
        tst     r10,#0x20           /* check THRE */
        beq     50b
        ldrb    r10,[r9],#1         /* Load character from string */
        tst     r10,#0xff           /* Check if zero */
        beq  	_Halt         		/* exit if zero */
        strb    r10,[r8]            /* put character into TX */
        b       50b

FIQtxt: .asciz "#--- FIQ interrupt\r\n"
UNDtxt: .asciz "#--- UNDEF exception\r\n"
SWItxt: .asciz "#--- SWI exception\r\n"
PABtxt: .asciz "#--- Prefetch Abort exception\r\n"
DABtxt: .asciz "#--- Data Abort exception\r\n"

        .align	2  /* following code has to be word aligned */

/**********************************************************************/
/************************    Reset Handler     ************************/
/**********************************************************************/
Reset_Code:  

	/* Setup a stack for each mode */

    	ldr   r0, =_stack_end
    	msr   CPSR_c, #MODE_UND|I_BIT|F_BIT 	/* Undefined Instruction Mode  */
    	mov   sp, r0
    	sub   r0, r0, #UND_STACK_SIZE
    	msr   CPSR_c, #MODE_ABT|I_BIT|F_BIT 	/* Abort Mode */
    	mov   sp, r0
    	sub   r0, r0, #ABT_STACK_SIZE
    	msr   CPSR_c, #MODE_FIQ|I_BIT|F_BIT 	/* FIQ Mode */
    	mov   sp, r0	
        sub   r0, r0, #FIQ_STACK_SIZE
    	msr   CPSR_c, #MODE_IRQ|I_BIT|F_BIT 	/* IRQ Mode */
    	mov   sp, r0
    	sub   r0, r0, #IRQ_STACK_SIZE
    	msr   CPSR_c, #MODE_SVC|I_BIT|F_BIT 	/* Supervisor Mode */
    	mov   sp, r0
    	sub   r0, r0, #SVC_STACK_SIZE
    	msr   CPSR_c, #MODE_SYS|I_BIT|F_BIT 	/* System and User Modes */
    	mov   sp, r0

		/**********************************************************/	
		/* System init											  */
		/* PLL x 4, PCLK x 1/4					  				  */
		/* CCLK=58.9824MHz, PCLK=58.9824MHz		  				  */
		/* UART0 at 115200 bps, 8-bit, 1-stop, no parity, FIFO on */
		/**********************************************************/

		ldr		r1,=0xE01FC000
		mov		r2,#0xaa
		mov		r3,#0x55
		mov		r0,#0x23		@ PLL x 4
		strb	r0,[r1,#0x84]	@ PLLCFG
		strb	r2,[r1,#0x8c]
		strb	r3,[r1,#0x8c]
		mov		r0,#1			@ PLL on
		strb	r0,[r1,#0x80]	@ PLLCON
		strb	r2,[r1,#0x8c]
		strb	r3,[r1,#0x8c]
1:		ldrh	r0,[r1,#0x88]	@ PLLSTAT
		tst		r0,#0x400		@ PLOCK on ?
		beq		1b
		mov		r0,#3			@ PLL connected
		strb	r0,[r1,#0x80]	@ PLLCON
		strb	r2,[r1,#0x8c]
		strb	r3,[r1,#0x8c]
		mov		r0,#1
		str		r0,[r1,#0x100]	@ APBDIV: PCLK=CCLK/1

        mov     r0,#2			@ MAM init
        str     r0,[r1]     	@ MAMCR=2 (Fully enabled)
        mov     r0,#3
        str     r0,[r1,#4]  	@ MAMTIM=3 (3 cycles/flash read)

		sub		r1,r1,#(0xE01FC000-0xE002C000)	@ PINSEL0
		mov		r0,#5			@ P0.0, P0.1 as UART
		str		r0,[r1]
		sub		r1,r1,#(0xE002C000-0xE000C000)	@ UART0
		mov		r0,#0x83
		strb	r0,[r1,#12]		@ LCR=0x83
		mov		r0,#32			@ divisor for 115200 baud (PCLK=58.9824MHz)
		strb	r0,[r1]			@ DLL
		mov		r0,#0
		strb	r0,[r1,#4]		@ DLH
		mov		r0,#3
		strb	r0,[r1,#12]		@ LCR=3 (8 bit, 1 stop, no parity)
		mov		r0,#7
		strb	r0,[r1,#8]		@ FCR=7 (FIFOs on)

	/* copy .data section (Copy from ROM to RAM) */
        ldr     R1, =_etext
        ldr     R2, =_data
        ldr     R3, =_edata
1:      cmp     R2, R3
        ldrlo   R0, [R1], #4
        strlo   R0, [R2], #4
        blo     1b

	/* Clear .bss section (Zero init)  */
        mov     R0, #0
        ldr     R1, =_bss_start
        ldr     R2, =_bss_end
2:		cmp     R1, R2
        strlo   R0, [R1], #4
        blo     2b

	/* Enter the C code */

		bl		main

		.global _Halt
_Halt:
3:		b	3b	

	/********************************************************/	
	/* Active delay loop 					*/
	/* 4 Clock Cycles per loop, R0 = number of loops	*/
	/* Total delay (including call & return) = 4*(N+1)	*/
	/********************************************************/
		.global _delay_loop
_delay_loop:
		subs	r0,r0,#1
		bne	_delay_loop
		mov	pc,lr


	/****************************************/	
	/* print decimal number			*/
	/****************************************/
		.global _U0prtnum

_U0prtnum:
		mov 	r3,#0		@ digit counter
1:		mov 	r2,#32		@ R0/=10, R1=remainder
		mov		r1,#0
2:		adds	r0,r0,r0
		adc		r1,r1,r1
		cmp		r1,#10
		subge	r1,r1,#10
		addge	r0,r0,#1
		subs	r2,r2,#1
		bne		2b
		add		r1,r1,#'0'	@ convert to ASCII
		strb	r1,[sp,#-1]!	@ store digit in the STACK
		add		r3,r3,#1	@ increment digit counter
		cmp		r0,#0		@ repeat until number is zero
		bne		1b

		ldr     r1,=0xE000C000  @ UART0 THR
3:		ldrb    r0,[r1,#0x14]   @ UART0 LSR, wait until THRE is one
		tst     r0,#0x20        @ THRE is bit 5
		beq     3b
		ldrb	r0,[sp],#1	@ get digit from stack
		strb	r0,[r1]		@ send it through UART0 THR
		subs	r3,r3,#1	@ repeat until all digits are printed
		bne		3b
		mov		pc,lr

	/*********************************/
	/* print hexadecimal numbers	 */
	/*********************************/
		.global _U0prthex
		.global _U0prthex8

_U0prthex:			@ 32 bits
		mov		r2,#8
		b 		_U0prthex_entry
_U0prthex8:			@ 8 bits
		mov		r2,#2
		mov		r0,r0, lsl #24	@ adjust to the left
_U0prthex_entry:
		ldr     r1,=0xE000C000  @ UART0 THR
1:		ldrb    r3,[r1,#0x14]   @ UART0 LSR, wait until THRE is one
		tst		r3,#0x20
		beq		1b
		mov		r0,r0, ror #28	@ ...rol #4
		and		r3,r0,#0x0f
		cmp		r3,#9		@ 0..9 or A..F ?
		addgt	r3,r3,#7	@ offset from '9'+1 to 'A' in the ASCII code
		add		r3,r3,#'0'	@ convert to ASCII
		strb	r3,[r1]		@ send through UART0 THR
		subs	r2,r2,#1	@ repeat until no more digits pending
		bne		1b
		mov		pc,lr

	/******************************************/	
	/* print string				  			  */
	/******************************************/
		.global _U0puts

_U0puts:
		ldr     r1,=0xE000C000  @ UART0 THR
1:		ldrb	r2,[r1,#0x14]	@ UART0 LSR, wait until THRE is one
		tst		r2,#0x20
		beq		1b
		ldrb	r2,[r0],#1	@ get char
		tst		r2,#0xff
		moveq	pc,lr		@ return if 0
		strb	r2,[r1]		@ send through UART0 THR
		b		1b

	/******************************************/	
	/* print character						  */
	/******************************************/
		.global _U0putch

_U0putch:
		ldr     r1,=0xE000C000  @ UART0 THR
1:		ldrb	r2,[r1,#0x14]	@ UART0 LSR, wait until THRE is one
		tst		r2,#0x20
		beq		1b
		strb	r0,[r1]
		mov		pc,lr

	/******************************************/	
	/* read character						  */
	/******************************************/
		.global _U0getch

_U0getch:
		ldr     r1,=0xE000C000  @ UART0 THR
1:		ldrb	r0,[r1,#0x14]	@ UART0 LSR, wait until THRE is one
		tst		r0,#1
		beq		1b
		ldrb	r0,[r1]
		mov		pc,lr


.end

