From d7087fdd3b998192afb03b34fd8034071d06bde7 Mon Sep 17 00:00:00 2001 From: bernard Date: Sun, 15 Oct 2017 22:56:46 +0800 Subject: [DeviceDrivers] change cmd type. 1. Change 'rt_uint8_t' type of cmd to 'int'; 2. Add waitqueue; 3. Split device ipc header files; --- components/drivers/include/drivers/alarm.h | 2 +- components/drivers/include/drivers/audio.h | 2 +- components/drivers/include/ipc/completion.h | 23 +++ components/drivers/include/ipc/dataqueue.h | 53 +++++ components/drivers/include/ipc/pipe.h | 36 ++++ components/drivers/include/ipc/poll.h | 53 +++++ components/drivers/include/ipc/ringbuffer.h | 88 +++++++++ components/drivers/include/ipc/waitqueue.h | 39 ++++ components/drivers/include/ipc/workqueue.h | 41 ++++ components/drivers/include/rtdevice.h | 287 +--------------------------- 10 files changed, 343 insertions(+), 281 deletions(-) create mode 100644 components/drivers/include/ipc/completion.h create mode 100644 components/drivers/include/ipc/dataqueue.h create mode 100644 components/drivers/include/ipc/pipe.h create mode 100644 components/drivers/include/ipc/poll.h create mode 100644 components/drivers/include/ipc/ringbuffer.h create mode 100644 components/drivers/include/ipc/waitqueue.h create mode 100644 components/drivers/include/ipc/workqueue.h (limited to 'components/drivers/include') diff --git a/components/drivers/include/drivers/alarm.h b/components/drivers/include/drivers/alarm.h index 010e954810..99dd8ef9b8 100644 --- a/components/drivers/include/drivers/alarm.h +++ b/components/drivers/include/drivers/alarm.h @@ -76,7 +76,7 @@ struct rt_alarm_container rt_alarm_t rt_alarm_create(rt_alarm_callback_t callback, struct rt_alarm_setup *setup); -rt_err_t rt_alarm_control(rt_alarm_t alarm, rt_uint8_t cmd, void *arg); +rt_err_t rt_alarm_control(rt_alarm_t alarm, int cmd, void *arg); void rt_alarm_update(rt_device_t dev, rt_uint32_t event); rt_err_t rt_alarm_delete(rt_alarm_t alarm); rt_err_t rt_alarm_start(rt_alarm_t alarm); diff --git a/components/drivers/include/drivers/audio.h b/components/drivers/include/drivers/audio.h index 70e837421b..5f974994e7 100644 --- a/components/drivers/include/drivers/audio.h +++ b/components/drivers/include/drivers/audio.h @@ -159,7 +159,7 @@ struct rt_audio_ops rt_err_t (*suspend) (struct rt_audio_device *audio,int stream); rt_err_t (*resume) (struct rt_audio_device *audio,int stream); - rt_err_t (*control) (struct rt_audio_device *audio, rt_uint8_t cmd, void *arg); + rt_err_t (*control) (struct rt_audio_device *audio, int cmd, void *arg); rt_size_t (*transmit) (struct rt_audio_device *audio, const void *writeBuf,void *readBuf, rt_size_t size); //get page size of codec or private buffer's info diff --git a/components/drivers/include/ipc/completion.h b/components/drivers/include/ipc/completion.h new file mode 100644 index 0000000000..e3e883ba8b --- /dev/null +++ b/components/drivers/include/ipc/completion.h @@ -0,0 +1,23 @@ +#ifndef COMPLETION_H_ +#define COMPLETION_H_ + +#include + +/** + * Completion + */ + +struct rt_completion +{ + rt_uint32_t flag; + + /* suspended list */ + rt_list_t suspended_list; +}; + +void rt_completion_init(struct rt_completion *completion); +rt_err_t rt_completion_wait(struct rt_completion *completion, + rt_int32_t timeout); +void rt_completion_done(struct rt_completion *completion); + +#endif diff --git a/components/drivers/include/ipc/dataqueue.h b/components/drivers/include/ipc/dataqueue.h new file mode 100644 index 0000000000..44ffed655e --- /dev/null +++ b/components/drivers/include/ipc/dataqueue.h @@ -0,0 +1,53 @@ +#ifndef DATAQUEUE_H__ +#define DATAQUEUE_H__ + +#include + +#define RT_DATAQUEUE_EVENT_UNKNOWN 0x00 +#define RT_DATAQUEUE_EVENT_POP 0x01 +#define RT_DATAQUEUE_EVENT_PUSH 0x02 +#define RT_DATAQUEUE_EVENT_LWM 0x03 + +struct rt_data_item; +#define RT_DATAQUEUE_SIZE(dq) ((dq)->put_index - (dq)->get_index) +#define RT_DATAQUEUE_EMPTY(dq) ((dq)->size - RT_DATAQUEUE_SIZE(dq)) +/* data queue implementation */ +struct rt_data_queue +{ + rt_uint16_t size; + rt_uint16_t lwm; + rt_bool_t waiting_lwm; + + rt_uint16_t get_index; + rt_uint16_t put_index; + + struct rt_data_item *queue; + + rt_list_t suspended_push_list; + rt_list_t suspended_pop_list; + + /* event notify */ + void (*evt_notify)(struct rt_data_queue *queue, rt_uint32_t event); +}; + +/** + * DataQueue for DeviceDriver + */ +rt_err_t rt_data_queue_init(struct rt_data_queue *queue, + rt_uint16_t size, + rt_uint16_t lwm, + void (*evt_notify)(struct rt_data_queue *queue, rt_uint32_t event)); +rt_err_t rt_data_queue_push(struct rt_data_queue *queue, + const void *data_ptr, + rt_size_t data_size, + rt_int32_t timeout); +rt_err_t rt_data_queue_pop(struct rt_data_queue *queue, + const void **data_ptr, + rt_size_t *size, + rt_int32_t timeout); +rt_err_t rt_data_queue_peak(struct rt_data_queue *queue, + const void **data_ptr, + rt_size_t *size); +void rt_data_queue_reset(struct rt_data_queue *queue); + +#endif diff --git a/components/drivers/include/ipc/pipe.h b/components/drivers/include/ipc/pipe.h new file mode 100644 index 0000000000..e6888bfc2e --- /dev/null +++ b/components/drivers/include/ipc/pipe.h @@ -0,0 +1,36 @@ +#ifndef PIPE_H__ +#define PIPE_H__ + +/** + * Pipe Device + */ +#include +#include + +#ifndef RT_PIPE_BUFSZ +#define PIPE_BUFSZ 512 +#else +#define PIPE_BUFSZ RT_PIPE_BUFSZ +#endif + +struct rt_pipe_device +{ + struct rt_device parent; + + /* ring buffer in pipe device */ + struct rt_ringbuffer *fifo; + + rt_uint8_t readers; + rt_uint8_t writers; + + rt_wqueue_t reader_queue; + rt_wqueue_t writer_queue; + + struct rt_mutex lock; +}; +typedef struct rt_pipe_device rt_pipe_t; + +rt_pipe_t *rt_pipe_create(const char *name); + +#endif + diff --git a/components/drivers/include/ipc/poll.h b/components/drivers/include/ipc/poll.h new file mode 100644 index 0000000000..0279fe3b5d --- /dev/null +++ b/components/drivers/include/ipc/poll.h @@ -0,0 +1,53 @@ +/* + * File : poll.h + * This file is part of Device File System in RT-Thread RTOS + * COPYRIGHT (C) 2006-2017, RT-Thread Development Team + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Change Logs: + * Date Author Notes + * 2016-09-19 Heyuanjie The first version. + * 2016-12-26 Bernard Update poll interface + */ +#ifndef IPC_POLL_H__ +#define IPC_POLL_H__ + +#ifdef __cplusplus +extern "C" { +#endif + +struct rt_pollreq; +typedef void (*poll_queue_proc)(rt_wqueue_t *, struct rt_pollreq *); + +typedef struct rt_pollreq +{ + poll_queue_proc _proc; + short _key; +} rt_pollreq_t; + +rt_inline void rt_poll_add(rt_wqueue_t *wq, rt_pollreq_t *req) +{ + if (req && req->_proc && wq) + { + req->_proc(wq, req); + } +} + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/components/drivers/include/ipc/ringbuffer.h b/components/drivers/include/ipc/ringbuffer.h new file mode 100644 index 0000000000..4cfab6d69c --- /dev/null +++ b/components/drivers/include/ipc/ringbuffer.h @@ -0,0 +1,88 @@ +#ifndef RINGBUFFER_H__ +#define RINGBUFFER_H__ + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +/* ring buffer */ +struct rt_ringbuffer +{ + rt_uint8_t *buffer_ptr; + /* use the msb of the {read,write}_index as mirror bit. You can see this as + * if the buffer adds a virtual mirror and the pointers point either to the + * normal or to the mirrored buffer. If the write_index has the same value + * with the read_index, but in a different mirror, the buffer is full. + * While if the write_index and the read_index are the same and within the + * same mirror, the buffer is empty. The ASCII art of the ringbuffer is: + * + * mirror = 0 mirror = 1 + * +---+---+---+---+---+---+---+|+~~~+~~~+~~~+~~~+~~~+~~~+~~~+ + * | 0 | 1 | 2 | 3 | 4 | 5 | 6 ||| 0 | 1 | 2 | 3 | 4 | 5 | 6 | Full + * +---+---+---+---+---+---+---+|+~~~+~~~+~~~+~~~+~~~+~~~+~~~+ + * read_idx-^ write_idx-^ + * + * +---+---+---+---+---+---+---+|+~~~+~~~+~~~+~~~+~~~+~~~+~~~+ + * | 0 | 1 | 2 | 3 | 4 | 5 | 6 ||| 0 | 1 | 2 | 3 | 4 | 5 | 6 | Empty + * +---+---+---+---+---+---+---+|+~~~+~~~+~~~+~~~+~~~+~~~+~~~+ + * read_idx-^ ^-write_idx + * + * The tradeoff is we could only use 32KiB of buffer for 16 bit of index. + * But it should be enough for most of the cases. + * + * Ref: http://en.wikipedia.org/wiki/Circular_buffer#Mirroring */ + rt_uint16_t read_mirror : 1; + rt_uint16_t read_index : 15; + rt_uint16_t write_mirror : 1; + rt_uint16_t write_index : 15; + /* as we use msb of index as mirror bit, the size should be signed and + * could only be positive. */ + rt_int16_t buffer_size; +}; + +enum rt_ringbuffer_state +{ + RT_RINGBUFFER_EMPTY, + RT_RINGBUFFER_FULL, + /* half full is neither full nor empty */ + RT_RINGBUFFER_HALFFULL, +}; + +/** + * RingBuffer for DeviceDriver + * + * Please note that the ring buffer implementation of RT-Thread + * has no thread wait or resume feature. + */ +void rt_ringbuffer_init(struct rt_ringbuffer *rb, rt_uint8_t *pool, rt_int16_t size); +void rt_ringbuffer_reset(struct rt_ringbuffer *rb); +rt_size_t rt_ringbuffer_put(struct rt_ringbuffer *rb, const rt_uint8_t *ptr, rt_uint16_t length); +rt_size_t rt_ringbuffer_put_force(struct rt_ringbuffer *rb, const rt_uint8_t *ptr, rt_uint16_t length); +rt_size_t rt_ringbuffer_putchar(struct rt_ringbuffer *rb, const rt_uint8_t ch); +rt_size_t rt_ringbuffer_putchar_force(struct rt_ringbuffer *rb, const rt_uint8_t ch); +rt_size_t rt_ringbuffer_get(struct rt_ringbuffer *rb, rt_uint8_t *ptr, rt_uint16_t length); +rt_size_t rt_ringbuffer_getchar(struct rt_ringbuffer *rb, rt_uint8_t *ch); +rt_size_t rt_ringbuffer_data_len(struct rt_ringbuffer *rb); + +#ifdef RT_USING_HEAP +struct rt_ringbuffer* rt_ringbuffer_create(rt_uint16_t length); +void rt_ringbuffer_destroy(struct rt_ringbuffer *rb); +#endif + +rt_inline rt_uint16_t rt_ringbuffer_get_size(struct rt_ringbuffer *rb) +{ + RT_ASSERT(rb != RT_NULL); + return rb->buffer_size; +} + +/** return the size of empty space in rb */ +#define rt_ringbuffer_space_len(rb) ((rb)->buffer_size - rt_ringbuffer_data_len(rb)) + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/components/drivers/include/ipc/waitqueue.h b/components/drivers/include/ipc/waitqueue.h new file mode 100644 index 0000000000..1746d0f1cd --- /dev/null +++ b/components/drivers/include/ipc/waitqueue.h @@ -0,0 +1,39 @@ +#ifndef WAITQUEUE_H__ +#define WAITQUEUE_H__ + +#include + +struct rt_wqueue_node; + +typedef rt_list_t rt_wqueue_t; +typedef int (*rt_wqueue_func_t)(struct rt_wqueue_node *wait, void *key); + +struct rt_wqueue_node +{ + rt_thread_t polling_thread; + rt_list_t list; + + rt_wqueue_func_t wakeup; + rt_uint32_t key; +}; +typedef struct rt_wqueue_node rt_wqueue_node_t; + +int __wqueue_default_wake(struct rt_wqueue_node *wait, void *key); + +void rt_wqueue_add(rt_wqueue_t *queue, struct rt_wqueue_node *node); +void rt_wqueue_remove(struct rt_wqueue_node *node); +int rt_wqueue_wait(rt_wqueue_t *queue, int condition, int timeout); +void rt_wqueue_wakeup(rt_wqueue_t *queue, void *key); + +#define DEFINE_WAIT_FUNC(name, function) \ + struct rt_wqueue_node name = { \ + rt_current_thread, \ + RT_LIST_OBJECT_INIT(((name).list)), \ + \ + function, \ + 0 \ + } + +#define DEFINE_WAIT(name) DEFINE_WAIT_FUNC(name, __wqueue_default_wake) + +#endif diff --git a/components/drivers/include/ipc/workqueue.h b/components/drivers/include/ipc/workqueue.h new file mode 100644 index 0000000000..36eb825dc9 --- /dev/null +++ b/components/drivers/include/ipc/workqueue.h @@ -0,0 +1,41 @@ +#ifndef WORKQUEUE_H__ +#define WORKQUEUE_H__ + +#include + +/* workqueue implementation */ +struct rt_workqueue +{ + rt_list_t work_list; + struct rt_work *work_current; /* current work */ + rt_thread_t work_thread; +}; + +struct rt_work +{ + rt_list_t list; + + void (*work_func)(struct rt_work* work, void* work_data); + void *work_data; +}; + +#ifdef RT_USING_HEAP +/** + * WorkQueue for DeviceDriver + */ +struct rt_workqueue *rt_workqueue_create(const char* name, rt_uint16_t stack_size, rt_uint8_t priority); +rt_err_t rt_workqueue_destroy(struct rt_workqueue* queue); +rt_err_t rt_workqueue_dowork(struct rt_workqueue* queue, struct rt_work* work); +rt_err_t rt_workqueue_cancel_work(struct rt_workqueue* queue, struct rt_work* work); + +rt_inline void rt_work_init(struct rt_work* work, void (*work_func)(struct rt_work* work, void* work_data), + void* work_data) +{ + rt_list_init(&(work->list)); + work->work_func = work_func; + work->work_data = work_data; +} +#endif + +#endif + diff --git a/components/drivers/include/rtdevice.h b/components/drivers/include/rtdevice.h index 74406e82f9..0f021da66e 100644 --- a/components/drivers/include/rtdevice.h +++ b/components/drivers/include/rtdevice.h @@ -28,290 +28,20 @@ #include +#include "ipc/ringbuffer.h" +#include "ipc/completion.h" +#include "ipc/dataqueue.h" +#include "ipc/workqueue.h" +#include "ipc/waitqueue.h" +#include "ipc/pipe.h" +#include "ipc/poll.h" + #ifdef __cplusplus extern "C" { #endif #define RT_DEVICE(device) ((rt_device_t)device) -/* completion flag */ -struct rt_completion -{ - rt_uint32_t flag; - - /* suspended list */ - rt_list_t suspended_list; -}; - -/* ring buffer */ -struct rt_ringbuffer -{ - rt_uint8_t *buffer_ptr; - /* use the msb of the {read,write}_index as mirror bit. You can see this as - * if the buffer adds a virtual mirror and the pointers point either to the - * normal or to the mirrored buffer. If the write_index has the same value - * with the read_index, but in a different mirror, the buffer is full. - * While if the write_index and the read_index are the same and within the - * same mirror, the buffer is empty. The ASCII art of the ringbuffer is: - * - * mirror = 0 mirror = 1 - * +---+---+---+---+---+---+---+|+~~~+~~~+~~~+~~~+~~~+~~~+~~~+ - * | 0 | 1 | 2 | 3 | 4 | 5 | 6 ||| 0 | 1 | 2 | 3 | 4 | 5 | 6 | Full - * +---+---+---+---+---+---+---+|+~~~+~~~+~~~+~~~+~~~+~~~+~~~+ - * read_idx-^ write_idx-^ - * - * +---+---+---+---+---+---+---+|+~~~+~~~+~~~+~~~+~~~+~~~+~~~+ - * | 0 | 1 | 2 | 3 | 4 | 5 | 6 ||| 0 | 1 | 2 | 3 | 4 | 5 | 6 | Empty - * +---+---+---+---+---+---+---+|+~~~+~~~+~~~+~~~+~~~+~~~+~~~+ - * read_idx-^ ^-write_idx - * - * The tradeoff is we could only use 32KiB of buffer for 16 bit of index. - * But it should be enough for most of the cases. - * - * Ref: http://en.wikipedia.org/wiki/Circular_buffer#Mirroring */ - rt_uint16_t read_mirror : 1; - rt_uint16_t read_index : 15; - rt_uint16_t write_mirror : 1; - rt_uint16_t write_index : 15; - /* as we use msb of index as mirror bit, the size should be signed and - * could only be positive. */ - rt_int16_t buffer_size; -}; - -/* portal device */ -struct rt_portal_device -{ - struct rt_device parent; - struct rt_device *write_dev; - struct rt_device *read_dev; -}; - -/* pipe device */ -#define PIPE_DEVICE(device) ((struct rt_pipe_device*)(device)) -enum rt_pipe_flag -{ - /* both read and write won't block */ - RT_PIPE_FLAG_NONBLOCK_RDWR = 0x00, - /* read would block */ - RT_PIPE_FLAG_BLOCK_RD = 0x01, - /* write would block */ - RT_PIPE_FLAG_BLOCK_WR = 0x02, - /* write to this pipe will discard some data when the pipe is full. - * When this flag is set, RT_PIPE_FLAG_BLOCK_WR will be ignored since write - * operation will always be success. */ - RT_PIPE_FLAG_FORCE_WR = 0x04, -}; - -struct rt_pipe_device -{ - struct rt_device parent; - - /* ring buffer in pipe device */ - struct rt_ringbuffer ringbuffer; - - enum rt_pipe_flag flag; - - /* suspended list */ - rt_list_t suspended_read_list; - rt_list_t suspended_write_list; - - struct rt_portal_device *write_portal; - struct rt_portal_device *read_portal; -}; - -#define PIPE_CTRL_GET_SPACE 0x14 /**< get the remaining size of a pipe device */ - -#define RT_DATAQUEUE_EVENT_UNKNOWN 0x00 -#define RT_DATAQUEUE_EVENT_POP 0x01 -#define RT_DATAQUEUE_EVENT_PUSH 0x02 -#define RT_DATAQUEUE_EVENT_LWM 0x03 - -struct rt_data_item; -#define RT_DATAQUEUE_SIZE(dq) ((dq)->put_index - (dq)->get_index) -#define RT_DATAQUEUE_EMPTY(dq) ((dq)->size - RT_DATAQUEUE_SIZE(dq)) -/* data queue implementation */ -struct rt_data_queue -{ - rt_uint16_t size; - rt_uint16_t lwm; - - rt_uint16_t get_index; - rt_uint16_t put_index; - - struct rt_data_item *queue; - - rt_list_t suspended_push_list; - rt_list_t suspended_pop_list; - - /* event notify */ - void (*evt_notify)(struct rt_data_queue *queue, rt_uint32_t event); -}; - -/* workqueue implementation */ -struct rt_workqueue -{ - rt_list_t work_list; - struct rt_work *work_current; /* current work */ - rt_thread_t work_thread; -}; - -struct rt_work -{ - rt_list_t list; - - void (*work_func)(struct rt_work* work, void* work_data); - void *work_data; -}; - -/** - * Completion - */ -void rt_completion_init(struct rt_completion *completion); -rt_err_t rt_completion_wait(struct rt_completion *completion, - rt_int32_t timeout); -void rt_completion_done(struct rt_completion *completion); - -/** - * RingBuffer for DeviceDriver - * - * Please note that the ring buffer implementation of RT-Thread - * has no thread wait or resume feature. - */ -void rt_ringbuffer_init(struct rt_ringbuffer *rb, - rt_uint8_t *pool, - rt_int16_t size); -rt_size_t rt_ringbuffer_put(struct rt_ringbuffer *rb, - const rt_uint8_t *ptr, - rt_uint16_t length); -rt_size_t rt_ringbuffer_put_force(struct rt_ringbuffer *rb, - const rt_uint8_t *ptr, - rt_uint16_t length); -rt_size_t rt_ringbuffer_putchar(struct rt_ringbuffer *rb, - const rt_uint8_t ch); -rt_size_t rt_ringbuffer_putchar_force(struct rt_ringbuffer *rb, - const rt_uint8_t ch); -rt_size_t rt_ringbuffer_get(struct rt_ringbuffer *rb, - rt_uint8_t *ptr, - rt_uint16_t length); -rt_size_t rt_ringbuffer_getchar(struct rt_ringbuffer *rb, rt_uint8_t *ch); - -enum rt_ringbuffer_state -{ - RT_RINGBUFFER_EMPTY, - RT_RINGBUFFER_FULL, - /* half full is neither full nor empty */ - RT_RINGBUFFER_HALFFULL, -}; - -rt_inline rt_uint16_t rt_ringbuffer_get_size(struct rt_ringbuffer *rb) -{ - RT_ASSERT(rb != RT_NULL); - return rb->buffer_size; -} - -rt_inline enum rt_ringbuffer_state -rt_ringbuffer_status(struct rt_ringbuffer *rb) -{ - if (rb->read_index == rb->write_index) - { - if (rb->read_mirror == rb->write_mirror) - return RT_RINGBUFFER_EMPTY; - else - return RT_RINGBUFFER_FULL; - } - return RT_RINGBUFFER_HALFFULL; -} - -/** return the size of data in rb */ -rt_inline rt_uint16_t rt_ringbuffer_data_len(struct rt_ringbuffer *rb) -{ - switch (rt_ringbuffer_status(rb)) - { - case RT_RINGBUFFER_EMPTY: - return 0; - case RT_RINGBUFFER_FULL: - return rb->buffer_size; - case RT_RINGBUFFER_HALFFULL: - default: - if (rb->write_index > rb->read_index) - return rb->write_index - rb->read_index; - else - return rb->buffer_size - (rb->read_index - rb->write_index); - }; -} - -/** return the size of empty space in rb */ -#define rt_ringbuffer_space_len(rb) ((rb)->buffer_size - rt_ringbuffer_data_len(rb)) - -/** - * Pipe Device - */ -rt_err_t rt_pipe_init(struct rt_pipe_device *pipe, - const char *name, - enum rt_pipe_flag flag, - rt_uint8_t *buf, - rt_size_t size); -rt_err_t rt_pipe_detach(struct rt_pipe_device *pipe); -#ifdef RT_USING_HEAP -rt_err_t rt_pipe_create(const char *name, enum rt_pipe_flag flag, rt_size_t size); -void rt_pipe_destroy(struct rt_pipe_device *pipe); -#endif - -/** - * Portal for DeviceDriver - */ - -rt_err_t rt_portal_init(struct rt_portal_device *portal, - const char *portal_name, - const char *write_dev, - const char *read_dev); -rt_err_t rt_portal_detach(struct rt_portal_device *portal); - -#ifdef RT_USING_HEAP -rt_err_t rt_portal_create(const char *name, - const char *write_dev, - const char *read_dev); -void rt_portal_destroy(struct rt_portal_device *portal); -#endif - -/** - * DataQueue for DeviceDriver - */ -rt_err_t rt_data_queue_init(struct rt_data_queue *queue, - rt_uint16_t size, - rt_uint16_t lwm, - void (*evt_notify)(struct rt_data_queue *queue, rt_uint32_t event)); -rt_err_t rt_data_queue_push(struct rt_data_queue *queue, - const void *data_ptr, - rt_size_t data_size, - rt_int32_t timeout); -rt_err_t rt_data_queue_pop(struct rt_data_queue *queue, - const void **data_ptr, - rt_size_t *size, - rt_int32_t timeout); -rt_err_t rt_data_queue_peak(struct rt_data_queue *queue, - const void **data_ptr, - rt_size_t *size); -void rt_data_queue_reset(struct rt_data_queue *queue); - -#ifdef RT_USING_HEAP -/** - * WorkQueue for DeviceDriver - */ -struct rt_workqueue *rt_workqueue_create(const char* name, rt_uint16_t stack_size, rt_uint8_t priority); -rt_err_t rt_workqueue_destroy(struct rt_workqueue* queue); -rt_err_t rt_workqueue_dowork(struct rt_workqueue* queue, struct rt_work* work); -rt_err_t rt_workqueue_cancel_work(struct rt_workqueue* queue, struct rt_work* work); - -rt_inline void rt_work_init(struct rt_work* work, void (*work_func)(struct rt_work* work, void* work_data), - void* work_data) -{ - rt_list_init(&(work->list)); - work->work_func = work_func; - work->work_data = work_data; -} -#endif - #ifdef RT_USING_RTC #include "drivers/rtc.h" #ifdef RT_USING_ALARM @@ -383,4 +113,3 @@ rt_inline void rt_work_init(struct rt_work* work, void (*work_func)(struct rt_wo #endif #endif /* __RT_DEVICE_H__ */ - -- cgit v1.3.1