diff options
Diffstat (limited to 'include')
| -rw-r--r-- | include/rtdef.h | 632 | ||||
| -rw-r--r-- | include/rthw.h | 59 | ||||
| -rw-r--r-- | include/rtthread.h | 342 |
3 files changed, 1033 insertions, 0 deletions
diff --git a/include/rtdef.h b/include/rtdef.h new file mode 100644 index 0000000000..2c21f5a258 --- /dev/null +++ b/include/rtdef.h @@ -0,0 +1,632 @@ +/* + * File : rtdef.h + * This file is part of RT-Thread RTOS + * COPYRIGHT (C) 2006, RT-Thread Development Team + * + * The license and distribution terms for this file may be + * found in the file LICENSE in this distribution or at + * http://openlab.rt-thread.com/license/LICENSE. + * + * Change Logs: + * Date Author Notes + * 2007-01-10 Bernard the first version + * 2008-07-12 Bernard remove all rt_int8, rt_uint32_t etc typedef + */ +#ifndef __RT_DEF_H__ +#define __RT_DEF_H__ + +#include <rtconfig.h> + +#ifdef __cplusplus +extern "C" { +#endif + +typedef signed char rt_int8_t; +typedef signed short rt_int16_t; +typedef signed long rt_int32_t; +typedef unsigned char rt_uint8_t; +typedef unsigned short rt_uint16_t; +typedef unsigned long rt_uint32_t; +typedef int rt_bool_t; + +#define RT_UINT8_MAX 0xff +#define RT_UINT16_MAX 0xffff +#define RT_UINT32_MAX 0xffffffff + +/* 32bit CPU */ +typedef long rt_base_t; +typedef unsigned long rt_ubase_t; + +/* RT-Thread bool type definitions */ +#define RT_TRUE 1 +#define RT_FALSE 0 + +#ifdef __CC_ARM /* ARM Compiler */ + #include <stdarg.h> + #define SECTION(x) __attribute__((section(x))) + #define UNUSED __attribute__((unused)) + #define rt_inline static __inline + +#elif defined (__ICCARM__) /* for IAR Compiler */ + #include <stdarg.h> + #define SECTION(x) @ x + #define UNUSED + #define rt_inline inline + +#elif defined (__GNUC__) /* GNU GCC Compiler */ + #ifdef RT_USING_NEWLIB + #include <stdarg.h> + #else + typedef void *__sys_va_list; + typedef __sys_va_list va_list; + #define __va_rounded_size(type) \ + (((sizeof (type) + sizeof (int) - 1) / sizeof (int)) * sizeof (int)) + #define va_start(ap, lastarg) \ + (ap = ((char *) &(lastarg) + __va_rounded_size(lastarg))) + #define va_end(ap) ((void)0) + /* little endian */ + #define va_arg(ap, type) \ + (ap = (__sys_va_list) ((char *) (ap) + __va_rounded_size (type)), \ + *((type *) (void *) ((char *) (ap) - __va_rounded_size (type)))) + #endif + + #define SECTION(x) __attribute__((section(x))) + #define UNUSED __attribute__((unused)) + #define rt_inline static __inline +#endif + +/* event length */ +#define RT_EVENT_LENGTH 32 + +/* memory management option */ +#define RT_MM_PAGE_SIZE 4096 +#define RT_MM_PAGE_MASK (RT_MM_PAGE_SIZE - 1) +#define RT_MM_PAGE_BITS 12 + +/* RT-Thread definitions */ +typedef rt_base_t rt_err_t; /* Type for error number. */ +typedef rt_uint32_t rt_time_t; /* Type for time stamp. */ +typedef rt_uint32_t rt_tick_t; /* Type for tick count. */ +typedef rt_base_t rt_flag_t; /* Type for flags. */ +typedef rt_ubase_t rt_size_t; /* Type for size number. */ +typedef rt_ubase_t rt_dev_t; /* Type for device. */ +typedef rt_uint32_t rt_off_t; /* Type for offset. */ + +/* maximun value of base type */ +#define RT_UINT8_MAX 0xff /* Maxium number of UINT8. */ +#define RT_UINT16_MAX 0xffff /* Maxium number of UINT16. */ +#define RT_UINT32_MAX 0xffffffff /* Maxium number of UINT32. */ + +/* RT-Thread version information */ +#define RT_VERSION 3 +#define RT_SUBVERSION 0 + +/** + * @addtogroup Error + */ +/*@{*/ +/* RT-Thread error code definitions */ +#define RT_EOK 0 /* There is no error */ +#define RT_ERROR 1 /* A generic error happens */ +#define RT_ETIMEOUT 2 /* Timed out */ +#define RT_EFULL 3 /* The resource is full */ +#define RT_EEMPTY 4 /* The resource is empty */ +#define RT_ENOMEM 5 /* No memory */ +#define RT_ENOSYS 6 /* No system */ +#define RT_EBUSY 7 /* Busy */ +/*@}*/ + +#ifdef RT_DEBUG +#define RT_ASSERT(EX) if (!(EX)) { rt_kprintf("(%s) assert failed at %s:%d \n", #EX, __FUNCTION__, __LINE__); while (1);} +#else +#define RT_ASSERT(EX) +#endif + +/** + * @def RT_ALIGN(size, align) + * Return the most contiguous size aligned at specified width. RT_ALIGN(13, 4) + * would equal to 16. It is needed in some critical contexts. + */ +#define RT_ALIGN(size, align) (((size) + (align) - 1) & ~((align)-1)) + +/** + * @def RT_NULL + * Similar as the \c NULL in C library. + */ +#define RT_NULL ((void *)0) + +struct rt_list_node +{ + struct rt_list_node *next; /* point to next node. */ + struct rt_list_node *prev; /* point to prev node. */ +}; +typedef struct rt_list_node rt_list_t; /* Type for lists. */ + +/** + * @addtogroup KernelObject + */ +/*@{*/ +/* + * Base structure of Kernel object + */ +struct rt_object +{ + /* name of kernel object */ + char name[RT_NAME_MAX]; + /* type of kernel object */ + rt_uint8_t type; + /* flag of kernel object */ + rt_uint8_t flag; + /* list pointer of kernel object */ + rt_list_t list; +}; +typedef struct rt_object* rt_object_t; /* Type for kernel objects. */ + +/** + * The object type can be one of the follows with specific + * macros enabled: + * - Thread + * - Process + * - Semaphore + * - Mutex + * - FastEvent + * - Event + * - MailBox + * - MessageQueue + * - MemPool + * - Device + * - Timer + * - Unknown + * - Static + */ +enum rt_object_class_type +{ + RT_Object_Class_Thread = 0, /* The object is a thread. */ +#ifdef RT_USING_SEMAPHORE + RT_Object_Class_Semaphore, /* The object is a semaphore. */ +#endif +#ifdef RT_USING_MUTEX + RT_Object_Class_Mutex, /* The object is a mutex. */ +#endif +#ifdef RT_USING_FASTEVENT + RT_Object_Class_FastEvent, /* The object is a fast event. */ +#endif +#ifdef RT_USING_EVENT + RT_Object_Class_Event, /* The object is a event. */ +#endif +#ifdef RT_USING_MAILBOX + RT_Object_Class_MailBox, /* The object is a mail box. */ +#endif +#ifdef RT_USING_MESSAGEQUEUE + RT_Object_Class_MessageQueue,/* The object is a message queue. */ +#endif +#ifdef RT_USING_MEMPOOL + RT_Object_Class_MemPool, /* The object is a memory pool. */ +#endif +#ifdef RT_USING_DEVICE + RT_Object_Class_Device, /* The object is a device */ +#endif + RT_Object_Class_Timer, /* The object is a timer. */ +#ifdef RT_USING_MODULE + RT_Object_Class_Module, /* The object is a module. */ +#endif + RT_Object_Class_Unknown, /* The object is unknown. */ + RT_Object_Class_Static = 0x80/* The object is a static object. */ +}; + +/* + * the information of the kernel object + */ +struct rt_object_information +{ + enum rt_object_class_type type; /* object class type. */ + rt_list_t object_list; /* object list. */ + rt_size_t object_size; /* object size. */ +}; +/*@}*/ + +/** + * @addtogroup Clock + */ +/*@{*/ + +/* + * clock & timer macros + */ +#define RT_TIMER_FLAG_DEACTIVATED 0x0 /* timer is deactive. */ +#define RT_TIMER_FLAG_ACTIVATED 0x1 /* timer is active. */ +#define RT_TIMER_FLAG_ONE_SHOT 0x0 /* one shot timer. */ +#define RT_TIMER_FLAG_PERIODIC 0x2 /* periodic timer. */ + +#define RT_TIMER_CTRL_SET_TIME 0x0 /* set timer. */ +#define RT_TIMER_CTRL_GET_TIME 0x1 /* get timer. */ +#define RT_TIMER_CTRL_SET_ONESHOT 0x2 /* change timer to one shot. */ +#define RT_TIMER_CTRL_SET_PERIODIC 0x3 /* change timer to periodic. */ + +/* + * timer structure + * + */ +struct rt_timer +{ + struct rt_object parent; + + rt_list_t list; /* the node of timer list. */ + + void (*timeout_func)(void* parameter);/* timeout function. */ + void *parameter; /* timeout function's parameter. */ + + rt_tick_t init_tick; /* timer timeout tick. */ + rt_tick_t timeout_tick; /* timeout tick. */ +}; +typedef struct rt_timer* rt_timer_t; +/*@}*/ + +/** + * @addtogroup Thread + */ +/*@{*/ + +/* + * Thread + */ + +/* thread state definitions */ +#define RT_THREAD_RUNNING 0x0 /* Running. */ +#define RT_THREAD_READY 0x1 /* Ready. */ +#define RT_THREAD_SUSPEND 0x2 /* Suspend. */ +#define RT_THREAD_BLOCK RT_THREAD_SUSPEND /* Blocked. */ +#define RT_THREAD_CLOSE 0x3 /* Closed. */ +#define RT_THREAD_INIT RT_THREAD_CLOSE /* Inited. */ + +#define RT_THREAD_FLAGS_TIMERSLICE 0x01 + +#define RT_THREAD_CTRL_STARTUP 0x00 /* Starup thread. */ +#define RT_THREAD_CTRL_CLOSE 0x01 /* Close thread. */ +#define RT_THREAD_CTRL_CHANGE_PRIORITY 0x02 /* Change thread priority. */ +#define RT_THREAD_CTRL_INFO 0x03 /* Get thread information. */ + +typedef struct rt_thread* rt_thread_t; +typedef struct rt_module* rt_module_t; + +/* + * Thread related structure + */ +struct rt_thread +{ + /* rt object */ + char name[RT_NAME_MAX]; /* the name of thread */ + rt_uint8_t type; /* type of object */ + rt_uint8_t flags; /* thread's flags */ + + rt_list_t list; /* the object list */ + + rt_thread_t tid; /* the thread id */ + rt_list_t tlist; /* the thread list */ + + /* stack point and entry */ + void* sp; /* stack point */ + void* entry; /* entry */ + void* parameter; /* parameter */ + void* stack_addr; /* stack address */ + rt_uint16_t stack_size; /* stack size */ + + /* error code */ + rt_err_t error; /* error code */ + + /* priority */ + rt_uint8_t current_priority; /* current priority */ + rt_uint8_t init_priority; /* initialized priority */ +#if RT_THREAD_PRIORITY_MAX > 32 + rt_uint8_t number; + rt_uint8_t high_mask; +#endif + rt_uint32_t number_mask; + +#if defined(RT_USING_EVENT) || defined(RT_USING_FASTEVENT) + /* thread event */ + rt_uint32_t event_set; + rt_uint8_t event_info; +#endif + + rt_uint8_t stat; /* thread stat */ + + rt_ubase_t init_tick; /* thread's tick */ + rt_ubase_t remaining_tick; /* remaining tick */ + + struct rt_timer thread_timer; /* thread timer */ + +#ifdef RT_USING_MODULE + rt_module_t module_parent; /* module parent */ +#endif + + rt_uint32_t user_data; /* user data */ +}; +/*@}*/ + +#ifdef RT_USING_MODULE +struct rt_module +{ + /* inherit from object */ + struct rt_object parent; + + rt_uint32_t module_data; + void* module_space; + + void* module_entry; + rt_uint32_t stack_size; + rt_uint32_t thread_priority; + rt_thread_t module_thread; + + /* module memory pool */ + rt_uint32_t mempool_size; + void* module_mempool; + + /* object in this module, module object is the last basic object type */ + struct rt_object_information module_object[RT_Object_Class_Module]; +}; +#endif + +/** + * @addtogroup IPC + */ +/*@{*/ +/* + * ipc & sync + */ +#define RT_IPC_FLAG_FIFO 0x00 /* FIFOed IPC. @ref IPC. */ +#define RT_IPC_FLAG_PRIO 0x01 /* PRIOed IPC. @ref IPC. */ + +#define RT_WAITING_FOREVER -1 /* Block forever until get resource. */ +#define RT_WAITING_NO 0 /* Non-block. */ + +/* + * Base structure of IPC object + */ +struct rt_ipc_object +{ + struct rt_object parent; + + rt_list_t suspend_thread; /* threads pended on this resource. */ + rt_uint32_t suspend_thread_count; /* numbers of thread pended on this resource. */ +}; + +#ifdef RT_USING_SEMAPHORE +/* + * semaphore + * + * Binary and counter semaphore are both supported. + */ +struct rt_semaphore +{ + struct rt_ipc_object parent; + + rt_base_t value; /* value of semaphore. */ +}; +typedef struct rt_semaphore* rt_sem_t; +#endif + +#ifdef RT_USING_MUTEX +/* + * mutex + */ +struct rt_mutex +{ + struct rt_ipc_object parent; + + rt_base_t value; /* value of mutex. */ + + struct rt_thread* owner; /* current owner of mutex. */ + rt_uint8_t original_priority; /* priority of last thread hold the mutex. */ + + rt_base_t hold; /* numbers of thread hold the mutex. Only 0 or 1 is legal. */ +}; +typedef struct rt_mutex* rt_mutex_t; +#endif + +#if defined(RT_USING_EVENT) || defined(RT_USING_FASTEVENT) +#define RT_EVENT_FLAG_AND 0x01 +#define RT_EVENT_FLAG_OR 0x02 +#define RT_EVENT_FLAG_CLEAR 0x04 +#endif + +#ifdef RT_USING_FASTEVENT +/* + * fast_event + */ +struct rt_fast_event +{ + struct rt_object parent; + + rt_uint32_t set; /* event set. */ + + rt_list_t thread_list[RT_EVENT_LENGTH]; /* threads blocked on this resource. */ +}; +typedef struct rt_fast_event* rt_fast_event_t; +#endif + +#ifdef RT_USING_EVENT +/* + * event + */ +struct rt_event +{ + struct rt_ipc_object parent; + + rt_uint32_t set; /* event set. */ +}; +typedef struct rt_event* rt_event_t; +#endif + +#ifdef RT_USING_MAILBOX +/* + * mailbox + * + */ +struct rt_mailbox +{ + struct rt_ipc_object parent; + + rt_uint32_t* msg_pool; /* start address of message buffer. */ + + rt_size_t size; /* size of message pool. */ + + rt_ubase_t entry; /* index of messages in msg_pool. */ + rt_ubase_t in_offset, out_offset; /* in/output offset of the message buffer. */ +}; +typedef struct rt_mailbox* rt_mailbox_t; +#endif + +#ifdef RT_USING_MESSAGEQUEUE +/* + * messagequeue + */ +struct rt_messagequeue +{ + struct rt_ipc_object parent; + + void* msg_pool; /* start address of message queue. */ + + rt_size_t msg_size; /* message size of each message. */ + rt_size_t max_msgs; /* max number of messages. */ + + void* msg_queue_head; /* list head. */ + void* msg_queue_tail; /* list tail. */ + void* msg_queue_free; /* pointer indicated the free node of queue. */ + + rt_ubase_t entry; /* index of messages in the queue. */ +}; +typedef struct rt_messagequeue* rt_mq_t; +#endif +/*@}*/ + +/** + * @addtogroup MM + */ +/*@{*/ +/* + * memory management + * heap & partition + */ +#ifdef RT_USING_MEMPOOL +/* + * Base structure of Memory pool object + */ +struct rt_mempool +{ + struct rt_object parent; + + void* start_address; /* memory pool start */ + rt_size_t size; /* size of memory pool */ + + rt_size_t block_size; /* size of memory blocks */ + rt_uint8_t* block_list; /* memory blocks list */ + + rt_size_t block_total_count; /* numbers of memory block */ + rt_size_t block_free_count; /* numbers of free memory block */ + + rt_list_t suspend_thread; /* threads pended on this resource */ + rt_size_t suspend_thread_count; /* numbers of thread pended on this resource */ +}; +typedef struct rt_mempool* rt_mp_t; +#endif +/*@}*/ + +#ifdef RT_USING_DEVICE +/** + * @addtogroup Device + */ +/*@{*/ + +/* + * device (I/O) system + */ +enum rt_device_class_type +{ + RT_Device_Class_Char = 0, /* character device */ + RT_Device_Class_Block, /* block device */ + RT_Device_Class_NetIf, /* net interface */ + RT_Device_Class_MTD, /* memory device */ + RT_Device_Class_CAN, /* CAN device */
+ RT_Device_Class_RTC, /* RTC device */ + RT_Device_Class_Unknown /* unknown device */ +}; + +/* device flags */ +#define RT_DEVICE_FLAG_DEACTIVATE 0x000 /* not inited */ + +#define RT_DEVICE_FLAG_RDONLY 0x001 /* read only */ +#define RT_DEVICE_FLAG_WRONLY 0x002 /* write only */ +#define RT_DEVICE_FLAG_RDWR 0x003 /* read and write */ + +#define RT_DEVICE_FLAG_REMOVABLE 0x004 /* removable device */ +#define RT_DEVICE_FLAG_STANDALONE 0x008 /* standalone device */ +#define RT_DEVICE_FLAG_ACTIVATED 0x010 /* device is activated */ +#define RT_DEVICE_FLAG_SUSPENDED 0x020 /* device is suspended */ +#define RT_DEVICE_FLAG_STREAM 0x040 /* stream mode */ + +#define RT_DEVICE_FLAG_INT_RX 0x100 /* INT mode on Rx */ +#define RT_DEVICE_FLAG_DMA_RX 0x200 /* DMA mode on Rx */ +#define RT_DEVICE_FLAG_INT_TX 0x400 /* INT mode on Tx */ +#define RT_DEVICE_FLAG_DMA_TX 0x800 /* DMA mode on Tx */ + +#define RT_DEVICE_OFLAG_CLOSE 0x000 /* device is closed */ +#define RT_DEVICE_OFLAG_RDONLY 0x001 /* read only access */ +#define RT_DEVICE_OFLAG_WRONLY 0x002 /* write only access */ +#define RT_DEVICE_OFLAG_RDWR 0x003 /* read and write */ +#define RT_DEVICE_OFLAG_OPEN 0x008 /* device is opened */ + +/* general device commands */ +#define RT_DEVICE_CTRL_RESUME 0x01 /* resume device */ +#define RT_DEVICE_CTRL_SUSPEND 0x02 /* suspend device */ + +/* special device commands */ +#define RT_DEVICE_CTRL_CHAR_STREAM 0x10 /* stream mode on char device */ +#define RT_DEVICE_CTRL_BLK_GETGEOME 0x10 /* get geometry information */ +#define RT_DEVICE_CTRL_NETIF_GETMAC 0x10 /* get mac address */ +#define RT_DEVICE_CTRL_MTD_FORMAT 0x10 /* format a MTD device */ +#define RT_DEVICE_CTRL_RTC_GET_TIME 0x10 /* get time */
+#define RT_DEVICE_CTRL_RTC_SET_TIME 0x11 /* set time */ +
+typedef struct rt_device* rt_device_t; +/* + * Device related structure + */ +struct rt_device +{ + struct rt_object parent; + + /* device type */ + enum rt_device_class_type type; + /* device flag and device open flag*/ + rt_uint16_t flag, open_flag; + + /* device call back */ + rt_err_t (*rx_indicate)(rt_device_t dev, rt_size_t size); + rt_err_t (*tx_complete)(rt_device_t dev, void* buffer); + + /* common device interface */ + rt_err_t (*init) (rt_device_t dev); + rt_err_t (*open) (rt_device_t dev, rt_uint16_t oflag); + rt_err_t (*close) (rt_device_t dev); + rt_size_t (*read) (rt_device_t dev, rt_off_t pos, void* buffer, rt_size_t size); + rt_size_t (*write) (rt_device_t dev, rt_off_t pos, const void* buffer, rt_size_t size); + rt_err_t (*control)(rt_device_t dev, rt_uint8_t cmd, void *args); + +#ifdef RT_USING_DEVICE_SUSPEND + rt_err_t (*suspend) (rt_device_t dev); + rt_err_t (*resumed) (rt_device_t dev); +#endif + + /* device private data */ + void* private; +}; + +/*@}*/ +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/rthw.h b/include/rthw.h new file mode 100644 index 0000000000..964b357556 --- /dev/null +++ b/include/rthw.h @@ -0,0 +1,59 @@ +/* + * File : rthw.h + * This file is part of RT-Thread RTOS + * COPYRIGHT (C) 2006, RT-Thread Development Team + * + * The license and distribution terms for this file may be + * found in the file LICENSE in this distribution or at + * http://openlab.rt-thread.com/license/LICENSE. + * + * Change Logs: + * Date Author Notes + * 2006-03-18 Bernard the first version + * 2006-04-25 Bernard add rt_hw_context_switch_interrupt declaration + * 2006-09-24 Bernard add rt_hw_context_switch_to declaration + */ + +#ifndef __RT_HW_H__ +#define __RT_HW_H__ + +#include <rtthread.h> + +#ifdef __cplusplus +extern "C" { +#endif + +void rt_hw_cpu_icache_enable(void); +void rt_hw_cpu_icache_disable(void); +rt_base_t rt_hw_cpu_icache_status(void); +void rt_hw_cpu_dcache_enable(void); +void rt_hw_cpu_dcache_disable(void); +rt_base_t rt_hw_cpu_dcache_status(void); +void rt_hw_cpu_reset(void); +void rt_hw_cpu_shutdown(void); + +rt_uint8_t *rt_hw_stack_init(void *entry, void *parameter, + rt_uint8_t *stack_addr, void *exit); + +void rt_hw_interrupt_init(void); +void rt_hw_interrupt_mask(int vector); +void rt_hw_interrupt_umask(int vector); +void rt_hw_interrupt_install(int vector, rt_isr_handler_t new_handler, rt_isr_handler_t *old_handler); +void rt_hw_interrupt_handle(int vector); + +rt_base_t rt_hw_interrupt_disable(void); +void rt_hw_interrupt_enable(rt_base_t level); +void rt_hw_context_switch(rt_uint32_t from, rt_uint32_t to); +void rt_hw_context_switch_to(rt_uint32_t to); +void rt_hw_context_switch_interrupt(rt_uint32_t from, rt_uint32_t to); + +void rt_hw_console_output(const char* str); + +void rt_hw_backtrace(rt_uint32_t *fp, rt_uint32_t thread_entry); +void rt_hw_show_memory(rt_uint32_t addr, rt_uint32_t size); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/rtthread.h b/include/rtthread.h new file mode 100644 index 0000000000..540c1aacdb --- /dev/null +++ b/include/rtthread.h @@ -0,0 +1,342 @@ +/* + * File : rtthread.h + * This file is part of RT-Thread RTOS + * COPYRIGHT (C) 2006, RT-Thread Development Team + * + * The license and distribution terms for this file may be + * found in the file LICENSE in this distribution or at + * http://openlab.rt-thread.com/license/LICENSE. + * + * Change Logs: + * Date Author Notes + * 2006-03-18 Bernard the first version + * 2006-04-26 Bernard add semaphore APIs + * 2006-08-10 Bernard add version information + * 2007-01-28 Bernard rename RT_OBJECT_Class_Static to RT_Object_Class_Static + * 2007-03-03 Bernard clean up the definitions to rtdef.h + */ + +#ifndef __RT_THREAD_H__ +#define __RT_THREAD_H__ + +#include <rtdef.h> + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @addtogroup KernelObject + */ +/*@{*/ +/* + * kernel object interface + */ + +void rt_system_object_init(void); +void rt_object_init(struct rt_object* object, enum rt_object_class_type type, const char* name); +void rt_object_detach(rt_object_t object); +rt_object_t rt_object_allocate(enum rt_object_class_type type, const char* name); +void rt_object_delete(rt_object_t object); +rt_object_t rt_object_find(enum rt_object_class_type type, const char* name); +rt_err_t rt_object_is_systemobject(rt_object_t object); +/*@}*/ + +/** + * @addtogroup Clock + */ +/*@{*/ +/* + * clock & timer interface + */ +void rt_system_tick_init(void); +rt_tick_t rt_tick_get(void); +void rt_tick_increase(void); +rt_tick_t rt_tick_from_millisecond(rt_uint32_t ms); + +void rt_system_timer_init(void); +void rt_timer_init(rt_timer_t timer, + const char* name, + void (*timeout)(void* parameter), void* parameter, + rt_tick_t time, rt_uint8_t flag); +rt_err_t rt_timer_detach(rt_timer_t timer); +rt_timer_t rt_timer_create(const char* name, + void (*timeout)(void* parameter), void* parameter, + rt_tick_t time, rt_uint8_t flag); +rt_err_t rt_timer_delete(rt_timer_t timer); +rt_err_t rt_timer_start(rt_timer_t timer); +rt_err_t rt_timer_stop(rt_timer_t timer); +rt_err_t rt_timer_control(rt_timer_t timer, rt_uint8_t cmd, void* arg); +/*@}*/ + +/** + * @addtogroup Thread + */ +/*@{*/ +/* + * thread interface + */ +rt_err_t rt_thread_init(struct rt_thread* thread, + const char* name, + void (*entry)(void* parameter), void* parameter, + void* stack_start, rt_uint32_t stack_size, + rt_uint8_t priority, rt_uint32_t tick); +rt_err_t rt_thread_detach(rt_thread_t thread); +rt_thread_t rt_thread_create (const char* name, + void (*entry)(void* parameter), void* parameter, + rt_uint32_t stack_size, + rt_uint8_t priority, rt_uint32_t tick); +rt_thread_t rt_thread_self(void); +rt_thread_t rt_thread_find(char* name); +rt_err_t rt_thread_startup(rt_thread_t thread); +rt_err_t rt_thread_delete(rt_thread_t thread); + +rt_err_t rt_thread_yield(void); +rt_err_t rt_thread_delay(rt_tick_t tick); +rt_err_t rt_thread_control(rt_thread_t thread, rt_uint8_t cmd, void* arg); +rt_err_t rt_thread_suspend(rt_thread_t thread); +rt_err_t rt_thread_resume(rt_thread_t thread); +void rt_thread_timeout(void* parameter); + +#ifdef RT_USING_HOOK +void rt_thread_suspend_hook(void (*hook)(rt_thread_t thread)); +void rt_thread_resume_hook (void (*hook)(rt_thread_t thread)); +#endif + +/* + * idle thread interface + */ +void rt_thread_idle_init(void); +#ifdef RT_USING_HOOK +void rt_thread_idle_sethook(void (*hook)(void)); +#endif + +/* + * schedule service + */ +void rt_system_scheduler_init(void); +void rt_system_scheduler_start(void); + +void rt_schedule(void); +void rt_schedule_insert_thread(struct rt_thread* thread); +void rt_schedule_remove_thread(struct rt_thread* thread); + +void rt_enter_critical(void); +void rt_exit_critical(void); + +#ifdef RT_USING_HOOK +void rt_schedule_sethook(void (*hook)(rt_thread_t from, rt_thread_t to)); +#endif +/*@}*/ + +/** + * @addtogroup MM + */ +/*@{*/ +/* + * memory management interface + */ +#ifdef RT_USING_MEMPOOL +/* + * memory pool interface + */ +rt_err_t rt_mp_init(struct rt_mempool* mp, const char* name, void *start, rt_size_t size, rt_size_t block_size); +rt_err_t rt_mp_detach(struct rt_mempool* mp); +rt_mp_t rt_mp_create(const char* name, rt_size_t block_count, rt_size_t block_size); +rt_err_t rt_mp_delete(rt_mp_t mp); + +void *rt_mp_alloc (rt_mp_t mp, rt_int32_t time); +void rt_mp_free (void *block); + +#ifdef RT_USING_HOOK +void rt_mp_alloc_sethook(void (*hook)(void *block)); +void rt_mp_free_sethook(void (*hook)(void *block)); +#endif +#endif + +#ifdef RT_USING_HEAP +/* + * heap memory interface + */ +void rt_system_heap_init(void* begin_addr, void* end_addr); + +void* rt_malloc(rt_size_t nbytes); +void rt_free (void *ptr); +void* rt_realloc(void *ptr, rt_size_t nbytes); + +#ifdef RT_USING_HOOK +void rt_malloc_sethook(void (*hook)(void *ptr, rt_uint32_t size)); +void rt_free_sethook(void (*hook)(void *ptr)); +#endif +#endif +/*@}*/ + +/** + * @addtogroup IPC + */ +/*@{*/ +#ifdef RT_USING_SEMAPHORE +/* + * semaphore interface + */ +rt_err_t rt_sem_init (rt_sem_t sem, const char* name, rt_uint32_t value, rt_uint8_t flag); +rt_err_t rt_sem_detach (rt_sem_t sem); +rt_sem_t rt_sem_create (const char* name, rt_uint32_t value, rt_uint8_t flag); +rt_err_t rt_sem_delete (rt_sem_t sem); + +rt_err_t rt_sem_take (rt_sem_t sem, rt_int32_t time); +rt_err_t rt_sem_trytake(rt_sem_t sem); +rt_err_t rt_sem_release(rt_sem_t sem); +rt_err_t rt_sem_control(rt_sem_t sem, rt_uint8_t cmd, void* arg); +#endif + +#ifdef RT_USING_MUTEX +/* + * mutex interface + */ +rt_err_t rt_mutex_init (rt_mutex_t mutex, const char* name, rt_uint8_t flag); +rt_err_t rt_mutex_detach (rt_mutex_t mutex); +rt_mutex_t rt_mutex_create (const char* name, rt_uint8_t flag); +rt_err_t rt_mutex_delete (rt_mutex_t mutex); + +rt_err_t rt_mutex_take (rt_mutex_t mutex, rt_int32_t time); +rt_err_t rt_mutex_release(rt_mutex_t mutex); +rt_err_t rt_mutex_control(rt_mutex_t mutex, rt_uint8_t cmd, void* arg); +#endif + +#ifdef RT_USING_FASTEVENT +/* + * fast_event interface + */ +rt_err_t rt_fast_event_init(rt_fast_event_t event, const char* name, rt_uint8_t flag); +rt_err_t rt_fast_event_detach(rt_fast_event_t event); +rt_fast_event_t rt_fast_event_create (const char* name, rt_uint8_t flag); +rt_err_t rt_fast_event_delete (rt_fast_event_t event); + +rt_err_t rt_fast_event_send(rt_fast_event_t event, rt_uint8_t bit); +rt_err_t rt_fast_event_recv(rt_fast_event_t event, rt_uint8_t bit, rt_uint8_t opt, rt_int32_t timeout); +rt_err_t rt_fast_event_control (rt_fast_event_t event, rt_uint8_t cmd, void* arg); +#endif + +#ifdef RT_USING_EVENT +/* + * event interface + */ +rt_err_t rt_event_init(rt_event_t event, const char* name, rt_uint8_t flag); +rt_err_t rt_event_detach(rt_event_t event); +rt_event_t rt_event_create (const char* name, rt_uint8_t flag); +rt_err_t rt_event_delete (rt_event_t event); + +rt_err_t rt_event_send(rt_event_t event, rt_uint32_t set); +rt_err_t rt_event_recv(rt_event_t event, rt_uint32_t set, rt_uint8_t opt, rt_int32_t timeout, rt_uint32_t* recved); +rt_err_t rt_event_control (rt_event_t event, rt_uint8_t cmd, void* arg); + +#endif + +#ifdef RT_USING_MAILBOX +/* + * mailbox interface + * + */ +rt_err_t rt_mb_init(rt_mailbox_t mb, const char* name, void* msgpool, rt_size_t size, rt_uint8_t flag); +rt_err_t rt_mb_detach(rt_mailbox_t mb); +rt_mailbox_t rt_mb_create (const char* name, rt_size_t size, rt_uint8_t flag); +rt_err_t rt_mb_delete (rt_mailbox_t mb); + +rt_err_t rt_mb_send (rt_mailbox_t mb, rt_uint32_t value); +rt_err_t rt_mb_recv (rt_mailbox_t mb, rt_uint32_t* value, rt_int32_t timeout); +rt_err_t rt_mb_control(rt_mailbox_t mb, rt_uint8_t cmd, void* arg); +#endif + +#ifdef RT_USING_MESSAGEQUEUE +/* + * message queue interface + */ +rt_err_t rt_mq_init(rt_mq_t mq, const char* name, void *msgpool, rt_size_t msg_size, rt_size_t pool_size, rt_uint8_t flag); +rt_err_t rt_mq_detach(rt_mq_t mq); +rt_mq_t rt_mq_create (const char* name, rt_size_t msg_size, rt_size_t max_msgs, rt_uint8_t flag); +rt_err_t rt_mq_delete (rt_mq_t mq); + +rt_err_t rt_mq_send (rt_mq_t mq, void* buffer, rt_size_t size); +rt_err_t rt_mq_urgent(rt_mq_t mq, void* buffer, rt_size_t size); +rt_err_t rt_mq_recv (rt_mq_t mq, void* buffer, rt_size_t size, rt_int32_t timeout); +rt_err_t rt_mq_control(rt_mq_t mq, rt_uint8_t cmd, void* arg); +#endif +/*@}*/ + +#ifdef RT_USING_DEVICE +/** + * @addtogroup Device + */ +/*@{*/ +/* + * device (I/O) system interface + */ + +rt_device_t rt_device_find(const char* name); + +rt_err_t rt_device_register(rt_device_t dev, const char* name, rt_uint16_t flags); +rt_err_t rt_device_unregister(rt_device_t dev); +rt_err_t rt_device_init_all(void); + +rt_err_t rt_device_set_rx_indicate(rt_device_t dev, rt_err_t (*rx_ind )(rt_device_t dev, rt_size_t size)); +rt_err_t rt_device_set_tx_complete(rt_device_t dev, rt_err_t (*tx_done)(rt_device_t dev, void *buffer)); + +rt_err_t rt_device_open (rt_device_t dev, rt_uint16_t oflag); +rt_err_t rt_device_close(rt_device_t dev); +rt_size_t rt_device_read (rt_device_t dev, rt_off_t pos, void* buffer, rt_size_t size); +rt_size_t rt_device_write(rt_device_t dev, rt_off_t pos, const void* buffer, rt_size_t size); +rt_err_t rt_device_control(rt_device_t dev, rt_uint8_t cmd, void* arg); +/*@}*/ +#endif + +/* + * interrupt service + */ +typedef void (*rt_isr_handler_t)(int vector); + +/* + * rt_interrupt_enter and rt_interrupt_leave only can be called by BSP + */ +void rt_interrupt_enter(void); +void rt_interrupt_leave(void); + +/** + * @addtogroup KernelService + */ +/*@{*/ +/* + * general kernel service + */ +rt_int32_t rt_sprintf(char *buf ,const char *format,...); +rt_int32_t rt_vsprintf(char *dest, const char *format, va_list arg_ptr); +rt_int32_t rt_sprintf(char *buf ,const char *format,...); +rt_int32_t rt_snprintf(char *buf, rt_size_t size, const char *format, ...); +void rt_kprintf(const char *fmt, ...); + +rt_err_t rt_get_errno(void); +void rt_set_errno(rt_err_t no); + +void* rt_memset(void *src, int c, rt_ubase_t n); +void* rt_memcpy(void *dest, const void *src, rt_ubase_t n); + +rt_ubase_t rt_strncmp(const char * cs, const char * ct, rt_ubase_t count); +rt_ubase_t rt_strlen (const char *src); +char *rt_strdup(const char *s); + +char * rt_strstr( const char * str1, const char * str2 ); +rt_int32_t rt_sscanf(const char * buf, const char * fmt, ...); +char *rt_strncpy(char *dest, const char *src, rt_ubase_t n); +void* rt_memmove(void *dest, const void *src, rt_ubase_t n); +rt_int32_t rt_memcmp(const void * cs,const void * ct, rt_ubase_t count); +rt_uint32_t rt_strcasecmp(const char *a, const char *b); + +void rt_show_version(void); + +/*@}*/ + +#ifdef __cplusplus +} +#endif +/*@}*/ +#endif |