/* * File : rtdef.h * This file is part of RT-Thread RTOS * COPYRIGHT (C) 2006 - 2012, 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 * * 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 * 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__ #include #ifdef __cplusplus extern "C" { #endif /** * @addtogroup BasicDef */ /*@{*/ /* RT-Thread version information */ #define RT_VERSION 1L /**< major version number */ #define RT_SUBVERSION 1L /**< minor version number */ #define RT_REVISION 0L /**< revise version number */ /* RT-Thread version */ #define RTTHREAD_VERSION ((RT_VERSION * 10000) + \ (RT_SUBVERSION * 100) + RT_REVISION) /* 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 */ /* 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 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 */ /*@}*/ /* maximum 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 #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) #else #define RTT_API __declspec(dllexport) #endif #elif defined (__IAR_SYSTEMS_ICC__) /* for IAR Compiler */ #include #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 #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)) #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)))) #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) #endif #endif #define SECTION(x) __attribute__((section(x))) #define UNUSED __attribute__((unused)) #define ALIGN(n) __attribute__((aligned(n))) #define rt_inline static __inline #define RTT_API #elif defined (__ADSPBLACKFIN__) /* for VisualDSP++ Compiler */ #include #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 /* 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 /** * @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_EIO 8 /**< IO error */ /*@}*/ /** * @ingroup BasicDef * * @def RT_ALIGN(size, align) * 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)) /** * @ingroup BasicDef * * @def RT_ALIGN_DOWN(size, align) * 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)) /** * @ingroup BasicDef * * @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 */ /*@{*/ /* * kernel object macros */ #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 */ #ifdef RT_USING_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. */ /** * The object type can be one of the follows with specific * macros enabled: * - Thread * - Semaphore * - Mutex * - Event * - MailBox * - MessageQueue * - MemHeap * - MemPool * - Device * - Timer * - Module * - 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_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_MEMHEAP RT_Object_Class_MemHeap, /**< The object is a memory heap */ #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 */ }; /** * The hook function call macro */ #ifdef RT_USING_HOOK #define RT_OBJECT_HOOK_CALL(func, argv) \ do { if ((func) != RT_NULL) func argv; } while (0) #else #define RT_OBJECT_HOOK_CALL(func, argv) #endif /*@}*/ /** * @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_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 */ /** * timer structure */ struct rt_timer { struct rt_object parent; /**< inherit from rt_object */ 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_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 /**< Startup 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. */ /** * Thread 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 */ #ifdef RT_USING_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 */ rt_uint16_t stack_size; /**< stack size */ /* error code */ rt_err_t error; /**< error code */ rt_uint8_t stat; /**< thread stat */ /* 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) /* thread event */ rt_uint32_t event_set; rt_uint8_t event_info; #endif rt_ubase_t init_tick; /**< thread's initialized tick */ rt_ubase_t remaining_tick; /**< remaining tick */ struct rt_timer thread_timer; /**< built-in thread timer */ void (*cleanup)(struct rt_thread *tid); /**< cleanup function when thread exit */ rt_uint32_t user_data; /**< private user data beyond this thread */ }; typedef struct rt_thread *rt_thread_t; /*@}*/ /** * @addtogroup IPC */ /*@{*/ /** * IPC flags and control command definitions */ #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_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 */ rt_list_t suspend_thread; /**< threads pended on this resource */ }; #ifdef RT_USING_SEMAPHORE /** * Semaphore structure */ struct rt_semaphore { struct rt_ipc_object parent; /**< inherit from ipc_object */ rt_uint16_t value; /**< value of semaphore. */ }; typedef struct rt_semaphore *rt_sem_t; #endif #ifdef RT_USING_MUTEX /** * Mutual exclusion (mutex) structure */ struct rt_mutex { struct rt_ipc_object parent; /**< inherit from ipc_object */ 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 */ struct rt_thread *owner; /**< current owner of mutex */ }; 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 */ /* * event structure */ struct rt_event { struct rt_ipc_object parent; /**< inherit from ipc_object */ rt_uint32_t set; /**< event set */ }; typedef struct rt_event *rt_event_t; #endif #ifdef RT_USING_MAILBOX /** * mailbox structure * */ struct rt_mailbox { struct rt_ipc_object parent; /**< inherit from ipc_object */ rt_uint32_t *msg_pool; /**< start address of message buffer */ 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_list_t suspend_sender_thread; /**< sender thread suspended on this mailbox */ }; typedef struct rt_mailbox *rt_mailbox_t; #endif #ifdef RT_USING_MESSAGEQUEUE /** * message queue structure */ struct rt_messagequeue { struct rt_ipc_object parent; /**< inherit from ipc_object */ 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 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 */ }; typedef struct rt_messagequeue *rt_mq_t; #endif /*@}*/ #ifdef RT_USING_MEMPOOL /** * @addtogroup MM */ /*@{*/ /* * memory management * heap & partition */ /** * memory item on the heap */ struct rt_memheap_item { rt_uint32_t magic; struct rt_memheap_item *next, *prev; struct rt_memheap_item *next_free, *prev_free; struct rt_memheap* pool_ptr; }; /** * Base structure of memory heap object */ struct rt_memheap { struct rt_object parent; /* pool start address and size */ void *start_addr; rt_uint32_t pool_size; rt_uint32_t available_size; /* used block list */ struct rt_memheap_item* block_list; /* free block list and free block list header */ struct rt_memheap_item* free_list; struct rt_memheap_item free_header; }; /** * Base structure of Memory pool object */ struct rt_mempool { struct rt_object parent; /**< inherit from rt_object */ 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) class type */ 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_I2CBUS, /**< I2C bus device */ RT_Device_Class_I2CDevice, /**< I2C device */ RT_Device_Class_USBDevice, /**< USB slave device */ RT_Device_Class_USBHost, /**< USB host bus */ RT_Device_Class_SPIBUS, /**< SPI bus device */ RT_Device_Class_SPIDevice, /**< SPI device */ RT_Device_Class_SDIO, /**< SDIO bus device */ RT_Device_Class_Unknown /**< unknown device */ }; /** * device flags defitions */ #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_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 structure */ struct rt_device { 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 */ rt_uint8_t device_id; /* 0 - 255 */ /* 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 void *user_data; /**< device private data */ }; /** * block device geometry structure */ 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 */ }; /** * 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 /* graphic deice */ enum { RTGRAPHIC_PIXEL_FORMAT_MONO = 0, RTGRAPHIC_PIXEL_FORMAT_GRAY4, RTGRAPHIC_PIXEL_FORMAT_GRAY16, RTGRAPHIC_PIXEL_FORMAT_RGB332, RTGRAPHIC_PIXEL_FORMAT_RGB444, RTGRAPHIC_PIXEL_FORMAT_RGB565, RTGRAPHIC_PIXEL_FORMAT_RGB565P, RTGRAPHIC_PIXEL_FORMAT_RGB666, RTGRAPHIC_PIXEL_FORMAT_RGB888, RTGRAPHIC_PIXEL_FORMAT_ARGB888 }; /** * build a pixel position according to (x, y) coordinates. */ #define RTGRAPHIC_PIXEL_POSITION(x, y) ((x << 16) | y) /** * graphic device information structure */ 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_uint16_t width; /**< width of graphic device */ rt_uint16_t height; /**< height of graphic device */ rt_uint8_t *framebuffer; /**< frame buffer */ }; /** * rectangle information structure */ struct rt_device_rect_info { rt_uint16_t x, y; /**< x, y coordinate */ rt_uint16_t width, height; /**< width and height */ }; /** * graphic operations */ 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 (*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); }; #define rt_graphix_ops(device) ((struct rt_device_graphic_ops *)(device->user_data)) /*@}*/ #endif #ifdef RT_USING_MODULE /** * @addtogroup Module */ /*@{*/ /* * module system */ #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 */ 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 */ rt_uint32_t thread_priority; #ifdef RT_USING_SLAB /* 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 */ #endif rt_uint32_t nsym; /**< number of symbol in the module */ struct rt_module_symtab *symtab; /**< module symbol table */ 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; /*@}*/ #endif #ifdef __cplusplus } #endif #endif