import RT-Thread RTOS 0.3.x to Google SVN

git-svn-id: https://rt-thread.googlecode.com/svn/trunk@2 bbd45198-f89e-11dd-88c7-29a3b14d5316

3 files changed, 1033 insertions, 0 deletions

diff --git a/include/rtdef.h b/include/rtdef.h
new file mode 100644
index 0000000000..2c21f5a258
--- /dev/null
+++ b/include/rtdef.h
@@ -0,0 +1,632 @@
+/*
+ * File      : rtdef.h
+ * 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
+ * 2007-01-10     Bernard      the first version
+ * 2008-07-12	  Bernard	   remove all rt_int8, rt_uint32_t etc typedef
+ */
+#ifndef __RT_DEF_H__
+#define __RT_DEF_H__
+
+#include <rtconfig.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef signed char  rt_int8_t;
+typedef signed short rt_int16_t;
+typedef signed long  rt_int32_t;
+typedef unsigned char  rt_uint8_t;
+typedef unsigned short rt_uint16_t;
+typedef unsigned long  rt_uint32_t;
+typedef int rt_bool_t;
+
+#define RT_UINT8_MAX	0xff
+#define RT_UINT16_MAX	0xffff
+#define RT_UINT32_MAX	0xffffffff
+
+/* 32bit CPU */
+typedef long rt_base_t;
+typedef unsigned long rt_ubase_t;
+
+/* RT-Thread bool type definitions */
+#define RT_TRUE 			1
+#define RT_FALSE 			0
+
+#ifdef __CC_ARM                 /* ARM Compiler */
+    #include <stdarg.h>
+    #define SECTION(x)  __attribute__((section(x)))
+    #define UNUSED  __attribute__((unused))
+    #define rt_inline   static __inline
+
+#elif defined (__ICCARM__)        /* for IAR Compiler */
+    #include <stdarg.h>
+    #define SECTION(x)  @ x
+    #define UNUSED
+    #define rt_inline inline
+
+#elif defined (__GNUC__)        /* GNU GCC Compiler */
+    #ifdef RT_USING_NEWLIB
+        #include <stdarg.h>
+    #else
+        typedef void *__sys_va_list;
+        typedef __sys_va_list va_list;
+        #define __va_rounded_size(type)	\
+            (((sizeof (type) + sizeof (int) - 1) / sizeof (int)) * sizeof (int))
+        #define va_start(ap, lastarg)	\
+            (ap = ((char *) &(lastarg) + __va_rounded_size(lastarg)))
+        #define va_end(ap)	((void)0)
+        /*	little endian */
+        #define va_arg(ap, type)	\
+            (ap = (__sys_va_list) ((char *) (ap) + __va_rounded_size (type)),  \
+            *((type *) (void *) ((char *) (ap) - __va_rounded_size (type))))
+    #endif
+
+    #define SECTION(x) __attribute__((section(x)))
+    #define UNUSED __attribute__((unused))
+    #define rt_inline static __inline
+#endif
+
+/* event length */
+#define RT_EVENT_LENGTH		32
+
+/* memory management option */
+#define RT_MM_PAGE_SIZE		4096
+#define RT_MM_PAGE_MASK 	(RT_MM_PAGE_SIZE - 1)
+#define RT_MM_PAGE_BITS		12
+
+/* RT-Thread definitions */
+typedef rt_base_t	rt_err_t;		/* Type for error number.	*/
+typedef rt_uint32_t	rt_time_t;		/* Type for time stamp. 	*/
+typedef rt_uint32_t	rt_tick_t;		/* Type for tick count. 	*/
+typedef rt_base_t	rt_flag_t;		/* Type for flags. 			*/
+typedef rt_ubase_t	rt_size_t;		/* Type for size number.	*/
+typedef rt_ubase_t	rt_dev_t;		/* Type for device.			*/
+typedef rt_uint32_t	rt_off_t;		/* Type for offset.			*/
+
+/* maximun value of base type */
+#define RT_UINT8_MAX	0xff		/* Maxium number of UINT8.	*/
+#define RT_UINT16_MAX	0xffff		/* Maxium number of UINT16.	*/
+#define RT_UINT32_MAX	0xffffffff	/* Maxium number of UINT32.	*/
+
+/* RT-Thread version information */
+#define RT_VERSION			3
+#define RT_SUBVERSION		0
+
+/**
+ * @addtogroup Error
+ */
+/*@{*/
+/* RT-Thread error code definitions */
+#define RT_EOK				0		/* There is no error 		*/
+#define RT_ERROR			1		/* A generic error happens 	*/
+#define RT_ETIMEOUT			2		/* Timed out 				*/
+#define RT_EFULL			3		/* The resource is full		*/
+#define RT_EEMPTY			4		/* The resource is empty 	*/
+#define RT_ENOMEM			5		/* No memory				*/
+#define RT_ENOSYS			6		/* No system 				*/
+#define RT_EBUSY			7		/* Busy						*/
+/*@}*/
+
+#ifdef RT_DEBUG
+#define RT_ASSERT(EX)		if (!(EX)) { rt_kprintf("(%s) assert failed at %s:%d \n", #EX, __FUNCTION__, __LINE__); while (1);}
+#else
+#define RT_ASSERT(EX)
+#endif
+
+/**
+ * @def RT_ALIGN(size, align)
+ * Return the most contiguous size aligned at specified width. RT_ALIGN(13, 4)
+ * would equal to 16. It is needed in some critical contexts.
+ */
+#define RT_ALIGN(size, align)	(((size) + (align) - 1) & ~((align)-1))
+
+/**
+ * @def RT_NULL
+ * Similar as the \c NULL in C library.
+ */
+#define RT_NULL 				((void *)0)
+
+struct rt_list_node
+{
+	struct rt_list_node *next;	/* point to next node. */
+	struct rt_list_node *prev;	/* point to prev node. */
+};
+typedef struct rt_list_node rt_list_t;	/* Type for lists. */
+
+/**
+ * @addtogroup KernelObject
+ */
+/*@{*/
+/*
+ * Base structure of Kernel object
+ */
+struct rt_object
+{
+	/* name of kernel object			*/
+	char      name[RT_NAME_MAX];
+	/* type of kernel object 			*/
+	rt_uint8_t  type;
+	/* flag of kernel object			*/
+	rt_uint8_t  flag;
+	/* list pointer of kernel object 	*/
+	rt_list_t	list;
+};
+typedef struct rt_object* rt_object_t;	/* Type for kernel objects. */
+
+/**
+ *	The object type can be one of the follows with specific
+ *	macros enabled:
+ *	- Thread
+ *	- Process
+ *	- Semaphore
+ *	- Mutex
+ *	- FastEvent
+ *	- Event
+ *	- MailBox
+ *	- MessageQueue
+ *	- MemPool
+ *  - Device
+ *	- Timer
+ *	- Unknown
+ *	- Static
+ */
+enum rt_object_class_type
+{
+	RT_Object_Class_Thread = 0,	/* The object is a thread. */
+#ifdef RT_USING_SEMAPHORE
+	RT_Object_Class_Semaphore,	/* The object is a semaphore. */
+#endif
+#ifdef RT_USING_MUTEX
+	RT_Object_Class_Mutex,		/* The object is a mutex. */
+#endif
+#ifdef RT_USING_FASTEVENT
+	RT_Object_Class_FastEvent,	/* The object is a fast event. */
+#endif
+#ifdef RT_USING_EVENT
+	RT_Object_Class_Event,		/* The object is a event. */
+#endif
+#ifdef RT_USING_MAILBOX
+	RT_Object_Class_MailBox,	/* The object is a mail box. */
+#endif
+#ifdef RT_USING_MESSAGEQUEUE
+	RT_Object_Class_MessageQueue,/* The object is a message queue. */
+#endif
+#ifdef RT_USING_MEMPOOL
+	RT_Object_Class_MemPool,	/* The object is a memory pool. */
+#endif
+#ifdef RT_USING_DEVICE
+	RT_Object_Class_Device,		/* The object is a device */
+#endif
+	RT_Object_Class_Timer,		/* The object is a timer. */
+#ifdef RT_USING_MODULE
+	RT_Object_Class_Module,		/* The object is a module. */
+#endif
+	RT_Object_Class_Unknown,	/* The object is unknown. */
+	RT_Object_Class_Static = 0x80/* The object is a static object. */
+};
+
+/*
+ * the information of the kernel object
+ */
+struct rt_object_information
+{
+	enum rt_object_class_type type;		/* object class type. */
+	rt_list_t object_list;				/* object list. */
+	rt_size_t object_size;				/* object size. */
+};
+/*@}*/
+
+/**
+ * @addtogroup Clock
+ */
+/*@{*/
+
+/*
+ * clock & timer macros
+ */
+#define RT_TIMER_FLAG_DEACTIVATED	0x0	/* timer is deactive. */
+#define RT_TIMER_FLAG_ACTIVATED		0x1	/* timer is active. */
+#define RT_TIMER_FLAG_ONE_SHOT		0x0	/* one shot timer. */
+#define RT_TIMER_FLAG_PERIODIC		0x2	/* periodic timer. */
+
+#define RT_TIMER_CTRL_SET_TIME		0x0	/* set timer. */
+#define RT_TIMER_CTRL_GET_TIME		0x1	/* get timer. */
+#define RT_TIMER_CTRL_SET_ONESHOT	0x2	/* change timer to one shot. */
+#define RT_TIMER_CTRL_SET_PERIODIC	0x3	/* change timer to periodic. */
+
+/*
+ * timer structure
+ *
+ */
+struct rt_timer
+{
+	struct rt_object parent;
+
+	rt_list_t list;						/* the node of timer list. */
+
+	void (*timeout_func)(void* parameter);/* timeout function. */
+	void *parameter;					/* timeout function's parameter. */
+
+	rt_tick_t init_tick;				/* timer timeout tick. */
+	rt_tick_t timeout_tick;				/* timeout tick. */
+};
+typedef struct rt_timer* rt_timer_t;
+/*@}*/
+
+/**
+ * @addtogroup Thread
+ */
+/*@{*/
+
+/*
+ * Thread
+ */
+
+/* thread state definitions */
+#define RT_THREAD_RUNNING	0x0					/* Running. */
+#define RT_THREAD_READY		0x1					/* Ready. */
+#define RT_THREAD_SUSPEND	0x2					/* Suspend. */
+#define RT_THREAD_BLOCK		RT_THREAD_SUSPEND	/* Blocked. */
+#define RT_THREAD_CLOSE		0x3					/* Closed. */
+#define RT_THREAD_INIT		RT_THREAD_CLOSE		/* Inited. */
+
+#define RT_THREAD_FLAGS_TIMERSLICE 		0x01
+
+#define RT_THREAD_CTRL_STARTUP			0x00	/* Starup thread. */
+#define RT_THREAD_CTRL_CLOSE			0x01	/* Close thread. */
+#define RT_THREAD_CTRL_CHANGE_PRIORITY	0x02	/* Change thread priority. */
+#define RT_THREAD_CTRL_INFO				0x03	/* Get thread information. */
+
+typedef struct rt_thread* rt_thread_t;
+typedef struct rt_module* rt_module_t;
+
+/*
+ * Thread related structure
+ */
+struct rt_thread
+{
+	/* rt object */
+	char        name[RT_NAME_MAX];			/* the name of thread */
+	rt_uint8_t	type;						/* type of object */
+	rt_uint8_t  flags;						/* thread's flags */
+
+	rt_list_t	list;						/* the object list */
+
+	rt_thread_t tid;						/* the thread id */
+	rt_list_t	tlist;						/* the thread list */
+
+	/* stack point and entry */
+	void*		sp;							/* stack point */
+	void*		entry;						/* entry */
+	void*       parameter;					/* parameter */
+	void*       stack_addr;					/* stack address */
+	rt_uint16_t stack_size;					/* stack size */
+
+	/* error code */
+	rt_err_t    error;						/* error code */
+
+	/* priority */
+	rt_uint8_t	current_priority;			/* current priority */
+	rt_uint8_t	init_priority;				/* initialized priority */
+#if RT_THREAD_PRIORITY_MAX > 32
+	rt_uint8_t 	number;
+	rt_uint8_t	high_mask;
+#endif
+	rt_uint32_t	number_mask;
+
+#if defined(RT_USING_EVENT) || defined(RT_USING_FASTEVENT)
+	/* thread event */
+	rt_uint32_t event_set;
+	rt_uint8_t	event_info;
+#endif
+
+	rt_uint8_t	stat;						/* thread stat */
+
+	rt_ubase_t	init_tick;					/* thread's tick */
+	rt_ubase_t 	remaining_tick;				/* remaining tick */
+
+	struct rt_timer thread_timer;			/* thread timer */
+
+#ifdef RT_USING_MODULE
+	rt_module_t module_parent;				/* module parent */
+#endif
+
+	rt_uint32_t user_data;					/* user data */
+};
+/*@}*/
+
+#ifdef RT_USING_MODULE
+struct rt_module
+{
+	/* inherit from object */
+	struct rt_object parent;
+
+	rt_uint32_t module_data;
+	void* module_space;
+
+	void* module_entry;
+	rt_uint32_t stack_size;
+	rt_uint32_t thread_priority;
+	rt_thread_t module_thread;
+
+	/* module memory pool */
+	rt_uint32_t mempool_size;
+	void* module_mempool;
+
+	/* object in this module, module object is the last basic object type */
+	struct rt_object_information module_object[RT_Object_Class_Module];
+};
+#endif
+
+/**
+ * @addtogroup IPC
+ */
+/*@{*/
+/*
+ * ipc & sync
+ */
+#define RT_IPC_FLAG_FIFO	0x00	/* FIFOed IPC. @ref IPC. */
+#define RT_IPC_FLAG_PRIO	0x01	/* PRIOed IPC. @ref IPC. */
+
+#define RT_WAITING_FOREVER	-1		/* Block forever until get resource. */
+#define RT_WAITING_NO		0		/* Non-block. */
+
+/*
+ * Base structure of IPC object
+ */
+struct rt_ipc_object
+{
+	struct rt_object parent;
+
+	rt_list_t suspend_thread;		/* threads pended on this resource. */
+	rt_uint32_t suspend_thread_count;	/* numbers of thread pended on this resource. */
+};
+
+#ifdef RT_USING_SEMAPHORE
+/*
+ * semaphore
+ *
+ * Binary and counter semaphore are both supported.
+ */
+struct rt_semaphore
+{
+	struct rt_ipc_object parent;
+
+	rt_base_t value;				/* value of semaphore. */
+};
+typedef struct rt_semaphore* rt_sem_t;
+#endif
+
+#ifdef RT_USING_MUTEX
+/*
+ * mutex
+ */
+struct rt_mutex
+{
+	struct rt_ipc_object parent;
+
+	rt_base_t value;				/* value of mutex. */
+
+	struct rt_thread* owner;		/* current owner of mutex. */
+	rt_uint8_t original_priority;	/* priority of last thread hold the mutex. */
+
+	rt_base_t hold;					/* numbers of thread hold the mutex. Only 0 or 1 is legal. */
+};
+typedef struct rt_mutex* rt_mutex_t;
+#endif
+
+#if defined(RT_USING_EVENT) || defined(RT_USING_FASTEVENT)
+#define RT_EVENT_FLAG_AND		0x01
+#define RT_EVENT_FLAG_OR		0x02
+#define RT_EVENT_FLAG_CLEAR		0x04
+#endif
+
+#ifdef RT_USING_FASTEVENT
+/*
+ * fast_event
+ */
+struct rt_fast_event
+{
+	struct rt_object parent;
+
+	rt_uint32_t set;				/* event set. */
+
+	rt_list_t thread_list[RT_EVENT_LENGTH];	/* threads blocked on this resource. */
+};
+typedef struct rt_fast_event* rt_fast_event_t;
+#endif
+
+#ifdef RT_USING_EVENT
+/*
+ * event
+ */
+struct rt_event
+{
+	struct rt_ipc_object parent;
+
+	rt_uint32_t set;				/* event set. */
+};
+typedef struct rt_event* rt_event_t;
+#endif
+
+#ifdef RT_USING_MAILBOX
+/*
+ * mailbox
+ *
+ */
+struct rt_mailbox
+{
+	struct rt_ipc_object parent;
+
+	rt_uint32_t* msg_pool;	/* start address of message buffer. */
+
+	rt_size_t size;			/* size of message pool. */
+
+	rt_ubase_t entry;		/* index of messages in msg_pool. */
+	rt_ubase_t in_offset, out_offset;	/* in/output offset of the message buffer. */
+};
+typedef struct rt_mailbox* rt_mailbox_t;
+#endif
+
+#ifdef RT_USING_MESSAGEQUEUE
+/*
+ * messagequeue
+ */
+struct rt_messagequeue
+{
+	struct rt_ipc_object parent;
+
+	void* msg_pool;			/* start address of message queue. */
+
+	rt_size_t msg_size;		/* message size of each message. */
+	rt_size_t max_msgs;		/* max number of messages. */
+
+	void* msg_queue_head;	/* list head. */
+	void* msg_queue_tail;	/* list tail. */
+	void* msg_queue_free;	/* pointer indicated the free node of queue. */
+
+	rt_ubase_t entry;		/* index of messages in the queue. */
+};
+typedef struct rt_messagequeue* rt_mq_t;
+#endif
+/*@}*/
+
+/**
+ * @addtogroup MM
+ */
+/*@{*/
+/*
+ * memory management
+ * heap & partition
+ */
+#ifdef RT_USING_MEMPOOL
+/*
+ * Base structure of Memory pool object
+ */
+struct rt_mempool
+{
+	struct rt_object parent;
+
+	void* start_address;			/* memory pool start */
+	rt_size_t size;					/* size of memory pool */
+
+	rt_size_t block_size;			/* size of memory blocks */
+	rt_uint8_t* block_list;			/* memory blocks list */
+
+	rt_size_t block_total_count;	/* numbers of memory block */
+	rt_size_t block_free_count;		/* numbers of free memory block */
+
+	rt_list_t suspend_thread;		/* threads pended on this resource */
+	rt_size_t suspend_thread_count;	/* numbers of thread pended on this resource */
+};
+typedef struct rt_mempool* rt_mp_t;
+#endif
+/*@}*/
+
+#ifdef RT_USING_DEVICE
+/**
+ * @addtogroup Device
+ */
+/*@{*/
+
+/*
+ * device (I/O) system
+ */
+enum rt_device_class_type
+{
+	RT_Device_Class_Char = 0,	/* character device	*/
+	RT_Device_Class_Block,		/* block device */
+	RT_Device_Class_NetIf,		/* net interface */
+	RT_Device_Class_MTD,		/* memory device */
+	RT_Device_Class_CAN,		/* CAN device */

+	RT_Device_Class_RTC,		/* RTC device */
+	RT_Device_Class_Unknown		/* unknown device */
+};
+
+/* device flags */
+#define RT_DEVICE_FLAG_DEACTIVATE	0x000	/* not inited 			*/
+
+#define RT_DEVICE_FLAG_RDONLY		0x001	/* read only 			*/
+#define RT_DEVICE_FLAG_WRONLY		0x002	/* write only 			*/
+#define RT_DEVICE_FLAG_RDWR			0x003	/* read and write 		*/
+
+#define RT_DEVICE_FLAG_REMOVABLE	0x004	/* removable device 	*/
+#define RT_DEVICE_FLAG_STANDALONE	0x008	/* standalone device	*/
+#define RT_DEVICE_FLAG_ACTIVATED	0x010	/* device is activated 	*/
+#define RT_DEVICE_FLAG_SUSPENDED	0x020	/* device is suspended 	*/
+#define RT_DEVICE_FLAG_STREAM		0x040	/* stream mode 			*/
+
+#define RT_DEVICE_FLAG_INT_RX		0x100	/* INT mode on Rx 		*/
+#define RT_DEVICE_FLAG_DMA_RX		0x200	/* DMA mode on Rx 		*/
+#define RT_DEVICE_FLAG_INT_TX		0x400	/* INT mode on Tx 		*/
+#define RT_DEVICE_FLAG_DMA_TX		0x800	/* DMA mode on Tx		*/
+
+#define RT_DEVICE_OFLAG_CLOSE		0x000	/* device is closed 	*/
+#define RT_DEVICE_OFLAG_RDONLY		0x001	/* read only access		*/
+#define RT_DEVICE_OFLAG_WRONLY		0x002	/* write only access	*/
+#define RT_DEVICE_OFLAG_RDWR		0x003	/* read and write 		*/
+#define RT_DEVICE_OFLAG_OPEN		0x008	/* device is opened 	*/
+
+/* general device commands */
+#define RT_DEVICE_CTRL_RESUME	    0x01	/* resume device 	*/
+#define RT_DEVICE_CTRL_SUSPEND	    0x02	/* suspend device 	*/
+
+/* special device commands */
+#define RT_DEVICE_CTRL_CHAR_STREAM	0x10	/* stream mode on char device 	*/
+#define RT_DEVICE_CTRL_BLK_GETGEOME	0x10	/* get geometry information 	*/
+#define RT_DEVICE_CTRL_NETIF_GETMAC	0x10	/* get mac address 				*/
+#define RT_DEVICE_CTRL_MTD_FORMAT	0x10	/* format a MTD device 			*/
+#define RT_DEVICE_CTRL_RTC_GET_TIME	0x10	/* get time */

+#define RT_DEVICE_CTRL_RTC_SET_TIME	0x11	/* set time */
+

+typedef struct rt_device* rt_device_t;
+/*
+ * Device related structure
+ */
+struct rt_device
+{
+	struct rt_object parent;
+
+	/* device type */
+	enum rt_device_class_type type;
+	/* device flag and device open flag*/
+	rt_uint16_t flag, open_flag;
+
+	/* device call back */
+	rt_err_t (*rx_indicate)(rt_device_t dev, rt_size_t size);
+	rt_err_t (*tx_complete)(rt_device_t dev, void* buffer);
+
+	/* common device interface */
+	rt_err_t  (*init)	(rt_device_t dev);
+	rt_err_t  (*open)	(rt_device_t dev, rt_uint16_t oflag);
+	rt_err_t  (*close)	(rt_device_t dev);
+	rt_size_t (*read)	(rt_device_t dev, rt_off_t pos, void* buffer, rt_size_t size);
+	rt_size_t (*write)	(rt_device_t dev, rt_off_t pos, const void* buffer, rt_size_t size);
+	rt_err_t  (*control)(rt_device_t dev, rt_uint8_t cmd, void *args);
+
+#ifdef RT_USING_DEVICE_SUSPEND
+	rt_err_t (*suspend) (rt_device_t dev);
+	rt_err_t (*resumed) (rt_device_t dev);
+#endif
+
+	/* device private data */
+	void* private;
+};
+
+/*@}*/
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/include/rthw.h b/include/rthw.h
new file mode 100644
index 0000000000..964b357556
--- /dev/null
+++ b/include/rthw.h
@@ -0,0 +1,59 @@
+/*
+ * File      : rthw.h
+ * 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-18     Bernard      the first version
+ * 2006-04-25     Bernard      add rt_hw_context_switch_interrupt declaration
+ * 2006-09-24     Bernard      add rt_hw_context_switch_to declaration
+ */
+
+#ifndef __RT_HW_H__
+#define __RT_HW_H__
+
+#include <rtthread.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void rt_hw_cpu_icache_enable(void);
+void rt_hw_cpu_icache_disable(void);
+rt_base_t rt_hw_cpu_icache_status(void);
+void rt_hw_cpu_dcache_enable(void);
+void rt_hw_cpu_dcache_disable(void);
+rt_base_t rt_hw_cpu_dcache_status(void);
+void rt_hw_cpu_reset(void);
+void rt_hw_cpu_shutdown(void);
+
+rt_uint8_t *rt_hw_stack_init(void *entry, void *parameter,
+	rt_uint8_t *stack_addr, void *exit);
+
+void rt_hw_interrupt_init(void);
+void rt_hw_interrupt_mask(int vector);
+void rt_hw_interrupt_umask(int vector);
+void rt_hw_interrupt_install(int vector, rt_isr_handler_t new_handler, rt_isr_handler_t *old_handler);
+void rt_hw_interrupt_handle(int vector);
+
+rt_base_t rt_hw_interrupt_disable(void);
+void rt_hw_interrupt_enable(rt_base_t level);
+void rt_hw_context_switch(rt_uint32_t from, rt_uint32_t to);
+void rt_hw_context_switch_to(rt_uint32_t to);
+void rt_hw_context_switch_interrupt(rt_uint32_t from, rt_uint32_t to);
+
+void rt_hw_console_output(const char* str);
+
+void rt_hw_backtrace(rt_uint32_t *fp, rt_uint32_t thread_entry);
+void rt_hw_show_memory(rt_uint32_t addr, rt_uint32_t size);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/include/rtthread.h b/include/rtthread.h
new file mode 100644
index 0000000000..540c1aacdb
--- /dev/null
+++ b/include/rtthread.h
@@ -0,0 +1,342 @@
+/*
+ * File      : rtthread.h
+ * 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-18     Bernard      the first version
+ * 2006-04-26     Bernard      add semaphore APIs
+ * 2006-08-10     Bernard      add version information
+ * 2007-01-28     Bernard      rename RT_OBJECT_Class_Static to RT_Object_Class_Static
+ * 2007-03-03     Bernard      clean up the definitions to rtdef.h
+ */
+
+#ifndef __RT_THREAD_H__
+#define __RT_THREAD_H__
+
+#include <rtdef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @addtogroup KernelObject
+ */
+/*@{*/
+/*
+ * kernel object interface
+ */
+
+void rt_system_object_init(void);
+void rt_object_init(struct rt_object* object, enum rt_object_class_type type, const char* name);
+void rt_object_detach(rt_object_t object);
+rt_object_t rt_object_allocate(enum rt_object_class_type type, const char* name);
+void rt_object_delete(rt_object_t object);
+rt_object_t rt_object_find(enum rt_object_class_type type, const char* name);
+rt_err_t rt_object_is_systemobject(rt_object_t object);
+/*@}*/
+
+/**
+ * @addtogroup Clock
+ */
+/*@{*/
+/*
+ * clock & timer interface
+ */
+void rt_system_tick_init(void);
+rt_tick_t rt_tick_get(void);
+void rt_tick_increase(void);
+rt_tick_t rt_tick_from_millisecond(rt_uint32_t ms);
+
+void rt_system_timer_init(void);
+void rt_timer_init(rt_timer_t timer,
+	const char* name,
+	void (*timeout)(void* parameter), void* parameter,
+	rt_tick_t time, rt_uint8_t flag);
+rt_err_t rt_timer_detach(rt_timer_t timer);
+rt_timer_t rt_timer_create(const char* name,
+	void (*timeout)(void* parameter), void* parameter,
+	rt_tick_t time, rt_uint8_t flag);
+rt_err_t rt_timer_delete(rt_timer_t timer);
+rt_err_t rt_timer_start(rt_timer_t timer);
+rt_err_t rt_timer_stop(rt_timer_t timer);
+rt_err_t rt_timer_control(rt_timer_t timer, rt_uint8_t cmd, void* arg);
+/*@}*/
+
+/**
+ * @addtogroup Thread
+ */
+/*@{*/
+/*
+ * thread interface
+ */
+rt_err_t rt_thread_init(struct rt_thread* thread,
+	const char* name,
+	void (*entry)(void* parameter), void* parameter,
+	void* stack_start, rt_uint32_t stack_size,
+	rt_uint8_t priority, rt_uint32_t tick);
+rt_err_t rt_thread_detach(rt_thread_t thread);
+rt_thread_t rt_thread_create (const char* name,
+	void (*entry)(void* parameter), void* parameter,
+	rt_uint32_t stack_size,
+	rt_uint8_t priority, rt_uint32_t tick);
+rt_thread_t rt_thread_self(void);
+rt_thread_t rt_thread_find(char* name);
+rt_err_t rt_thread_startup(rt_thread_t thread);
+rt_err_t rt_thread_delete(rt_thread_t thread);
+
+rt_err_t rt_thread_yield(void);
+rt_err_t rt_thread_delay(rt_tick_t tick);
+rt_err_t rt_thread_control(rt_thread_t thread, rt_uint8_t cmd, void* arg);
+rt_err_t rt_thread_suspend(rt_thread_t thread);
+rt_err_t rt_thread_resume(rt_thread_t thread);
+void rt_thread_timeout(void* parameter);
+
+#ifdef RT_USING_HOOK
+void rt_thread_suspend_hook(void (*hook)(rt_thread_t thread));
+void rt_thread_resume_hook (void (*hook)(rt_thread_t thread));
+#endif
+
+/*
+ * idle thread interface
+ */
+void rt_thread_idle_init(void);
+#ifdef RT_USING_HOOK
+void rt_thread_idle_sethook(void (*hook)(void));
+#endif
+
+/*
+ * schedule service
+ */
+void rt_system_scheduler_init(void);
+void rt_system_scheduler_start(void);
+
+void rt_schedule(void);
+void rt_schedule_insert_thread(struct rt_thread* thread);
+void rt_schedule_remove_thread(struct rt_thread* thread);
+
+void rt_enter_critical(void);
+void rt_exit_critical(void);
+
+#ifdef RT_USING_HOOK
+void rt_schedule_sethook(void (*hook)(rt_thread_t from, rt_thread_t to));
+#endif
+/*@}*/
+
+/**
+ * @addtogroup MM
+ */
+/*@{*/
+/*
+ * memory management interface
+ */
+#ifdef RT_USING_MEMPOOL
+/*
+ * memory pool interface
+ */
+rt_err_t rt_mp_init(struct rt_mempool* mp, const char* name, void *start, rt_size_t size, rt_size_t block_size);
+rt_err_t rt_mp_detach(struct rt_mempool* mp);
+rt_mp_t rt_mp_create(const char* name, rt_size_t block_count, rt_size_t block_size);
+rt_err_t rt_mp_delete(rt_mp_t mp);
+
+void *rt_mp_alloc (rt_mp_t mp, rt_int32_t time);
+void rt_mp_free  (void *block);
+
+#ifdef RT_USING_HOOK
+void rt_mp_alloc_sethook(void (*hook)(void *block));
+void rt_mp_free_sethook(void (*hook)(void *block));
+#endif
+#endif
+
+#ifdef RT_USING_HEAP
+/*
+ * heap memory interface
+ */
+void rt_system_heap_init(void* begin_addr, void* end_addr);
+
+void* rt_malloc(rt_size_t nbytes);
+void rt_free (void *ptr);
+void* rt_realloc(void *ptr, rt_size_t nbytes);
+
+#ifdef RT_USING_HOOK
+void rt_malloc_sethook(void (*hook)(void *ptr, rt_uint32_t size));
+void rt_free_sethook(void (*hook)(void *ptr));
+#endif
+#endif
+/*@}*/
+
+/**
+ * @addtogroup IPC
+ */
+/*@{*/
+#ifdef RT_USING_SEMAPHORE
+/*
+ * semaphore interface
+ */
+rt_err_t rt_sem_init (rt_sem_t sem, const char* name, rt_uint32_t value, rt_uint8_t flag);
+rt_err_t rt_sem_detach (rt_sem_t sem);
+rt_sem_t rt_sem_create (const char* name, rt_uint32_t value, rt_uint8_t flag);
+rt_err_t rt_sem_delete (rt_sem_t sem);
+
+rt_err_t rt_sem_take (rt_sem_t sem, rt_int32_t time);
+rt_err_t rt_sem_trytake(rt_sem_t sem);
+rt_err_t rt_sem_release(rt_sem_t sem);
+rt_err_t rt_sem_control(rt_sem_t sem, rt_uint8_t cmd, void* arg);
+#endif
+
+#ifdef RT_USING_MUTEX
+/*
+ * mutex interface
+ */
+rt_err_t rt_mutex_init (rt_mutex_t mutex, const char* name, rt_uint8_t flag);
+rt_err_t rt_mutex_detach (rt_mutex_t mutex);
+rt_mutex_t rt_mutex_create (const char* name, rt_uint8_t flag);
+rt_err_t rt_mutex_delete (rt_mutex_t mutex);
+
+rt_err_t rt_mutex_take (rt_mutex_t mutex, rt_int32_t time);
+rt_err_t rt_mutex_release(rt_mutex_t mutex);
+rt_err_t rt_mutex_control(rt_mutex_t mutex, rt_uint8_t cmd, void* arg);
+#endif
+
+#ifdef RT_USING_FASTEVENT
+/*
+ * fast_event interface
+ */
+rt_err_t rt_fast_event_init(rt_fast_event_t event, const char* name, rt_uint8_t flag);
+rt_err_t rt_fast_event_detach(rt_fast_event_t event);
+rt_fast_event_t rt_fast_event_create (const char* name, rt_uint8_t flag);
+rt_err_t rt_fast_event_delete (rt_fast_event_t event);
+
+rt_err_t rt_fast_event_send(rt_fast_event_t event, rt_uint8_t bit);
+rt_err_t rt_fast_event_recv(rt_fast_event_t event, rt_uint8_t bit, rt_uint8_t opt, rt_int32_t timeout);
+rt_err_t rt_fast_event_control (rt_fast_event_t event, rt_uint8_t cmd, void* arg);
+#endif
+
+#ifdef RT_USING_EVENT
+/*
+ * event interface
+ */
+rt_err_t rt_event_init(rt_event_t event, const char* name, rt_uint8_t flag);
+rt_err_t rt_event_detach(rt_event_t event);
+rt_event_t rt_event_create (const char* name, rt_uint8_t flag);
+rt_err_t rt_event_delete (rt_event_t event);
+
+rt_err_t rt_event_send(rt_event_t event, rt_uint32_t set);
+rt_err_t rt_event_recv(rt_event_t event, rt_uint32_t set, rt_uint8_t opt, rt_int32_t timeout, rt_uint32_t* recved);
+rt_err_t rt_event_control (rt_event_t event, rt_uint8_t cmd, void* arg);
+
+#endif
+
+#ifdef RT_USING_MAILBOX
+/*
+ * mailbox interface
+ *
+ */
+rt_err_t rt_mb_init(rt_mailbox_t mb, const char* name, void* msgpool, rt_size_t size, rt_uint8_t flag);
+rt_err_t rt_mb_detach(rt_mailbox_t mb);
+rt_mailbox_t rt_mb_create (const char* name, rt_size_t size, rt_uint8_t flag);
+rt_err_t rt_mb_delete (rt_mailbox_t mb);
+
+rt_err_t rt_mb_send (rt_mailbox_t mb, rt_uint32_t value);
+rt_err_t rt_mb_recv (rt_mailbox_t mb, rt_uint32_t* value, rt_int32_t timeout);
+rt_err_t rt_mb_control(rt_mailbox_t mb, rt_uint8_t cmd, void* arg);
+#endif
+
+#ifdef RT_USING_MESSAGEQUEUE
+/*
+ * message queue interface
+ */
+rt_err_t rt_mq_init(rt_mq_t mq, const char* name, void *msgpool, rt_size_t msg_size, rt_size_t pool_size, rt_uint8_t flag);
+rt_err_t rt_mq_detach(rt_mq_t mq);
+rt_mq_t rt_mq_create (const char* name, rt_size_t msg_size, rt_size_t max_msgs, rt_uint8_t flag);
+rt_err_t rt_mq_delete (rt_mq_t mq);
+
+rt_err_t rt_mq_send (rt_mq_t mq, void* buffer, rt_size_t size);
+rt_err_t rt_mq_urgent(rt_mq_t mq, void* buffer, rt_size_t size);
+rt_err_t rt_mq_recv (rt_mq_t mq, void* buffer, rt_size_t size, rt_int32_t timeout);
+rt_err_t rt_mq_control(rt_mq_t mq, rt_uint8_t cmd, void* arg);
+#endif
+/*@}*/
+
+#ifdef RT_USING_DEVICE
+/**
+ * @addtogroup Device
+ */
+/*@{*/
+/*
+ * device (I/O) system interface
+ */
+
+rt_device_t rt_device_find(const char* name);
+
+rt_err_t rt_device_register(rt_device_t dev, const char* name, rt_uint16_t flags);
+rt_err_t rt_device_unregister(rt_device_t dev);
+rt_err_t rt_device_init_all(void);
+
+rt_err_t rt_device_set_rx_indicate(rt_device_t dev, rt_err_t (*rx_ind )(rt_device_t dev, rt_size_t size));
+rt_err_t rt_device_set_tx_complete(rt_device_t dev, rt_err_t (*tx_done)(rt_device_t dev, void *buffer));
+
+rt_err_t  rt_device_open (rt_device_t dev, rt_uint16_t oflag);
+rt_err_t  rt_device_close(rt_device_t dev);
+rt_size_t rt_device_read (rt_device_t dev, rt_off_t pos, void* buffer, rt_size_t size);
+rt_size_t rt_device_write(rt_device_t dev, rt_off_t pos, const void* buffer, rt_size_t size);
+rt_err_t  rt_device_control(rt_device_t dev, rt_uint8_t cmd, void* arg);
+/*@}*/
+#endif
+
+/*
+ * interrupt service
+ */
+typedef void (*rt_isr_handler_t)(int vector);
+
+/*
+ * rt_interrupt_enter and rt_interrupt_leave only can be called by BSP
+ */
+void rt_interrupt_enter(void);
+void rt_interrupt_leave(void);
+
+/**
+ * @addtogroup KernelService
+ */
+/*@{*/
+/*
+ * general kernel service
+ */
+rt_int32_t rt_sprintf(char *buf ,const char *format,...);
+rt_int32_t rt_vsprintf(char *dest, const char *format, va_list arg_ptr);
+rt_int32_t rt_sprintf(char *buf ,const char *format,...);
+rt_int32_t rt_snprintf(char *buf, rt_size_t size, const char *format, ...);
+void rt_kprintf(const char *fmt, ...);
+
+rt_err_t rt_get_errno(void);
+void rt_set_errno(rt_err_t no);
+
+void* rt_memset(void *src, int c, rt_ubase_t n);
+void* rt_memcpy(void *dest, const void *src, rt_ubase_t n);
+
+rt_ubase_t rt_strncmp(const char * cs, const char * ct, rt_ubase_t count);
+rt_ubase_t rt_strlen (const char *src);
+char *rt_strdup(const char *s);
+
+char * rt_strstr( const char * str1, const char * str2 );
+rt_int32_t rt_sscanf(const char * buf, const char * fmt, ...);
+char *rt_strncpy(char *dest, const char *src, rt_ubase_t n);
+void* rt_memmove(void *dest, const void *src, rt_ubase_t n);
+rt_int32_t rt_memcmp(const void * cs,const void * ct, rt_ubase_t count);
+rt_uint32_t rt_strcasecmp(const char *a, const char *b);
+
+void rt_show_version(void);
+
+/*@}*/
+
+#ifdef __cplusplus
+}
+#endif
+/*@}*/
+#endif