Merge pull request #132 from MrVan/sep6200

SEP6200 Support

bsp/sep6200/SConscript

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,89 @@
+/*
+ * File      : application.c
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2006 - 2013, RT-Thread Development Team
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Change Logs:
+ * Date           Author		Notes
+ * 2013-7-14      Peng Fan  Simple application
+ */
+
+/**
+ * @addtogroup sep6200
+ */
+
+/*@{*/
+
+#include "board.h"
+#include <rtthread.h>
+
+#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

@@ -0,0 +1,117 @@
+/*
+ * File      : startup.c
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2006 - 2013, RT-Thread Development Team
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * 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
+  /* Not implemented */
+#endif
+
+#ifdef RT_USING_LWIP
+  /* Not implemented */
+#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 ;
+
+}

bsp/sep6200/board.h

@@ -0,0 +1,34 @@
+/*
+ * File      : board.h
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2006 - 2013, RT-Thread Development Team
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * 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);
+
+#endif

bsp/sep6200/drivers/SConscript

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,174 @@
+/*
+ * File		: board.c
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2006 - 2013, RT-Thread Development Team
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2013-7-14      Peng Fan     sep6200 implementation
+ */
+
+/**
+ * @addtogroup sep6200
+ */
+
+/*@{*/
+#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
+ */
+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;
+	}
+}
+
+/*
+ * 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;
+}
+
+/**
+* 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

@@ -0,0 +1,210 @@
+/* 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 */
+/* #define RT_USING_DFS_ELMFAT */
+/* #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

@@ -0,0 +1,54 @@
+import os
+
+# toolchains options
+ARCH     = 'unicore32'
+CPU      = 'sep6200'
+TextBase = '0x40000000'
+
+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/'
+else :
+    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 -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

@@ -0,0 +1,86 @@
+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/context_gcc.S

@@ -0,0 +1,115 @@
+/*
+ * File      : context_gcc.S
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2006 - 2013, RT-Thread Development Team
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2013-7-14      Peng Fan     sep6200 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

@@ -0,0 +1,290 @@
+/*
+ * File      : cpu.c
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2006 - 2013, RT-Thread Development Team
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2013-7-14      Peng Fan     sep6200 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

@@ -0,0 +1,223 @@
+/*
+ * File      : interrupt.c
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2006 - 2013, RT-Thread Development Team
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2013-7-14      Peng Fan     sep6200 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/sep6200.h

@@ -0,0 +1,471 @@
+/*
+ * File      : sep6200.h
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2006 - 2013, RT-Thread Development Team
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2013-7-17      Peng Fan     sep6200 implementation
+ */
+
+#ifndef __SEP6200_H
+#define __SEP6200_H
+
+#include <rtthread.h>
+
+/*Core definations*/
+#define PRIVMODE  0x13
+#define	Mode_USR	0x10
+#define	Mode_REAL	0x11
+#define	Mode_IRQ	0x12
+#define	Mode_PRIV	0x13
+#define	Mode_TRAP	0x17
+#define	Mode_EXT	0x1B
+#define	Mode_SUSR	0x1F
+
+/*
+ *  Address
+ */
+
+#define	 SEP6200_VIC_BASE	0xb0000000
+#define  SEP6200_PMU_BASE	0xb0001000
+#define  SEP6200_RTC_BASE	0xb0002000
+#define	 SEP6200_TIMER_BASE 0xb0003000
+#define  SEP6200_PWM_BASE	0xb0004000
+#define  SEP6200_GPIO_BASE	0xb0006000
+#define  SEP6200_TOUCH_ADC	0xb0007000
+#define  SEP6200_SYSCTL_BASE	0xb0008000
+#define  SEP6200_UART0_BASE	0xb1000000
+#define  SEP6200_UART1_BASE	0xb1001000
+#define  SEP6200_UART2_BASE	0xb1002000
+#define  SEP6200_UART3_BASE	0xb1003000
+#define	 SEP6200_SSI1_BASE	0xb1004000
+#define	 SEP6200_SSI2_BASE	0xb1005000
+#define	 SEP6200_SSI3_BASE	0xb1006000
+#define  SEP6200_I2C_BASE	0xb1007000
+#define  SEP6200_I2S_BASE	0xb1008000
+#define  SEP6200_USB_BASE    0xb1010000
+#define  SEP6200_DMAC2_BASE  0xb1011000
+#define  SEP6200_ESRAM_BASE  0xb2000000
+#define	 SEP6200_NORREG_BASE0xb2020000
+#define	 SEP6200_SDIO1_BASE	0xb2022000
+#define	 SEP6200_SDIO2_BASE	0xb2023000
+#define	 SEP6200_LCDC_BASE	0xb2025000
+#define	 SEP6200_VPU_BASE	0xb2026000
+#define	 SEP6200_DMAC1_BASE	0xb2027000
+#define	 SEP6200_DDR2_REG	0xb3000000
+#define	 SEP6200_DDR_MEM	0x40000000
+
+#define SEP6200_UART0_DLBL	(SEP6200_UART0_BASE+0x00)
+#define SEP6200_UART0_RXFIFO	(SEP6200_UART0_BASE+0x00)
+#define SEP6200_UART0_TXFIFO	(SEP6200_UART0_BASE+0x00)
+#define SEP6200_UART0_DLBH	(SEP6200_UART0_BASE+0x04)
+#define SEP6200_UART0_IER	(SEP6200_UART0_BASE+0x04)
+#define SEP6200_UART0_IIR	(SEP6200_UART0_BASE+0x08)
+#define SEP6200_UART0_FCR	(SEP6200_UART0_BASE+0x08)
+#define SEP6200_UART0_LCR	(SEP6200_UART0_BASE+0x0c)
+#define SEP6200_UART0_MCR	(SEP6200_UART0_BASE+0x10)
+#define SEP6200_UART0_LSR	(SEP6200_UART0_BASE+0x14)
+#define SEP6200_UART0_MSR	(SEP6200_UART0_BASE+0x18)
+
+
+#define    SEP6200_TIMER_T1LCR              (SEP6200_TIMER_BASE + 0X000)
+#define    SEP6200_TIMER_T1CCR              (SEP6200_TIMER_BASE + 0X004)
+#define    SEP6200_TIMER_T1CR               (SEP6200_TIMER_BASE + 0X008)
+#define    SEP6200_TIMER_T1ISCR             (SEP6200_TIMER_BASE + 0X00C)
+#define    SEP6200_TIMER_T1IMSR             (SEP6200_TIMER_BASE + 0X010)
+#define    SEP6200_TIMER_T2LCR              (SEP6200_TIMER_BASE + 0X020)
+#define    SEP6200_TIMER_T2CCR              (SEP6200_TIMER_BASE + 0X024)
+#define    SEP6200_TIMER_T2CR               (SEP6200_TIMER_BASE + 0X028)
+#define    SEP6200_TIMER_T2ISCR             (SEP6200_TIMER_BASE + 0X02C)
+#define    SEP6200_TIMER_T2IMSR             (SEP6200_TIMER_BASE + 0X030)
+#define    SEP6200_TIMER_T3LCR              (SEP6200_TIMER_BASE + 0X040)
+#define    SEP6200_TIMER_T3CCR              (SEP6200_TIMER_BASE + 0X044)
+#define    SEP6200_TIMER_T3CR               (SEP6200_TIMER_BASE + 0X048)
+#define    SEP6200_TIMER_T3ISCR             (SEP6200_TIMER_BASE + 0X04C)
+#define    SEP6200_TIMER_T3IMSR             (SEP6200_TIMER_BASE + 0X050)
+#define    SEP6200_TIMER_T3CAPR             (SEP6200_TIMER_BASE + 0X054)
+#define    SEP6200_TIMER_T4LCR              (SEP6200_TIMER_BASE + 0X060)
+#define    SEP6200_TIMER_T4CCR              (SEP6200_TIMER_BASE + 0X064)
+#define    SEP6200_TIMER_T4CR               (SEP6200_TIMER_BASE + 0X068)
+#define    SEP6200_TIMER_T4ISCR             (SEP6200_TIMER_BASE + 0X06C)
+#define    SEP6200_TIMER_T4IMSR             (SEP6200_TIMER_BASE + 0X070)
+#define    SEP6200_TIMER_T4CAPR             (SEP6200_TIMER_BASE + 0X074)
+#define    SEP6200_TIMER_T5LCR              (SEP6200_TIMER_BASE + 0X080)
+#define    SEP6200_TIMER_T5CCR              (SEP6200_TIMER_BASE + 0X084)
+#define    SEP6200_TIMER_T5CR               (SEP6200_TIMER_BASE + 0X088)
+#define    SEP6200_TIMER_T5ISCR             (SEP6200_TIMER_BASE + 0X08C)
+#define    SEP6200_TIMER_T5IMSR             (SEP6200_TIMER_BASE + 0X090)
+#define    SEP6200_TIMER_T5CAPR             (SEP6200_TIMER_BASE + 0X094)
+#define    SEP6200_TIMER_T6LCR              (SEP6200_TIMER_BASE + 0X0A0)
+#define    SEP6200_TIMER_T6CCR              (SEP6200_TIMER_BASE + 0X0A4)
+#define    SEP6200_TIMER_T6CR               (SEP6200_TIMER_BASE + 0X0A8)
+#define    SEP6200_TIMER_T6ISCR             (SEP6200_TIMER_BASE + 0X0AC)
+#define    SEP6200_TIMER_T6IMSR             (SEP6200_TIMER_BASE + 0X0B0)
+#define    SEP6200_TIMER_T6CAPR             (SEP6200_TIMER_BASE + 0X0B4)
+#define    SEP6200_TIMER_T7LCR              (SEP6200_TIMER_BASE + 0X0C0)
+#define    SEP6200_TIMER_T7CCR              (SEP6200_TIMER_BASE + 0X0C4)
+#define    SEP6200_TIMER_T7CR               (SEP6200_TIMER_BASE + 0X0C8)
+#define    SEP6200_TIMER_T7ISCR             (SEP6200_TIMER_BASE + 0X0CC)
+#define    SEP6200_TIMER_T7IMSR             (SEP6200_TIMER_BASE + 0X0D0)
+#define    SEP6200_TIMER_T8LCR              (SEP6200_TIMER_BASE + 0X0E0)
+#define    SEP6200_TIMER_T8CCR              (SEP6200_TIMER_BASE + 0X0E4)
+#define    SEP6200_TIMER_T8CR               (SEP6200_TIMER_BASE + 0X0E8)
+#define    SEP6200_TIMER_T8ISCR             (SEP6200_TIMER_BASE + 0X0EC)
+#define    SEP6200_TIMER_T8IMSR             (SEP6200_TIMER_BASE + 0X0F0)
+#define    SEP6200_TIMER_T9LCR              (SEP6200_TIMER_BASE + 0X100)
+#define    SEP6200_TIMER_T9CCR              (SEP6200_TIMER_BASE + 0X104)
+#define    SEP6200_TIMER_T9CR               (SEP6200_TIMER_BASE + 0X108)
+#define    SEP6200_TIMER_T9ISCR             (SEP6200_TIMER_BASE + 0X10C)
+#define    SEP6200_TIMER_T9IMSR             (SEP6200_TIMER_BASE + 0X110)
+#define    SEP6200_TIMER_T10LCR             (SEP6200_TIMER_BASE + 0X120)
+#define    SEP6200_TIMER_T10CCR             (SEP6200_TIMER_BASE + 0X124)
+#define    SEP6200_TIMER_T10CR              (SEP6200_TIMER_BASE + 0X128)
+#define    SEP6200_TIMER_T10ISCR            (SEP6200_TIMER_BASE + 0X12C)
+#define    SEP6200_TIMER_T10IMSR            (SEP6200_TIMER_BASE + 0X130)
+#define    SEP6200_TIMER_TIMSR              (SEP6200_TIMER_BASE + 0X140)
+#define    SEP6200_TIMER_TISCR              (SEP6200_TIMER_BASE + 0X144)
+#define    SEP6200_TIMER_TISR               (SEP6200_TIMER_BASE + 0X148)
+
+#define    SEP6200_VIC_INT_SLT_L            (SEP6200_VIC_BASE + 0x000)
+#define    SEP6200_VIC_INT_SLT_H            (SEP6200_VIC_BASE + 0x004)
+#define    SEP6200_VIC_INT_EN_L             (SEP6200_VIC_BASE + 0x008)
+#define    SEP6200_VIC_INT_EN_H             (SEP6200_VIC_BASE + 0x00C)
+#define    SEP6200_VIC_INT_EN_CLR_L         (SEP6200_VIC_BASE + 0x010)
+#define    SEP6200_VIC_INT_EN_CLR_H         (SEP6200_VIC_BASE + 0x014)
+#define    SEP6200_VIC_SFT_INT_L            (SEP6200_VIC_BASE + 0x018)
+#define    SEP6200_VIC_SFT_INT_H            (SEP6200_VIC_BASE + 0x01C)
+#define    SEP6200_VIC_SFT_INT_CLR_L        (SEP6200_VIC_BASE + 0x020)
+#define    SEP6200_VIC_SFT_INT_CLR_H        (SEP6200_VIC_BASE + 0x024)
+#define    SEP6200_VIC_INT_MSK_ALL          (SEP6200_VIC_BASE + 0x028)
+#define    SEP6200_VIC_RAW_INT_SRC_L        (SEP6200_VIC_BASE + 0x030)
+#define    SEP6200_VIC_RAW_INT_SRC_H        (SEP6200_VIC_BASE + 0x034)
+#define    SEP6200_VIC_RAW_IRQ_STS_L        (SEP6200_VIC_BASE + 0x038)
+#define    SEP6200_VIC_RAW_IRQ_STS_H        (SEP6200_VIC_BASE + 0x03C)
+#define    SEP6200_VIC_RAW_FIQ_STS_L        (SEP6200_VIC_BASE + 0x040)
+#define    SEP6200_VIC_RAW_FIQ_STS_H        (SEP6200_VIC_BASE + 0x044)
+#define    SEP6200_VIC_MSK_IRQ_STS_L        (SEP6200_VIC_BASE + 0x048)
+#define    SEP6200_VIC_MSK_IRQ_STS_H        (SEP6200_VIC_BASE + 0x04C)
+#define    SEP6200_VIC_MSK_FIQ_STS_L        (SEP6200_VIC_BASE + 0x050)
+#define    SEP6200_VIC_MSK_FIQ_STS_H        (SEP6200_VIC_BASE + 0x054)
+#define    SEP6200_VIC_IRQ_PENDING_L        (SEP6200_VIC_BASE + 0x058)
+#define    SEP6200_VIC_IRQ_PENDING_H        (SEP6200_VIC_BASE + 0x05C)
+#define    SEP6200_VIC_FIQ_PENDING_L        (SEP6200_VIC_BASE + 0x060)
+#define    SEP6200_VIC_FIQ_PENDING_H        (SEP6200_VIC_BASE + 0x064)
+#define    SEP6200_VIC_IRQ_VECTOR_BASE      (SEP6200_VIC_BASE + 0x070)
+#define    SEP6200_VIC_FIQ_VECTOR_BASE      (SEP6200_VIC_BASE + 0x074)
+#define    SEP6200_VIC_IRQ_VECTOR_NUM       (SEP6200_VIC_BASE + 0x078)
+#define    SEP6200_VIC_FIQ_VECTOR_NUM       (SEP6200_VIC_BASE + 0x07C)
+#define    SEP6200_VIC_IRQ_VECTOR_ADDR      (SEP6200_VIC_BASE + 0x080)
+#define    SEP6200_VIC_FIQ_VECTOR_ADDR      (SEP6200_VIC_BASE + 0x084)
+#define    SEP6200_VIC_PROIRTY_MASK         (SEP6200_VIC_BASE + 0x090)
+#define    SEP6200_VIC_VECTOR_PROIRTY00     (SEP6200_VIC_BASE + 0x100)
+#define    SEP6200_VIC_VECTOR_PROIRTY01     (SEP6200_VIC_BASE + 0x104)
+#define    SEP6200_VIC_VECTOR_PROIRTY02     (SEP6200_VIC_BASE + 0x108)
+#define    SEP6200_VIC_VECTOR_PROIRTY03     (SEP6200_VIC_BASE + 0x10C)
+#define    SEP6200_VIC_VECTOR_PROIRTY04     (SEP6200_VIC_BASE + 0x110)
+#define    SEP6200_VIC_VECTOR_PROIRTY05     (SEP6200_VIC_BASE + 0x114)
+#define    SEP6200_VIC_VECTOR_PROIRTY06     (SEP6200_VIC_BASE + 0x118)
+#define    SEP6200_VIC_VECTOR_PROIRTY07     (SEP6200_VIC_BASE + 0x11C)
+#define    SEP6200_VIC_VECTOR_PROIRTY08     (SEP6200_VIC_BASE + 0x120)
+#define    SEP6200_VIC_VECTOR_PROIRTY09     (SEP6200_VIC_BASE + 0x124)
+#define    SEP6200_VIC_VECTOR_PROIRTY10     (SEP6200_VIC_BASE + 0x128)
+#define    SEP6200_VIC_VECTOR_PROIRTY11     (SEP6200_VIC_BASE + 0x12C)
+#define    SEP6200_VIC_VECTOR_PROIRTY12     (SEP6200_VIC_BASE + 0x130)
+#define    SEP6200_VIC_VECTOR_PROIRTY13     (SEP6200_VIC_BASE + 0x134)
+#define    SEP6200_VIC_VECTOR_PROIRTY14     (SEP6200_VIC_BASE + 0x138)
+#define    SEP6200_VIC_VECTOR_PROIRTY15     (SEP6200_VIC_BASE + 0x13C)
+#define    SEP6200_VIC_VECTOR_PROIRTY16     (SEP6200_VIC_BASE + 0x140)
+#define    SEP6200_VIC_VECTOR_PROIRTY17     (SEP6200_VIC_BASE + 0x144)
+#define    SEP6200_VIC_VECTOR_PROIRTY18     (SEP6200_VIC_BASE + 0x148)
+#define    SEP6200_VIC_VECTOR_PROIRTY19     (SEP6200_VIC_BASE + 0x14C)
+#define    SEP6200_VIC_VECTOR_PROIRTY20     (SEP6200_VIC_BASE + 0x150)
+#define    SEP6200_VIC_VECTOR_PROIRTY21     (SEP6200_VIC_BASE + 0x154)
+#define    SEP6200_VIC_VECTOR_PROIRTY22     (SEP6200_VIC_BASE + 0x158)
+#define    SEP6200_VIC_VECTOR_PROIRTY23     (SEP6200_VIC_BASE + 0x15C)
+#define    SEP6200_VIC_VECTOR_PROIRTY24     (SEP6200_VIC_BASE + 0x160)
+#define    SEP6200_VIC_VECTOR_PROIRTY25     (SEP6200_VIC_BASE + 0x164)
+#define    SEP6200_VIC_VECTOR_PROIRTY26     (SEP6200_VIC_BASE + 0x168)
+#define    SEP6200_VIC_VECTOR_PROIRTY27     (SEP6200_VIC_BASE + 0x16C)
+#define    SEP6200_VIC_VECTOR_PROIRTY28     (SEP6200_VIC_BASE + 0x170)
+#define    SEP6200_VIC_VECTOR_PROIRTY29     (SEP6200_VIC_BASE + 0x174)
+#define    SEP6200_VIC_VECTOR_PROIRTY30     (SEP6200_VIC_BASE + 0x178)
+#define    SEP6200_VIC_VECTOR_PROIRTY31     (SEP6200_VIC_BASE + 0x17C)
+#define    SEP6200_VIC_VECTOR_PROIRTY32     (SEP6200_VIC_BASE + 0x180)
+#define    SEP6200_VIC_VECTOR_PROIRTY33     (SEP6200_VIC_BASE + 0x184)
+#define    SEP6200_VIC_VECTOR_PROIRTY34     (SEP6200_VIC_BASE + 0x188)
+#define    SEP6200_VIC_VECTOR_PROIRTY35     (SEP6200_VIC_BASE + 0x18C)
+#define    SEP6200_VIC_VECTOR_PROIRTY36     (SEP6200_VIC_BASE + 0x190)
+#define    SEP6200_VIC_VECTOR_PROIRTY37     (SEP6200_VIC_BASE + 0x194)
+#define    SEP6200_VIC_VECTOR_PROIRTY38     (SEP6200_VIC_BASE + 0x198)
+#define    SEP6200_VIC_VECTOR_PROIRTY39     (SEP6200_VIC_BASE + 0x19C)
+#define    SEP6200_VIC_VECTOR_PROIRTY40     (SEP6200_VIC_BASE + 0x1A0)
+#define    SEP6200_VIC_VECTOR_PROIRTY41     (SEP6200_VIC_BASE + 0x1A4)
+#define    SEP6200_VIC_VECTOR_PROIRTY42     (SEP6200_VIC_BASE + 0x1A8)
+#define    SEP6200_VIC_VECTOR_PROIRTY43     (SEP6200_VIC_BASE + 0x1AC)
+#define    SEP6200_VIC_VECTOR_PROIRTY44     (SEP6200_VIC_BASE + 0x1B0)
+#define    SEP6200_VIC_VECTOR_PROIRTY45     (SEP6200_VIC_BASE + 0x1B4)
+#define    SEP6200_VIC_VECTOR_PROIRTY46     (SEP6200_VIC_BASE + 0x1B8)
+#define    SEP6200_VIC_VECTOR_PROIRTY47     (SEP6200_VIC_BASE + 0x1BC)
+#define    SEP6200_VIC_VECTOR_PROIRTY48     (SEP6200_VIC_BASE + 0x1C0)
+#define    SEP6200_VIC_VECTOR_PROIRTY49     (SEP6200_VIC_BASE + 0x1C4)
+#define    SEP6200_VIC_VECTOR_PROIRTY50     (SEP6200_VIC_BASE + 0x1C8)
+#define    SEP6200_VIC_VECTOR_PROIRTY51     (SEP6200_VIC_BASE + 0x1CC)
+#define    SEP6200_VIC_VECTOR_PROIRTY52     (SEP6200_VIC_BASE + 0x1D0)
+#define    SEP6200_VIC_VECTOR_PROIRTY53     (SEP6200_VIC_BASE + 0x1D4)
+#define    SEP6200_VIC_VECTOR_PROIRTY54     (SEP6200_VIC_BASE + 0x1D8)
+#define    SEP6200_VIC_VECTOR_PROIRTY55     (SEP6200_VIC_BASE + 0x1DC)
+#define    SEP6200_VIC_VECTOR_PROIRTY56     (SEP6200_VIC_BASE + 0x1E0)
+#define    SEP6200_VIC_VECTOR_PROIRTY57     (SEP6200_VIC_BASE + 0x1E4)
+#define    SEP6200_VIC_VECTOR_PROIRTY58     (SEP6200_VIC_BASE + 0x1E8)
+#define    SEP6200_VIC_VECTOR_PROIRTY59     (SEP6200_VIC_BASE + 0x1EC)
+#define    SEP6200_VIC_VECTOR_PROIRTY60     (SEP6200_VIC_BASE + 0x1F0)
+#define    SEP6200_VIC_VECTOR_PROIRTY61     (SEP6200_VIC_BASE + 0x1F4)
+#define    SEP6200_VIC_VECTOR_PROIRTY62     (SEP6200_VIC_BASE + 0x1F8)
+#define    SEP6200_VIC_VECTOR_PROIRTY63     (SEP6200_VIC_BASE + 0x1FC)
+
+#define    SEP6200_PMU_PLL_SET              (SEP6200_PMU_BASE + 0x000)
+#define    SEP6200_PMU_APLL_CFG             (SEP6200_PMU_BASE + 0x004)
+#define    SEP6200_PMU_MPLL_GFG             (SEP6200_PMU_BASE + 0x008)
+#define    SEP6200_PMU_DPLL_CFG             (SEP6200_PMU_BASE + 0x00C)
+#define    SEP6200_PMU_PMDR                 (SEP6200_PMU_BASE + 0x010)
+#define    SEP6200_PMU_CLK_GT_CFG1          (SEP6200_PMU_BASE + 0x014)
+#define    SEP6200_PMU_CLK_GT_CFG2          (SEP6200_PMU_BASE + 0x018)
+#define    SEP6200_PMU_PWR_GT_CFG           (SEP6200_PMU_BASE + 0x01C)
+#define    SEP6200_PMU_AHB_CLK_CFG          (SEP6200_PMU_BASE + 0x020)
+#define    SEP6200_PMU_ARM_CLK_CFG          (SEP6200_PMU_BASE + 0x024)
+#define    SEP6200_PMU_DDR_CLK_CFG          (SEP6200_PMU_BASE + 0x028)
+#define    SEP6200_PMU_PIX_CLK_CFG          (SEP6200_PMU_BASE + 0x02C)
+#define    SEP6200_PMU_GPU_CLK2X_CFG        (SEP6200_PMU_BASE + 0x030)
+#define    SEP6200_PMU_DIV_SET              (SEP6200_PMU_BASE + 0x034)
+#define    SEP6200_PMU_CRYSTAL_CFG          (SEP6200_PMU_BASE + 0x038)
+#define    SEP6200_PMU_MSK_WAKEUP           (SEP6200_PMU_BASE + 0x03C)
+#define    SEP6200_PMU_RTCR                 (SEP6200_PMU_BASE + 0x040)
+#define    SEP6200_PMU_CLR_WAKEUP           (SEP6200_PMU_BASE + 0x044)
+#define    SEP6200_PMU_WAKEUP_TIME          (SEP6200_PMU_BASE + 0x048)
+#define    SEP6200_PMU_SLEEP_FLAG           (SEP6200_PMU_BASE + 0x04C)
+#define    SEP6200_PMU_WAIT_PWR_SWITCH      (SEP6200_PMU_BASE + 0x050)
+#define    SEP6200_PMU_PWR_STATE            (SEP6200_PMU_BASE + 0x054)
+#define    SEP6200_PMU_INT_POL_SEL          (SEP6200_PMU_BASE + 0x058)
+#define    SEP6200_PMU_PLLLD                (SEP6200_PMU_BASE + 0x05C)
+#define    SEP6200_PMU_IC_ENABLE            (SEP6200_PMU_BASE + 0x060)
+#define    SEP6200_PMU_IC_TAR               (SEP6200_PMU_BASE + 0x064)
+#define    SEP6200_PMU_IC_SCL_LCNT          (SEP6200_PMU_BASE + 0x068)
+#define    SEP6200_PMU_IC_SCL_HCNT          (SEP6200_PMU_BASE + 0x06C)
+#define    SEP6200_PMU_IC_DATA_CMD          (SEP6200_PMU_BASE + 0x070)
+#define    SEP6200_PMU_IC_STATE             (SEP6200_PMU_BASE + 0x074)
+#define    SEP6200_PMU_IC_SET               (SEP6200_PMU_BASE + 0x078)
+#define    SEP6200_PMU_HA_PWR_OFF_DAT       (SEP6200_PMU_BASE + 0x07C)
+#define    SEP6200_PMU_HA_PWR_ON_DAT        (SEP6200_PMU_BASE + 0x080)
+#define    SEP6200_PMU_HA_PWR_OFF_DAT_CNT   (SEP6200_PMU_BASE + 0x084)
+#define    SEP6200_PMU_HA_PWR_ON_DAT_CNT    (SEP6200_PMU_BASE + 0x088)
+#define    SEP6200_PMU_PWR_OFF_TIME         (SEP6200_PMU_BASE + 0x08C)
+#define    SEP6200_PMU_PWR_ON_TIME          (SEP6200_PMU_BASE + 0x090)
+#define    SEP6200_PMU_PWR_ON_POL_SEL       (SEP6200_PMU_BASE + 0x094)
+#define    SEP6200_PMU_RETURN_ADDR          (SEP6200_PMU_BASE + 0x098)
+#define    SEP6200_PMU_INT                  (SEP6200_PMU_BASE + 0x09C)
+
+/* define the interrupt source number */
+#define    INTSRC_RESERVE2      63
+#define    INTSRC_RESERVE1      62
+#define    INTSRC_LCDC          61
+#define    INTSRC_GPU           60
+#define    INTSRC_VPU           59
+#define    INTSRC_TIMER3        58
+#define    INTSRC_TIMER2        57
+#define    INTSRC_TIMER1        56
+#define    INTSRC_NAND          55
+#define    INTSRC_I2S           54
+#define    INTSRC_I2C3          53
+#define    INTSRC_I2C2          52
+#define    INTSRC_I2C1          51
+#define    INTSRC_SSI3          50
+#define    INTSRC_SSI2          49
+#define    INTSRC_SSI1          48
+#define    INTSRC_SDIO2         47
+#define    INTSRC_SDIO1         46
+#define    INTSRC_UART3         45
+#define    INTSRC_UART2         44
+#define    INTSRC_UART1         43
+#define    INTSRC_UART0         42
+#define    INTSRC_PWM           41
+#define    INTSRC_USB           40
+#define    INTSRC_USBDMA        39
+#define    INTSRC_DMAC2         38
+#define    INTSRC_DMAC1         37
+#define    INTSRC_PMUIRQ_A11    36
+#define    INTSRC_DMAIRQ_A11    35
+#define    INTSRC_GPS           34
+#define    INTSRC_RTC           33
+#define    INTSRC_RESERVED16    32
+#define    INTSRC_PORTE12       31
+#define    INTSRC_PORTE11       30
+#define    INTSRC_PORTE10       29
+#define    INTSRC_PORTE9        28
+#define    INTSRC_PORTE5        27
+#define    INTSRC_PORTE4        26
+#define    INTSRC_PORTD9        25
+#define    INTSRC_PORTD8        24
+#define    INTSRC_PORTD3        23
+#define    INTSRC_PORTD2        22
+#define    INTSRC_PORTD1        21
+#define    INTSRC_PORTD0        20
+#define    INTSRC_PORTC3        19
+#define    INTSRC_PORTC2        18
+#define    INTSRC_PORTC1        17
+#define    INTSRC_PORTC0        16
+#define    INTSRC_EXT15         15
+#define    INTSRC_EXT14         14
+#define    INTSRC_EXT13         13
+#define    INTSRC_EXT12         12
+#define    INTSRC_EXT11         11
+#define    INTSRC_EXT10         10
+#define    INTSRC_EXT9          9
+#define    INTSRC_EXT8          8
+#define    INTSRC_EXT7          7
+#define    INTSRC_EXT6          6
+#define    INTSRC_EXT5          5
+#define    INTSRC_EXT4          4
+#define    INTSRC_AO_EXT3       3
+#define    INTSRC_AO_EXT2       2
+#define    INTSRC_AO_EXT1       1
+#define    INTSRC_AO_EXT0       0
+
+
+typedef    char                 S8;        /* signed 8-bit integer */
+typedef    short                S16;       /* signed 16-bit integer */
+typedef    long                 S32;       /* signed 32-bit integer */
+typedef    unsigned char        U8;        /* unsigned 8-bit integer */
+typedef    unsigned short       U16;       /* unsigned 16-bit integer */
+typedef    unsigned long        U32;       /* unsigned 32-bit integer */
+
+typedef    volatile U32 *       RP;
+typedef    volatile U16 *       RP16;
+typedef    volatile U8  *       RP8;
+
+typedef    void                 *VP;       /* pointer to an unpredictable data type */
+typedef    void                 (*FP)();   /* program start address */
+
+#ifndef    _BOOL_TYPE_
+#define    _BOOL_TYPE_
+typedef    int                  BOOL;	     /* Boolean value.  TRUE (1) or FALSE (0). */
+#endif
+
+typedef    int                  ER;         /* Error code.  A signed integer. */
+
+/**
+ * IO definitions
+ *
+ * define access restrictions to peripheral registers
+ */
+
+#define     __I     volatile const            /*!< defines 'read only' permissions      */
+#define     __O     volatile                  /*!< defines 'write only' permissions     */
+#define     __IO    volatile                  /*!< defines 'read / write' permissions   */
+#define     __iomem volatile
+
+
+/*Macros for debug*/
+
+#define EOUT(fmt,...) \
+	do \
+	{ 	\
+		rt_kprintf("EOUT:(%s:%i)  ",__FILE__,__LINE__); \
+		rt_kprintf(fmt,##__VA_ARGS__); \
+	}while(0)
+
+#define RT_DEBUG
+#ifdef RT_DEBUG
+	#define DBOUT(fmt,...) \
+	do \
+	{ 	\
+		rt_kprintf("DBOUT:(%s:%i)  ",__FILE__,__LINE__); \
+		rt_kprintf(fmt,##__VA_ARGS__); \
+	}while(0)
+#else
+	#define DBOUT(fmt,...) \
+	do{}while(0)
+#endif
+
+#ifdef	RT_DEBUG
+	#define ASSERT(arg) \
+	if((arg) == 0) \
+	{		\
+		while(1) \
+		{		  \
+			rt_kprintf("have a assert failure\n"); \
+		}										 \
+	}
+#else
+	#define ASSERT(arg) \
+	do		\
+	{		 \
+	}while(0)
+#endif
+
+
+#define write_reg(reg,value) \
+	do \
+	{ \
+		*(RP)(reg) = value; \
+	}while(0)
+
+#define read_reg(reg) (*(RP)reg)
+
+
+struct rt_hw_register
+{
+	rt_uint32_t r0;
+	rt_uint32_t r1;
+	rt_uint32_t r2;
+	rt_uint32_t r3;
+	rt_uint32_t r4;
+	rt_uint32_t r5;
+	rt_uint32_t r6;
+	rt_uint32_t r7;
+	rt_uint32_t r8;
+	rt_uint32_t r9;
+	rt_uint32_t r10;
+	rt_uint32_t r11;
+	rt_uint32_t r12;
+	rt_uint32_t r13;
+	rt_uint32_t r14;
+	rt_uint32_t r15;
+	rt_uint32_t r16;
+	rt_uint32_t r17;
+	rt_uint32_t r18;
+	rt_uint32_t r19;
+	rt_uint32_t r20;
+	rt_uint32_t r21;
+	rt_uint32_t r22;
+	rt_uint32_t r23;
+	rt_uint32_t r24;
+	rt_uint32_t sb;
+	rt_uint32_t sl;
+	rt_uint32_t fp;
+	rt_uint32_t ip;
+	rt_uint32_t sp;
+	rt_uint32_t lr;
+	rt_uint32_t pc;
+	rt_uint32_t asr;
+	rt_uint32_t bsr;
+	rt_uint32_t ORIG_r0;
+};
+
+/*@}*/
+
+#endif

libcpu/unicore32/sep6200/serial.c

@@ -0,0 +1,289 @@
+/*
+ * File      : serial.c
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2006 - 2013, RT-Thread Development Team
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * 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

@@ -0,0 +1,106 @@
+/*
+ * File      : serial.h
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2006 - 2013, RT-Thread Development Team
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * 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

@@ -0,0 +1,88 @@
+/*
+ * File      : stack.c
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2006 - 2013, RT-Thread Development Team
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2013-7-14      Peng Fan     sep6200 implementation
+ */
+
+#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

@@ -0,0 +1,363 @@
+/*
+ * File      : start.S
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2006 - 2013, RT-Thread Development Team
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * 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
+
+/*
+ *************************************************************************
+ *
+ * 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 + 1024
+
+.globl FIQ_STACK_START
+FIQ_STACK_START:
+     .word   _fiq_stack_start +1024
+
+.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 + 4096
+
+.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
+
+  /* copy the vector code to address 0 */
+	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 */
+	.align  5
+extend_handle:
+    b rt_hw_trap_extn
+swi_handle:
+    b rt_hw_trap_swi
+iabort_handle:
+    b rt_hw_trap_pabt
+dabort_handle:
+    b rt_hw_trap_dabt
+reserve_handle:
+    b rt_hw_trap_resv
+
+.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:
+  b rt_hw_trap_fiq
+
+_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 */
+
+  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 (lr), [sp-]
+  stm.w (r16 - r28), [sp-]
+  stm.w (r4 - r15), [sp-]
+	mov		r4,  r1	/* Special optimised code below		*/
+  mov		r5,  r3
+  ldm.w (r0 - r3), [r4]+
+  stm.w (r0 - 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*/
+
+	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]+
+  ldm.w (pc), [sp]+
+
+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

@@ -0,0 +1,29 @@
+/*
+ * File      : trace.c
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2006 - 2013, RT-Thread Development Team
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2017-07-17     Peng Fan     sep6200 implementation
+ */
+#include <rtthread.h>
+
+void rt_hw_backtrace(rt_uint32_t *fp, rt_uint32_t thread_entry)
+{
+
+}

libcpu/unicore32/sep6200/trap.c

@@ -0,0 +1,174 @@
+/*
+ * File      : trap.c
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2006 - 2013, RT-Thread Development Team
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * 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");
+}
+
+/*@}*/