springcute
/
rt-thread
mirror of https://github.com/RT-Thread/rt-thread.git
2
0
Fork 3
Code Issues Releases Wiki Activity

cleanup kernel code 

git-svn-id: https://rt-thread.googlecode.com/svn/trunk@1722 bbd45198-f89e-11dd-88c7-29a3b14d5316
This commit is contained in:
dzzxzz 2011-09-23 05:57:31 +00:00
parent 2ab9a1602e
commit 7926109356
7 changed files with 424 additions and 407 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
include/rtdebug.h
View File

@ -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)

107
include/rtdef.h
View File

@ -1,11 +1,11 @@
/*
* 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
@ -15,6 +15,7 @@
* 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__
@ -66,9 +67,9 @@ typedef rt_base_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. */
#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 */
@ -102,14 +103,14 @@ typedef rt_base_t rt_off_t; /**< Type for offset */
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;
@ -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
@ -202,11 +203,11 @@ struct rt_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 */
};
typedef struct rt_object* rt_object_t; /* Type for kernel objects. */
typedef struct rt_object *rt_object_t; /* Type for kernel objects. */
/**
* The object type can be one of the follows with specific
@ -307,13 +308,13 @@ struct rt_timer
rt_list_t list; /**< the node of timer list */
void (*timeout_func)(void* parameter); /**< timeout function */
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;
typedef struct rt_timer *rt_timer_t;
/*@}*/
/**
@ -343,7 +344,7 @@ typedef struct rt_timer* rt_timer_t;
#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
@ -357,17 +358,17 @@ struct rt_thread
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 */
/* stack point and entry */
void* sp; /**< stack point */
void* entry; /**< entry */
void* parameter; /**< parameter */
void* stack_addr; /**< stack address */
void *sp; /**< stack point */
void *entry; /**< entry */
void *parameter; /**< parameter */
void *stack_addr; /**< stack address */
rt_uint16_t stack_size; /**< stack size */
/* error code */
@ -395,7 +396,7 @@ struct rt_thread
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 */
};
@ -438,7 +439,7 @@ struct rt_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
@ -456,7 +457,7 @@ struct rt_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
@ -476,7 +477,7 @@ struct rt_event
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
@ -488,16 +489,16 @@ struct rt_mailbox
{
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 */
};
typedef struct rt_mailbox* rt_mailbox_t;
typedef struct rt_mailbox *rt_mailbox_t;
#endif
#ifdef RT_USING_MESSAGEQUEUE
@ -508,18 +509,18 @@ struct rt_messagequeue
{
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
/*@}*/
@ -551,7 +552,7 @@ struct rt_mempool
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
/*@}*/
@ -622,7 +623,7 @@ enum rt_device_class_type
#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
*/
@ -641,8 +642,8 @@ struct rt_device
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_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 */
};
/**
@ -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))
/*@}*/
/**
@ -750,16 +751,16 @@ struct rt_module
{
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 */
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 */
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 */
@ -770,7 +771,7 @@ struct rt_module
/**< 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
/*@}*/

9
include/rthw.h
View File

@ -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);

14
include/rtm.h
View File

@ -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

183
include/rtthread.h
View File

@ -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
@ -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);

2
src/object.c
View File

@ -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 */

6
src/thread.c
View File

@ -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
*