soc_maker 0.1.1

data/examples/or1200_test/sw/orp.ld

@@ -0,0 +1,60 @@
+MEMORY
+	{
+	reset	: ORIGIN = 0x00000000, LENGTH = 0x00000200
+	vectors : ORIGIN = 0x00000200, LENGTH = 0x00001000
+    ram     : ORIGIN = 0x00001200, LENGTH = 0x00006E00  /*0x8000 total*/
+	}
+
+SECTIONS
+{
+	.reset :
+        {
+        *(.reset)
+        } > reset
+
+
+ 
+	.vectors :
+        {
+        _vec_start = .;
+        *(.vectors)
+        _vec_end = .;
+        } > vectors
+
+        .text :
+        {
+        *(.text)
+        } > ram
+
+      .rodata :
+        {
+        *(.rodata)
+        *(.rodata.*)
+        } > ram
+ 
+     .icm :
+        {
+        _icm_start = .;
+        *(.icm)
+        _icm_end = .;
+        } > ram
+
+     .data :
+        {
+        _dst_beg = .;
+        *(.data)
+        _dst_end = .;
+        } > ram
+ 
+      .bss :
+        {
+        *(.bss)
+        } > ram
+ 
+      .stack (NOLOAD) :
+        {
+        *(.stack)
+        _src_addr = .;
+        } > ram
+
+}

data/examples/or1200_test/sw/reset.S

@@ -0,0 +1,112 @@
+/* Support file for c based tests */
+#include "or1200.h"
+#include <board.h>
+
+    .section .stack
+    .space STACK_SIZE
+_stack:
+
+    .section .reset, "ax"
+
+    .org    0x100
+_reset_vector:
+    l.nop
+    l.nop
+    l.addi  r2,r0,0x0
+    l.addi  r3,r0,0x0
+    l.addi  r4,r0,0x0
+    l.addi  r5,r0,0x0
+    l.addi  r6,r0,0x0
+    l.addi  r7,r0,0x0
+    l.addi  r8,r0,0x0
+    l.addi  r9,r0,0x0
+    l.addi  r10,r0,0x0
+    l.addi  r11,r0,0x0
+    l.addi  r12,r0,0x0
+    l.addi  r13,r0,0x0
+    l.addi  r14,r0,0x0
+    l.addi  r15,r0,0x0
+    l.addi  r16,r0,0x0
+    l.addi  r17,r0,0x0
+    l.addi  r18,r0,0x0
+    l.addi  r19,r0,0x0
+    l.addi  r20,r0,0x0
+    l.addi  r21,r0,0x0
+    l.addi  r22,r0,0x0
+    l.addi  r23,r0,0x0
+    l.addi  r24,r0,0x0
+    l.addi  r25,r0,0x0
+    l.addi  r26,r0,0x0
+    l.addi  r27,r0,0x0
+    l.addi  r28,r0,0x0
+    l.addi  r29,r0,0x0
+    l.addi  r30,r0,0x0
+    l.addi  r31,r0,0x0
+
+/*        
+    l.movhi r3,hi(MC_BASE_ADDR) 
+    l.ori   r3,r3,MC_BA_MASK
+    l.addi  r5,r0,0x00
+    l.sw    0(r3),r5
+*/      
+    l.movhi r3,hi(_start)
+    l.ori   r3,r3,lo(_start)
+    l.jr    r3
+    l.nop
+
+    .section .text
+
+_start:
+
+.if IC | DC
+    /* Flush IC and/or DC */
+    l.addi  r10,r0,0   
+    l.addi  r11,r0,0   
+    l.addi  r12,r0,0   
+.if IC
+    l.addi  r11,r0,IC_SIZE
+.endif
+.if DC
+    l.addi    r12,r0,DC_SIZE
+.endif
+    l.sfleu    r12,r11
+    l.bf    loop
+    l.nop
+    l.add    r11,r0,r12
+loop:
+.if IC
+    l.mtspr r0,r10,SPR_ICBIR
+.endif
+.if DC
+    l.mtspr r0,r10,SPR_DCBIR
+.endif
+    l.sfne  r10,r11
+    l.bf    loop   
+    l.addi  r10,r10,16
+
+    /* Enable IC and/or DC */
+    l.addi  r10,r0,(SPR_SR_SM)
+.if IC
+    l.ori    r10,r10,(SPR_SR_ICE)
+.endif
+.if DC
+    l.ori    r10,r10,(SPR_SR_DCE)
+.endif
+    l.mtspr r0,r10,SPR_SR
+    l.nop
+    l.nop
+    l.nop
+    l.nop
+    l.nop
+.endif
+
+/* Set stack pointer */
+    l.movhi r1,hi(_stack)
+    l.ori   r1,r1,lo(_stack)
+
+/* Jump to main */
+    l.movhi r2,hi(CLABEL(reset))
+    l.ori   r2,r2,lo(CLABEL(reset))
+    l.jr    r2
+    l.nop
+

data/examples/or1200_test/sw/support.c

@@ -0,0 +1,123 @@
+/* Support */
+
+#ifndef OR32
+#include <sys/time.h>
+#endif
+
+#include "or1200.h"
+#include "support.h"
+#include "int.h"
+
+#ifdef UART_PRINTF
+#include <uart.h>
+#endif
+
+#if OR32
+void int_main();
+
+void ext_except()
+{
+	int_main();
+}
+
+/* Start function, called by reset exception handler.  */
+void reset ()
+{
+	int i = main();
+	or32_exit (i);  
+}
+
+/* return value by making a syscall */
+void or32_exit (int i)
+{
+	asm("l.add r3,r0,%0": : "r" (i));
+	asm("l.nop %0": :"K" (NOP_EXIT));
+	while (1);
+}
+
+#ifdef UART_PRINTF
+
+static int uart_init_done = 0;
+
+#define PRINTFBUFFER_SIZE 512
+char PRINTFBUFFER[PRINTFBUFFER_SIZE]; // Declare a global printf buffer
+
+void minsoc_printf(const char *fmt, ...)
+{
+	// init uart if not done already
+	if (!uart_init_done)
+	{
+		uart_init();
+		uart_init_done = 1;
+	}
+
+	va_list args;
+	va_start(args, fmt);
+
+	//int str_l = vsnprintf(PRINTFBUFFER, PRINTFBUFFER_SIZE, fmt, args);
+	int str_l = vfnprintf(PRINTFBUFFER, PRINTFBUFFER_SIZE, fmt, args);
+
+	if (!str_l) return; // no length string - just return
+
+	int c=0;
+	// now print each char via the UART
+	while (c < str_l)
+		uart_putc(PRINTFBUFFER[c++]);
+
+	va_end(args);
+}
+
+#else
+/* activate printf support in simulator */
+void minsoc_printf(const char *fmt, ...)
+{
+	va_list args;
+	va_start(args, fmt);
+	__asm__ __volatile__ ("  l.addi\tr3,%1,0\n \
+			l.addi\tr4,%2,0\n \
+			l.nop %0": :"K" (NOP_PRINTF), "r" (fmt), "r"  (args));
+}
+
+#endif
+
+
+
+
+/* print long */
+void report(unsigned long value)
+{
+	asm("l.addi\tr3,%0,0": :"r" (value));
+	asm("l.nop %0": :"K" (NOP_REPORT));
+}
+
+/* just to satisfy linker */
+void __main()
+{
+}
+
+/* start_TIMER                    */
+void start_timer(int x)
+{
+}
+
+/* For writing into SPR. */
+void mtspr(unsigned long spr, unsigned long value)
+{	
+	asm("l.mtspr\t\t%0,%1,0": : "r" (spr), "r" (value));
+}
+
+/* For reading SPR. */
+unsigned long mfspr(unsigned long spr)
+{	
+	unsigned long value;
+	asm("l.mfspr\t\t%0,%1,0" : "=r" (value) : "r" (spr));
+	return value;
+}
+
+#else
+void report(unsigned long value)
+{
+	printf("report(0x%x);\n", (unsigned) value);
+}
+
+#endif

data/examples/or1200_test/sw/support.h

@@ -0,0 +1,33 @@
+/* Support file for or32 tests.  This file should is included
+   in each test. It calls main() function and add support for
+   basic functions */
+
+#ifndef SUPPORT_H
+#define SUPPORT_H
+
+#include <stdarg.h>
+#include <stddef.h>
+#include <limits.h>
+
+/* Register access macros */
+#define REG8(add) *((volatile unsigned char *)(add))
+#define REG16(add) *((volatile unsigned short *)(add))
+#define REG32(add) *((volatile unsigned long *)(add))
+
+/* For writing into SPR. */
+void mtspr(unsigned long spr, unsigned long value);
+
+/* For reading SPR. */
+unsigned long mfspr(unsigned long spr);
+
+/* Function to be called at entry point - not defined here.  */
+int main ();
+
+/* Prints out a value */
+void report(unsigned long value);
+
+/* return value by making a syscall */
+extern void or32_exit (int i) __attribute__ ((__noreturn__));
+
+
+#endif /* SUPPORT_H */

data/examples/or1200_test/sw/tick.c

@@ -0,0 +1,30 @@
+#include "or1200.h"
+#include "support.h"
+#include "tick.h"
+
+int tick_int;
+
+void tick_ack(void)
+{
+	tick_int--;
+}
+
+void tick_init(void)
+{
+	mtspr(SPR_TTMR, 25000000 & SPR_TTMR_PERIOD);    //1s
+	//mtspr(SPR_TTMR, 125000 & SPR_TTMR_PERIOD);    //5ms
+
+	mtspr(SPR_TTMR, mfspr(SPR_TTMR) | SPR_TTMR_RT | SPR_TTMR_IE);	//restart after match, enable interrupt
+	mtspr(SPR_TTMR, mfspr(SPR_TTMR) & ~(SPR_TTMR_IP));    //clears interrupt
+
+	//set OR1200 to accept exceptions
+	mtspr(SPR_SR, mfspr(SPR_SR) | SPR_SR_TEE);
+
+	tick_int = 0;
+}
+
+void tick_except(void)
+{
+	tick_int++;
+	mtspr(SPR_TTMR, mfspr(SPR_TTMR) & ~(SPR_TTMR_IP));    //clears interrupt
+}

data/examples/or1200_test/sw/tick.h

@@ -0,0 +1,2 @@
+void tick_init(void);
+void tick_ack(void);

data/examples/or1200_test/sw/uart.c

@@ -0,0 +1,136 @@
+#include <board.h>
+#include <support.h>
+#include "uart.h"
+
+#define BOTH_EMPTY (UART_LSR_TEMT | UART_LSR_THRE)
+
+#define WAIT_FOR_XMITR \
+	do { \
+		lsr = REG8(uart_base + UART_LSR); \
+	} while ((lsr & BOTH_EMPTY) != BOTH_EMPTY)
+
+#define WAIT_FOR_THRE \
+	do { \
+		lsr = REG8(uart_base + UART_LSR); \
+	} while ((lsr & UART_LSR_THRE) != UART_LSR_THRE)
+
+#define CHECK_FOR_CHAR (REG8(uart_base + UART_LSR) & UART_LSR_DR)
+
+#define WAIT_FOR_CHAR \
+	do { \
+		lsr = REG8(uart_base + UART_LSR); \
+	} while ((lsr & UART_LSR_DR) != UART_LSR_DR)
+
+#define UART_TX_BUFF_LEN 32
+#define UART_TX_BUFF_MASK (UART_TX_BUFF_LEN -1)
+
+static unsigned long uart_base = 0;
+
+char tx_buff[UART_TX_BUFF_LEN];
+volatile int tx_level, rx_level;
+
+void uart_init(unsigned long base)
+{
+	int divisor;
+    uart_base = base;
+	/* Reset receiver and transmiter */
+	/* Set RX interrupt for each byte */
+	REG8(uart_base + UART_FCR) = UART_FCR_ENABLE_FIFO | UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT | UART_FCR_TRIGGER_1;
+
+	/* Enable RX interrupt */
+	REG8(uart_base + UART_IER) = UART_IER_RDI | UART_IER_THRI;
+
+	/* Set 8 bit char, 1 stop bit, no parity */
+	REG8(uart_base + UART_LCR) = UART_LCR_WLEN8 & ~(UART_LCR_STOP | UART_LCR_PARITY);
+
+	/* Set baud rate */
+	divisor = IN_CLK/(16 * UART_BAUD_RATE);
+	REG8(uart_base + UART_LCR) |= UART_LCR_DLAB;
+	REG8(uart_base + UART_DLM) = (divisor >> 8) & 0x000000ff;
+	REG8(uart_base + UART_DLL) = divisor & 0x000000ff;
+	REG8(uart_base + UART_LCR) &= ~(UART_LCR_DLAB);
+
+	return;
+}
+
+void uart_putc(char c)
+{
+	unsigned char lsr;
+
+	WAIT_FOR_THRE;
+	REG8(uart_base + UART_TX) = c;
+	WAIT_FOR_XMITR;
+}
+
+
+
+char uart_getc()
+{
+	char c;
+	c = REG8(uart_base + UART_RX);
+	return c;
+}
+
+
+void uart_interrupt()
+{
+	char lala;
+	unsigned char interrupt_id;
+	interrupt_id = REG8(uart_base + UART_IIR);
+	if ( interrupt_id & UART_IIR_RDI )
+	{
+		lala = uart_getc();
+		uart_putc(lala+1);
+	}
+
+}
+
+void uart_print_str(char *p)
+{
+	while(*p != 0) {
+		uart_putc(*p);
+		p++;
+	}
+}
+
+void uart_print_long(unsigned long ul)
+{
+	int i;
+	char c;
+
+
+	uart_print_str("0x");
+	for(i=0; i<8; i++) {
+
+		c = (char) (ul>>((7-i)*4)) & 0xf;
+		if(c >= 0x0 && c<=0x9)
+			c += '0';
+		else
+			c += 'a' - 10;
+		uart_putc(c);
+	}
+
+}
+
+void uart_print_short(unsigned long ul)
+{
+	int i;
+	char c;
+	char flag=0;
+
+
+	uart_print_str("0x");
+	for(i=0; i<8; i++) {
+
+		c = (char) (ul>>((7-i)*4)) & 0xf;
+		if(c >= 0x0 && c<=0x9)
+			c += '0';
+		else
+			c += 'a' - 10;
+		if ((c != '0') || (i==7))
+			flag=1;
+		if(flag)
+			uart_putc(c);
+	}
+
+}