diff options
33 files changed, 1200 insertions, 755 deletions
diff --git a/components/drivers/audio/audio.c b/components/drivers/audio/audio.c index 0b2f9a0cdd..dbd661217a 100644 --- a/components/drivers/audio/audio.c +++ b/components/drivers/audio/audio.c @@ -293,7 +293,7 @@ static rt_size_t _audio_dev_write(struct rt_device *dev, rt_off_t pos, const voi return size; } -static rt_err_t _audio_dev_control(struct rt_device *dev, rt_uint8_t cmd, void *args) +static rt_err_t _audio_dev_control(struct rt_device *dev, int cmd, void *args) { rt_err_t result = RT_EOK; struct rt_audio_device *audio; diff --git a/components/drivers/hwtimer/hwtimer.c b/components/drivers/hwtimer/hwtimer.c index 22b8d6262c..bbe50aa2f7 100644 --- a/components/drivers/hwtimer/hwtimer.c +++ b/components/drivers/hwtimer/hwtimer.c @@ -206,7 +206,7 @@ static rt_size_t rt_hwtimer_write(struct rt_device *dev, rt_off_t pos, const voi return size; } -static rt_err_t rt_hwtimer_control(struct rt_device *dev, rt_uint8_t cmd, void *args) +static rt_err_t rt_hwtimer_control(struct rt_device *dev, int cmd, void *args) { rt_err_t result = RT_EOK; rt_hwtimer_t *timer; diff --git a/components/drivers/i2c/fm24clxx.c b/components/drivers/i2c/fm24clxx.c index 4856a945da..c37a62973a 100644 --- a/components/drivers/i2c/fm24clxx.c +++ b/components/drivers/i2c/fm24clxx.c @@ -47,7 +47,7 @@ static rt_err_t fm24clxx_close(rt_device_t dev) return RT_EOK; } -static rt_err_t fm24clxx_control(rt_device_t dev, rt_uint8_t cmd, void *args) +static rt_err_t fm24clxx_control(rt_device_t dev, int cmd, void *args) { return RT_EOK; } diff --git a/components/drivers/i2c/i2c_dev.c b/components/drivers/i2c/i2c_dev.c index 4b811c62ea..377e394cb3 100644 --- a/components/drivers/i2c/i2c_dev.c +++ b/components/drivers/i2c/i2c_dev.c @@ -66,7 +66,7 @@ static rt_size_t i2c_bus_device_write(rt_device_t dev, } static rt_err_t i2c_bus_device_control(rt_device_t dev, - rt_uint8_t cmd, + int cmd, void *args) { rt_err_t ret; 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 <rtthread.h> + +/** + * 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 <rtthread.h> + +#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 <rtthread.h> +#include <rtdevice.h> + +#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 <rtthread.h> + +/* 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 <rtthread.h> + +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 <rtthread.h> + +/* 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 <rtthread.h> +#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__ */ - diff --git a/components/drivers/misc/pin.c b/components/drivers/misc/pin.c index fb139575b4..9cbe47089e 100644 --- a/components/drivers/misc/pin.c +++ b/components/drivers/misc/pin.c @@ -60,7 +60,7 @@ static rt_size_t _pin_write(rt_device_t dev, rt_off_t pos, const void *buffer, r return size; } -static rt_err_t _pin_control(rt_device_t dev, rt_uint8_t cmd, void *args) +static rt_err_t _pin_control(rt_device_t dev, int cmd, void *args) { struct rt_device_pin_mode *mode; struct rt_device_pin *pin = (struct rt_device_pin *)dev; diff --git a/components/drivers/mtd/mtd_nand.c b/components/drivers/mtd/mtd_nand.c index 8511dca120..8cd0a03d5d 100644 --- a/components/drivers/mtd/mtd_nand.c +++ b/components/drivers/mtd/mtd_nand.c @@ -64,7 +64,7 @@ static rt_size_t _mtd_write(rt_device_t dev, return size; } -static rt_err_t _mtd_control(rt_device_t dev, rt_uint8_t cmd, void *args) +static rt_err_t _mtd_control(rt_device_t dev, int cmd, void *args) { return RT_EOK; } diff --git a/components/drivers/mtd/mtd_nor.c b/components/drivers/mtd/mtd_nor.c index 3b4a0adf18..72bbc5a873 100644 --- a/components/drivers/mtd/mtd_nor.c +++ b/components/drivers/mtd/mtd_nor.c @@ -60,7 +60,7 @@ static rt_size_t _mtd_write(rt_device_t dev, return size; } -static rt_err_t _mtd_control(rt_device_t dev, rt_uint8_t cmd, void *args) +static rt_err_t _mtd_control(rt_device_t dev, int cmd, void *args) { return RT_EOK; } diff --git a/components/drivers/rtc/alarm.c b/components/drivers/rtc/alarm.c index 0cb0362504..6660128603 100644 --- a/components/drivers/rtc/alarm.c +++ b/components/drivers/rtc/alarm.c @@ -397,7 +397,7 @@ void rt_alarm_update(rt_device_t dev, rt_uint32_t event) * \param cmd control command * \param arg argument */ -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) { rt_err_t ret = RT_ERROR; diff --git a/components/drivers/sdio/block_dev.c b/components/drivers/sdio/block_dev.c index e1c7f1dcdd..3e142ee6e4 100644 --- a/components/drivers/sdio/block_dev.c +++ b/components/drivers/sdio/block_dev.c @@ -222,7 +222,7 @@ static rt_err_t rt_mmcsd_close(rt_device_t dev) return RT_EOK; } -static rt_err_t rt_mmcsd_control(rt_device_t dev, rt_uint8_t cmd, void *args) +static rt_err_t rt_mmcsd_control(rt_device_t dev, int cmd, void *args) { struct mmcsd_blk_device *blk_dev = (struct mmcsd_blk_device *)dev->user_data; switch (cmd) @@ -247,7 +247,7 @@ static rt_size_t rt_mmcsd_read(rt_device_t dev, if (dev == RT_NULL) { - rt_set_errno(-DFS_STATUS_EINVAL); + rt_set_errno(-EINVAL); return 0; } @@ -259,7 +259,7 @@ static rt_size_t rt_mmcsd_read(rt_device_t dev, /* the length of reading must align to SECTOR SIZE */ if (err) { - rt_set_errno(-DFS_STATUS_EIO); + rt_set_errno(-EIO); return 0; } return size; @@ -276,7 +276,7 @@ static rt_size_t rt_mmcsd_write(rt_device_t dev, if (dev == RT_NULL) { - rt_set_errno(-DFS_STATUS_EINVAL); + rt_set_errno(-EINVAL); return 0; } @@ -288,7 +288,7 @@ static rt_size_t rt_mmcsd_write(rt_device_t dev, /* the length of reading must align to SECTOR SIZE */ if (err) { - rt_set_errno(-DFS_STATUS_EIO); + rt_set_errno(-EIO); return 0; } diff --git a/components/drivers/serial/serial.c b/components/drivers/serial/serial.c index 6aa8da6493..48b60caeaf 100644 --- a/components/drivers/serial/serial.c +++ b/components/drivers/serial/serial.c @@ -38,6 +38,178 @@ #include <rtthread.h> #include <rtdevice.h> +// #define DEBUG_ENABLE +#define DEBUG_LEVEL DBG_LOG +#define DBG_SECTION_NAME "[UART]" +#define DEBUG_COLOR +#include <rtdbg.h> + +#ifdef RT_USING_POSIX_TERMIOS +#include <posix_termios.h> +#endif + +#ifdef RT_USING_DFS_DEVFS +#include <dfs_posix.h> + +/* it's possible the 'getc/putc' is defined by stdio.h in gcc/newlib. */ +#ifdef getc +#undef getc +#endif + +#ifdef putc +#undef putc +#endif + +static rt_err_t serial_fops_rx_ind(rt_device_t dev, rt_size_t size) +{ + rt_wqueue_wakeup(&(dev->wait_queue), (void*)POLLIN); + + return RT_EOK; +} + +/* fops for serial */ +static int serial_fops_open(struct dfs_fd *fd) +{ + rt_err_t ret = 0; + rt_uint16_t flags = 0; + rt_device_t device; + + device = (rt_device_t)fd->data; + RT_ASSERT(device != RT_NULL); + + switch (fd->flags & O_ACCMODE) + { + case O_RDONLY: + dbg_log(DBG_LOG, "fops open: O_RDONLY!\n"); + flags = RT_DEVICE_FLAG_INT_RX | RT_DEVICE_FLAG_RDONLY; + break; + case O_WRONLY: + dbg_log(DBG_LOG, "fops open: O_WRONLY!\n"); + flags = RT_DEVICE_FLAG_WRONLY; + break; + case O_RDWR: + dbg_log(DBG_LOG, "fops open: O_RDWR!\n"); + flags = RT_DEVICE_FLAG_INT_RX | RT_DEVICE_FLAG_RDWR; + break; + default: + dbg_log(DBG_ERROR, "fops open: unknown mode - %d!\n", fd->flags & O_ACCMODE); + break; + } + + rt_device_set_rx_indicate(device, serial_fops_rx_ind); + ret = rt_device_open(device, flags); + if (ret == RT_EOK) return 0; + + return ret; +} + +static int serial_fops_close(struct dfs_fd *fd) +{ + rt_device_t device; + + device = (rt_device_t)fd->data; + + rt_device_set_rx_indicate(device, RT_NULL); + rt_device_close(device); + + return 0; +} + +static int serial_fops_ioctl(struct dfs_fd *fd, int cmd, void *args) +{ + rt_device_t device; + + device = (rt_device_t)fd->data; + switch (cmd) + { + case FIONREAD: + break; + case FIONWRITE: + break; + } + + return rt_device_control(device, cmd, args); +} + +static int serial_fops_read(struct dfs_fd *fd, void *buf, size_t count) +{ + int size = 0; + rt_device_t device; + + device = (rt_device_t)fd->data; + + do + { + size = rt_device_read(device, -1, buf, count); + if (size <= 0) + { + if (fd->flags & O_NONBLOCK) + { + size = -EAGAIN; + break; + } + + rt_wqueue_wait(&(device->wait_queue), 0, RT_WAITING_FOREVER); + } + }while (size <= 0); + + return size; +} + +static int serial_fops_write(struct dfs_fd *fd, const void *buf, size_t count) +{ + rt_device_t device; + + device = (rt_device_t)fd->data; + return rt_device_write(device, -1, buf, count); +} + +static int serial_fops_poll(struct dfs_fd *fd, struct rt_pollreq *req) +{ + int mask = 0; + int flags = 0; + rt_device_t device; + struct rt_serial_device *serial; + + device = (rt_device_t)fd->data; + RT_ASSERT(device != RT_NULL); + + serial = (struct rt_serial_device *)device; + + /* only support POLLIN */ + flags = fd->flags & O_ACCMODE; + if (flags == O_RDONLY || flags == O_RDWR) + { + rt_base_t level; + struct rt_serial_rx_fifo* rx_fifo; + + rt_poll_add(&(device->wait_queue), req); + + rx_fifo = (struct rt_serial_rx_fifo*) serial->serial_rx; + + level = rt_hw_interrupt_disable(); + if (rx_fifo->get_index != rx_fifo->put_index) + mask |= POLLIN; + rt_hw_interrupt_enable(level); + } + + return mask; +} + +const static struct dfs_file_ops _serial_fops = +{ + serial_fops_open, + serial_fops_close, + serial_fops_ioctl, + serial_fops_read, + serial_fops_write, + RT_NULL, /* flush */ + RT_NULL, /* lseek */ + RT_NULL, /* getdents */ + serial_fops_poll, +}; +#endif + /* * Serial poll routines */ @@ -371,11 +543,14 @@ static rt_err_t rt_serial_init(struct rt_device *dev) static rt_err_t rt_serial_open(struct rt_device *dev, rt_uint16_t oflag) { + rt_uint16_t stream_flag = 0; struct rt_serial_device *serial; RT_ASSERT(dev != RT_NULL); serial = (struct rt_serial_device *)dev; + dbg_log(DBG_LOG, "open serial device: 0x%08x with open flag: 0x%04x\n", + dev, oflag); /* check device flag with the open flag */ if ((oflag & RT_DEVICE_FLAG_DMA_RX) && !(dev->flag & RT_DEVICE_FLAG_DMA_RX)) return -RT_EIO; @@ -386,6 +561,10 @@ static rt_err_t rt_serial_open(struct rt_device *dev, rt_uint16_t oflag) if ((oflag & RT_DEVICE_FLAG_INT_TX) && !(dev->flag & RT_DEVICE_FLAG_INT_TX)) return -RT_EIO; + /* keep steam flag */ + if ((oflag & RT_DEVICE_FLAG_STREAM) || (dev->open_flag & RT_DEVICE_FLAG_STREAM)) + stream_flag = RT_DEVICE_FLAG_STREAM; + /* get open flags */ dev->open_flag = oflag & 0xff; @@ -477,6 +656,9 @@ static rt_err_t rt_serial_open(struct rt_device *dev, rt_uint16_t oflag) } } + /* set stream flag */ + dev->open_flag |= stream_flag; + return RT_EOK; } @@ -604,10 +786,61 @@ static rt_size_t rt_serial_write(struct rt_device *dev, } } +#ifdef RT_USING_POSIX_TERMIOS +struct speed_baudrate_item +{ + speed_t speed; + int baudrate; +}; + +const static struct speed_baudrate_item _tbl[] = +{ + {B2400, BAUD_RATE_2400}, + {B4800, BAUD_RATE_4800}, + {B9600, BAUD_RATE_9600}, + {B19200, BAUD_RATE_19200}, + {B38400, BAUD_RATE_38400}, + {B57600, BAUD_RATE_57600}, + {B115200, BAUD_RATE_115200}, + {B230400, BAUD_RATE_230400}, + {B460800, BAUD_RATE_460800}, + {B921600, BAUD_RATE_921600}, + {B2000000, BAUD_RATE_2000000}, + {B3000000, BAUD_RATE_3000000}, +}; + +static speed_t _get_speed(int baudrate) +{ + int index; + + for (index = 0; index < sizeof(_tbl)/sizeof(_tbl[0]); index ++) + { + if (_tbl[index].baudrate == baudrate) + return _tbl[index].speed; + } + + return B0; +} + +static int _get_baudrate(speed_t speed) +{ + int index; + + for (index = 0; index < sizeof(_tbl)/sizeof(_tbl[0]); index ++) + { + if (_tbl[index].speed == speed) + return _tbl[index].baudrate; + } + + return 0; +} +#endif + static rt_err_t rt_serial_control(struct rt_device *dev, - rt_uint8_t cmd, + int cmd, void *args) { + rt_err_t ret = RT_EOK; struct rt_serial_device *serial; RT_ASSERT(dev != RT_NULL); @@ -642,16 +875,92 @@ static rt_err_t rt_serial_control(struct rt_device *dev, serial->ops->configure(serial, (struct serial_configure *) args); } } - + + break; + +#ifdef RT_USING_POSIX_TERMIOS + case TCGETA: + { + struct termios *tio = (struct termios*)args; + if (tio == RT_NULL) return -RT_EINVAL; + + tio->c_iflag = 0; + tio->c_oflag = 0; + tio->c_lflag = 0; + + /* update oflag for console device */ + if (rt_console_get_device() == dev) + tio->c_oflag = OPOST | ONLCR; + + /* set cflag */ + tio->c_cflag = 0; + if (serial->config.data_bits == DATA_BITS_5) + tio->c_cflag = CS5; + else if (serial->config.data_bits == DATA_BITS_6) + tio->c_cflag = CS6; + else if (serial->config.data_bits == DATA_BITS_7) + tio->c_cflag = CS7; + else if (serial->config.data_bits == DATA_BITS_8) + tio->c_cflag = CS8; + + if (serial->config.stop_bits == STOP_BITS_2) + tio->c_cflag |= CSTOPB; + + if (serial->config.parity == PARITY_EVEN) + tio->c_cflag |= PARENB; + else if (serial->config.parity == PARITY_ODD) + tio->c_cflag |= (PARODD | PARENB); + + cfsetospeed(tio, _get_speed(serial->config.baud_rate)); + } + break; + + case TCSETAW: + case TCSETAF: + case TCSETA: + { + int baudrate; + struct serial_configure config; + + struct termios *tio = (struct termios*)args; + if (tio == RT_NULL) return -RT_EINVAL; + + config = serial->config; + + baudrate = _get_baudrate(cfgetospeed(tio)); + config.baud_rate = baudrate; + + if (tio->c_cflag & CS6) config.data_bits = DATA_BITS_6; + else if (tio->c_cflag & CS7) config.data_bits = DATA_BITS_7; + else if (tio->c_cflag & CS8) config.data_bits = DATA_BITS_8; + else config.data_bits = DATA_BITS_5; + + if (tio->c_cflag & CSTOPB) config.data_bits = STOP_BITS_2; + else config.data_bits = STOP_BITS_1; + + if (tio->c_cflag & PARENB) + { + if (tio->c_cflag & PARODD) config.parity = PARITY_ODD; + else config.parity = PARITY_EVEN; + } + else config.parity = PARITY_NONE; + + serial->ops->configure(serial, &config); + } + break; + case TCFLSH: break; + case TCXONC: + break; +#endif default : /* control device */ - serial->ops->control(serial, cmd, args); + ret = serial->ops->control(serial, cmd, args); break; } - return RT_EOK; + return ret; } /* @@ -662,6 +971,7 @@ rt_err_t rt_hw_serial_register(struct rt_serial_device *serial, rt_uint32_t flag, void *data) { + rt_err_t ret; struct rt_device *device; RT_ASSERT(serial != RT_NULL); @@ -680,7 +990,14 @@ rt_err_t rt_hw_serial_register(struct rt_serial_device *serial, device->user_data = data; /* register a character device */ - return rt_device_register(device, name, flag); + ret = rt_device_register(device, name, flag); + +#if defined(RT_USING_DFS) && defined(RT_USING_DFS_DEVFS) + /* set fops */ + device->fops = &_serial_fops; +#endif + + return ret; } /* ISR for serial interrupt */ @@ -812,3 +1129,4 @@ void rt_hw_serial_isr(struct rt_serial_device *serial, int event) } } } + diff --git a/components/drivers/spi/enc28j60.c b/components/drivers/spi/enc28j60.c index 7152abdfd5..058b93a645 100644 --- a/components/drivers/spi/enc28j60.c +++ b/components/drivers/spi/enc28j60.c @@ -343,7 +343,7 @@ static rt_err_t enc28j60_init(rt_device_t dev) } /* control the interface */ -static rt_err_t enc28j60_control(rt_device_t dev, rt_uint8_t cmd, void *args) +static rt_err_t enc28j60_control(rt_device_t dev, int cmd, void *args) { struct net_device * enc28j60 = (struct net_device *)dev; switch(cmd) diff --git a/components/drivers/spi/spi_dev.c b/components/drivers/spi/spi_dev.c index 375a5e0fa1..eca971a6e7 100644 --- a/components/drivers/spi/spi_dev.c +++ b/components/drivers/spi/spi_dev.c @@ -54,7 +54,7 @@ static rt_size_t _spi_bus_device_write(rt_device_t dev, } static rt_err_t _spi_bus_device_control(rt_device_t dev, - rt_uint8_t cmd, + int cmd, void *args) { /* TODO: add control command handle */ @@ -120,7 +120,7 @@ static rt_size_t _spidev_device_write(rt_device_t dev, } static rt_err_t _spidev_device_control(rt_device_t dev, - rt_uint8_t cmd, + int cmd, void *args) { switch (cmd) diff --git a/components/drivers/spi/spi_flash_at45dbxx.c b/components/drivers/spi/spi_flash_at45dbxx.c index f9a15b27dd..8798e35cf6 100644 --- a/components/drivers/spi/spi_flash_at45dbxx.c +++ b/components/drivers/spi/spi_flash_at45dbxx.c @@ -117,7 +117,7 @@ static rt_err_t AT45DB_flash_close(rt_device_t dev) return RT_EOK; } -static rt_err_t AT45DB_flash_control(rt_device_t dev, rt_uint8_t cmd, void *args) +static rt_err_t AT45DB_flash_control(rt_device_t dev, int cmd, void *args) { RT_ASSERT(dev != RT_NULL); diff --git a/components/drivers/spi/spi_flash_gd.c b/components/drivers/spi/spi_flash_gd.c index e07b3ba3b1..df41150a5d 100644 --- a/components/drivers/spi/spi_flash_gd.c +++ b/components/drivers/spi/spi_flash_gd.c @@ -195,7 +195,7 @@ static rt_err_t w25qxx_flash_close(rt_device_t dev) return RT_EOK; } -static rt_err_t w25qxx_flash_control(rt_device_t dev, rt_uint8_t cmd, void *args) +static rt_err_t w25qxx_flash_control(rt_device_t dev, int cmd, void *args) { RT_ASSERT(dev != RT_NULL); diff --git a/components/drivers/spi/spi_flash_sfud.c b/components/drivers/spi/spi_flash_sfud.c index d70c9f8451..aef6babe0e 100644 --- a/components/drivers/spi/spi_flash_sfud.c +++ b/components/drivers/spi/spi_flash_sfud.c @@ -49,7 +49,7 @@ static char log_buf[RT_CONSOLEBUF_SIZE]; void sfud_log_debug(const char *file, const long line, const char *format, ...); -static rt_err_t rt_sfud_control(rt_device_t dev, rt_uint8_t cmd, void *args) { +static rt_err_t rt_sfud_control(rt_device_t dev, int cmd, void *args) { RT_ASSERT(dev != RT_NULL); switch (cmd) { diff --git a/components/drivers/spi/spi_flash_sst25vfxx.c b/components/drivers/spi/spi_flash_sst25vfxx.c index 70f00f24d5..3843d20ff2 100644 --- a/components/drivers/spi/spi_flash_sst25vfxx.c +++ b/components/drivers/spi/spi_flash_sst25vfxx.c @@ -173,7 +173,7 @@ static rt_err_t sst25vfxx_flash_close(rt_device_t dev) return RT_EOK; } -static rt_err_t sst25vfxx_flash_control(rt_device_t dev, rt_uint8_t cmd, void *args) +static rt_err_t sst25vfxx_flash_control(rt_device_t dev, int cmd, void *args) { struct spi_flash_sst25vfxx * spi_flash; diff --git a/components/drivers/spi/spi_flash_w25qxx.c b/components/drivers/spi/spi_flash_w25qxx.c index 2db997464f..a413aec673 100644 --- a/components/drivers/spi/spi_flash_w25qxx.c +++ b/components/drivers/spi/spi_flash_w25qxx.c @@ -205,7 +205,7 @@ static rt_err_t w25qxx_flash_close(rt_device_t dev) return RT_EOK; } -static rt_err_t w25qxx_flash_control(rt_device_t dev, rt_uint8_t cmd, void *args) +static rt_err_t w25qxx_flash_control(rt_device_t dev, int cmd, void *args) { RT_ASSERT(dev != RT_NULL); diff --git a/components/drivers/spi/spi_wifi_rw009.c b/components/drivers/spi/spi_wifi_rw009.c index 5faf63642a..5fb36f33cf 100644 --- a/components/drivers/spi/spi_wifi_rw009.c +++ b/components/drivers/spi/spi_wifi_rw009.c @@ -530,7 +530,7 @@ static rt_size_t rw009_wifi_write(rt_device_t dev, rt_off_t pos, const void *buf return 0; } -static rt_err_t rw009_wifi_control(rt_device_t dev, rt_uint8_t cmd, void *args) +static rt_err_t rw009_wifi_control(rt_device_t dev, int cmd, void *args) { struct rw009_wifi *wifi_device = (struct rw009_wifi *)dev; rt_err_t result = RT_EOK; diff --git a/components/drivers/src/pipe.c b/components/drivers/src/pipe.c index f438a92898..b455870c8a 100644 --- a/components/drivers/src/pipe.c +++ b/components/drivers/src/pipe.c @@ -1,7 +1,7 @@ /* * File : pipe.c * This file is part of RT-Thread RTOS - * COPYRIGHT (C) 2012, RT-Thread Development Team + * COPYRIGHT (C) 2012-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 @@ -21,273 +21,407 @@ * Date Author Notes * 2012-09-30 Bernard first version. */ - #include <rthw.h> -#include <rtthread.h> #include <rtdevice.h> +#include <dfs_file.h> +#include <dfs_posix.h> -static void _rt_pipe_resume_writer(struct rt_pipe_device *pipe) +#if defined(RT_USING_DFS) && defined(RT_USING_DFS_DEVFS) +static int pipe_open(struct dfs_fd *fd) { - if (!rt_list_isempty(&pipe->suspended_write_list)) - { - rt_thread_t thread; + rt_device_t device; + rt_pipe_t *pipe; - RT_ASSERT(pipe->flag & RT_PIPE_FLAG_BLOCK_WR); + pipe = (rt_pipe_t *)fd->data; + if (!pipe) return -1; - /* get suspended thread */ - thread = rt_list_entry(pipe->suspended_write_list.next, - struct rt_thread, - tlist); + device = &(pipe->parent); + rt_mutex_take(&(pipe->lock), RT_WAITING_FOREVER); - /* resume the write thread */ - rt_thread_resume(thread); + if (device->ref_count == 0) + { + pipe->fifo = rt_ringbuffer_create(PIPE_BUFSZ); + } - rt_schedule(); + switch (fd->flags & O_ACCMODE) + { + case O_RDONLY: + pipe->readers ++; + break; + case O_WRONLY: + pipe->writers ++; + break; + case O_RDWR: + pipe->readers ++; + pipe->writers ++; + break; } + device->ref_count ++; + + rt_mutex_release(&(pipe->lock)); + + return 0; } -static rt_size_t rt_pipe_read(rt_device_t dev, - rt_off_t pos, - void *buffer, - rt_size_t size) +static int pipe_close(struct dfs_fd *fd) { - rt_uint32_t level; - rt_thread_t thread; - struct rt_pipe_device *pipe; - rt_size_t read_nbytes; + rt_device_t device; + rt_pipe_t *pipe; - pipe = PIPE_DEVICE(dev); - RT_ASSERT(pipe != RT_NULL); + pipe = (rt_pipe_t *)fd->data; + if (!pipe) return -1; - if (!(pipe->flag & RT_PIPE_FLAG_BLOCK_RD)) + device = &(pipe->parent); + rt_mutex_take(&(pipe->lock), RT_WAITING_FOREVER); + + switch (fd->flags & O_ACCMODE) { - level = rt_hw_interrupt_disable(); - read_nbytes = rt_ringbuffer_get(&(pipe->ringbuffer), buffer, size); + case O_RDONLY: + pipe->readers --; + break; + case O_WRONLY: + pipe->writers --; + break; + case O_RDWR: + pipe->readers --; + pipe->writers --; + break; + } - /* if the ringbuffer is empty, there won't be any writer waiting */ - if (read_nbytes) - _rt_pipe_resume_writer(pipe); + if (pipe->writers == 0) + { + rt_wqueue_wakeup(&(pipe->reader_queue), (void*)(POLLIN | POLLERR | POLLHUP)); + } - rt_hw_interrupt_enable(level); + if (pipe->readers == 0) + { + rt_wqueue_wakeup(&(pipe->writer_queue), (void*)(POLLOUT | POLLERR | POLLHUP)); + } - return read_nbytes; + if (device->ref_count == 1) + { + rt_free(pipe->fifo); + pipe->fifo = RT_NULL; } + device->ref_count --; - thread = rt_thread_self(); + rt_mutex_release(&(pipe->lock)); - /* current context checking */ - RT_DEBUG_NOT_IN_INTERRUPT; + return 0; +} - do { - level = rt_hw_interrupt_disable(); - read_nbytes = rt_ringbuffer_get(&(pipe->ringbuffer), buffer, size); - if (read_nbytes == 0) - { - rt_thread_suspend(thread); - /* waiting on suspended read list */ - rt_list_insert_before(&(pipe->suspended_read_list), - &(thread->tlist)); - rt_hw_interrupt_enable(level); +static int pipe_ioctl(struct dfs_fd *fd, int cmd, void *args) +{ + rt_pipe_t *pipe; + int ret = 0; - rt_schedule(); - } - else - { - _rt_pipe_resume_writer(pipe); - rt_hw_interrupt_enable(level); - break; - } - } while (read_nbytes == 0); + pipe = (rt_pipe_t *)fd->data; + + switch (cmd) + { + case FIONREAD: + *((int*)args) = rt_ringbuffer_data_len(pipe->fifo); + break; + case FIONWRITE: + *((int*)args) = rt_ringbuffer_space_len(pipe->fifo); + break; + default: + ret = -EINVAL; + break; + } - return read_nbytes; + return ret; } -static void _rt_pipe_resume_reader(struct rt_pipe_device *pipe) +static int pipe_read(struct dfs_fd *fd, void *buf, size_t count) { - if (pipe->parent.rx_indicate) - pipe->parent.rx_indicate(&pipe->parent, - rt_ringbuffer_data_len(&pipe->ringbuffer)); + int len = 0; + rt_pipe_t *pipe; - if (!rt_list_isempty(&pipe->suspended_read_list)) - { - rt_thread_t thread; + pipe = (rt_pipe_t *)fd->data; - RT_ASSERT(pipe->flag & RT_PIPE_FLAG_BLOCK_RD); + /* no process has the pipe open for writing, return end-of-file */ + if (pipe->writers == 0) + return 0; - /* get suspended thread */ - thread = rt_list_entry(pipe->suspended_read_list.next, - struct rt_thread, - tlist); + rt_mutex_take(&(pipe->lock), RT_WAITING_FOREVER); - /* resume the read thread */ - rt_thread_resume(thread); + while (1) + { + if (pipe->writers == 0) + { + goto out; + } + + len = rt_ringbuffer_get(pipe->fifo, buf, count); + + if (len > 0) + { + break; + } + else + { + if (fd->flags & O_NONBLOCK) + { + len = -EAGAIN; + goto out; + } - rt_schedule(); + rt_mutex_release(&pipe->lock); + rt_wqueue_wakeup(&(pipe->writer_queue), (void*)POLLOUT); + rt_wqueue_wait(&(pipe->reader_queue), 0, -1); + rt_mutex_take(&(pipe->lock), RT_WAITING_FOREVER); + } } + + /* wakeup writer */ + rt_wqueue_wakeup(&(pipe->writer_queue), (void*)POLLOUT); + +out: + rt_mutex_release(&pipe->lock); + + return len; } -static rt_size_t rt_pipe_write(rt_device_t dev, - rt_off_t pos, - const void *buffer, - rt_size_t size) +static int pipe_write(struct dfs_fd *fd, const void *buf, size_t count) { - rt_uint32_t level; - rt_thread_t thread; - struct rt_pipe_device *pipe; - rt_size_t write_nbytes; + int len; + rt_pipe_t *pipe; + int wakeup = 0; + int ret = 0; + uint8_t *pbuf; - pipe = PIPE_DEVICE(dev); - RT_ASSERT(pipe != RT_NULL); + pipe = (rt_pipe_t *)fd->data; - if ((pipe->flag & RT_PIPE_FLAG_FORCE_WR) || - !(pipe->flag & RT_PIPE_FLAG_BLOCK_WR)) + if (pipe->readers == 0) { - level = rt_hw_interrupt_disable(); + ret = -EPIPE; + goto out; + } + + if (count == 0) + return 0; - if (pipe->flag & RT_PIPE_FLAG_FORCE_WR) - write_nbytes = rt_ringbuffer_put_force(&(pipe->ringbuffer), - buffer, size); + pbuf = (uint8_t*)buf; + rt_mutex_take(&pipe->lock, -1); + + while (1) + { + if (pipe->readers == 0) + { + if (ret == 0) + ret = -EPIPE; + break; + } + + len = rt_ringbuffer_put(pipe->fifo, pbuf, count - ret); + ret += len; + pbuf += len; + wakeup = 1; + + if (ret == count) + { + break; + } else - write_nbytes = rt_ringbuffer_put(&(pipe->ringbuffer), - buffer, size); + { + if (fd->flags & O_NONBLOCK) + { + if (ret == 0) + { + ret = -EAGAIN; + } - _rt_pipe_resume_reader(pipe); + break; + } + } - rt_hw_interrupt_enable(level); + rt_mutex_release(&pipe->lock); + rt_wqueue_wakeup(&(pipe->reader_queue), (void*)POLLIN); + /* pipe full, waiting on suspended write list */ + rt_wqueue_wait(&(pipe->writer_queue), 0, -1); + rt_mutex_take(&pipe->lock, -1); + } - return write_nbytes; + rt_mutex_release(&pipe->lock); + if (wakeup) + { + rt_wqueue_wakeup(&(pipe->reader_queue), (void*)POLLIN); } - thread = rt_thread_self(); +out: + + return ret; +} - /* current context checking */ - RT_DEBUG_NOT_IN_INTERRUPT; +static int pipe_poll(struct dfs_fd *fd, rt_pollreq_t *req) +{ + int mask = 0; + rt_pipe_t *pipe; + int mode = 0; + pipe = (rt_pipe_t *)fd->data; + + rt_poll_add(&(pipe->reader_queue), req); + rt_poll_add(&(pipe->writer_queue), req); + + switch (fd->flags & O_ACCMODE) + { + case O_RDONLY: + mode = 1; + break; + case O_WRONLY: + mode = 2; + break; + case O_RDWR: + mode = 3; + break; + } - do { - level = rt_hw_interrupt_disable(); - write_nbytes = rt_ringbuffer_put(&(pipe->ringbuffer), buffer, size); - if (write_nbytes == 0) + if (mode & 1) + { + if (rt_ringbuffer_data_len(pipe->fifo) != 0) + { + mask |= POLLIN; + } + if (pipe->writers == 0) { - /* pipe full, waiting on suspended write list */ - rt_thread_suspend(thread); - /* waiting on suspended read list */ - rt_list_insert_before(&(pipe->suspended_write_list), - &(thread->tlist)); - rt_hw_interrupt_enable(level); + mask |= POLLHUP; + } + } - rt_schedule(); + if (mode & 2) + { + if (rt_ringbuffer_space_len(pipe->fifo) != 0) + { + mask |= POLLOUT; } - else + if (pipe->readers == 0) { - _rt_pipe_resume_reader(pipe); - rt_hw_interrupt_enable(level); - break; + mask |= POLLERR; } - } while (write_nbytes == 0); + } - return write_nbytes; + return mask; } -static rt_err_t rt_pipe_control(rt_device_t dev, rt_uint8_t cmd, void *args) +static const struct dfs_file_ops pipe_fops = { - if (cmd == PIPE_CTRL_GET_SPACE && args) - *(rt_size_t*)args = rt_ringbuffer_space_len(&PIPE_DEVICE(dev)->ringbuffer); - return RT_EOK; -} + pipe_open, + pipe_close, + pipe_ioctl, + pipe_read, + pipe_write, + RT_NULL, + RT_NULL, + RT_NULL, + pipe_poll, +}; -/** - * This function will initialize a pipe device and put it under control of - * resource management. - * - * @param pipe the pipe device - * @param name the name of pipe device - * @param flag the attribute of the pipe device - * @param buf the buffer of pipe device - * @param size the size of pipe device buffer - * - * @return the operation status, RT_EOK on successful - */ -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_pipe_t *rt_pipe_create(const char *name) { - RT_ASSERT(pipe); - RT_ASSERT(buf); + rt_pipe_t *pipe; + rt_device_t dev; - /* initialize suspended list */ - rt_list_init(&pipe->suspended_read_list); - rt_list_init(&pipe->suspended_write_list); + pipe = rt_malloc(sizeof(rt_pipe_t)); + if (pipe == RT_NULL) return RT_NULL; - /* initialize ring buffer */ - rt_ringbuffer_init(&pipe->ringbuffer, buf, size); + rt_memset(pipe, 0, sizeof(rt_pipe_t)); + rt_mutex_init(&(pipe->lock), name, RT_IPC_FLAG_FIFO); + rt_list_init(&(pipe->reader_queue)); + rt_list_init(&(pipe->writer_queue)); - pipe->flag = flag; + dev = &(pipe->parent); + dev->type = RT_Device_Class_Pipe; - /* create pipe */ - pipe->parent.type = RT_Device_Class_Pipe; - pipe->parent.init = RT_NULL; - pipe->parent.open = RT_NULL; - pipe->parent.close = RT_NULL; - pipe->parent.read = rt_pipe_read; - pipe->parent.write = rt_pipe_write; - pipe->parent.control = rt_pipe_control; + if (rt_device_register(&(pipe->parent), name, RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_REMOVABLE) != 0) + { + rt_free(pipe); + return RT_NULL; + } + dev->fops = (void*)&pipe_fops; - return rt_device_register(&(pipe->parent), name, RT_DEVICE_FLAG_RDWR); + return pipe; } -RTM_EXPORT(rt_pipe_init); -/** - * This function will detach a pipe device from resource management - * - * @param pipe the pipe device - * - * @return the operation status, RT_EOK on successful - */ -rt_err_t rt_pipe_detach(struct rt_pipe_device *pipe) +int rt_pipe_delete(const char *name) { - return rt_device_unregister(&pipe->parent); + int result = 0; + rt_device_t device; + + device = rt_device_find(name); + if (device) + { + if (device->type == RT_Device_Class_Pipe) + { + rt_pipe_t *pipe; + + if (device->ref_count != 0) + { + return -RT_EBUSY; + } + + pipe = (rt_pipe_t *)device; + + rt_mutex_detach(&(pipe->lock)); + rt_device_unregister(device); + + rt_free(pipe); + } + else + { + result = -1; + } + } + else + { + result = -1; + } + + return result; } -RTM_EXPORT(rt_pipe_detach); -#ifdef RT_USING_HEAP -rt_err_t rt_pipe_create(const char *name, enum rt_pipe_flag flag, rt_size_t size) +int pipe(int fildes[2]) { - rt_uint8_t *rb_memptr = RT_NULL; - struct rt_pipe_device *pipe = RT_NULL; + rt_pipe_t *pipe; + char dname[8]; + char dev_name[32]; + static int pipeno = 0; - /* get aligned size */ - size = RT_ALIGN(size, RT_ALIGN_SIZE); - pipe = (struct rt_pipe_device *)rt_calloc(1, sizeof(struct rt_pipe_device)); + rt_snprintf(dname, sizeof(dname), "pipe%d", pipeno++); + + pipe = rt_pipe_create(dname); if (pipe == RT_NULL) - return -RT_ENOMEM; + { + return -1; + } - /* create ring buffer of pipe */ - rb_memptr = rt_malloc(size); - if (rb_memptr == RT_NULL) + rt_snprintf(dev_name, sizeof(dev_name), "/dev/%s", dname); + fildes[0] = open(dev_name, O_RDONLY, 0); + if (fildes[0] < 0) { - rt_free(pipe); - return -RT_ENOMEM; + return -1; } - return rt_pipe_init(pipe, name, flag, rb_memptr, size); + fildes[1] = open(dev_name, O_WRONLY, 0); + if (fildes[1] < 0) + { + close(fildes[1]); + return -1; + } + + return 0; } -RTM_EXPORT(rt_pipe_create); -void rt_pipe_destroy(struct rt_pipe_device *pipe) +int mkfifo(const char *path, mode_t mode) { + rt_pipe_t *pipe; + + pipe = rt_pipe_create(path); if (pipe == RT_NULL) - return; - - /* un-register pipe device */ - rt_pipe_detach(pipe); - - /* release memory */ - rt_free(pipe->ringbuffer.buffer_ptr); - rt_free(pipe); + { + return -1; + } - return; + return 0; } -RTM_EXPORT(rt_pipe_destroy); -#endif /* RT_USING_HEAP */ +#endif diff --git a/components/drivers/src/portal.c b/components/drivers/src/portal.c deleted file mode 100644 index 779812e9ca..0000000000 --- a/components/drivers/src/portal.c +++ /dev/null @@ -1,256 +0,0 @@ -/* - * File : portal.c - * This file is part of RT-Thread RTOS - * COPYRIGHT (C) 2013, 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 - * 2013-08-19 Grissiom initial version - */ - -#include <rtthread.h> -#include <rtdevice.h> - -#define PT_WRITE_DEV(pt) (((struct rt_portal_device*)pt)->write_dev) -#define PT_READ_DEV(pt) (((struct rt_portal_device*)pt)->read_dev) - -static rt_err_t _portal_init(rt_device_t dev) -{ - rt_err_t err; - struct rt_portal_device *portal; - - RT_ASSERT(dev); - - portal = (struct rt_portal_device*)dev; - - err = rt_device_init(portal->write_dev); - if (err != RT_EOK) - return err; - - err = rt_device_init(portal->read_dev); - - return err; -} - -static rt_err_t _portal_open(rt_device_t dev, rt_uint16_t oflag) -{ - rt_err_t err; - struct rt_portal_device *portal; - - RT_ASSERT(dev); - - if (!oflag) - return -RT_ERROR; - - portal = (struct rt_portal_device*)dev; - - if (oflag & RT_DEVICE_OFLAG_RDONLY) - { - err = rt_device_open(portal->read_dev, RT_DEVICE_OFLAG_RDONLY); - if (err != RT_EOK) - return err; - } - - if (oflag & RT_DEVICE_OFLAG_WRONLY) - { - err = rt_device_open(portal->write_dev, RT_DEVICE_OFLAG_WRONLY); - if (err != RT_EOK) - return err; - } - - return RT_EOK; -} - -static rt_err_t _portal_close(rt_device_t dev) -{ - struct rt_portal_device *portal; - - RT_ASSERT(dev); - - portal = (struct rt_portal_device*)dev; - - rt_device_close(portal->write_dev); - rt_device_close(portal->read_dev); - - return RT_EOK; -} - -static rt_size_t _portal_read(rt_device_t dev, - rt_off_t pos, - void *buffer, - rt_size_t size) -{ - return rt_device_read(PT_READ_DEV(dev), - pos, buffer, size); -} - -static rt_size_t _portal_write(rt_device_t dev, - rt_off_t pos, - const void *buffer, - rt_size_t size) -{ - return rt_device_write(PT_WRITE_DEV(dev), - pos, buffer, size); -} - -static rt_err_t _portal_rx_indicate(rt_device_t dev, rt_size_t size) -{ - struct rt_pipe_device *pipe; - - RT_ASSERT(dev && dev->type == RT_Device_Class_Pipe); - - pipe = (struct rt_pipe_device*)dev; - - if (pipe->read_portal->parent.rx_indicate) - return pipe->read_portal->parent.rx_indicate( - (rt_device_t)pipe->read_portal, size); - - return -RT_ENOSYS; -} - -static rt_err_t _portal_tx_complete(rt_device_t dev, void *buf) -{ - struct rt_pipe_device *pipe; - - RT_ASSERT(dev && dev->type == RT_Device_Class_Pipe); - - pipe = (struct rt_pipe_device*)dev; - - if (pipe->write_portal->parent.tx_complete) - return pipe->write_portal->parent.tx_complete( - (rt_device_t)pipe->write_portal, buf); - - return -RT_ENOSYS; -} - -/** - * This function will initialize a portal device and put it under control of - * resource management. - * - * Portal is a device that connect devices - * - * Currently, you can only connect pipes in portal. Pipes are unidirectional. - * But with portal, you can construct a bidirectional device with two pipes. - * The inner connection is just like this: - * - * portal0 portal1 - * read || || write - * <--<---||<---<---||<---<-- (pipe0) - * || || - * -->--->||--->--->||--->--> (pipe1) - * write || || read - * - * You will always construct two portals on two pipes, say, "portal0" and - * "portal1". Data written into "portal0" can be retrieved in "portal1" and - * vice versa. `rx_indicate` and `tx_complete` events are propagated - * accordingly. - * - * @param portal the portal device - * @param portal_name the name of the portal device - * @param write_dev the name of the pipe device that this portal write into - * @param read_dev the name of the pipe device that this portal read from - * - * @return the operation status, RT_EOK on successful. -RT_ENOSYS on one pipe - * device could not be found. - */ -rt_err_t rt_portal_init(struct rt_portal_device *portal, - const char *portal_name, - const char *write_dev, - const char *read_dev) -{ - rt_device_t dev; - - RT_ASSERT(portal); - - portal->parent.type = RT_Device_Class_Portal; - portal->parent.init = _portal_init; - portal->parent.open = _portal_open; - portal->parent.close = _portal_close; - portal->parent.write = _portal_write; - portal->parent.read = _portal_read; - /* single control of the two devices makes no sense */ - portal->parent.control = RT_NULL; - - dev = rt_device_find(write_dev); - if (dev == RT_NULL) - return -RT_ENOSYS; - RT_ASSERT(dev->type == RT_Device_Class_Pipe); - portal->write_dev = dev; - rt_device_set_tx_complete(&portal->parent, dev->tx_complete); - rt_device_set_tx_complete(dev, _portal_tx_complete); - ((struct rt_pipe_device*)dev)->write_portal = portal; - - dev = rt_device_find(read_dev); - if (dev == RT_NULL) - { - rt_device_set_tx_complete(dev, portal->parent.tx_complete); - return -RT_ENOSYS; - } - RT_ASSERT(dev->type == RT_Device_Class_Pipe); - portal->read_dev = dev; - rt_device_set_rx_indicate(&portal->parent, dev->rx_indicate); - rt_device_set_rx_indicate(dev, _portal_rx_indicate); - ((struct rt_pipe_device*)dev)->read_portal = portal; - - return rt_device_register(&(portal->parent), - portal_name, - RT_DEVICE_FLAG_RDWR); -} -RTM_EXPORT(rt_portal_init); - -/** - * This function will detach a portal device from resource management - * - * @param portal the portal device - * - * @return the operation status, RT_EOK on successful - */ -rt_err_t rt_portal_detach(struct rt_portal_device *portal) -{ - return rt_device_unregister(&portal->parent); -} -RTM_EXPORT(rt_portal_detach); - -#ifdef RT_USING_HEAP -rt_err_t rt_portal_create(const char *name, - const char *write_dev, - const char *read_dev) -{ - struct rt_portal_device *portal; - - portal = (struct rt_portal_device*)rt_calloc(1, sizeof(*portal)); - if (portal == RT_NULL) - return -RT_ENOMEM; - - return rt_portal_init(portal, name, write_dev, read_dev); -} -RTM_EXPORT(rt_portal_create); - -void rt_portal_destroy(struct rt_portal_device *portal) -{ - if (portal == RT_NULL) - return; - - rt_portal_detach(portal); - - rt_free(portal); - - return; -} -RTM_EXPORT(rt_portal_destroy); -#endif /* RT_USING_HEAP */ - diff --git a/components/drivers/src/ringbuffer.c b/components/drivers/src/ringbuffer.c index 8c2705ceb1..baeeea0e50 100644 --- a/components/drivers/src/ringbuffer.c +++ b/components/drivers/src/ringbuffer.c @@ -21,18 +21,31 @@ * Date Author Notes * 2012-09-30 Bernard first version. * 2013-05-08 Grissiom reimplement + * 2016-08-18 heyuanjie add interface */ #include <rtthread.h> #include <rtdevice.h> #include <string.h> +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; +} + void rt_ringbuffer_init(struct rt_ringbuffer *rb, rt_uint8_t *pool, rt_int16_t size) { RT_ASSERT(rb != RT_NULL); - RT_ASSERT(size > 0) + RT_ASSERT(size > 0); /* initialize read and write index */ rb->read_mirror = rb->read_index = 0; @@ -284,3 +297,76 @@ rt_size_t rt_ringbuffer_getchar(struct rt_ringbuffer *rb, rt_uint8_t *ch) } RTM_EXPORT(rt_ringbuffer_getchar); +/** + * get the size of data in rb + */ +rt_size_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); + }; +} +RTM_EXPORT(rt_ringbuffer_data_len); + +/** + * empty the rb + */ +void rt_ringbuffer_reset(struct rt_ringbuffer *rb) +{ + RT_ASSERT(rb != RT_NULL); + + rb->read_mirror = 0; + rb->read_index = 0; + rb->write_mirror = 0; + rb->write_index = 0; +} +RTM_EXPORT(rt_ringbuffer_reset); + +#ifdef RT_USING_HEAP + +struct rt_ringbuffer* rt_ringbuffer_create(rt_uint16_t size) +{ + struct rt_ringbuffer *rb; + rt_uint8_t *pool; + + RT_ASSERT(size > 0); + + size = RT_ALIGN_DOWN(size, RT_ALIGN_SIZE); + + rb = rt_malloc(sizeof(struct rt_ringbuffer)); + if (rb == RT_NULL) + goto exit; + + pool = rt_malloc(size); + if (pool == RT_NULL) + { + rt_free(rb); + goto exit; + } + rt_ringbuffer_init(rb, pool, size); + +exit: + return rb; +} +RTM_EXPORT(rt_ringbuffer_create); + +void rt_ringbuffer_destroy(struct rt_ringbuffer *rb) +{ + RT_ASSERT(rb != RT_NULL); + + rt_free(rb->buffer_ptr); + rt_free(rb); +} +RTM_EXPORT(rt_ringbuffer_destroy); + +#endif diff --git a/components/drivers/src/waitqueue.c b/components/drivers/src/waitqueue.c new file mode 100644 index 0000000000..a5be7eb36e --- /dev/null +++ b/components/drivers/src/waitqueue.c @@ -0,0 +1,101 @@ +#include <stdint.h> + +#include <rthw.h> +#include <rtdevice.h> +#include <rtservice.h> + +extern struct rt_thread *rt_current_thread; + +void rt_wqueue_add(rt_wqueue_t *queue, struct rt_wqueue_node *node) +{ + rt_base_t level; + + level = rt_hw_interrupt_disable(); + rt_list_insert_before(queue, &(node->list)); + rt_hw_interrupt_enable(level); +} + +void rt_wqueue_remove(struct rt_wqueue_node *node) +{ + rt_base_t level; + + level = rt_hw_interrupt_disable(); + rt_list_remove(&(node->list)); + rt_hw_interrupt_enable(level); +} + +int __wqueue_default_wake(struct rt_wqueue_node *wait, void *key) +{ + return 0; +} + +void rt_wqueue_wakeup(rt_wqueue_t *queue, void *key) +{ + rt_base_t level; + register int need_schedule = 0; + + struct rt_list_node *node; + struct rt_wqueue_node *entry; + + if (rt_list_isempty(queue)) + return; + + level = rt_hw_interrupt_disable(); + for (node = queue->next; node != queue; node = node->next) + { + entry = rt_list_entry(node, struct rt_wqueue_node, list); + if (entry->wakeup(entry, key) == 0) + { + rt_thread_resume(entry->polling_thread); + need_schedule = 1; + + rt_wqueue_remove(entry); + break; + } + } + rt_hw_interrupt_enable(level); + + if (need_schedule) + rt_schedule(); +} + +int rt_wqueue_wait(rt_wqueue_t *queue, int condition, int msec) +{ + int tick; + rt_thread_t tid = rt_current_thread; + rt_timer_t tmr = &(tid->thread_timer); + struct rt_wqueue_node __wait; + + tick = rt_tick_from_millisecond(msec); + + if ((condition) || (tick == 0)) + return 0; + + __wait.polling_thread = rt_thread_self(); + __wait.key = 0; + __wait.wakeup = __wqueue_default_wake; + rt_list_init(&__wait.list); + + rt_wqueue_add(queue, &__wait); + + /* current context checking */ + RT_DEBUG_NOT_IN_INTERRUPT; + rt_thread_suspend(tid); + + /* start timer */ + if (tick != RT_WAITING_FOREVER) + { + rt_timer_control(tmr, + RT_TIMER_CTRL_SET_TIME, + &tick); + + rt_timer_start(tmr); + } + + rt_schedule(); + + rt_wqueue_remove(&__wait); + + return 0; +} + diff --git a/components/drivers/watchdog/watchdog.c b/components/drivers/watchdog/watchdog.c index c9620d319b..af2dcace78 100644 --- a/components/drivers/watchdog/watchdog.c +++ b/components/drivers/watchdog/watchdog.c @@ -67,7 +67,7 @@ static rt_err_t rt_watchdog_close(struct rt_device *dev) } static rt_err_t rt_watchdog_control(struct rt_device *dev, - rt_uint8_t cmd, + int cmd, void *args) { rt_watchdog_t *wtd; |