soc_maker 0.1.1

data/examples/or1200_test/rtl/xilinx_internal_jtag_options.v

@@ -0,0 +1,12 @@
+
+
+// Xilinx has a different HDL entity for the internal JTAG in each of these.
+// How thoughtful.
+
+//`define SPARTAN2
+//`define SPARTAN3  // This is also used for SPARTAN 3E devices
+`define SPARTAN3A
+//`define VIRTEX
+//`define VIRTEX2  // Also used for the VIRTEX 2P
+//`define VIRTEX4
+//`define VIRTEX5

data/examples/or1200_test/sw/README.txt

@@ -0,0 +1,35 @@
+
+!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+Please note: this software is taken from the 
+minsoc project: http://www.minsoc.com and is just 
+used for prove of concept.
+!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+
+Prerequisites:
+
+ - Synthesized FPGA design
+ - Advanced debug system compiled 
+   and working (same revision than for HDL sources)
+ - Spartan-3an starter kit
+
+Do the following steps to run the SW
+
+
+ 1. Programm FPGA with impact
+ 2. Compile sources
+    >> bash ./compile.sh
+ 3. Open serial output, for example with `kermit`
+ 4. Run advanced debug bridge:
+    >> PATH_TO_BRIDGE/adv_jtag_bridge -t -b /PATH_TO_/Xilinx/bsdl -x 1 xpc_usb
+
+    The result should show a successful test and "JTAG bridge ready!"
+ 5. Run GDB:
+    >>or32-elf-gdb uart.or32
+    (gdb) target remote localhost:9999
+    (gdb) load
+    (gdb) set $pc=0x100
+    (gdb) continue
+ 
+    The serial output should show "Hello World."
+

data/examples/or1200_test/sw/bin2vmem.c

@@ -0,0 +1,159 @@
+/*$$HEADER*/
+/******************************************************************************/
+/*                                                                            */
+/*                    H E A D E R   I N F O R M A T I O N                     */
+/*                                                                            */
+/******************************************************************************/
+
+// Project Name                   : ORPSoC v2
+// File Name                      : bin2vmem.c
+// Prepared By                    : jb, jb@orsoc.se
+// Project Start                  : 2009-05-13
+
+/*$$COPYRIGHT NOTICE*/
+/******************************************************************************/
+/*                                                                            */
+/*                      C O P Y R I G H T   N O T I C E                       */
+/*                                                                            */
+/******************************************************************************/
+/*
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; 
+  version 2.1 of the License, a copy of which is available from
+  http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+/*$$DESCRIPTION*/
+/******************************************************************************/
+/*                                                                            */
+/*                           D E S C R I P T I O N                            */
+/*                                                                            */
+/******************************************************************************/
+//
+// Generates VMEM output to stdout from binary images.
+// Use with redirection like: ./bin2vmem app.bin > app.vmem
+// To change either the number of bytes per word or word per line, change
+// the following defines.
+// Currently output is WORD addressed, NOT byte addressed
+// eg: @00000000 00000000 00000000 00000000 00000000
+//     @00000004 00000000 00000000 00000000 00000000
+//     @00000008 00000000 00000000 00000000 00000000
+//     @0000000c 00000000 00000000 00000000 00000000
+//     etc..
+//
+
+#define WORDS_PER_LINE 4
+#define BYTES_PER_WORD 4
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+ 
+int main(int argc, char **argv)
+{
+
+	FILE  *fd;
+	int c;
+	int i = 0;
+	int write_size_word=0; // Disabled by default
+	int filename_index=1;
+	unsigned int image_size;
+
+	// Counters keeping track of what we've printed
+	int current_addr = 0;
+	int word_counter = 0;
+	int byte_counter = 0;
+
+	if(argc < 2) {
+	  fprintf(stderr,"\n\tInsufficient options.\n");
+	  fprintf(stderr,"\tPlease specify a binary file to convert to VMEM\n");
+	  fprintf(stderr,"\n\tbin2vmem - creates vmem output to stdout from bin\n");
+	  exit(1);
+	}
+	
+	fd = fopen( argv[filename_index], "r" );
+
+	if (fd == NULL) {
+		fprintf(stderr,"failed to open input file: %s\n",argv[1]);
+		exit(1);
+	}
+
+	fseek(fd, 0, SEEK_END);
+	image_size = ftell(fd);
+	fseek(fd,0,SEEK_SET);
+
+	if (write_size_word)
+	  {
+	    // or1200 startup method of determining size of boot image we're copying by reading out
+	    // the very first word in flash is used. Determine the length of this file
+	    fseek(fd, 0, SEEK_END);
+	    image_size = ftell(fd);
+	    fseek(fd,0,SEEK_SET);
+	    
+	    // Now we should have the size of the file in bytes. Let's ensure it's a word multiple
+	    image_size+=3;
+	    image_size &= 0xfffffffc;
+
+	    // Sanity check on image size
+	    if (image_size < 8){ 
+	      fprintf(stderr, "Bad binary image. Size too small\n");
+	      return 1;
+	    }
+	    
+	    // Now write out the image size
+	    printf("@%8x", current_addr);
+	    printf("%8x", image_size);
+	    current_addr += WORDS_PER_LINE * BYTES_PER_WORD;
+	  }
+	else
+	  {
+	  }
+
+
+	// Fix for the current bootloader software! Skip the first 4 bytes of application data. Hopefully it's not important. 030509 -- jb
+	//for(i=0;i<4;i++)
+	//  c=fgetc(fd);
+	i=0;
+	int starting_new_line  = 1;
+	// Now write out the binary data to VMEM format: @ADDRESSS XXXXXXXX XXXXXXXX XXXXXXXX XXXXXXXX
+	while ((c = fgetc(fd)) != EOF) {
+	  if (starting_new_line)
+	    {
+	      // New line - print the current addr and then increment it
+	      printf("@%.8x", current_addr);
+	      //current_addr += WORDS_PER_LINE * BYTES_PER_WORD;
+	      current_addr += WORDS_PER_LINE;
+	      starting_new_line = 0;
+	    }
+	  if (byte_counter == 0)
+	    printf(" ");
+	  
+	  printf("%.2x", (unsigned int) c); // now print the actual char
+	 
+	  byte_counter++;
+	  
+	  if (byte_counter == BYTES_PER_WORD)
+	    {
+	      word_counter++;
+	      byte_counter=0;
+	    }
+	  if (word_counter == WORDS_PER_LINE)
+	    {
+	      printf("\n");   
+	      word_counter = 0;
+	      starting_new_line = 1;
+	    }
+	}
+	
+	return 0;
+}	

data/examples/or1200_test/sw/board.h

@@ -0,0 +1,24 @@
+#ifndef _BOARD_H_
+#define _BOARD_H_
+
+#define MC_ENABLED	0
+
+#define IC_ENABLE 	0
+#define IC_SIZE         8192
+#define DC_ENABLE 	0
+#define DC_SIZE         8192
+
+#define IN_CLK  	50000000
+
+#define STACK_SIZE	0x00100
+
+#define UART_BAUD_RATE 	115200
+
+//#define ETH_MACADDR0	0x00
+//#define ETH_MACADDR1	0x12
+//#define ETH_MACADDR2  	0x34
+//#define ETH_MACADDR3	0x56
+//#define ETH_MACADDR4  	0x78
+//#define ETH_MACADDR5	0x9a
+
+#endif

data/examples/or1200_test/sw/compile.sh

@@ -0,0 +1,18 @@
+#!/bin/bash
+
+gcc -o bin2vmem  bin2vmem.c 
+
+or32-elf-gcc -Wall -mhard-mul -mhard-div -nostdlib -g -O0 -c -I./ int.c -o int.o
+or32-elf-gcc -Wall -mhard-mul -mhard-div -nostdlib -g -O0 -c -I./ support.c -o support.o
+or32-elf-gcc -Wall -mhard-mul -mhard-div -nostdlib -g -O0 -c -I./ main.c -o main.o
+or32-elf-gcc -Wall -mhard-mul -mhard-div -nostdlib -g -O0 -c -I./ uart.c -o uart.o
+or32-elf-gcc -Wall -mhard-mul -mhard-div -nostdlib -g -O0 -c -I./ tick.c -o tick.o
+or32-elf-gcc -Wall -mhard-mul -mhard-div -nostdlib -g -O0 -c -I./ interrupts.c -o interrupts.o
+
+or32-elf-gcc -Wall -mhard-mul -mhard-div -nostdlib -g -O0  -I./ -c -o except.o except.S
+or32-elf-gcc -Wall -mhard-mul -mhard-div -nostdlib -g -O0  -I./ -c -DIC=0 -DDC=0 -o reset.o reset.S
+
+or32-elf-ld -T orp.ld main.o uart.o support.o int.o reset.o except.o tick.o interrupts.o -o uart.or32
+or32-elf-objcopy -O binary uart.or32 uart.bin
+./bin2vmem uart.bin > uart.vmem
+

data/examples/or1200_test/sw/except.S

@@ -0,0 +1,152 @@
+#include "or1200.h"
+
+// Linked from 0x200, so subtract 0x200 from each .org
+.section .vectors, "ax" 
+
+/*
+   .org 0x100
+
+   _reset:
+   l.nop
+   l.j    _reset_except
+   l.nop
+ */
+
+/*  This cannot be a regular function because it would waste the return register r9 of the interrupted procedure. */
+/*  Furthermore, if this would be a function and l.j handler would be outside of this, the return register set here would be use upon return of this function. */
+/*  However, the desired behavior is to finish the handler and let the return of the service routine simply restore the registers and return to the interrupted procedure.  */
+#define intr_handler(handler)   \
+	l.nop                   ;\
+l.addi  r1,r1,-244          /*free 29 words (29 x 4 = 112) + 4 because stack points to contained data (stack is r1)*/;\
+/*plus 128 bytes not to mess with the previous frame pointer (32 register x 4 bytes = 128 bytes ) (required by C++ multiple threading) */;\
+l.sw    0x18(r1),r9         /*save register r9(return addr) to stack*/;\
+l.jal   store_regs          /*save registers r3-r31 (except r9) to stack (r9 is changed here)*/;\
+l.nop                       ;\
+;\
+l.movhi r9,hi(end_except)   /*set return addr to end_except instruction*/;\
+l.ori   r9,r9,lo(end_except)/*set return addr to end_except instruction*/;\
+l.j    CLABEL(handler)      ;\
+l.nop
+
+.org 0x000
+_except_200:
+intr_handler(buserr_except)
+
+	.org 0x100
+	_except_300:
+intr_handler(dpf_except)
+
+	.org 0x200
+	_except_400:
+intr_handler(ipf_except)
+
+	.org 0x300
+	_except_500:
+intr_handler(tick_except)
+
+	.org 0x400
+	_except_600:
+intr_handler(align_except)
+
+	.org 0x500
+	_except_700:
+intr_handler(illegal_except)
+
+	.org 0x600
+	_except_800:
+intr_handler(ext_except)
+
+	.org 0x700
+	_except_900:
+intr_handler(dtlbmiss_except)
+
+	.org 0x800
+	_except_a00:
+intr_handler(itlbmiss_except)
+
+	.org 0x900
+	_except_b00:
+intr_handler(range_except)
+
+	.org 0xa00
+	_except_c00:
+intr_handler(syscall_except)
+
+	.org 0xb00
+	_except_d00:
+intr_handler(res1_except)
+
+	.org 0xc00
+	_except_e00:
+intr_handler(trap_except)
+
+	.org 0xd00
+	_except_f00:
+intr_handler(res2_except)
+
+	store_regs:        //save registers r3-r31 (except r9) to stack
+	l.sw    0x00(r1),r3
+	l.sw    0x04(r1),r4
+	l.sw    0x08(r1),r5
+	l.sw    0x0c(r1),r6
+	l.sw    0x10(r1),r7
+	l.sw    0x14(r1),r8
+	l.sw    0x1c(r1),r10
+	l.sw    0x20(r1),r11
+	l.sw    0x24(r1),r12
+	l.sw    0x28(r1),r13
+	l.sw    0x2c(r1),r14
+	l.sw    0x30(r1),r15
+	l.sw    0x34(r1),r16
+	l.sw    0x38(r1),r17
+	l.sw    0x3c(r1),r18
+	l.sw    0x40(r1),r19
+	l.sw    0x44(r1),r20
+	l.sw    0x48(r1),r21
+	l.sw    0x4c(r1),r22
+	l.sw    0x50(r1),r23
+	l.sw    0x54(r1),r24
+	l.sw    0x58(r1),r25
+	l.sw    0x5c(r1),r26
+	l.sw    0x60(r1),r27
+	l.sw    0x64(r1),r28
+	l.sw    0x68(r1),r29
+	l.sw    0x6c(r1),r30
+	l.sw    0x70(r1),r31
+	l.jr    r9
+	l.nop
+
+	end_except:        //load back registers from stack r3-r31
+	l.lwz   r3,0x00(r1)
+	l.lwz   r4,0x04(r1)
+	l.lwz   r5,0x08(r1)
+	l.lwz   r6,0x0c(r1)
+	l.lwz   r7,0x10(r1)
+	l.lwz   r8,0x14(r1)
+	l.lwz   r9,0x18(r1)
+	l.lwz   r10,0x1c(r1)
+	l.lwz   r11,0x20(r1)
+	l.lwz   r12,0x24(r1)
+	l.lwz   r13,0x28(r1)
+	l.lwz   r14,0x2c(r1)
+	l.lwz   r15,0x30(r1)
+	l.lwz   r16,0x34(r1)
+	l.lwz   r17,0x38(r1)
+	l.lwz   r18,0x3c(r1)
+	l.lwz   r19,0x40(r1)
+	l.lwz   r20,0x44(r1)
+	l.lwz   r21,0x48(r1)
+	l.lwz   r22,0x4c(r1)
+	l.lwz   r23,0x50(r1)
+	l.lwz   r24,0x54(r1)
+	l.lwz   r25,0x58(r1)
+	l.lwz   r26,0x5c(r1)
+	l.lwz   r27,0x60(r1)
+	l.lwz   r28,0x64(r1)
+	l.lwz   r29,0x68(r1)
+	l.lwz   r30,0x6c(r1)
+l.lwz   r31,0x70(r1)
+	l.addi  r1,r1,244                //free stack places
+	l.rfe                            //recover SR register and prior PC (jumps back to program)
+	l.nop
+

data/examples/or1200_test/sw/int.c

@@ -0,0 +1,79 @@
+/* This file is part of test microkernel for OpenRISC 1000. */
+/* (C) 2001 Simon Srot, srot@opencores.org */
+
+#include "support.h"
+#include "or1200.h"
+#include "int.h"
+
+/* Interrupt handlers table */
+struct ihnd int_handlers[MAX_INT_HANDLERS];
+
+/* Initialize routine */
+int int_init()
+{
+	int i;
+
+	for(i = 0; i < MAX_INT_HANDLERS; i++) {
+		int_handlers[i].handler = 0;
+		int_handlers[i].arg = 0;
+	}
+	mtspr(SPR_PICMR, 0x00000000);
+
+	//set OR1200 to accept exceptions
+	mtspr(SPR_SR, mfspr(SPR_SR) | SPR_SR_IEE);
+
+	return 0;
+}
+
+/* Add interrupt handler */ 
+int int_add(unsigned long vect, void (* handler)(void *), void *arg)
+{
+	if(vect >= MAX_INT_HANDLERS)
+		return -1;
+
+	int_handlers[vect].handler = handler;
+	int_handlers[vect].arg = arg;
+
+	mtspr(SPR_PICMR, mfspr(SPR_PICMR) | (0x00000001L << vect));
+
+	return 0;
+}
+
+/* Disable interrupt */ 
+int int_disable(unsigned long vect)
+{
+	if(vect >= MAX_INT_HANDLERS)
+		return -1;
+
+	mtspr(SPR_PICMR, mfspr(SPR_PICMR) & ~(0x00000001L << vect));
+
+	return 0;
+}
+
+/* Enable interrupt */ 
+int int_enable(unsigned long vect)
+{
+	if(vect >= MAX_INT_HANDLERS)
+		return -1;
+
+	mtspr(SPR_PICMR, mfspr(SPR_PICMR) | (0x00000001L << vect));
+
+	return 0;
+}
+
+/* Main interrupt handler */
+void int_main()
+{
+	unsigned long picsr = mfspr(SPR_PICSR);   //process only the interrupts asserted at signal catch, ignore all during process
+	unsigned long i = 0;
+
+	while(i < 32) {
+		if((picsr & (0x01L << i)) && (int_handlers[i].handler != 0)) {
+			(*int_handlers[i].handler)(int_handlers[i].arg); 
+		}
+		i++;
+	}
+
+	mtspr(SPR_PICSR, 0);      //clear interrupt status: all modules have level interrupts, which have to be cleared by software,
+}                           //thus this is safe, since non processed interrupts will get re-asserted soon enough
+