rtdef.h

/*
 * 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 <rtconfig.h>

#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 <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)
    #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
    #define RTT_API

#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))
            #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 <stdarg.h>
    #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 (_MSC_VER)
    #include <stdarg.h>
    #define SECTION(x)
    #define UNUSED
    #define ALIGN(n)                    __declspec(align(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;                     /* input offset of the message buffer */
    rt_uint16_t          out_offset;                    /* 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;
    struct rt_memheap_item *prev;
    struct rt_memheap_item *next_free;
    struct rt_memheap_item *prev_free;

    struct rt_memheap      *pool_ptr;
};

/**
 * Base structure of memory heap object
 */
struct rt_memheap
{
    struct rt_object        parent;

    void                   *start_addr;                 /* pool start address and size */

    rt_uint32_t             pool_size;
    rt_uint32_t             available_size;

    struct rt_memheap_item *block_list;                 /* used block list */

    struct rt_memheap_item *free_list;                  /* free block list */
    struct rt_memheap_item  free_header;                /* free block list 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_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_PM,                                 /* PM pseudo 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_BLK_SYNC         0x11            /* flush data to block device */
#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;                     /* device flag */
    rt_uint16_t               open_flag;                /* 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
#define RTGRAPHIC_CTRL_FILL_RECT        5
#define RTGRAPHIC_CTRL_DRAW_RECT        6

/* 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;
    rt_uint16_t y;                                      /* x, y coordinate */
    rt_uint16_t width;
    rt_uint16_t 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