SEP6200 Support

bsp/sep6200/SConscript

+from building import *
+
+cwd  = GetCurrentDir()
+objs = []
+list = os.listdir(cwd)
+
+for d in list:
+    path = os.path.join(cwd, d)
+    if os.path.isfile(os.path.join(path, 'SConscript')):
+        objs = objs + SConscript(os.path.join(d, 'SConscript'))
+
+Return('objs')

bsp/sep6200/SConstruct

+import os
+import sys
+import rtconfig
+
+if os.getenv('RTT_ROOT'):
+    RTT_ROOT = os.getenv('RTT_ROOT')
+else:
+    RTT_ROOT = os.path.normpath(os.getcwd() + '/../..')
+
+sys.path = sys.path + [os.path.join(RTT_ROOT, 'tools')]
+from building import *
+
+TARGET = 'rtthread-sep6200.' + rtconfig.TARGET_EXT
+
+env = Environment(tools = ['mingw'],
+	AS = rtconfig.AS, ASFLAGS = rtconfig.AFLAGS,
+	CC = rtconfig.CC, CCFLAGS = rtconfig.CFLAGS,
+	AR = rtconfig.AR, ARFLAGS = '-rc',
+	LINK = rtconfig.LINK, LINKFLAGS = rtconfig.LFLAGS)
+env.PrependENVPath('PATH', rtconfig.EXEC_PATH)
+
+env.Replace(LINKCOM = ['$LINK $SOURCES $LINKFLAGS -o $TARGET'])
+Export('RTT_ROOT')
+Export('rtconfig')
+
+# prepare building environment
+objs = PrepareBuilding(env, RTT_ROOT)
+
+# build program
+env.Program(TARGET, objs)
+
+# end building
+EndBuilding(TARGET)

bsp/sep6200/application/SConscript

+from building import *
+
+cwd = GetCurrentDir()
+src	= Glob('*.c')
+CPPPATH = [cwd, str(Dir('#'))]
+
+group = DefineGroup('Applications', src, depend = [''], CPPPATH = CPPPATH)
+
+Return('group')

bsp/sep6200/application/application.c

+/*
+ * File      : application.c
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2006 - 2012, RT-Thread Development Team
+ *
+ * The license and distribution terms for this file may be
+ * found in the file LICENSE in this distribution or at
+ * http://www.rt-thread.org/license/LICENSE
+ *
+ * Change Logs:
+ * Date           Author		Notes
+ * 2007-11-20     Yi.Qiu		add rtgui application
+ * 2008-6-28      Bernard		no rtgui init
+ * 2013-7-14      Peng Fan  modified from mini4020
+ */
+
+/**
+ * @addtogroup sep6200
+ */
+
+/*@{*/
+
+#include "board.h"
+#include <rtthread.h>
+
+#ifdef RT_USING_DFS
+#include <dfs_init.h>
+#include <dfs_elm.h>
+#include <dfs_fs.h>
+#include <dfs_posix.h>
+#endif
+
+#ifdef RT_USING_RTGUI
+#include <rtgui/rtgui.h>
+extern void radio_rtgui_init(void);
+#endif
+
+#define RT_INIT_THREAD_STACK_SIZE (2*1024)
+
+void rt_init_thread_entry(void *parameter)
+{
+  while(1){
+    rt_thread_sleep(200);
+    rt_hw_console_output("init thread\n");
+  }
+}
+
+void rt_test1_thread_entry(void *parameter)
+{
+  while(1){
+    rt_thread_sleep(800);
+    rt_hw_console_output("test1 thread\n");
+  }
+}
+
+void rt_test2_thread_entry(void *parameter)
+{
+  while(1){
+    rt_thread_sleep(300);
+    rt_hw_console_output("test2 thread\n");
+  }
+}
+
+int rt_application_init(void)
+{
+	rt_thread_t init_thread;
+	rt_thread_t test1_thread;
+	rt_thread_t test2_thread;
+
+	init_thread = rt_thread_create("init",
+								rt_init_thread_entry, RT_NULL,
+								RT_INIT_THREAD_STACK_SIZE, 8, 20);
+
+	test1_thread = rt_thread_create("test1",
+								rt_test1_thread_entry, RT_NULL,
+								512, 200, 20);
+	test2_thread = rt_thread_create("test2",
+								rt_test2_thread_entry, RT_NULL,
+								512, 200, 20);
+
+	if (init_thread != RT_NULL)
+		rt_thread_startup(init_thread);
+
+	if (test1_thread != RT_NULL)
+		rt_thread_startup(test1_thread);
+
+	if (test2_thread != RT_NULL)
+		rt_thread_startup(test2_thread);
+
+	return 0;
+}
+
+/*@}*/

bsp/sep6200/application/startup.c

+/*
+ * File      : application.c
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2009 - 2012, RT-Thread Development Team
+ *
+ * The license and distribution terms for this file may be
+ * found in the file LICENSE in this distribution or at
+ * http://www.rt-thread.org/license/LICENSE
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2013-7-14      Peng Fan     Modified from mini4020
+ */
+
+#include <rthw.h>
+#include <rtthread.h>
+
+#include <board.h>
+#include <serial.h>
+#ifdef RT_USING_FINSH
+#include <finsh.h>
+#endif
+
+#ifdef RT_USING_LWIP
+#include <lwip/sys.h>
+#include <netif/ethernetif.h>
+#endif
+
+#include <sep6200.h>
+
+rt_uint8_t _irq_stack_start[1024];
+rt_uint8_t _fiq_stack_start[1024];
+rt_uint8_t _undefined_stack_start[512];
+rt_uint8_t _abort_stack_start[512];
+rt_uint8_t _priv_stack_start[4096]; SECTION(".nobss");
+extern unsigned char __bss_start;
+extern unsigned char __bss_end;
+
+
+extern void rt_hw_board_init(void);
+extern void rt_application_init(void);
+extern void finsh_system_init(void);
+extern void sd_init(void);
+
+void rtthread_startup()
+{
+	/* init hardware interrupt */
+	rt_hw_interrupt_init();
+
+	/* init board */
+	rt_hw_board_init();
+
+	/* show version */
+	rt_show_version();
+
+	/* init tick */
+	rt_system_tick_init();
+
+	/* init kernel object */
+	rt_system_object_init();
+
+	/* init timer system */
+	rt_system_timer_init();
+
+	/* init heap memory system */
+	rt_system_heap_init(&__bss_end, (void*)0x45000000);
+
+	/* init scheduler system */
+	rt_system_scheduler_init();
+
+#ifdef RT_USING_DEVICE
+
+#ifdef RT_USING_DFS
+	rt_hw_sdcard_init();
+#endif
+
+#ifdef RT_USING_LWIP
+	eth_system_device_init();
+	rt_hw_dm9000_init();
+#endif
+
+	/*init all registed devices */
+	rt_device_init_all();
+#endif
+
+	/* init application */
+	rt_application_init();
+
+#ifdef RT_USING_FINSH
+	/* init finsh */
+	finsh_system_init();
+#ifdef RT_USING_DEVICE
+	finsh_set_device("uart0");
+#endif
+#endif
+
+  rt_system_timer_thread_init();
+
+	/* init idle thread */
+	rt_thread_idle_init();
+
+	/* start scheduler */
+	rt_system_scheduler_start();
+
+	/* never reach here */
+	return ;
+
+}
+
+int main()
+{
+	rt_uint32_t UNUSED level;
+
+	/* disable interrupt first */
+	level = rt_hw_interrupt_disable();
+
+	/* startup RT-Thread RTOS */
+	rtthread_startup();
+
+	return 0;
+}

bsp/sep6200/board.h

+/*
+ * File      : board.h
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2009 - 2012, RT-Thread Development Team
+ *
+ * The license and distribution terms for this file may be
+ * found in the file LICENSE in this distribution or at
+ * http://www.rt-thread.org/license/LICENSE
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2006-10-08     Bernard      add board.h to this bsp
+ * 2010-10-5      Wangmeng     sep4020 implemention
+ * 2013-7-14      Peng Fan     Modified from sep4020
+ */
+
+#ifndef __BOARD_H__
+#define __BOARD_H__
+
+#include <sep6200.h>
+
+void rt_hw_board_init(void);
+void rt_hw_sdcard_init(void);
+
+#endif

bsp/sep6200/drivers/SConscript

+from building import *
+
+cwd = GetCurrentDir()
+src = Glob('*.c')
+
+# remove no need file.
+if GetDepend('RT_USING_LWIP') == False:
+    SrcRemove(src, 'dm9161.c')
+if GetDepend('RT_USING_DFS') == False:
+    SrcRemove(src, 'sdcard.c')
+if GetDepend('RT_USING_RTGUI') == False:
+    SrcRemove(src, 'lcd.c')
+    SrcRemove(src, 'lcdc.c')
+
+CPPPATH = [cwd]
+
+group = DefineGroup('Drivers', src, depend = [''], CPPPATH = CPPPATH)
+
+Return('group')

bsp/sep6200/drivers/board.c

+/*
+ * File		: board.c
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2006 - 2012 RT-Thread Develop Team
+ *
+ * The license and distribution terms for this file may be
+ * found in the file LICENSE in this distribution or at
+ * http://openlab.rt-thread.com/license/LICENSE
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2013-7-14      Peng Fan     sep6200 implementation
+ */
+
+#include <rthw.h>
+#include <rtthread.h>
+
+#include <serial.h>
+
+#include <sep6200.h>
+
+void rt_hw_serial_putc(const char c);
+
+#define UART0	((struct uartport *)SEP6200_UART0_BASE)
+
+struct rt_device uart0_device;
+struct serial_int_rx uart0_int_rx;
+struct serial_device uart0 =
+{
+	UART0,
+	&uart0_int_rx,
+  RT_NULL
+};
+
+/*
+ * This function will handle rtos timer
+ */
+void rt_timer_handler(int vector, void *param)
+{
+	rt_uint32_t clear_int;
+
+	/* clear timer interrupt */
+	if (read_reg(SEP6200_TIMER_T2IMSR) & 0x1)
+		clear_int = read_reg(SEP6200_TIMER_T2ISCR);
+
+	rt_tick_increase();
+}
+
+/*
+ * This function will handle serial interrupt
+ */
+#if 1
+void rt_serial_handler(int vector, void *param)
+{
+	rt_uint32_t num;
+	switch (vector) {
+		case INTSRC_UART0:
+
+      /*No interrupt*/
+			if ((*(RP)SEP6200_UART0_IIR & 0x1))
+				return;
+
+      /*Get the serial interrupt num*/
+			num = (*(RP)SEP6200_UART0_IIR >> 1) & 0x7;
+
+      /*Receive or timeout*/
+      if ((num == 6) || (num == 2))
+			  rt_hw_serial_isr(&uart0_device);
+			break;
+		/*1,2,3 not implemented now, do in future*/
+		case INTSRC_UART1:
+			break;
+		case INTSRC_UART2:
+			break;
+		case INTSRC_UART3:
+			break;
+	}
+}
+#endif
+
+/*
+ * This function will init timer2 for system ticks
+ */
+
+#define BUS4_FREQ	320000000UL
+#define TIMER_CLK	BUS4_FREQ
+#define HZ 100
+void rt_hw_timer_init(void)
+{
+	*(RP)SEP6200_TIMER_T2LCR = (TIMER_CLK + HZ / 2) / HZ;
+	*(RP)SEP6200_TIMER_T2CR	 = 0x6;
+
+	rt_hw_interrupt_install(INTSRC_TIMER1, rt_timer_handler, RT_NULL, "timer");
+	rt_hw_interrupt_umask(INTSRC_TIMER1);
+
+	/* start the timer */
+	*(RP)SEP6200_TIMER_T2CR |= 0x1;
+}
+
+/*
+ * This function will init uart
+ */
+#define UART_CLK 60000000UL
+void rt_hw_uart_init(void)
+{
+	const rt_uint32_t uartclk = UART_CLK;
+
+	*(RP)(SEP6200_UART0_LCR) = 0x83;
+	*(RP)(SEP6200_UART0_DLBH) = (uartclk/16/115200) >> 8;
+	*(RP)(SEP6200_UART0_DLBL) = (uartclk/16/115200) & 0xff;
+	*(RP)(SEP6200_UART0_LCR) = 0x83 & (~(0x1 << 7));
+
+	*(RP)(SEP6200_UART0_FCR) = 0x0;
+	*(RP)(SEP6200_UART0_MCR) = 0x0;
+
+	*(RP)(SEP6200_UART0_IER) = 0x0;
+	/* Enable rx interrupt*/
+	*(RP)(SEP6200_UART0_IER) |= 0x1;
+	/* Disable tx interrupt*/
+	*(RP)(SEP6200_UART0_IER) &= ~(0x1 << 1);
+
+	rt_hw_interrupt_install(INTSRC_UART0, rt_serial_handler, RT_NULL, "uart0");
+	rt_hw_interrupt_umask(INTSRC_UART0);
+
+	rt_hw_serial_register(&uart0_device, "uart0",
+			RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX | RT_DEVICE_FLAG_STREAM,
+			&uart0);
+}
+
+void rt_hw_board_init(void)
+{
+  int i = 0;
+	rt_hw_uart_init();
+	rt_hw_timer_init();
+}
+
+/*
+ * Write one char to serial, must not trigger interrupt
+ */
+void rt_hw_serial_putc(const char c)
+{
+	if (c == '\n')
+		rt_hw_serial_putc('\r');
+
+	while (!((*(RP)SEP6200_UART0_LSR) & 0x40));
+
+	*(RP)(SEP6200_UART0_TXFIFO) = c;
+}
+
+void printhex(unsigned int data)
+{
+	int i = 0,a = 0;
+	for (i = 0; i < 8; i++) {
+		a = (data>>(32-(i+1)*4))&0xf;
+		if (((a<=9)&&(a>=0)))
+			rt_hw_serial_putc(a + 0x30);
+		else if ((a <= 0xf) && (a >= 0xa))
+			rt_hw_serial_putc(a-0xa+0x61);
+	}
+	rt_hw_serial_putc('\n');
+}
+
+/**
+* This function is used by rt_kprintf to display a string on console.
+*
+* @param str the displayed string^M
+*/
+void rt_hw_console_output(const char *str)
+{
+  while (*str) {
+    rt_hw_serial_putc(*str++);
+  }
+}

bsp/sep6200/rtconfig.h

+/* RT-Thread config file */
+#ifndef __RTTHREAD_CFG_H__
+#define __RTTHREAD_CFG_H__
+
+#define RT_DEBUG
+//#define RT_DEBUG_IRQ 1
+//#define RT_DEBUG_TIMER 1
+
+//#define RT_DEBUG_MEM                   1
+//#define RT_DEBUG_MEMHEAP               1
+//#define RT_DEBUG_MODULE                1
+//#define RT_DEBUG_SCHEDULER             1
+//#define RT_DEBUG_SLAB                  1
+//#define RT_DEBUG_THREAD                1
+//#define RT_DEBUG_IPC                   1
+
+/* RT_NAME_MAX*/
+#define RT_NAME_MAX	8
+
+/* RT_ALIGN_SIZE*/
+#define RT_ALIGN_SIZE	4
+
+/* PRIORITY_MAX */
+#define RT_THREAD_PRIORITY_MAX	256
+
+/* Tick per Second */
+#define RT_TICK_PER_SECOND	100
+
+/* SECTION: RT_DEBUG */
+/* Thread Debug */
+#define RT_DEBUG
+/* #define RT_THREAD_DEBUG */
+
+#define RT_USING_OVERFLOW_CHECK
+
+/* Using Hook */
+#define RT_USING_HOOK
+
+/* Using Software Timer */
+//#define RT_USING_TIMER_SOFT
+#define RT_TIMER_THREAD_PRIO		8
+#define RT_TIMER_THREAD_STACK_SIZE	512
+#define RT_TIMER_TICK_PER_SECOND	10
+
+/* SECTION: IPC */
+/* Using Semaphore */
+#define RT_USING_SEMAPHORE
+
+/* Using Mutex */
+#define RT_USING_MUTEX
+
+/* Using Event */
+#define RT_USING_EVENT
+
+/* Using MailBox */
+#define RT_USING_MAILBOX
+
+/* Using Message Queue */
+#define RT_USING_MESSAGEQUEUE
+
+/* SECTION: Memory Management */
+/* Using Memory Pool Management*/
+#define RT_USING_MEMPOOL
+
+/* Using Dynamic Heap Management */
+#define RT_USING_HEAP
+
+/* Using Small MM */
+/* #define RT_USING_SMALL_MEM */
+
+/* Using SLAB Allocator */
+#define RT_USING_SLAB
+
+#define RT_USING_CONSOLE
+/* SECTION: Device System */
+/* Using Device System */
+#define RT_USING_DEVICE
+
+/* SECTION: Console options */
+/* the buffer size of console */
+#define RT_CONSOLEBUF_SIZE	128
+
+/* SECTION: finsh, a C-Express shell */
+/* Using FinSH as Shell*/
+#define RT_USING_FINSH
+#define FINSH_USING_SYMTAB
+#define FINSH USING DESCRIPTION
+
+/* SECTION: a runtime libc library */
+/* a runtime libc library */
+/* #define RT_USING_NEWLIB */
+
+/* SECTION: a mini libc */
+
+/* SECTION: C++ support */
+/* Using C++ support */
+/* #define RT_USING_CPLUSPLUS */
+
+/* SECTION: Device filesystem support */
+/* using DFS support */
+//#define RT_USING_DFS //fanpeng
+//#define RT_USING_DFS_ELMFAT //fanpeng
+/* #define RT_USING_DFS_YAFFS2 */
+
+/* #define DFS_USING_WORKDIR */
+
+/* the max number of mounted filesystem */
+#define DFS_FILESYSTEMS_MAX		2
+/* the max number of opened files 		*/
+#define DFS_FD_MAX					16
+/* the max number of cached sector 		*/
+#define DFS_CACHE_MAX_NUM   		4
+
+/* SECTION: lwip, a lighwight TCP/IP protocol stack */
+/* Using lighweight TCP/IP protocol stack */
+//#define RT_USING_LWIP
+//#define RT_LWIP_DNS
+
+/* Trace LwIP protocol */
+/* #define RT_LWIP_DEBUG */
+
+/* Enable ICMP protocol */
+#define RT_LWIP_ICMP
+
+/* Enable IGMP protocol */
+#define RT_LWIP_IGMP
+
+/* Enable UDP protocol */
+#define RT_LWIP_UDP
+
+/* Enable TCP protocol */
+#define RT_LWIP_TCP
+
+/* the number of simulatenously active TCP connections*/
+#define RT_LWIP_TCP_PCB_NUM	5
+
+/* TCP sender buffer space */
+#define RT_LWIP_TCP_SND_BUF	1024*10
+
+/* TCP receive window. */
+#define RT_LWIP_TCP_WND	1024
+
+/* Enable SNMP protocol */
+/* #define RT_LWIP_SNMP */
+
+/* Using DHCP */
+/* #define RT_LWIP_DHCP */
+
+/* ip address of target */
+#define RT_LWIP_IPADDR0	192
+#define RT_LWIP_IPADDR1	168
+#define RT_LWIP_IPADDR2	1
+#define RT_LWIP_IPADDR3	30
+
+/* gateway address of target */
+#define RT_LWIP_GWADDR0	192
+#define RT_LWIP_GWADDR1	168
+#define RT_LWIP_GWADDR2	1
+#define RT_LWIP_GWADDR3	1
+
+/* mask address of target */
+#define RT_LWIP_MSKADDR0	255
+#define RT_LWIP_MSKADDR1	255
+#define RT_LWIP_MSKADDR2	255
+#define RT_LWIP_MSKADDR3	0
+
+/* the number of blocks for pbuf */
+#define RT_LWIP_PBUF_NUM	16
+
+/* thread priority of tcpip thread */
+#define RT_LWIP_TCPTHREAD_PRIORITY	128
+
+/* mail box size of tcpip thread to wait for */
+#define RT_LWIP_TCPTHREAD_MBOX_SIZE	8
+
+/* thread stack size of tcpip thread */
+#define RT_LWIP_TCPTHREAD_STACKSIZE	4096
+
+/* thread priority of ethnetif thread */
+#define RT_LWIP_ETHTHREAD_PRIORITY	144
+
+/* mail box size of ethnetif thread to wait for */
+#define RT_LWIP_ETHTHREAD_MBOX_SIZE	32
+
+/* thread stack size of ethnetif thread */
+#define RT_LWIP_ETHTHREAD_STACKSIZE	1024
+
+/* SECTION: RTGUI support */
+/* using RTGUI support */
+/* #define RT_USING_RTGUI */
+
+/* name length of RTGUI object */
+#define RTGUI_NAME_MAX		16
+/* support 16 weight font */
+#define RTGUI_USING_FONT16
+/* support 16 weight font */
+#define RTGUI_USING_FONT12
+/* support Chinese font */
+#define RTGUI_USING_FONTHZ
+/* use DFS as file interface */
+#define RTGUI_USING_DFS_FILERW
+/* use font file as Chinese font */
+/* #define RTGUI_USING_HZ_FILE */
+/* use Chinese bitmap font */
+#define RTGUI_USING_HZ_BMP
+/* use small size in RTGUI */
+/* #define RTGUI_USING_SMALL_SIZE */
+/* use mouse cursor */
+/* #define RTGUI_USING_MOUSE_CURSOR */
+#endif

bsp/sep6200/rtconfig.py

+import os
+
+# toolchains options
+ARCH     = 'unicore32'
+CPU      = 'sep6200'
+TextBase = '0x00000000'
+
+CROSS_TOOL 	= 'gcc'
+
+if os.getenv('RTT_CC'):
+	CROSS_TOOL = os.getenv('RTT_CC')
+
+if  CROSS_TOOL == 'gcc':
+	PLATFORM 	= 'gcc'
+	EXEC_PATH 	= '/usr/unicore/gnu-toolchain-unicore/uc4-1.0-beta-hard-RHELAS5/bin/'
+elif CROSS_TOOL == 'keil':
+	PLATFORM 	= 'armcc'
+	EXEC_PATH 	= 'C:/Keil'
+elif CROSS_TOOL == 'iar':
+    print '================ERROR============================'
+    print 'Not support yet!'
+    print '================================================='
+    exit(0)
+
+if os.getenv('RTT_EXEC_PATH'):
+	EXEC_PATH = os.getenv('RTT_EXEC_PATH')
+
+#BUILD = 'debug'
+BUILD = 'release'
+
+if PLATFORM == 'gcc':
+    # toolchains
+    PREFIX = 'unicore32-linux-'
+    CC = PREFIX + 'gcc'
+    AS = PREFIX + 'gcc'
+    AR = PREFIX + 'ar'
+    LINK = PREFIX + 'ld'
+    TARGET_EXT = 'elf'
+    SIZE = PREFIX + 'size'
+    OBJDUMP = PREFIX + 'objdump'
+    OBJCPY = PREFIX + 'objcopy'
+
+    DEVICE = ' '
+    CFLAGS = DEVICE
+    AFLAGS = ' -c' + DEVICE + ' -x assembler-with-cpp' + ' -DTEXT_BASE=' + TextBase
+    LFLAGS = DEVICE + ' -Bstatic --gc-sections -Map=rtthread_sep6200.map -cref -u _start -Ttext 0x40000000 -T sep6200.ld -L/usr/unicore/gnu-toolchain-unicore/uc4-1.0-beta-hard-RHELAS5/lib/gcc/unicore32-linux/4.4.2 -lgcc' + ' -Ttext ' + TextBase
+
+    CPATH = ''
+    LPATH = ''
+
+    if BUILD == 'debug':
+        CFLAGS += ' -O0 -gdwarf-2'
+        AFLAGS += ' -gdwarf-2'
+    else:
+        CFLAGS += ' -O2'
+
+    POST_ACTION = OBJCPY + ' -O binary $TARGET rtthread.bin\n' + SIZE + ' $TARGET \n'

bsp/sep6200/sep6200.ld

+OUTPUT_FORMAT("elf32-littleunicore32", "elf32-bigunicore32", "elf32-littleunicore32")
+OUTPUT_ARCH(unicore32)
+ENTRY(_start)
+SEARCH_DIR("/usr/unicore/gnu-toolchain-unicore/uc4-1.0-beta-hard-RHELAS5/unicore32-linux/lib");
+SECTIONS
+{
+	. = 0x00000000;
+
+	. = ALIGN(4);
+	.text :
+	{
+		*(.init)
+		*(.text)
+		*(.gnu.linkonce.t*)
+
+		/* section information for finsh shell */
+		. = ALIGN(4);
+		__fsymtab_start = .;
+		KEEP(*(FSymTab))
+		__fsymtab_end = .;
+		. = ALIGN(4);
+		__vsymtab_start = .;
+		KEEP(*(VSymTab))
+		__vsymtab_end = .;
+		. = ALIGN(4);
+
+		/* section information for modules */
+		. = ALIGN(4);
+		__rtmsymtab_start = .;
+		KEEP(*(RTMSymTab))
+		__rtmsymtab_end = .;
+	}
+
+	. = ALIGN(4);
+	.rodata : { *(.rodata) *(.rodata.*) *(.gnu.linkonce.r*) *(.eh_frame) }
+
+	. = ALIGN(4);
+	.ctors :
+	{
+		PROVIDE(__ctors_start__ = .);
+		KEEP(*(SORT(.ctors.*)))
+		KEEP(*(.ctors))
+		PROVIDE(__ctors_end__ = .);
+	}
+
+	.dtors :
+	{
+		PROVIDE(__dtors_start__ = .);
+		KEEP(*(SORT(.dtors.*)))
+		KEEP(*(.dtors))
+		PROVIDE(__dtors_end__ = .);
+	}
+
+	. = ALIGN(4);
+	.data :
+	{
+		*(.data)
+		*(.data.*)
+		*(.gnu.linkonce.d*)
+	}
+
+	. = ALIGN(4);
+	.nobss : { *(.nobss) }
+
+  /*. = 0x00300000*/
+	. = ALIGN(4);
+	__bss_start = .;
+	.bss : { *(.bss) }
+	__bss_end = .;
+
+	/* stabs debugging sections. */
+	.stab 0 : { *(.stab) }
+	.stabstr 0 : { *(.stabstr) }
+	.stab.excl 0 : { *(.stab.excl) }
+	.stab.exclstr 0 : { *(.stab.exclstr) }
+	.stab.index 0 : { *(.stab.index) }
+	.stab.indexstr 0 : { *(.stab.indexstr) }
+	.comment 0 : { *(.comment) }
+	.debug_abbrev 0 : { *(.debug_abbrev) }
+	.debug_info 0 : { *(.debug_info) }
+	.debug_line 0 : { *(.debug_line) }
+	.debug_pubnames 0 : { *(.debug_pubnames) }
+	.debug_aranges 0 : { *(.debug_aranges) }
+
+	_end = .;
+}

libcpu/unicore32/sep6200/clk.c

+/*
+ * File      : clock.c
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2006, RT-Thread Development Team
+ *
+ * The license and distribution terms for this file may be
+ * found in the file LICENSE in this distribution or at
+ * http://openlab.rt-thread.com/license/LICENSE
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2013-7-16      Peng Fan     Just put the file here, should be implemented in
+ *                             future
+ */
+
+#include <rtthread.h>
+#include <sep6200.h>
+
+#define PLL_CFG(_f, _r) {.f = _f, .r = _r} /*f(frequency, MHz); r(config register value)*/
+#define MHz	1000000UL
+/*
+*SEP0611_CLOCK
+*├── APLL
+*│   └── CPU
+*├── DPLL
+*│   └── DDR
+*└── MPLL
+*    └── BUS1
+*        ├── BUS2
+*        │   ├── DMAC1
+*        │   ├── ESRAM
+*        │   ├── LCDC
+*        │   ├── NAND
+*        │   ├── NOR
+*        │   ├── SDIO1
+*        │   ├── SDIO2
+*        │   └── VPU
+*        ├── BUS3
+*        │   ├── BUS5
+*        │   │   ├── I2C1
+*        │   │   ├── I2C2
+*        │   │   ├── I2C3
+*        │   │   ├── I2S
+*        │   │   ├── SPI1
+*        │   │   ├── SPI2
+*        │   │   ├── SPI3
+*        │   │   ├── UART1
+*        │   │   ├── UART2
+*        │   │   ├── UART3
+*        │   │   └── UART4
+*        │   ├── DMAC2
+*        │   ├── GPU
+*        │   └── USB
+*        ├── BUS4
+*        │   ├── GPIO
+*        │   ├── GPSCTRL
+*        │   ├── PWM
+*        │   ├── RTC
+*        │   ├── SYSCTRL
+*        │   ├── TIMER
+*        │   └── VIC
+*        ├── DS1_2
+*        ├── DS1_3
+*        └── GPS
+*/
+
+enum sep0611_clk_gate{
+  DDRC = 0, BUS1, BUS2, BUS3, DS1_2,
+  DS1_3, USBC, DMAC1, NAND, DMAC2,
+  ESRAM, SDIO1, SDIO2, GPU, VPU,
+  BUS4, BUS5, VIC_, SYSCTRL, PRTC,
+  TIMER, GPSCTRL, GPIO, LCDC2HDMI, DDRPHY,
+  UART1, UART2, UART3, UART4, SPI1,
+  SPI2, SPI3,
+
+  I2C1 = 32, I2C2, I2C3, I2S, PWM,
+  H2X, LCDC, NOR, GPSHCLK, GPS,
+};
+
+typedef struct {
+	unsigned long f;
+	unsigned long r;
+}pll_t;
+
+static pll_t apll_tab[] = {
+  PLL_CFG(800*MHz, 0x00010810),
+};
+
+static pll_t mpll_tab[] = {
+  PLL_CFG(480*MHz, 0x00013C12),   // 480MHz
+};
+
+static pll_t dpll_tab[] = {
+  PLL_CFG(400*MHz, 0x00010812),   // 402MHz
+};
+
+static void rt_hw_set_system_clock(void)
+{
+  /*apll, mpll, dpll is set in uboot when system boots up*/
+}
+
+static void rt_hw_set_usb_clock(void)
+{
+
+}
+
+static void rt_hw_set_peripheral_clock(void)
+{
+
+}
+/**
+ * @brief System Clock Configuration
+ */
+/* apll mpll dpll should be set in u-boot, Here just set clock
+ * of the pherial
+ */
+void rt_hw_set_apll_clock(void)
+{
+
+}
+void rt_hw_set_mpll_clock(void)
+{
+
+}
+void rt_hw_set_dpll_clock(void)
+{
+
+}
+void rt_hw_clock_init(void)
+{
+	/* set system clock */
+	rt_hw_set_system_clock();
+}
+
+/**
+ * @brief Get system clock
+ */
+rt_uint32_t rt_hw_get_clock(void)
+{
+}
+
+/**
+ * @brief Enable module clock
+ */
+void rt_hw_enable_module_clock(rt_uint8_t module)
+{
+  if (module >= 32) {
+    write_reg(SEP6200_PMU_CLK_GT_CFG2, (1 << (module - 32)) | read_reg(SEP6200_PMU_CLK_GT_CFG2));
+  } else {
+    write_reg(SEP6200_PMU_CLK_GT_CFG1, (1 << module) | read_reg(SEP6200_PMU_CLK_GT_CFG1));
+  }
+}
+
+/**
+ * @brief Disable module clock
+ */
+void rt_hw_disable_module_clock(rt_uint8_t module)
+{
+  if (module >= 32) {
+    write_reg(SEP6200_PMU_CLK_GT_CFG2, ~(1 << (module - 32)) & read_reg(SEP6200_PMU_CLK_GT_CFG2));
+  } else {
+    write_reg(SEP6200_PMU_CLK_GT_CFG1, ~(1 << module) & read_reg(SEP6200_PMU_CLK_GT_CFG1));
+  }
+}

libcpu/unicore32/sep6200/context_gcc.S

+/*
+ * File      : context.S
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2006, RT-Thread Development Team
+ *
+ * The license and distribution terms for this file may be
+ * found in the file LICENSE in this distribution or at
+ * http://openlab.rt-thread.com/license/LICENSE
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2013-7-14      Peng Fan     First implementation
+ */
+
+/*!
+ * \addtogroup sep6200
+ */
+/*@{*/
+
+#define NOINT			0xc0
+
+/*
+ * rt_base_t rt_hw_interrupt_disable();
+ */
+.globl rt_hw_interrupt_disable
+.type rt_hw_interrupt_disable, %function
+rt_hw_interrupt_disable:
+  stw.w   r1, [sp-], #4
+	mov    	r0, asr
+	or    	r1, r0, #NOINT
+	mov.a 	asr, r1
+  ldw.w   r1, [sp]+, #4
+	mov	    pc, lr
+
+/*
+ * void rt_hw_interrupt_enable(rt_base_t level);
+ */
+.globl rt_hw_interrupt_enable
+.type rt_hw_interrupt_disable, %function
+rt_hw_interrupt_enable:
+	mov.a asr, r0
+	mov pc, lr
+
+/*
+ * void rt_hw_context_switch(rt_uint32 from, rt_uint32 to);
+ * r0 --> from
+ * r1 --> to
+ */
+.globl rt_hw_context_switch
+.type rt_hw_interrupt_disable, %function
+rt_hw_context_switch:
+	stm.w   (lr), [sp-]
+	stm.w	(r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, lr), [sp-]
+	stm.w	(r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15),  [sp-]
+	mov	r4, asr
+	stm.w	(r4), [sp-]
+	mov 	r4, bsr
+	stm.w	(r4), [sp-]
+
+	stw	sp, [r0+]
+	ldw	sp, [r1+]
+
+	ldm.w	(r4), [sp]+
+	mov.a	bsr,r4
+	ldm.w	(r4), [sp]+
+	mov.a	asr, r4
+
+	ldm.w	(r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15), [sp]+
+	ldm.w	(r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, lr, pc), [sp]+
+
+/*
+ * void rt_hw_context_switch_to(rt_uint32 to);
+ * r0 --> to
+ */
+.globl rt_hw_context_switch_to
+rt_hw_context_switch_to:
+	ldw	sp, [r0+]
+	ldm.w	(r4), [sp]+
+	mov.a	bsr, r4
+	ldm.w	(r4), [sp]+
+	mov.a	asr, r4
+	ldm.w	(r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15), [sp]+
+	ldm.w	(r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, lr, pc), [sp]+
+
+/*
+ * void rt_hw_context_switch_interrupt(rt_uint32 from, rt_uint32 to);
+ */
+.globl rt_thread_switch_interrupt_flag
+.globl rt_interrupt_from_thread
+.globl rt_interrupt_to_thread
+.globl rt_hw_context_switch_interrupt
+rt_hw_context_switch_interrupt:
+	ldw r2, =rt_thread_switch_interrupt_flag
+	ldw r3, [r2+]
+	cmpsub.a r3, #1
+	beq _reswitch
+	mov r3, #1
+	stw r3, [r2+]
+	ldw r2, =rt_interrupt_from_thread
+	stw r0, [r2+]
+_reswitch:
+	ldw r2, =rt_interrupt_to_thread
+	stw r1, [r2+]
+	mov pc, lr

libcpu/unicore32/sep6200/cpu.c

+/*
+ * File      : cpu.c
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2006, RT-Thread Develop Team
+ *
+ * The license and distribution terms for this file may be
+ * found in the file LICENSE in this distribution or at
+ * http://openlab.rt-thread.com/license/LICENSE
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2013-7-14      Peng Fan     first implementation
+ */
+
+#include <rthw.h>
+#include <rtthread.h>
+#include <sep6200.h>
+
+/**
+ * @addtogroup sep6200
+ */
+/*@{*/
+
+#ifdef __GNUC__
+rt_inline void cache_invalid(void)
+{
+	__asm__ volatile ("movc	p0.c5, r1, #28\n"
+			"nop;nop;nop;nop;nop;nop;nop;nop;\n"
+			:
+			:
+			:"memory", "cc"
+			);
+}
+
+rt_inline void cache_enable(void)
+{
+	__asm__ volatile ( "movc r1, p0.c1, #0\n"
+			"or r1, r1, #0xc\n"
+			"movc p0.c1, r1, #0\n"
+			"nop;nop;nop;nop;nop;nop;nop;nop;\n"
+			:
+			:
+			:"r0", "memory", "cc");
+}
+
+rt_inline void clean_dcache(void)
+{
+    __asm__ volatile ( "mov ip, #0\n"
+               "movc p0.c5, ip, #10\n"
+               "nop; nop; nop; nop; nop; nop; nop; nop\n"
+               :
+	       :
+	       :"ip", "memory", "cc");
+}
+
+rt_inline rt_uint32_t icache_status(void)
+{
+    rt_uint32_t ret;
+
+     __asm__ volatile ( "movc %0, p0.c1, #0\n"
+                "and %0, %0, #8\n"
+                : "=&r" (ret)
+                :
+                :"memory", "cc");
+
+    return ret;
+}
+
+rt_inline rt_uint32_t dcache_status(void)
+{
+    rt_uint32_t ret;
+
+    __asm__ volatile ( "movc %0, p0.c1, #0\n"
+               "and %0, %0, #4\n"
+               : "=&r" (ret)
+               :
+               :"memory", "cc");
+
+     return ret;
+}
+
+rt_inline void dcache_flush(void)
+{
+	__asm__ volatile ( "mov ip, #0\n"
+              "movc p0.c5, ip, #14\n"
+              "nop; nop; nop; nop; nop; nop; nop; nop\n"
+              :
+              :
+              : "ip" );
+}
+
+rt_inline void icache_invalid(void)
+{
+	 __asm__ volatile ( "mov r0, #0\n"
+               "movc p0.c5, r0, #20\n"
+               "nop; nop; nop; nop; nop; nop; nop; nop\n"
+               :
+               :
+               :"r0", "memory", "cc");
+}
+
+rt_inline void dcache_invalid(void)
+{
+    __asm__ volatile ( "mov r0, #0\n"
+                "movc p0.c5, r0, #12\n"
+               "nop; nop; nop; nop; nop; nop; nop; nop\n"
+               :
+               :
+               :"r0", "memory", "cc");
+}
+
+rt_inline void icache_disable(void)
+{
+	icache_invalid();
+	__asm__ volatile ( "movc r0, p0.c1, #0\n"
+               "andn r0, r0, #8\n"
+               "movc p0.c1, r0, #0\n"
+               :
+               :
+               :"r0", "memory", "cc");
+}
+
+rt_inline void dcache_disable(void)
+{
+	dcache_flush();
+	__asm__ volatile ( "movc r0, p0.c1, #0\n"
+               "andn r0, r0, #20\n"
+               "movc p0.c1, r0, #0\n"
+               :
+               :
+               :"r0", "memory", "cc");
+
+}
+
+rt_inline void icache_enable(void)
+{
+    __asm__ volatile ( "mov r0, #0\n"
+               "movc p0.c5, r0, #20\n"
+               "nop; nop; nop; nop; nop; nop; nop; nop\n"
+               :
+               :
+               :"r0", "memory", "cc");
+
+    __asm__ volatile ( "movc r0, p0.c1, #0\n"
+               "or r0, r0, #8\n"
+               "movc p0.c1, r0, #0\n"
+               :
+               :
+               :"r0", "memory", "cc");
+}
+
+rt_inline void dcache_enable(void)
+{
+    __asm__ volatile ( "mov r0, #0\n"
+           "movc p0.c5, r0, #12\n"
+           "nop; nop; nop; nop; nop; nop; nop; nop\n"
+           :
+           :
+           :"r0", "memory", "cc");
+
+    __asm__ volatile ( "movc r0, p0.c1, #0\n"
+           "or r0, r0, #20\n"
+           "movc p0.c1, r0, #0\n"
+           :
+           :
+           :"r0", "memory", "cc");
+}
+#endif
+
+
+/**
+ * enable I-Cache
+ *
+ */
+void rt_hw_cpu_icache_enable()
+{
+	icache_enable();
+}
+
+/**
+ * disable I-Cache
+ *
+ */
+void rt_hw_cpu_icache_disable()
+{
+	icache_disable();
+}
+
+/**
+ * return the status of I-Cache
+ *
+ */
+rt_base_t rt_hw_cpu_icache_status()
+{
+	return icache_status();
+}
+
+/**
+ * enable D-Cache
+ *
+ */
+void rt_hw_cpu_dcache_enable()
+{
+	dcache_enable();
+}
+
+/**
+ * disable D-Cache
+ *
+ */
+void rt_hw_cpu_dcache_disable()
+{
+	dcache_disable();
+}
+
+/**
+ * return the status of D-Cache
+ *
+ */
+rt_base_t rt_hw_cpu_dcache_status()
+{
+	return dcache_status();
+}
+
+static void sep6200_reset(rt_uint32_t addr)
+{
+     __asm__ volatile ( "mov ip, #0\n"
+		     "movc p0.c5, ip, #28\n" /*Cache invalidate all*/
+		     "movc p0.c6, ip, #6\n" /*TLB invalidate all*/
+		     "nop;nop;nop;nop;nop;nop;nop;nop;\n"
+		     "movc ip, p0.c1, #0\n" /*ctrl register*/
+		     "andn ip, ip, #0x000f\n" /*disable caches and mmu*/
+		     "movc p0.c1, ip, #0\n"
+		     "nop\n"
+		     "mov pc, %0\n"
+		     "nop;nop;nop;nop;nop;nop;nop;nop;\n"
+		      : "=&r" (addr)
+		      :
+		      :"memory", "cc");
+}
+
+static void sep6200_poweroff(void)
+{
+	rt_kprintf("sep6200 power off not implemented\n");
+  while(1);
+}
+
+/**
+ * reset cpu by dog's time-out
+ *
+ */
+void rt_hw_cpu_reset()
+{
+
+	rt_kprintf("Soft reset, Restarting system...\n");
+	sep6200_reset(0);
+
+	while(1);	/* loop forever and wait for reset to happen */
+
+	/* NEVER REACHED */
+}
+
+/**
+ *  shutdown CPU
+ *
+ */
+void rt_hw_cpu_shutdown()
+{
+	rt_uint32_t level;
+	rt_kprintf("shutdown...\n");
+
+	level = rt_hw_interrupt_disable();
+	sep6200_poweroff();
+	while (level)
+	{
+		RT_ASSERT(0);
+	}
+}
+
+/*@}*/

libcpu/unicore32/sep6200/interrupt.c

+/*
+ * File      : interrupt.c
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2006, RT-Thread Development Team
+ *
+ * The license and distribution terms for this file may be
+ * found in the file LICENSE in this distribution or at
+ * http://openlab.rt-thread.com/license/LICENSE
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2013-7-14      Peng Fan     First implementation
+ */
+
+#include <rtthread.h>
+#include <rthw.h>
+#include <sep6200.h>
+
+#define MAX_HANDLERS	64
+
+
+#define SEP6200_IRQ_TYPE 0
+#define SEP6200_FIQ_TYPE 1
+
+#define int_enable_all() 					  \
+	do {							  \
+		*(volatile unsigned long*)SEP6200_VIC_INT_EN_L = ~0x0;\
+		*(volatile unsigned long*)SEP6200_VIC_INT_EN_H = ~0x0;\
+	}while(0)
+#define int_disable_all() 					 \
+	do {							 \
+		*(volatile unsigned long*)SEP6200_VIC_INT_EN_L = 0x0;\
+		*(volatile unsigned long*)SEP6200_VIC_INT_EN_H = 0x0;\
+	}while(0)
+#define mask_all_int(int_type)					 \
+	do {							 \
+		if (int_type == SEP6200_IRQ_TYPE){		 \
+		*(volatile unsigned long*)SEP6200_VIC_INT_MSK_ALL = 0x1;\
+		} else if (int_type == SEP6200_FIQ_TYPE) {\
+		*(volatile unsigned long*)SEP6200_VIC_INT_MSK_ALL = 0x2;\
+		}\
+	}while(0)
+#define unmask_all_int(int_type)\
+	do {							 \
+		if (int_type == SEP6200_IRQ_TYPE){		 \
+		*(volatile unsigned long*)SEP6200_VIC_INT_MSK_ALL = ~0x1;\
+		} else if (int_type == SEP6200_FIQ_TYPE) {\
+		*(volatile unsigned long*)SEP6200_VIC_INT_MSK_ALL = ~0x2;\
+		}\
+	}while(0)
+
+#define SEP6200_INT_SET(intnum)                                     \
+do{                                                                 \
+    if(intnum < 32)                                                 \
+        *(volatile unsigned long*)SEP6200_VIC_SFT_INT_L |= (1 << intnum); \
+    else                                                            \
+        *(volatile unsigned long*)SEP6200_VIC_SFT_INT_H |= (1 << (intnum - 32));  \
+}while(0)
+
+#define SEP6200_INT_CLR(intnum)   \
+do{                               \
+    if(intnum < 32)               \
+        *(volatile unsigned long*)SEP6200_VIC_SFT_INT_L &= ~(1 << intnum);\
+    else                          \
+        *(volatile unsigned long*)SEP6200_VIC_SFT_INT_H &= ~(1 << (intnum - 32)); \
+}while(0)
+
+#define SEP6200_INT_ENABLE(intnum)\
+do{                               \
+    if(intnum < 32)               \
+        *(volatile unsigned long*)SEP6200_VIC_INT_EN_L |= (1 << intnum);  \
+    else                          \
+        *(volatile unsigned long*)SEP6200_VIC_INT_EN_H |= (1 << (intnum - 32));   \
+}while(0)
+
+#define SEP6200_INT_DISABLE(intnum)                                 \
+do{                                                                 \
+    if(intnum < 32)                                                 \
+        *(volatile unsigned long*)SEP6200_VIC_INT_EN_L &= ~(1 << intnum); \
+    else                                                            \
+        *(volatile unsigned long*)SEP6200_VIC_INT_EN_H &= ~(1 << (intnum - 32));  \
+}while(0)
+
+
+extern rt_uint32_t rt_interrupt_nest;
+/* exception and interrupt handler table */
+struct rt_irq_desc isr_table[MAX_HANDLERS];
+rt_uint32_t rt_interrupt_from_thread, rt_interrupt_to_thread;
+rt_uint32_t rt_thread_switch_interrupt_flag;
+
+
+/* --------------------------------------------------------------------
+ *  Interrupt initialization
+ * -------------------------------------------------------------------- */
+
+/**
+ * @addtogroup sep6200
+ */
+/*@{*/
+
+void rt_hw_interrupt_mask(int irq);
+void rt_hw_interrupt_umask(int irq);
+
+rt_inline void sep6200_irq_enable(rt_uint32_t irq)
+{
+	SEP6200_INT_ENABLE(irq);
+}
+
+rt_inline void sep6200_irq_disable(rt_uint32_t irq)
+{
+	SEP6200_INT_DISABLE(irq);
+}
+
+rt_inline void sep6200_irq_unmask(rt_uint32_t irq)
+{
+	SEP6200_INT_ENABLE(irq);
+}
+
+rt_inline void sep6200_irq_mask(rt_uint32_t irq)
+{
+	SEP6200_INT_DISABLE(irq);
+}
+rt_isr_handler_t rt_hw_interrupt_handle(rt_uint32_t vector)
+{
+	rt_kprintf("Unhandled interrupt %d occured!!!\n", vector);
+	return RT_NULL;
+}
+
+/**
+ * This function will initialize hardware interrupt
+ */
+void rt_hw_interrupt_init(void)
+{
+	rt_int32_t i;
+	register rt_uint32_t idx;
+
+
+	/* init exceptions table */
+	for(idx=0; idx < MAX_HANDLERS; idx++)
+	{
+		isr_table[idx].handler = (rt_isr_handler_t)rt_hw_interrupt_handle;
+	}
+	int_disable_all();
+	mask_all_int(SEP6200_FIQ_TYPE);
+
+	//int_enable_all();
+	unmask_all_int(SEP6200_IRQ_TYPE);
+
+	/* init interrupt nest, and context in thread sp */
+	rt_interrupt_nest = 0;
+	rt_interrupt_from_thread = 0;
+	rt_interrupt_to_thread = 0;
+	rt_thread_switch_interrupt_flag = 0;
+}
+
+
+
+/**
+ * This function will mask a interrupt.
+ * @param vector the interrupt number
+ */
+void rt_hw_interrupt_mask(int irq)
+{
+	if (irq >= MAX_HANDLERS) {
+		rt_kprintf("Wrong irq num to mask\n");
+	} else {
+		sep6200_irq_mask(irq);
+	}
+
+}
+
+/**
+ * This function will un-mask a interrupt.
+ * @param vector the interrupt number
+ */
+void rt_hw_interrupt_umask(int irq)
+{
+	if (irq >= MAX_HANDLERS) {
+		rt_kprintf("Wrong irq num to unmask\n");
+	} else {
+		sep6200_irq_unmask(irq);
+	}
+}
+
+/**
+ * This function will install a interrupt service routine to a interrupt.
+ * @param vector the interrupt number
+ * @param new_handler the interrupt service routine to be installed
+ * @param old_handler the old interrupt service routine
+ */
+rt_isr_handler_t rt_hw_interrupt_install(int vector, rt_isr_handler_t handler,
+                                        void *param, char *name)
+{
+    rt_isr_handler_t old_handler = RT_NULL;
+
+    if(vector < MAX_HANDLERS)
+    {
+        old_handler = isr_table[vector].handler;
+
+        if (handler != RT_NULL)
+        {
+#ifdef RT_USING_INTERRUPT_INFO
+		    rt_strncpy(isr_table[vector].name, name, RT_NAME_MAX);
+#endif /* RT_USING_INTERRUPT_INFO */
+            isr_table[vector].handler = handler;
+            isr_table[vector].param = param;
+        }
+    }
+
+    return old_handler;
+}
+
+/*@}*/

libcpu/unicore32/sep6200/serial.c

+/*
+ * File      : serial.c
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2006, RT-Thread Development Team
+ *
+ * The license and distribution terms for this file may be
+ * found in the file LICENSE in this distribution or at
+ * http://openlab.rt-thread.com/license/LICENSE
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2013-03-16	    Peng Fan     Modified from sep4020
+ */
+#include <rtthread.h>
+#include <rthw.h>
+#include "serial.h"
+
+/**
+ * @addtogroup SEP6200
+ */
+/*@{*/
+
+/* RT-Thread Device Interface */
+/**
+ * This function initializes serial
+ */
+static rt_err_t rt_serial_init (rt_device_t dev)
+{
+	struct serial_device* uart = (struct serial_device*) dev->user_data;
+
+	if (!(dev->flag & RT_DEVICE_FLAG_ACTIVATED))
+	{
+
+		if (dev->flag & RT_DEVICE_FLAG_INT_RX)
+		{
+			rt_memset(uart->int_rx->rx_buffer, 0,
+				sizeof(uart->int_rx->rx_buffer));
+			uart->int_rx->read_index = uart->int_rx->save_index = 0;
+		}
+
+		if (dev->flag & RT_DEVICE_FLAG_INT_TX)
+		{
+			rt_memset(uart->int_tx->tx_buffer, 0,
+				sizeof(uart->int_tx->tx_buffer));
+			uart->int_tx->write_index = uart->int_tx->save_index = 0;
+		}
+
+		dev->flag |= RT_DEVICE_FLAG_ACTIVATED;
+	}
+
+	return RT_EOK;
+}
+
+/* save a char to serial buffer */
+static void rt_serial_savechar(struct serial_device* uart, char ch)
+{
+	rt_base_t level;
+
+	/* disable interrupt */
+	level = rt_hw_interrupt_disable();
+
+	uart->int_rx->rx_buffer[uart->int_rx->save_index] = ch;
+	uart->int_rx->save_index ++;
+	if (uart->int_rx->save_index >= UART_RX_BUFFER_SIZE)
+		uart->int_rx->save_index = 0;
+
+	/* if the next position is read index, discard this 'read char' */
+	if (uart->int_rx->save_index == uart->int_rx->read_index)
+	{
+		uart->int_rx->read_index ++;
+		if (uart->int_rx->read_index >= UART_RX_BUFFER_SIZE)
+			uart->int_rx->read_index = 0;
+	}
+
+	/* enable interrupt */
+	rt_hw_interrupt_enable(level);
+}
+
+static rt_err_t rt_serial_open(rt_device_t dev, rt_uint16_t oflag)
+{
+	RT_ASSERT(dev != RT_NULL);
+	return RT_EOK;
+}
+
+static rt_err_t rt_serial_close(rt_device_t dev)
+{
+	RT_ASSERT(dev != RT_NULL);
+	return RT_EOK;
+}
+
+static rt_size_t rt_serial_read (rt_device_t dev, rt_off_t pos, void* buffer, rt_size_t size)
+{
+	rt_uint8_t* ptr;
+	rt_err_t err_code;
+	struct serial_device* uart;
+
+	ptr = buffer;
+	err_code = RT_EOK;
+	uart = (struct serial_device*)dev->user_data;
+
+	if (dev->flag & RT_DEVICE_FLAG_INT_RX)
+	{
+		rt_base_t level;
+
+		/* interrupt mode Rx */
+		while (size)
+		{
+			if (uart->int_rx->read_index != uart->int_rx->save_index)
+			{
+				*ptr++ = uart->int_rx->rx_buffer[uart->int_rx->read_index];
+				size --;
+
+				/* disable interrupt */
+				level = rt_hw_interrupt_disable();
+
+				uart->int_rx->read_index ++;
+				if (uart->int_rx->read_index >= UART_RX_BUFFER_SIZE)
+					uart->int_rx->read_index = 0;
+
+				/* enable interrupt */
+				rt_hw_interrupt_enable(level);
+			}
+			else
+			{
+				/* set error code */
+				err_code = -RT_EEMPTY;
+				break;
+			}
+		}
+	}
+	else
+	{
+		/* polling mode */
+		while ((rt_uint32_t)ptr - (rt_uint32_t)buffer < size)
+		{
+			while (uart->uart_device->lsr & USTAT_RCV_READY)
+			{
+				*ptr = uart->uart_device->dlbl_fifo.txfifo & 0xff;
+				ptr ++;
+			}
+		}
+	}
+
+	/* set error code */
+	rt_set_errno(err_code);
+	return (rt_uint32_t)ptr - (rt_uint32_t)buffer;
+}
+
+static rt_size_t rt_serial_write (rt_device_t dev, rt_off_t pos, const void* buffer, rt_size_t size)
+{
+	rt_uint8_t* ptr;
+	rt_err_t err_code;
+	struct serial_device* uart;
+
+	err_code = RT_EOK;
+	ptr = (rt_uint8_t*)buffer;
+	uart = (struct serial_device*)dev->user_data;
+
+	if (dev->flag & RT_DEVICE_FLAG_INT_TX)
+	{
+		/* interrupt mode Tx */
+		while (uart->int_tx->save_index != uart->int_tx->write_index)
+		{
+			/* save on tx buffer */
+			uart->int_tx->tx_buffer[uart->int_tx->save_index] = *ptr++;
+
+			-- size;
+
+			/* move to next position */
+			uart->int_tx->save_index ++;
+
+			/* wrap save index */
+			if (uart->int_tx->save_index >= UART_TX_BUFFER_SIZE)
+				uart->int_tx->save_index = 0;
+		}
+
+		/* set error code */
+		if (size > 0)
+			err_code = -RT_EFULL;
+	}
+	else
+	{
+		/* polling mode */
+		while (size)
+		{
+			/*
+			 * to be polite with serial console add a line feed
+			 * to the carriage return character
+			 */
+			if (*ptr == '\n' && (dev->flag & RT_DEVICE_FLAG_STREAM))
+			{
+				while (!(uart->uart_device->lsr & USTAT_TXB_EMPTY));
+				uart->uart_device->dlbl_fifo.txfifo = '\r';
+			}
+
+			while (!(uart->uart_device->lsr & USTAT_TXB_EMPTY));
+			uart->uart_device->dlbl_fifo.txfifo = (*ptr & 0x1FF);
+
+			++ptr; --size;
+		}
+	}
+
+	/* set error code */
+	rt_set_errno(err_code);
+
+	return (rt_uint32_t)ptr - (rt_uint32_t)buffer;
+}
+
+static rt_err_t rt_serial_control (rt_device_t dev, rt_uint8_t cmd, void *args)
+{
+	RT_ASSERT(dev != RT_NULL);
+
+	switch (cmd)
+	{
+	case RT_DEVICE_CTRL_SUSPEND:
+		/* suspend device */
+		dev->flag |= RT_DEVICE_FLAG_SUSPENDED;
+		break;
+
+	case RT_DEVICE_CTRL_RESUME:
+		/* resume device */
+		dev->flag &= ~RT_DEVICE_FLAG_SUSPENDED;
+		break;
+	}
+
+	return RT_EOK;
+}
+
+/*
+ * serial register
+ */
+rt_err_t rt_hw_serial_register(rt_device_t device, const char* name, rt_uint32_t flag, struct serial_device *serial)
+{
+	RT_ASSERT(device != RT_NULL);
+
+	device->type 		= RT_Device_Class_Char;
+	device->rx_indicate = RT_NULL;
+	device->tx_complete = RT_NULL;
+	device->init 		= rt_serial_init;
+	device->open		= rt_serial_open;
+	device->close		= rt_serial_close;
+	device->read 		= rt_serial_read;
+	device->write 		= rt_serial_write;
+	device->control 	= rt_serial_control;
+	device->user_data   = serial;
+
+	/* register a character device */
+	return rt_device_register(device, name, RT_DEVICE_FLAG_RDWR | flag);
+}
+
+/* ISR for serial interrupt */
+void rt_hw_serial_isr(rt_device_t device)
+{
+	struct serial_device* uart = (struct serial_device*) device->user_data;
+
+	/* interrupt mode receive */
+	RT_ASSERT(device->flag & RT_DEVICE_FLAG_INT_RX);
+
+	/* save on rx buffer */
+	while (uart->uart_device->lsr & USTAT_RCV_READY)
+	{
+		rt_serial_savechar(uart, uart->uart_device->dlbl_fifo.rxfifo & 0xff);
+	}
+
+	/* invoke callback */
+	if (device->rx_indicate != RT_NULL)
+	{
+		rt_size_t rx_length;
+
+		/* get rx length */
+		rx_length = uart->int_rx->read_index > uart->int_rx->save_index ?
+			UART_RX_BUFFER_SIZE - uart->int_rx->read_index + uart->int_rx->save_index :
+			uart->int_rx->save_index - uart->int_rx->read_index;
+
+		device->rx_indicate(device, rx_length);
+	}
+}
+
+/*@}*/

libcpu/unicore32/sep6200/serial.h

+/*
+ * File      : serial.c
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2006, RT-Thread Development Team
+ *
+ * The license and distribution terms for this file may be
+ * found in the file LICENSE in this distribution or at
+ * http://openlab.rt-thread.com/license/LICENSE
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2006-03-13     Bernard      first version
+ * 2009-04-20     yi.qiu       modified according bernard's stm32 version
+ * 2010-10-6      wangmeng     added sep4020 surpport
+ * 2013-7-15      Peng Fan     Modified from sep4020
+ */
+
+#ifndef __SERIAL_H__
+#define __SERIAL_H__
+
+#include <sep6200.h>
+
+#define	USTAT_RCV_READY		0x01   	/* receive data ready */
+#define USTAT_OVERRUN		0x02	/* overrun */
+#define USTAT_PARITY_ERR	0x04	/* parity error */
+#define USTAT_FRAME_ERROR	0x08	/* frame error */
+#define USTAT_BREAK		0x10	/* break */
+#define	USTAT_TXB_EMPTY		0x40   	/* tx buffer empty */
+#define USTAT_RCV_ERR		0x80	/* receive error */
+
+#define BPS					115200	/* serial baudrate */
+
+#define UART_RX_BUFFER_SIZE		64
+#define UART_TX_BUFFER_SIZE		64
+
+/*For sep6200's uart have several secondary function*/
+/*we use union to decribe it*/
+
+union dlbl_fifo
+{
+	rt_uint32_t dlbl;
+	rt_uint32_t rxfifo;
+	rt_uint32_t txfifo;
+};
+
+union dlbh_ier
+{
+	rt_uint32_t dlbh;
+	rt_uint32_t ier;
+};
+
+union iir_fcr
+{
+	rt_uint32_t iir;
+	rt_uint32_t fcr;
+};
+
+struct serial_int_rx
+{
+	rt_uint8_t  rx_buffer[UART_RX_BUFFER_SIZE];
+	rt_uint32_t read_index, save_index;
+};
+
+struct serial_int_tx
+{
+	rt_uint8_t  tx_buffer[UART_TX_BUFFER_SIZE];
+	rt_uint32_t write_index, save_index;
+};
+
+typedef struct uartport
+{
+	union dlbl_fifo dlbl_fifo;
+	union dlbh_ier	dlbh_ier;
+	union iir_fcr	iir_fcr;
+	rt_uint32_t lcr;
+	rt_uint32_t mcr;
+	rt_uint32_t lsr;
+	rt_uint32_t msr;
+}uartport;
+
+struct serial_device
+{
+	uartport* uart_device;
+
+	/* rx structure */
+	struct serial_int_rx* int_rx;
+
+	/* tx structure */
+	struct serial_int_tx* int_tx;
+};
+
+rt_err_t rt_hw_serial_register(rt_device_t device, const char* name, rt_uint32_t flag, struct serial_device *serial);
+
+void rt_hw_serial_isr(rt_device_t device);
+
+#endif

libcpu/unicore32/sep6200/stack.c

+/*
+ * File      : stack.c
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2006, RT-Thread Development Team
+ *
+ * The license and distribution terms for this file may be
+ * found in the file LICENSE in this distribution or at
+ * http://openlab.rt-thread.com/license/LICENSE
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2013-7-14      Peng Fan     Modifiled from sep4020
+ */
+
+#include <rtthread.h>
+#include <sep6200.h>
+
+/**
+ * @addtogroup sep6200
+ */
+/*@{*/
+
+/**
+ * This function will initialize thread stack
+ *
+ * @param tentry the entry of thread
+ * @param parameter the parameter of entry
+ * @param stack_addr the beginning stack address
+ * @param texit the function will be called when thread exit
+ *
+ * @return stack address
+ */
+
+rt_uint8_t *rt_hw_stack_init(void *tentry, void *parameter,
+	rt_uint8_t *stack_addr, void *texit)
+{
+	rt_uint32_t *stk;
+
+	stk 	 = (rt_uint32_t*)stack_addr;
+	*(stk) 	 = (rt_uint32_t)tentry;			/* entry point */
+	*(--stk) = (rt_uint32_t)texit;			/* lr */
+	*(--stk) = 0;							/* r28 */
+	*(--stk) = 0;							/* r27 */
+	*(--stk) = 0;							/* r26 */
+	*(--stk) = 0;							/* r25 */
+	*(--stk) = 0;							/* r24 */
+	*(--stk) = 0;							/* r23 */
+	*(--stk) = 0;							/* r22 */
+	*(--stk) = 0;							/* r21 */
+	*(--stk) = 0;							/* r20 */
+	*(--stk) = 0;							/* r19 */
+	*(--stk) = 0;							/* r18 */
+	*(--stk) = 0;							/* r17 */
+	*(--stk) = 0;							/* r16 */
+	*(--stk) = 0;							/* r15 */
+	*(--stk) = 0;							/* r14 */
+	*(--stk) = 0;							/* r13 */
+	*(--stk) = 0;							/* r12 */
+	*(--stk) = 0;							/* r11 */
+	*(--stk) = 0;							/* r10 */
+	*(--stk) = 0;							/* r9 */
+	*(--stk) = 0;							/* r8 */
+	*(--stk) = 0;							/* r7 */
+	*(--stk) = 0;							/* r6 */
+	*(--stk) = 0;							/* r5 */
+	*(--stk) = 0;							/* r4 */
+	*(--stk) = 0;							/* r3 */
+	*(--stk) = 0;							/* r2 */
+	*(--stk) = 0;							/* r1 */
+	*(--stk) = (rt_uint32_t)parameter; /* r0 : argument */
+	*(--stk) = Mode_PRIV;					/* asr */
+	*(--stk) = Mode_PRIV;					/* bsr */ /*why both PRIV do not need switch?*/
+
+	/* return task's current stack address */
+	return (rt_uint8_t *)stk;
+}
+
+/*@}*/

libcpu/unicore32/sep6200/start_gcc.S

+/*
+ * File      : start.S
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2006, RT-Thread Development Team
+ *
+ * The license and distribution terms for this file may be
+ * found in the file LICENSE in this distribution or at
+ * http:/*openlab.rt-thread.com/license/LICENSE
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2013-07-13     Peng Fan     First implementation
+ */
+
+
+#define CONFIG_STACKSIZE 	1024
+#define S_FRAME_SIZE 		132
+
+#define S_OLD_R0 			132
+#define S_PSR  				128
+#define S_PC  				124
+#define S_LR  				120
+#define S_SP  				116
+
+#define S_IP  				112
+#define S_FP  				108
+#define S_R26  				104
+#define S_R25  				100
+#define S_R24  				96
+#define S_R23  				92
+#define S_R22  				88
+#define S_R21  				84
+#define S_R20 				80
+#define S_R19  				76
+#define S_R18  				72
+#define S_R17  				68
+#define S_R16  				64
+#define S_R15  				60
+#define S_R14  				56
+#define S_R13  				52
+#define S_R12  				48
+#define S_R11  				44
+#define S_R10  				40
+#define S_R9  				36
+#define S_R8  				32
+#define S_R7  				28
+#define S_R6  				24
+#define S_R5  				20
+#define S_R4  				16
+#define S_R3  				12
+#define S_R2  				8
+#define S_R1  				4
+#define S_R0 				0
+
+.equ 	USERMODE,			0x10
+.equ 	REALMODE,			0x11
+.equ 	IRQMODE,			0x12
+.equ 	PRIVMODE,			0x13
+.equ 	TRAPMODE,			0x17
+.equ 	EXTNMODE,			0x1b
+.equ 	MODEMASK,			0x1f
+.equ 	NOINT,				0xc0
+
+.equ 	RAM_BASE,			0x00000000	/*Start address of RAM		*/
+
+
+
+/*
+ *************************************************************************
+ *
+ * Jump vector table
+ *
+ *************************************************************************
+ */
+
+.section .init, "ax"
+.code 32
+.globl _start
+_start:
+     b   reset
+     ldw pc, _extend_handle
+     ldw pc, _swi_handle
+     ldw pc, _iabort_handle
+     ldw pc, _dabort_handle
+     ldw pc, _reserve_handle
+     ldw pc, _IRQ_handle
+     ldw pc, _FIQ_handle
+
+_extend_handle:     .word extend_handle
+_swi_handle:        .word swi_handle
+_iabort_handle:     .word iabort_handle
+_dabort_handle:     .word dabort_handle
+_reserve_handle:    .word reserve_handle
+_IRQ_handle:        .word IRQ_handle
+_FIQ_handle:        .word FIQ_handle
+    .balignl 16,0xdeadbeef
+
+/*
+ *************************************************************************
+ *
+ * Startup Code (reset vector)
+ * relocate armboot to ram
+ * setup stack
+ * jump to second stage
+ *
+ *************************************************************************
+ */
+.global _TEXT_BASE
+_TEXT_BASE:
+     .word   TEXT_BASE
+
+.globl _rtthread_start
+_rtthread_start:
+     .word   _start
+
+.globl _rtthread_end
+_rtthread_end:
+     .word   _end
+
+.globl _bss_start
+_bss_start:
+     .word   __bss_start     @ load end address
+
+.globl _bss_end
+_bss_end:
+    .word   __bss_end
+
+.globl IRQ_STACK_START
+IRQ_STACK_START:
+    .word   _irq_stack_start + 10240 - 4
+
+.globl FIQ_STACK_START
+FIQ_STACK_START:
+     .word   _fiq_stack_start +1024
+
+/*peng not sure*/
+.globl UNDEFINED_STACK_START
+UNDEFINED_STACK_START:
+	.word _undefined_stack_start + CONFIG_STACKSIZE
+
+.globl ABORT_STACK_START
+ABORT_STACK_START:
+	.word _abort_stack_start + CONFIG_STACKSIZE
+
+.globl _STACK_START
+_STACK_START:
+	.word _priv_stack_start + 40960 - 4
+
+.equ  SEP6200_VIC_BASE,		 0xb0000000
+.equ  SEP6200_SYSCTL_BASE,	 0xb0008000
+/* ----------------------------------entry------------------------------*/
+reset:
+	/* set the cpu to PRIV mode and disable cpu interrupt */
+	mov		r0, asr
+	andn		r0, r0, #0xff
+	or		r0, r0, #PRIVMODE|NOINT
+	mov.a		asr, r0
+
+	/* mask all IRQs by clearing all bits in the INTMRs */
+	ldw	r1, =SEP6200_VIC_BASE
+	ldw 	r0, =0xffffffff
+	stw	r0, [r1+], #0x20 /*interrupt enable clear*/
+	stw	r0, [r1+], #0x24
+
+
+	/*remap ddr to 0x00000000 address*/
+	ldw	r1, =SEP6200_SYSCTL_BASE
+	ldw	r0, [r1+]
+	ldw	r2, =0x80000000
+	or	r0, r0, r2
+	stw	r2, [r1+]
+
+	/* set interrupt vector */
+	/*do nothing here for vector*/
+
+	/* setup stack */
+	b.l		stack_setup
+
+	ldw	r12, =0x100
+	ldw	r0, = 0x40000000
+	ldw	r1, = 0x00000000
+copy_vetor:
+	ldw	r2, [r0]
+	stw	r2, [r1]
+	add	r0, r0, #4
+	add	r1, r1, #4
+	sub	r12, r12, #4
+	cmpsub.a	r12, #0
+	bne	copy_vetor
+
+	/* clear .bss */
+	ldw   	r0, _bss_start         /* bss start   */
+	ldw   	r1, _bss_end           /* bss end     */
+	mov   	r2,#0                  /* get a zero  */
+
+
+bss_loop:
+	stw r2, [r0]            @ clear loop...
+	add r0, r0, #4
+	cmpsub.a    r0, r1
+	bel bss_loop
+
+	/* call C++ constructors of global objects 							*/
+	ldw	r0, =__ctors_start__
+	ldw	r1, =__ctors_end__
+
+ctor_loop:
+	cmpsub.a	r0, r1
+	beq	ctor_end
+	ldw.w	r2, [r0]+, #4
+	stm.w	(r0, r1), [sp-]
+	add	lr, pc, #4
+	mov	pc, r2
+	ldm.w	(r0, r1), [sp]+
+	b ctor_loop
+ctor_end:
+
+  /*enable interrupt*/
+	mov 	r0, asr
+	andn 	r1, r0, #NOINT
+	mov.a 	asr, r1
+
+	/* start RT-Thread Kernel 		*/
+	ldw		pc, _rtthread_startup
+
+_rtthread_startup:
+	.word rtthread_startup
+
+/*
+ *************************************************************************
+ *
+ * Interrupt handling
+ *
+ *************************************************************************
+ */
+
+/* exception handlers */
+/*Just simple implementation here peng*/
+	.align  5
+extend_handle:
+    b extend_handle
+swi_handle:
+    b swi_handle
+iabort_handle:
+    b iabort_handle
+dabort_handle:
+    b dabort_handle
+reserve_handle:
+    b reserve_handle
+
+.globl 		rt_interrupt_enter
+.globl 		rt_interrupt_leave
+.globl 		rt_thread_switch_interrupt_flag
+.globl 		rt_interrupt_from_thread
+.globl 		rt_interrupt_to_thread
+IRQ_handle:
+
+  stm.w (lr), [sp-]
+  stm.w (r16 - r28), [sp-]
+  stm.w (r0 - r15), [sp-]
+
+	b.l		rt_interrupt_enter
+	b.l		rt_hw_trap_irq
+	b.l		rt_interrupt_leave
+
+	/* if rt_thread_switch_interrupt_flag set, jump to _interrupt_thread_switch and don't return */
+	ldw		r0, =rt_thread_switch_interrupt_flag
+	ldw		r1, [r0+]
+	cmpsub.a	r1, #1
+	beq		_interrupt_thread_switch
+
+  ldm.w (r0 - r15), [sp]+
+  ldm.w (r16 - r28), [sp]+
+  ldm.w (lr), [sp]+
+  mov.a pc, lr
+
+	.align	5
+FIQ_handle:
+    mov r0, #0x44
+    b.l printhex
+	mov pc, lr
+
+_interrupt_thread_switch:
+
+	mov		r1,  #0	/* clear rt_thread_switch_interrupt_flag*/
+	stw		r1,  [r0+]
+
+	/*reload register*/
+  ldm.w (r0 - r15), [sp]+
+  ldm.w (r16 - r28), [sp]+
+  ldm.w (lr), [sp]+
+
+	stm.w	(r0-r3), [sp-] /*save r0-r3*/
+
+	mov		r1,  sp
+	add		sp,  sp, #16 /* restore sp */
+	mov		r2,  lr	/* save old task's pc to r2 */
+
+#if 0
+	mov		r3,  bsr /* disable interrupt */
+	/*or		r0,  r3, #NOINT*/
+	mov.a		bsr, r3
+
+	ldw	r0,  =.+8 /* switch to interrupted task's stack */
+	mov.a	pc,  r0 /*switch bsr to asr, irq to priv mode*/
+
+#endif
+  mov r3, bsr
+  mov r0, #0xd3 /*I:F:0:PRIV*/
+  mov.a asr, r0
+
+	stm.w	(r2), [sp-] /* push old task's pc */
+
+	/* push old task's registers */
+	stm.w	(r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, lr), [sp-]
+	stm.w	(r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15), [sp-]
+	mov		r4,  r1	/* Special optimised code below		*/
+  mov		r5,  r3 /*pengpengpengpeng*/
+	ldm.w	(r0,r1, r2, r3), [r4]+
+	stm.w	(r0, r1, r2, r3), [sp-] /*push old task's r3-r0*/
+	stm.w	(r5),	 [sp-] /* push old task's asr */
+	mov	r4,  bsr
+	stm.w   (r4), [sp-]	/* push old task's bsr I am not sure peng*/
+
+	ldw		r4,  =rt_interrupt_from_thread
+	ldw		r5,  [r4+]
+	stw		sp,  [r5+]				/* store sp in preempted tasks's TCB*/
+
+	ldw	r6,  =rt_interrupt_to_thread
+	ldw	r6,  [r6+]
+	ldw	sp,  [r6+]	/* get new task's stack pointer	*/
+
+	ldm.w	(r4), [sp]+	/* pop new task's spsr				*/
+	mov.a	bsr, r4
+	ldm.w	(r4), [sp]+	/* pop new task's psr				*/
+	mov.a	asr, r4
+
+	/* pop new task's r0-r28,lr & pc */
+
+  ldm.w (r0 - r15), [sp]+
+  ldm.w (r16 - r28), [sp]+
+  ldm.w (lr), [sp]+
+  /*peng*/
+  ldm.w (pc), [sp]+
+#if 0
+  mov r0, lr
+  b.l printhex
+  ldm.w (r0), [sp]+
+  b.l printhex
+#endif
+
+stack_setup:
+	/*irq*/
+  mov ip, lr
+	mov		r0, asr
+	andn  r0, r0, #0x1f
+	or		r0, r0, #IRQMODE|NOINT
+	mov.a		asr, r0 /*IRQMODE*/
+  ldw   r0, =IRQ_STACK_START
+  ldw   sp, [r0+]
+	/*ldw		sp, IRQ_STACK_START*/
+
+	/*priv*/
+	mov		r0, asr
+	andn    	r0, r0, #0x1f
+	or		r0, r0, #PRIVMODE|NOINT
+	mov.a		asr, r0 /*PRIVMODE*/
+  ldw   r0, =_STACK_START
+  ldw   sp, [r0+]
+	/*ldw		sp, _STACK_START*/
+  mov lr, ip
+	/*fiq and other mode is not implemented in code here*/
+	mov 		pc, lr /*lr may not be valid for the mode changes*/
+/*/*}*/

libcpu/unicore32/sep6200/trace.c

+#include <rtthread.h>
+
+void rt_hw_backtrace(rt_uint32_t *fp, rt_uint32_t thread_entry)
+{
+
+}

libcpu/unicore32/sep6200/trap.c

+/*
+ * File      : trap.c
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2006, RT-Thread Development Team
+ *
+ * The license and distribution terms for this file may be
+ * found in the file LICENSE in this distribution or at
+ * http://openlab.rt-thread.com/license/LICENSE
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2013-03-16     Peng Fan     Modifiled from sep4020
+ */
+
+#include <rtthread.h>
+#include <rthw.h>
+
+#include <sep6200.h>
+
+/**
+ * @addtogroup sep6200
+ */
+/*@{*/
+
+extern struct rt_thread *rt_current_thread;
+
+/**
+ * this function will show registers of CPU
+ *
+ * @param regs the registers point
+ */
+
+void rt_hw_show_register (struct rt_hw_register *regs)
+{
+	rt_kprintf("Execption:\n");
+	rt_kprintf("r00:0x%08x r01:0x%08x r02:0x%08x r03:0x%08x\n", regs->r0, regs->r1, regs->r2, regs->r3);
+	rt_kprintf("r04:0x%08x r05:0x%08x r06:0x%08x r07:0x%08x\n", regs->r4, regs->r5, regs->r6, regs->r7);
+	rt_kprintf("r08:0x%08x r09:0x%08x r10:0x%08x r11:0x%08x\n", regs->r8, regs->r9, regs->r10,regs->r11);
+	rt_kprintf("r12:0x%08x r13:0x%08x r14:0x%08x r15:0x%08x\n", regs->r12,regs->r13,regs->r14,regs->r15);
+	rt_kprintf("r16:0x%08x r17:0x%08x r18:0x%08x r19:0x%08x\n", regs->r16,regs->r17,regs->r18,regs->r19);
+	rt_kprintf("r20:0x%08x r21:0x%08x r22:0x%08x r23:0x%08x\n", regs->r20,regs->r21,regs->r22,regs->r23);
+	rt_kprintf("r24:0x%08x sb:0x%08x  sl:0x%08xfp :0x%08x ip :0x%08x\n",regs->r24,regs->sb,regs->sl,regs->fp,regs->ip);
+	rt_kprintf("sp :0x%08x lr :0x%08x pc :0x%08x\n", regs->sp, regs->lr, regs->pc);
+	rt_kprintf("asr:0x%08x bsr:0x%08x\n", regs->asr,regs->bsr);
+}
+
+/**
+ * When unicore comes across an instruction which it cannot handle,
+ * it takes the extn instruction trap.
+ *
+ * @param regs system registers
+ *
+ * @note never invoke this function in application
+ */
+void rt_hw_trap_extn(struct rt_hw_register *regs)
+{
+	rt_hw_show_register(regs);
+
+	rt_kprintf("extn instruction\n");
+	rt_kprintf("thread - %s stack:\n", rt_current_thread->name);
+	rt_hw_backtrace((rt_uint32_t *)regs->fp, (rt_uint32_t)rt_current_thread->entry);
+
+	rt_hw_cpu_shutdown();
+}
+
+/**
+ * The software interrupt instruction (SWI) is used for entering
+ * Supervisor mode, usually to request a particular supervisor
+ * function.
+ *
+ * @param regs system registers
+ *
+ * @note never invoke this function in application
+ */
+void rt_hw_trap_swi(struct rt_hw_register *regs)
+{
+	rt_hw_show_register(regs);
+
+	rt_kprintf("software interrupt\n");
+	rt_hw_cpu_shutdown();
+}
+
+/**
+ * An abort indicates that the current memory access cannot be completed,
+ * which occurs during an instruction prefetch.
+ *
+ * @param regs system registers
+ *
+ * @note never invoke this function in application
+ */
+void rt_hw_trap_pabt(struct rt_hw_register *regs)
+{
+	rt_hw_show_register(regs);
+
+	rt_kprintf("prefetch abort\n");
+	rt_kprintf("thread - %s stack:\n", rt_current_thread->name);
+	rt_hw_backtrace((rt_uint32_t *)regs->fp, (rt_uint32_t)rt_current_thread->entry);
+
+	rt_hw_cpu_shutdown();
+}
+
+/**
+ * An abort indicates that the current memory access cannot be completed,
+ * which occurs during a data access.
+ *
+ * @param regs system registers
+ *
+ * @note never invoke this function in application
+ */
+void rt_hw_trap_dabt(struct rt_hw_register *regs)
+{
+	rt_hw_show_register(regs);
+
+	rt_kprintf("data abort\n");
+	rt_kprintf("thread - %s stack:\n", rt_current_thread->name);
+	rt_hw_backtrace((rt_uint32_t *)regs->fp, (rt_uint32_t)rt_current_thread->entry);
+
+	rt_hw_cpu_shutdown();
+}
+
+/**
+ * Normally, system will never reach here
+ *
+ * @param regs system registers
+ *
+ * @note never invoke this function in application
+ */
+void rt_hw_trap_resv(struct rt_hw_register *regs)
+{
+	rt_kprintf("not used\n");
+	rt_hw_show_register(regs);
+	rt_hw_cpu_shutdown();
+}
+
+extern struct rt_irq_desc isr_table[];
+
+void rt_hw_trap_irq(void)
+{
+  unsigned long intstat;
+  rt_uint32_t irq = 0;
+  rt_isr_handler_t isr_func;
+  void *param;
+
+  /* get the interrupt number */
+	irq = *(RP)(SEP6200_VIC_IRQ_VECTOR_NUM);
+
+  /* get interrupt service routine */
+  isr_func = isr_table[irq].handler;
+  param = isr_table[irq].param;
+
+  /* turn to interrupt service routine */
+  isr_func(irq, param);
+
+#ifdef RT_USING_INTERRUPT_INFO
+	isr_table[irq].counter++;
+#endif /* RT_USING_INTERRUPT_INFO */
+}
+
+void rt_hw_trap_fiq()
+{
+	rt_kprintf("fast interrupt request\n");
+}
+
+/*@}*/