cleanup kernel code

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

include/rtdebug.h

@@ -1,3 +1,13 @@
+/*
+ * File      : rtdebug.h
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2006 - 2011, RT-Thread Development Team
+ *
+ * The license and distribution terms for this file may be
+ * found in the file LICENSE in this distribution or at
+ * http://www.rt-thread.org/license/LICENSE
+ */
+ 
 #ifndef __RTDEBUG_H__
 #define __RTDEBUG_H__
 
@@ -44,18 +54,18 @@
 #define RT_DEBUG_CONTEXT_CHECK 1
 #endif
 
-#define RT_DEBUG_LOG(type,message)  do{ if(type) rt_kprintf message;}while(0)
+#define RT_DEBUG_LOG(type,message)  do { if (type) rt_kprintf message;} while (0)
 
-#define RT_ASSERT(EX)   if (!(EX)) {volatile char dummy=0;\
+#define RT_ASSERT(EX)   if (!(EX)) {volatile char dummy = 0;\
                             rt_kprintf("(%s) assert failed at %s:%d \n", \
-                            #EX, __FUNCTION__, __LINE__); while (dummy==0);}
+                            #EX, __FUNCTION__, __LINE__); while (dummy == 0);}
 
 /* Macro to check current context */
 #if RT_DEBUG_CONTEXT_CHECK
 #define RT_DEBUG_NOT_IN_INTERRUPT do {\
         rt_base_t level;\
         level = rt_hw_interrupt_disable();\
-        if(rt_interrupt_get_nest() != 0){\
+        if (rt_interrupt_get_nest() != 0){\
             rt_kprintf("Function[%s] shall not used in ISR\n", __FUNCTION__);\
             RT_ASSERT(0)}\
         rt_hw_interrupt_enable(level);} while (0)

include/rtdef.h

@@ -1,20 +1,21 @@
 /*
  * File      : rtdef.h
  * This file is part of RT-Thread RTOS
- * COPYRIGHT (C) 2006, RT-Thread Development Team
+ * COPYRIGHT (C) 2006 - 2011, 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.
+ * http://www.rt-thread.org/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
+ * 2008-07-12     Bernard      remove all rt_int8, rt_uint32_t etc typedef
  * 2010-10-26     yi.qiu       add module support
  * 2010-11-10     Bernard      add cleanup callback function in thread exit.
  * 2011-05-09     Bernard      use builtin va_arg in GCC 4.x
  */
+ 
 #ifndef __RT_DEF_H__
 #define __RT_DEF_H__
 
@@ -32,121 +33,121 @@ extern "C" {
 /**
  * RT-Thread version information
  */
-#define RT_VERSION						4L		/**< major version number */
-#define RT_SUBVERSION					0L		/**< minor version number */
+#define RT_VERSION                      4L      /**< major version number */
+#define RT_SUBVERSION                   0L      /**< minor version number */
 
 /**
  * RT-Thread basic data type definitions
  */
-typedef signed 	 char  					rt_int8_t;		/**<  8bit integer type */
-typedef signed 	 short 					rt_int16_t;		/**< 16bit integer type */
-typedef signed 	 long  					rt_int32_t;		/**< 32bit integer type */
-typedef unsigned char  					rt_uint8_t;		/**<  8bit unsigned integer type */
-typedef unsigned short 					rt_uint16_t;	/**< 16bit unsigned integer type */
-typedef unsigned long  					rt_uint32_t;	/**< 32bit unsigned integer type */
-typedef int 							rt_bool_t;		/**< boolean type */
+typedef signed   char                   rt_int8_t;      /**<  8bit integer type */
+typedef signed   short                  rt_int16_t;     /**< 16bit integer type */
+typedef signed   long                   rt_int32_t;     /**< 32bit integer type */
+typedef unsigned char                   rt_uint8_t;     /**<  8bit unsigned integer type */
+typedef unsigned short                  rt_uint16_t;    /**< 16bit unsigned integer type */
+typedef unsigned long                   rt_uint32_t;    /**< 32bit unsigned integer type */
+typedef int                             rt_bool_t;      /**< boolean type */
 
 /* 32bit CPU */
-typedef long 							rt_base_t;		/**< Nbit CPU related date type */
-typedef unsigned long 					rt_ubase_t;		/**< Nbit unsigned CPU related data type */
+typedef long                            rt_base_t;      /**< Nbit CPU related date type */
+typedef unsigned long                   rt_ubase_t;     /**< Nbit unsigned CPU related data type */
 
-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_base_t						rt_off_t;		/**< Type for offset			*/
+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_base_t                       rt_off_t;       /**< Type for offset            */
 
 /**
  * boolean type definitions
  */
-#define RT_TRUE 						1	/**< boolean true  */
-#define RT_FALSE 						0	/**< boolean fails */
+#define RT_TRUE                         1   /**< boolean true  */
+#define RT_FALSE                        0   /**< boolean fails */
 /*@}*/
 
-/* 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.					*/
-#define RT_TICK_MAX						RT_UINT32_MAX	/* Maxium number of tick                    */
+/* 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  */
+#define RT_TICK_MAX                     RT_UINT32_MAX   /* Maxium number of tick    */
 
 /* Compiler Related Definitions */
-#ifdef __CC_ARM                			 /* ARM Compiler 	*/
-    #include <stdarg.h>
-    #define SECTION(x)  				__attribute__((section(x)))
-    #define UNUSED  					__attribute__((unused))
-	#define ALIGN(n)					__attribute__((aligned(n)))
-    #define rt_inline   				static __inline
+#ifdef __CC_ARM                         /* ARM Compiler */
+	#include <stdarg.h>
+	#define SECTION(x)                  __attribute__((section(x)))
+	#define UNUSED                      __attribute__((unused))
+	#define ALIGN(n)                    __attribute__((aligned(n)))
+	#define rt_inline                   static __inline
 	/* module compiling */
 	#ifdef RT_USING_MODULE
-		#define RTT_API	__declspec(dllimport)
+		#define RTT_API __declspec(dllimport)
 	#else
 		#define RTT_API __declspec(dllexport)
 	#endif
 
-#elif defined (__IAR_SYSTEMS_ICC__)        		/* for IAR Compiler */
-    #include <stdarg.h>
-    #define SECTION(x)  				@ x
-    #define UNUSED
-	#define PRAGMA(x)					_Pragma(#x)
-	#define ALIGN(n)					PRAGMA(data_alignment=n)
-    #define rt_inline 					static inline
+#elif defined (__IAR_SYSTEMS_ICC__)     /* for IAR Compiler */
+	#include <stdarg.h>
+	#define SECTION(x)                  @ x
+	#define UNUSED
+	#define PRAGMA(x)                   _Pragma(#x)
+	#define ALIGN(n)                    PRAGMA(data_alignment=n)
+	#define rt_inline                   static inline
 	#define RTT_API
 
-#elif defined (__GNUC__)        		/* GNU GCC Compiler */
-    #ifdef RT_USING_NEWLIB
-        #include <stdarg.h>
-    #else
+#elif defined (__GNUC__)                /* GNU GCC Compiler */
+	#ifdef RT_USING_NEWLIB
+		#include <stdarg.h>
+	#else
 		#if __GNUC__ < 4
 			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))
+				(((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))))
+				(ap = (__sys_va_list) ((char *)(ap) + __va_rounded_size(type)),  \
+				*((type *) (void *) ((char *)(ap) - __va_rounded_size(type))))
 		#else
 			typedef __builtin_va_list __gnuc_va_list;
 			typedef __gnuc_va_list va_list;
-			#define va_start(v,l)	__builtin_va_start(v,l)
-			#define va_end(v)		__builtin_va_end(v)
-			#define va_arg(v,l)		__builtin_va_arg(v,l)
+			#define va_start(v,l)   __builtin_va_start(v,l)
+			#define va_end(v)       __builtin_va_end(v)
+			#define va_arg(v,l)     __builtin_va_arg(v,l)
 		#endif
-    #endif
+	#endif
 
-    #define SECTION(x) 					__attribute__((section(x)))
-    #define UNUSED 						__attribute__((unused))
-	#define ALIGN(n)					__attribute__((aligned(n)))
-    #define rt_inline 					static __inline
+	#define SECTION(x)                  __attribute__((section(x)))
+	#define UNUSED                      __attribute__((unused))
+	#define ALIGN(n)                    __attribute__((aligned(n)))
+	#define rt_inline                   static __inline
 	#define RTT_API
 #endif
 
-/* event length 			*/
-#define RT_EVENT_LENGTH					32
+/* 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
+#define RT_MM_PAGE_SIZE                 4096
+#define RT_MM_PAGE_MASK                 (RT_MM_PAGE_SIZE - 1)
+#define RT_MM_PAGE_BITS                 12
 
 /**
  * @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								*/
+#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                    */
 /*@}*/
 
 
@@ -157,7 +158,7 @@ typedef rt_base_t						rt_off_t;		/**< Type for offset			*/
  * Return the most contiguous size aligned at specified width. RT_ALIGN(13, 4)
  * would return 16.
  */
-#define RT_ALIGN(size, align)			(((size) + (align) - 1) & ~((align)-1))
+#define RT_ALIGN(size, align)           (((size) + (align) - 1) & ~((align) - 1))
 /**
  * @ingroup BasicDef
  *
@@ -165,7 +166,7 @@ typedef rt_base_t						rt_off_t;		/**< Type for offset			*/
  * Return the down number of aligned at specified width. RT_ALIGN_DOWN(13, 4)
  * would return 12. 
  */
-#define RT_ALIGN_DOWN(size, align)		((size) & ~((align) -1))
+#define RT_ALIGN_DOWN(size, align)      ((size) & ~((align) - 1))
 
 /**
  * @ingroup BasicDef
@@ -173,14 +174,14 @@ typedef rt_base_t						rt_off_t;		/**< Type for offset			*/
  * @def RT_NULL
  * Similar as the \c NULL in C library.
  */
-#define RT_NULL 						((void *)0)
+#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. 						*/
+	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. 							*/
+typedef struct rt_list_node rt_list_t;                  /* Type for lists.     */
 
 /**
  * @addtogroup KernelObject
@@ -190,69 +191,69 @@ typedef struct rt_list_node rt_list_t;					/* Type for lists. 							*/
 /*
  * kernel object macros
  */
-#define RT_OBJECT_FLAG_MODULE		0x80			/* is module object. 						*/
+#define RT_OBJECT_FLAG_MODULE           0x80            /* is module object.   */
 
 /**
  * Base structure of Kernel object
  */
 struct rt_object
 {
-	char      	name[RT_NAME_MAX];						/**< name of kernel object					*/
-	rt_uint8_t  type;									/**< type of kernel object 					*/
-	rt_uint8_t  flag;									/**< flag of kernel object					*/
+	char        name[RT_NAME_MAX];                      /**< name of kernel object      */
+	rt_uint8_t  type;                                   /**< type of kernel object      */
+	rt_uint8_t  flag;                                   /**< flag of kernel object      */
 
 #ifdef RT_USING_MODULE
-	void* module_id;									/**< id of application module				*/
+	void        *module_id;                             /**< id of application module   */
 #endif
-	rt_list_t	list;									/**< list node of kernel object 			*/
+	rt_list_t   list;                                   /**< list node of kernel object */
 };
-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
- *	- Semaphore
- *	- Mutex
- *	- Event
- *	- MailBox
- *	- MessageQueue
- *	- MemPool
+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
+ *  - Semaphore
+ *  - Mutex
+ *  - Event
+ *  - MailBox
+ *  - MessageQueue
+ *  - MemPool
  *  - Device
- *	- Timer
- *	- Unknown
- *	- Static
+ *  - Timer
+ *  - Unknown
+ *  - Static
  */
 enum rt_object_class_type
 {
-	RT_Object_Class_Thread = 0,							/**< The object is a thread. 				*/
+	RT_Object_Class_Thread = 0,                         /**< The object is a thread.                */
 #ifdef RT_USING_SEMAPHORE
-	RT_Object_Class_Semaphore,							/**< The object is a semaphore. 			*/
+	RT_Object_Class_Semaphore,                          /**< The object is a semaphore.             */
 #endif
 #ifdef RT_USING_MUTEX
-	RT_Object_Class_Mutex,								/**< The object is a mutex. 				*/
+	RT_Object_Class_Mutex,                              /**< The object is a mutex.                 */
 #endif
 #ifdef RT_USING_EVENT
-	RT_Object_Class_Event,								/**< The object is a 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. 				*/
+	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. 		*/
+	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. 			*/
+	RT_Object_Class_MemPool,                            /**< The object is a memory pool.           */
 #endif
 #ifdef RT_USING_DEVICE
-	RT_Object_Class_Device,								/**< The object is a device 				*/
+	RT_Object_Class_Device,                             /**< The object is a device                 */
 #endif
-	RT_Object_Class_Timer,								/**< The object is a timer. 				*/
+	RT_Object_Class_Timer,                              /**< The object is a timer.                 */
 #ifdef RT_USING_MODULE
-	RT_Object_Class_Module,								/**< The object is a 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. 		*/
+	RT_Object_Class_Unknown,                            /**< The object is unknown.                 */
+	RT_Object_Class_Static = 0x80                       /**< The object is a static object.         */
 };
 
 /**
@@ -260,9 +261,9 @@ enum rt_object_class_type
  */
 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 							*/
+	enum rt_object_class_type type;                     /**< object class type                      */
+	rt_list_t object_list;                              /**< object list                            */
+	rt_size_t object_size;                              /**< object size                            */
 };
 
 /**
@@ -285,35 +286,35 @@ struct rt_object_information
 /**
  * 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_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_FLAG_HARD_TIMER		0x0				/**< hard timer,the timer's callback function will be called in tick isr. 	*/
-#define RT_TIMER_FLAG_SOFT_TIMER		0x4				/**< soft timer,the timer's callback function will be called in timer thread. */
+#define RT_TIMER_FLAG_HARD_TIMER        0x0             /**< hard timer,the timer's callback function will be called in tick isr.     */
+#define RT_TIMER_FLAG_SOFT_TIMER        0x4             /**< soft timer,the timer's callback function will be called in timer thread. */
 
-#define RT_TIMER_CTRL_SET_TIME			0x0				/**< set timer control command 				*/
-#define RT_TIMER_CTRL_GET_TIME			0x1				/**< get timer control command 				*/
-#define RT_TIMER_CTRL_SET_ONESHOT		0x2				/**< change timer to one shot 				*/
-#define RT_TIMER_CTRL_SET_PERIODIC		0x3				/**< change timer to periodic 				*/
+#define RT_TIMER_CTRL_SET_TIME          0x0             /**< set timer control command              */
+#define RT_TIMER_CTRL_GET_TIME          0x1             /**< get timer control command              */
+#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;							/**< inherit from rt_object 				*/
+	struct rt_object parent;                            /**< inherit from rt_object                 */
 
-	rt_list_t list;										/**< the node of timer list 				*/
+	rt_list_t list;                                     /**< the node of timer list                 */
 
-	void (*timeout_func)(void* parameter);				/**< timeout function 						*/
-	void *parameter;									/**< timeout function's parameter 			*/
+	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 							*/
+	rt_tick_t init_tick;                                /**< timer timeout tick                     */
+	rt_tick_t timeout_tick;                             /**< timeout tick                           */
 };
-typedef struct rt_timer* rt_timer_t;
+typedef struct rt_timer *rt_timer_t;
 /*@}*/
 
 /**
@@ -328,22 +329,22 @@ typedef struct rt_timer* rt_timer_t;
 /*
  * thread state definitions
  */
-#define RT_THREAD_INIT					0x00				/**< Initialized status					*/
-#define RT_THREAD_READY					0x01				/**< Ready status						*/
-#define RT_THREAD_SUSPEND				0x02				/**< Suspend status						*/
-#define RT_THREAD_RUNNING				0x03				/**< Running status						*/
-#define RT_THREAD_BLOCK					RT_THREAD_SUSPEND	/**< Blocked status 					*/
-#define RT_THREAD_CLOSE					0x04				/**< Closed status						*/
+#define RT_THREAD_INIT                  0x00                /**< Initialized status                 */
+#define RT_THREAD_READY                 0x01                /**< Ready status                       */
+#define RT_THREAD_SUSPEND               0x02                /**< Suspend status                     */
+#define RT_THREAD_RUNNING               0x03                /**< Running status                     */
+#define RT_THREAD_BLOCK                 RT_THREAD_SUSPEND   /**< Blocked status                     */
+#define RT_THREAD_CLOSE                 0x04                /**< Closed status                      */
 
 /**
  * thread control command definitions
  */
-#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. 			*/
+#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_thread *rt_thread_t;
 
 /**
  * Thread structure
@@ -352,52 +353,52 @@ typedef struct rt_thread* rt_thread_t;
 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 						*/
+	char        name[RT_NAME_MAX];                      /**< the name of thread                     */
+	rt_uint8_t  type;                                   /**< type of object                         */
+	rt_uint8_t  flags;                                  /**< thread's flags                         */
 	
 #ifdef RT_USING_MODULE
-	void* 		module_id;								/**< id of application module				*/
+	void        *module_id;                             /**< id of application module               */
 #endif
 
-	rt_list_t	list;									/**< the object list 						*/
-	rt_list_t	tlist;									/**< the thread list 						*/
+	rt_list_t   list;                                   /**< the object list                        */
+	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 							*/
+	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 							*/
+	rt_err_t    error;                                  /**< error code                             */
 
-	rt_uint8_t	stat;									/**< thread stat 							*/
+	rt_uint8_t  stat;                                   /**< thread stat                            */
 
 	/* priority */
-	rt_uint8_t	current_priority;						/**< current priority 						*/
-	rt_uint8_t	init_priority;							/**< initialized 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;
+	rt_uint8_t  number;
+	rt_uint8_t  high_mask;
 #endif
-	rt_uint32_t	number_mask;
+	rt_uint32_t number_mask;
 
 #if defined(RT_USING_EVENT)
 	/* thread event */
 	rt_uint32_t event_set;
-	rt_uint8_t	event_info;
+	rt_uint8_t  event_info;
 #endif
 
-	rt_ubase_t	init_tick;								/**< thread's initialized tick 				*/
-	rt_ubase_t 	remaining_tick;							/**< remaining tick 						*/
+	rt_ubase_t  init_tick;                              /**< thread's initialized tick              */
+	rt_ubase_t  remaining_tick;                         /**< remaining tick                         */
 
-	struct rt_timer thread_timer;						/**< thread timer 							*/
+	struct rt_timer thread_timer;                       /**< thread timer                           */
 
-	void 		(*cleanup)(struct rt_thread* tid);		/**< cleanup function when thread exit 		*/
+	void (*cleanup)(struct rt_thread *tid);             /**< cleanup function when thread exit      */
 
-	rt_uint32_t user_data;								/**< user data 								*/
+	rt_uint32_t user_data;                              /**< user data                              */
 };
 /*@}*/
 
@@ -409,23 +410,23 @@ struct rt_thread
 /**
  * IPC flags and control command defitions
  */
-#define RT_IPC_FLAG_FIFO				0x00			/**< FIFOed IPC. @ref IPC. 					*/
-#define RT_IPC_FLAG_PRIO				0x01			/**< PRIOed IPC. @ref IPC. 					*/
+#define RT_IPC_FLAG_FIFO                0x00            /**< FIFOed IPC. @ref IPC.                  */
+#define RT_IPC_FLAG_PRIO                0x01            /**< PRIOed IPC. @ref IPC.                  */
 
-#define RT_IPC_CMD_UNKNOWN				0x00			/**< unknown IPC command 					*/
-#define RT_IPC_CMD_RESET				0x01			/**< reset IPC object 						*/
+#define RT_IPC_CMD_UNKNOWN              0x00            /**< unknown IPC command                    */
+#define RT_IPC_CMD_RESET                0x01            /**< reset IPC object                       */
 
-#define RT_WAITING_FOREVER				-1				/**< Block forever until get resource.		*/
-#define RT_WAITING_NO					0				/**< Non-block. 							*/
+#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;							/**< inherit from rt_object 				*/
+	struct rt_object parent;                            /**< inherit from rt_object                 */
 
-	rt_list_t suspend_thread;							/**< threads pended on this resource 		*/
+	rt_list_t suspend_thread;                           /**< threads pended on this resource        */
 };
 
 #ifdef RT_USING_SEMAPHORE
@@ -434,11 +435,11 @@ struct rt_ipc_object
  */
 struct rt_semaphore
 {
-	struct rt_ipc_object parent;						/**< inherit from ipc_object 				*/
+	struct rt_ipc_object parent;                        /**< inherit from ipc_object                */
 
-	rt_uint16_t value;									/**< value of semaphore. 					*/
+	rt_uint16_t value;                                  /**< value of semaphore.                    */
 };
-typedef struct rt_semaphore* rt_sem_t;
+typedef struct rt_semaphore *rt_sem_t;
 #endif
 
 #ifdef RT_USING_MUTEX
@@ -447,36 +448,36 @@ typedef struct rt_semaphore* rt_sem_t;
  */
 struct rt_mutex
 {
-	struct rt_ipc_object 	parent;						/**< inherit from ipc_object				*/
+	struct rt_ipc_object    parent;                     /**< inherit from ipc_object                */
 
-	rt_uint16_t 			value;						/**< value of mutex 						*/
+	rt_uint16_t             value;                      /**< value of mutex                         */
 
-	rt_uint8_t 				original_priority;			/**< priority of last thread hold the mutex */
-	rt_uint8_t 				hold;			 			/**< numbers of thread hold the mutex 		*/
+	rt_uint8_t              original_priority;          /**< priority of last thread hold the mutex */
+	rt_uint8_t              hold;                       /**< numbers of thread hold the mutex       */
 
-	struct rt_thread		*owner;						/**< current owner of mutex 				*/
+	struct rt_thread        *owner;                     /**< current owner of mutex                 */
 };
-typedef struct rt_mutex* rt_mutex_t;
+typedef struct rt_mutex *rt_mutex_t;
 #endif
 
 #ifdef RT_USING_EVENT
 /**
  * flag defintions in event
  */
-#define RT_EVENT_FLAG_AND				0x01			/**< logic and 								*/
-#define RT_EVENT_FLAG_OR				0x02			/**< logic or 								*/
-#define RT_EVENT_FLAG_CLEAR				0x04			/**< clear flag								*/
+#define RT_EVENT_FLAG_AND               0x01            /**< logic and                              */
+#define RT_EVENT_FLAG_OR                0x02            /**< logic or                               */
+#define RT_EVENT_FLAG_CLEAR             0x04            /**< clear flag                             */
 
 /*
  * event structure
  */
 struct rt_event
 {
-	struct rt_ipc_object parent;						/**< inherit from ipc_object 				*/
+	struct rt_ipc_object parent;                        /**< inherit from ipc_object                */
 
-	rt_uint32_t set;									/**< event set 								*/
+	rt_uint32_t set;                                    /**< event set                              */
 };
-typedef struct rt_event* rt_event_t;
+typedef struct rt_event *rt_event_t;
 #endif
 
 #ifdef RT_USING_MAILBOX
@@ -486,18 +487,18 @@ typedef struct rt_event* rt_event_t;
  */
 struct rt_mailbox
 {
-	struct rt_ipc_object parent;						/**< inherit from ipc_object 				*/
+	struct rt_ipc_object parent;                        /**< inherit from ipc_object                */
 
-	rt_uint32_t* msg_pool;								/**< start address of message buffer. 			*/
+	rt_uint32_t *msg_pool;                              /**< start address of message buffer        */
 
-	rt_uint16_t size;									/**< size of message pool. 						*/
+	rt_uint16_t size;                                   /**< size of message pool                   */
 
-	rt_uint16_t entry;									/**< index of messages in msg_pool. 				*/
-	rt_uint16_t in_offset, out_offset;					/**< in/output offset of the message buffer.		*/
+	rt_uint16_t entry;                                  /**< index of messages in msg_pool          */
+	rt_uint16_t in_offset, out_offset;                  /**< in/output offset of the message buffer */
 
-	rt_list_t suspend_sender_thread;					/**< sender thread suspended on this mb		*/
+	rt_list_t suspend_sender_thread;                    /**< sender thread suspended on this mb     */
 };
-typedef struct rt_mailbox* rt_mailbox_t;
+typedef struct rt_mailbox *rt_mailbox_t;
 #endif
 
 #ifdef RT_USING_MESSAGEQUEUE
@@ -506,20 +507,20 @@ typedef struct rt_mailbox* rt_mailbox_t;
  */
 struct rt_messagequeue
 {
-	struct rt_ipc_object parent;						/**< inherit from ipc_object 				*/
+	struct rt_ipc_object parent;                        /**< inherit from ipc_object                */
 
-	void* msg_pool;										/**< start address of message queue. 			*/
+	void *msg_pool;                                     /**< start address of message queue         */
 
-	rt_uint16_t msg_size;								/**< message size of each message. 				*/
-	rt_uint16_t max_msgs;								/**< max number of messages. 					*/
+	rt_uint16_t msg_size;                               /**< message size of each message           */
+	rt_uint16_t max_msgs;                               /**< max number of messages                 */
 
-	rt_uint16_t entry;									/**< index of messages in the queue. 			*/
+	rt_uint16_t entry;                                  /**< index of messages in the queue         */
 
-	void* msg_queue_head;								/**< list head. 								*/
-	void* msg_queue_tail;								/**< list tail. 								*/
-	void* msg_queue_free;								/**< pointer indicated the free node of queue. 	*/
+	void *msg_queue_head;                               /**< list head                              */
+	void *msg_queue_tail;                               /**< list tail                              */
+	void *msg_queue_free;                               /**< pointer indicated the free node of queue */
 };
-typedef struct rt_messagequeue* rt_mq_t;
+typedef struct rt_messagequeue *rt_mq_t;
 #endif
 /*@}*/
 
@@ -537,21 +538,21 @@ typedef struct rt_messagequeue* rt_mq_t;
  */
 struct rt_mempool
 {
-	struct rt_object parent;						/**< inherit from rt_object 					*/
+	struct rt_object parent;                        /**< inherit from rt_object                     */
 
-	void		*start_address;						/**< memory pool start 							*/
-	rt_size_t 	size;								/**< size of memory pool 						*/
+	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_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_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 	*/
+	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;
+typedef struct rt_mempool *rt_mp_t;
 #endif
 /*@}*/
 
@@ -566,83 +567,83 @@ typedef struct rt_mempool* rt_mp_t;
  */
 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_Sound,							/**< Sound device 								*/
-	RT_Device_Class_Graphic,						/**< Graphic device                             */
-	RT_Device_Class_I2C, 							/**< I2C device                                 */
-	RT_Device_Class_USBDevice,						/**< USB slave device                           */
-	RT_Device_Class_USBHost,						/**< USB host bus								*/
-	RT_Device_Class_Unknown							/**< unknown device 							*/
+	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_Sound,                          /**< Sound device                               */
+	RT_Device_Class_Graphic,                        /**< Graphic device                             */
+	RT_Device_Class_I2C,                            /**< I2C device                                 */
+	RT_Device_Class_USBDevice,                      /**< USB slave device                           */
+	RT_Device_Class_USBHost,                        /**< USB host bus                               */
+	RT_Device_Class_Unknown                         /**< unknown device                             */
 };
 
 /**
  * device flags defitions
  */
-#define RT_DEVICE_FLAG_DEACTIVATE		0x000		/**< device is not not initialized 				*/
+#define RT_DEVICE_FLAG_DEACTIVATE       0x000       /**< device is not not initialized              */
 
-#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_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_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_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 							*/
+#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 							*/
+#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 									*/
+#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;
+typedef struct rt_device *rt_device_t;
 /**
  * Device structure
  */
 struct rt_device
 {
-	struct rt_object parent;						/**< inherit from rt_object 					*/
+	struct rt_object parent;                        /**< inherit from rt_object                     */
 
-	enum rt_device_class_type type;					/**< device type 								*/
-	rt_uint16_t flag, open_flag;					/**< device flag and device open flag			*/
+	enum rt_device_class_type type;                 /**< device type                                */
+	rt_uint16_t flag, open_flag;                    /**< device flag and device 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  (*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
@@ -650,7 +651,7 @@ struct rt_device
 	rt_err_t (*resumed) (rt_device_t dev);
 #endif
 
-	void* user_data;								/**< device private data 						*/
+	void *user_data;                                /**< device private data                        */
 };
 
 /**
@@ -658,22 +659,22 @@ struct rt_device
  */
 struct rt_device_blk_geometry
 {
-	rt_uint32_t sector_count;						/**< count of sectors							*/
-	rt_uint32_t bytes_per_sector;					/**< number of bytes per sector 				*/
-	rt_uint32_t block_size;							/**< size to erase one block 					*/
+	rt_uint32_t sector_count;                       /**< count of sectors                           */
+	rt_uint32_t bytes_per_sector;                   /**< number of bytes per sector                 */
+	rt_uint32_t block_size;                         /**< size to erase one block                    */
 };
 
 /**
- * graphic device control command 
+ * graphic device control command
  */
-#define RTGRAPHIC_CTRL_RECT_UPDATE	0
-#define RTGRAPHIC_CTRL_POWERON		1
-#define RTGRAPHIC_CTRL_POWEROFF		2
-#define RTGRAPHIC_CTRL_GET_INFO		3
-#define RTGRAPHIC_CTRL_SET_MODE		4
+#define RTGRAPHIC_CTRL_RECT_UPDATE  0
+#define RTGRAPHIC_CTRL_POWERON      1
+#define RTGRAPHIC_CTRL_POWEROFF     2
+#define RTGRAPHIC_CTRL_GET_INFO     3
+#define RTGRAPHIC_CTRL_SET_MODE     4
 
 /* graphic deice */
-enum 
+enum
 {
 	RTGRAPHIC_PIXEL_FORMAT_MONO = 0,
 	RTGRAPHIC_PIXEL_FORMAT_GRAY4,
@@ -696,14 +697,14 @@ enum
  */
 struct rt_device_graphic_info
 {
-	rt_uint8_t  pixel_format;		/**< graphic format 		*/
-	rt_uint8_t  bits_per_pixel;		/**< bits per pixel 		*/
-	rt_uint16_t reserved;			/**< reserved field			*/
+	rt_uint8_t  pixel_format;       /**< graphic format           */
+	rt_uint8_t  bits_per_pixel;     /**< bits per pixel           */
+	rt_uint16_t reserved;           /**< reserved field           */
 
-	rt_uint16_t width;				/**< width of graphic device  */
-	rt_uint16_t height;				/**< height of graphic device */
+	rt_uint16_t width;              /**< width of graphic device  */
+	rt_uint16_t height;             /**< height of graphic device */
 
-	rt_uint8_t *framebuffer;		/**< frame buffer 			*/
+	rt_uint8_t *framebuffer;        /**< frame buffer             */
 };
 
 /**
@@ -711,8 +712,8 @@ struct rt_device_graphic_info
  */
 struct rt_device_rect_info
 {
-	rt_uint16_t x, y;				/**< x, y coordinate 		*/
-	rt_uint16_t width, height;		/**< width and height       */
+	rt_uint16_t x, y;               /**< x, y coordinate          */
+	rt_uint16_t width, height;      /**< width and height         */
 };
 
 /**
@@ -720,15 +721,15 @@ struct rt_device_rect_info
  */
 struct rt_device_graphic_ops
 {
-	void (*set_pixel) (const char* pixel, int x, int y);
-	void (*get_pixel) (char* pixel, int x, int y);
+	void (*set_pixel) (const char *pixel, int x, int y);
+	void (*get_pixel) (char *pixel, int x, int y);
 
-	void (*draw_hline)(const char* pixel, int x1, int x2, int y);
-	void (*draw_vline)(const char* pixel, int x, int y1, int y2);
+	void (*draw_hline)(const char *pixel, int x1, int x2, int y);
+	void (*draw_vline)(const char *pixel, int x, int y1, int y2);
 
-	void (*blit_line) (const char* pixel, int x, int y, rt_size_t size);
+	void (*blit_line) (const char *pixel, int x, int y, rt_size_t size);
 };
-#define rt_graphix_ops(device)		((struct rt_device_graphic_ops*)(device->user_data))
+#define rt_graphix_ops(device)    ((struct rt_device_graphic_ops *)(device->user_data))
 /*@}*/
 
 /**
@@ -740,37 +741,37 @@ struct rt_device_graphic_ops
  * module system
  */
 
-#define RT_MODULE_FLAG_WITHENTRY		0x00		/* with entry point								*/
-#define RT_MODULE_FLAG_WITHOUTENTRY		0x01		/* without entry point							*/
+#define RT_MODULE_FLAG_WITHENTRY        0x00        /* with entry point                             */
+#define RT_MODULE_FLAG_WITHOUTENTRY     0x01        /* without entry point                          */
 
 /**
  * Application Module structure
  */
 struct rt_module
 {
-	struct	rt_object parent;						/**< inherit from object */
+	struct rt_object parent;                        /**< inherit from object                        */
 
-	rt_uint8_t* module_space;						/**< module memory space						*/
+	rt_uint8_t  *module_space;                      /**< module memory space                        */
 
-	void*		module_entry;						/**< entry address of module's thread			*/
-	rt_thread_t module_thread;						/**< stack size of module's thread				*/
-	rt_uint32_t stack_size;							/**< priority of module's thread				*/
+	void        *module_entry;                      /**< entry address of module's thread           */
+	rt_thread_t module_thread;                      /**< stack size of module's thread              */
+	rt_uint32_t stack_size;                         /**< priority of module's thread                */
 	rt_uint32_t thread_priority;
 
 	/* module memory allocator */
-	void*		mem_list;							/**< module's free memory list					*/
-	void*	    page_array;							/**< module's using pages 						*/
-	rt_uint32_t page_cnt;							/**< module's using pages count					*/
+	void        *mem_list;                          /**< module's free memory list                  */
+	void        *page_array;                        /**< module's using pages                       */
+	rt_uint32_t page_cnt;                           /**< module's using pages count                 */
 
-	rt_uint32_t nsym;								/**< number of symbol in the module 			*/
-	struct rt_module_symtab *symtab;				/**< module symbol table 						*/
+	rt_uint32_t nsym;                               /**< number of symbol in the module             */
+	struct rt_module_symtab *symtab;                /**< module symbol table                        */
 
-	rt_uint32_t nref;								/**< reference count 							*/
+	rt_uint32_t nref;                               /**< reference count                            */
 	
 	/**< object in this module, module object is the last basic object type */
 	struct rt_object_information module_object[RT_Object_Class_Unknown];
 };
-typedef struct rt_module* rt_module_t;
+typedef struct rt_module *rt_module_t;
 #endif
 
 /*@}*/

include/rthw.h

@@ -1,11 +1,11 @@
 /*
  * File      : rthw.h
  * This file is part of RT-Thread RTOS
- * COPYRIGHT (C) 2006, RT-Thread Development Team
+ * COPYRIGHT (C) 2006 - 2011, 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.
+ * http://www.rt-thread.org/license/LICENSE
  *
  * Change Logs:
  * Date           Author       Notes
@@ -32,8 +32,7 @@ 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);
+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);
@@ -47,7 +46,7 @@ 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_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);

include/rtm.h

@@ -1,3 +1,13 @@
+/*
+ * File      : rtm.h
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2006 - 2011, RT-Thread Development Team
+ *
+ * The license and distribution terms for this file may be
+ * found in the file LICENSE in this distribution or at
+ * http://www.rt-thread.org/license/LICENSE
+ */
+ 
 #ifndef __RTM_H__
 #define __RTM_H__
 
@@ -19,8 +29,8 @@ const struct rt_module_symtab __rtmsym_##symbol SECTION("RTMSymTab")= 	\
 
 struct rt_module_symtab
 {
-	void* addr;
-	const char* name;
-}; 
+	void *addr;
+	const char *name;
+};
 
 #endif

include/rtthread.h

@@ -1,11 +1,11 @@
 /*
  * File      : rtthread.h
  * This file is part of RT-Thread RTOS
- * COPYRIGHT (C) 2006, RT-Thread Development Team
+ * COPYRIGHT (C) 2006 - 2011, 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.
+ * http://www.rt-thread.org/license/LICENSE
  *
  * Change Logs:
  * Date           Author       Notes
@@ -14,7 +14,7 @@
  * 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
- * 2010-04-11     yi.qiu      add module feature
+ * 2010-04-11     yi.qiu       add module feature
  */
 
 #ifndef __RT_THREAD_H__
@@ -37,19 +37,19 @@ extern "C" {
 
 void rt_system_object_init(void);
 struct rt_object_information *rt_object_get_information(enum rt_object_class_type type);
-void rt_object_init(struct rt_object* object, enum rt_object_class_type type, const char* name);
+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);
+rt_object_t rt_object_allocate(enum rt_object_class_type type, const char *name);
 void rt_object_delete(rt_object_t object);
 rt_err_t rt_object_is_systemobject(rt_object_t object);
-rt_object_t rt_object_find(const char* name, rt_uint8_t type);
+rt_object_t rt_object_find(const char *name, rt_uint8_t type);
 
 #ifdef RT_USING_HOOK
-void rt_object_attach_sethook(void (*hook)(struct rt_object* object));
-void rt_object_detach_sethook(void (*hook)(struct rt_object* object));
-void rt_object_trytake_sethook(void (*hook)(struct rt_object* object));
-void rt_object_take_sethook(void (*hook)(struct rt_object* object));
-void rt_object_put_sethook(void (*hook)(struct rt_object* object));
+void rt_object_attach_sethook(void (*hook)(struct rt_object *object));
+void rt_object_detach_sethook(void (*hook)(struct rt_object *object));
+void rt_object_trytake_sethook(void (*hook)(struct rt_object *object));
+void rt_object_take_sethook(void (*hook)(struct rt_object *object));
+void rt_object_put_sethook(void (*hook)(struct rt_object *object));
 #endif
 
 /*@}*/
@@ -71,20 +71,20 @@ void rt_system_timer_init(void);
 void rt_system_timer_thread_init(void);
 
 void rt_timer_init(rt_timer_t timer,
-	const char* name,
-	void (*timeout)(void* parameter), void* parameter,
+	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_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);
+rt_err_t rt_timer_control(rt_timer_t timer, rt_uint8_t cmd, void *arg);
 
 #ifdef RT_USING_HOOK
-void rt_timer_timeout_sethook(void (*hook)(struct rt_timer* timer));
+void rt_timer_timeout_sethook(void (*hook)(struct rt_timer *timer));
 #endif
 /*@}*/
 
@@ -95,27 +95,27 @@ void rt_timer_timeout_sethook(void (*hook)(struct rt_timer* timer));
 /*
  * 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_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_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_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_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);
+void rt_thread_timeout(void *parameter);
 
 /*
  * idle thread interface
@@ -133,8 +133,8 @@ 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_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);
@@ -155,17 +155,17 @@ void rt_scheduler_sethook(void (*hook)(rt_thread_t from, rt_thread_t to));
 /*
  * 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_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);
+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)(struct rt_mempool* mp, void *block));
-void rt_mp_free_sethook(void (*hook)(struct rt_mempool* mp, void *block));
+void rt_mp_alloc_sethook(void (*hook)(struct rt_mempool *mp, void *block));
+void rt_mp_free_sethook(void (*hook)(struct rt_mempool *mp, void *block));
 #endif
 #endif
 
@@ -173,16 +173,14 @@ void rt_mp_free_sethook(void (*hook)(struct rt_mempool* mp, void *block));
 /*
  * heap memory interface
  */
-void rt_system_heap_init(void* begin_addr, void* end_addr);
+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);
+void *rt_malloc(rt_size_t nbytes);
+void rt_free(void *ptr);
+void *rt_realloc(void *ptr, rt_size_t nbytes);
 void *rt_calloc(rt_size_t count, rt_size_t size);
 
-void rt_memory_info(rt_uint32_t *total, 
-	rt_uint32_t *used,
-	rt_uint32_t *max_used);
+void rt_memory_info(rt_uint32_t *total, rt_uint32_t *used, rt_uint32_t *max_used);
 
 #ifdef RT_USING_SLAB
 void *rt_page_alloc(rt_size_t npages);
@@ -205,44 +203,43 @@ void rt_free_sethook(void (*hook)(void *ptr));
 /*
  * 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_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_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);
+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_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_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);
+rt_err_t rt_mutex_control(rt_mutex_t mutex, 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_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_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);
-
+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
@@ -250,30 +247,30 @@ rt_err_t rt_event_control (rt_event_t event, rt_uint8_t cmd, void* arg);
  * 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_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_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_send_wait (rt_mailbox_t mb, rt_uint32_t value, rt_int32_t timeout);
-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);
+rt_err_t rt_mb_send(rt_mailbox_t mb, rt_uint32_t value);
+rt_err_t rt_mb_send_wait(rt_mailbox_t mb, rt_uint32_t value, rt_int32_t timeout);
+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_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_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);
+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
 /*@}*/
 
@@ -286,9 +283,9 @@ rt_err_t rt_mq_control(rt_mq_t mq, rt_uint8_t cmd, void* arg);
  * device (I/O) system interface
  */
 
-rt_device_t rt_device_find(const char* name);
+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_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);
 
@@ -298,9 +295,9 @@ rt_err_t rt_device_set_tx_complete(rt_device_t dev, rt_err_t (*tx_done)(rt_devic
 rt_err_t  rt_device_init (rt_device_t dev);
 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);
+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
 
@@ -313,15 +310,15 @@ rt_err_t  rt_device_control(rt_device_t dev, rt_uint8_t cmd, void* arg);
  * module interface
  */
 
-rt_module_t rt_module_load(const char* name, void* module_ptr);
+rt_module_t rt_module_load(const char *name, void *module_ptr);
 rt_err_t rt_module_unload(rt_module_t module);
-rt_module_t rt_module_open(const char* filename);
+rt_module_t rt_module_open(const char *filename);
 void *rt_module_malloc(rt_size_t size);
 void *rt_module_realloc(void *ptr, rt_size_t size);
 void rt_module_free(rt_module_t module, void *addr);
-rt_module_t rt_module_self (void);
-rt_err_t rt_module_set (rt_module_t module);
-rt_module_t rt_module_find(const char* name);
+rt_module_t rt_module_self(void);
+rt_err_t rt_module_set(rt_module_t module);
+rt_module_t rt_module_find(const char *name);
 
 #ifdef RT_USING_HOOK
 void rt_module_load_sethook(void (*hook)(rt_module_t module));
@@ -353,13 +350,13 @@ rt_uint8_t rt_interrupt_get_nest(void);
 /*
  * general kernel service
  */
-rt_int32_t rt_sprintf(char *buf ,const char *format,...);
+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_sprintf(char *buf ,const char *format, ...);
 rt_int32_t rt_snprintf(char *buf, rt_size_t size, const char *format, ...);
 
 #ifdef RT_USING_DEVICE
-rt_device_t rt_console_set_device(const char* name);
+rt_device_t rt_console_set_device(const char *name);
 #endif
 void rt_kprintf(const char *fmt, ...);
 
@@ -372,19 +369,19 @@ int *_rt_errno(void);
 #endif
 #endif
 
-void* rt_memset(void *src, int c, rt_ubase_t n);
-void* rt_memcpy(void *dest, const void *src, rt_ubase_t n);
+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_strncmp(const char *cs, const char *ct, rt_ubase_t count);
 rt_ubase_t rt_strcmp (const char *cs, const char *ct);
 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_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);
+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);

src/object.c

@@ -187,7 +187,7 @@ struct rt_object_information *rt_object_get_information(enum rt_object_class_typ
 void rt_object_init(struct rt_object *object, enum rt_object_class_type type, const char *name)
 {
 	register rt_base_t temp;
-	struct rt_object_information* information;
+	struct rt_object_information *information;
 
 #ifdef RT_USING_MODULE
 	/* get module object information */

src/thread.c

@@ -142,7 +142,7 @@ rt_err_t rt_thread_init(struct rt_thread *thread,
  * @return the created thread object
  *
  */
-rt_thread_t rt_thread_create (const char *name,
+rt_thread_t rt_thread_create(const char *name,
 	void (*entry)(void *parameter), void *parameter,
 	rt_uint32_t stack_size,
 	rt_uint8_t priority,
@@ -151,7 +151,7 @@ rt_thread_t rt_thread_create (const char *name,
 	struct rt_thread *thread;
 	void *stack_start;
 
-	thread = (struct rt_thread *) rt_object_allocate(RT_Object_Class_Thread, name);
+	thread = (struct rt_thread *)rt_object_allocate(RT_Object_Class_Thread, name);
 	if (thread == RT_NULL) return RT_NULL;
 
 	stack_start = (void *)rt_malloc(stack_size);
@@ -603,7 +603,7 @@ rt_err_t rt_thread_resume(rt_thread_t thread)
 
 /**
  * This function is the timeout function for thread, normally which is invoked
- * when thread is timeout to wait some recourse.
+ * when thread is timeout to wait some resourse.
  *
  * @param parameter the parameter of thread timeout function
  *