diff options
Diffstat (limited to 'components/drivers')
| -rw-r--r-- | components/drivers/include/rtdevice.h | 120 | ||||
| -rw-r--r-- | components/drivers/src/pipe.c | 136 | ||||
| -rw-r--r-- | components/drivers/src/portal.c | 256 | ||||
| -rw-r--r-- | components/drivers/src/ringbuffer.c | 101 | ||||
| -rw-r--r-- | components/drivers/usb/usbdevice/class/cdc_vcom.c | 10 |
5 files changed, 544 insertions, 79 deletions
diff --git a/components/drivers/include/rtdevice.h b/components/drivers/include/rtdevice.h index f8a944f5a7..60d4dc1e8a 100644 --- a/components/drivers/include/rtdevice.h +++ b/components/drivers/include/rtdevice.h @@ -45,9 +45,9 @@ struct rt_ringbuffer /* 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 differenct mirro, 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: + * 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 * +---+---+---+---+---+---+---+|+~~~+~~~+~~~+~~~+~~~+~~~+~~~+ @@ -73,31 +73,30 @@ struct rt_ringbuffer rt_int16_t buffer_size; }; -/** return the size of data in rb */ -rt_inline rt_uint16_t RT_RINGBUFFER_SIZE(struct rt_ringbuffer *rb) +/* portal device */ +struct rt_portal_device { - if (rb->read_index == rb->write_index) - { - if (rb->read_mirror == rb->write_mirror) - /* we are in the same side, the ringbuffer is empty. */ - return 0; - else - return rb->buffer_size; - } - else - { - 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_EMPTY(rb) ((rb)->buffer_size - RT_RINGBUFFER_SIZE(rb)) + 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; @@ -105,9 +104,14 @@ struct rt_pipe_device /* 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 RT_DATAQUEUE_EVENT_UNKNOWN 0x00 @@ -157,32 +161,98 @@ void rt_ringbuffer_init(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); + +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, rt_size_t size); +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, diff --git a/components/drivers/src/pipe.c b/components/drivers/src/pipe.c index 469c2d06e6..8a6c97aabf 100644 --- a/components/drivers/src/pipe.c +++ b/components/drivers/src/pipe.c @@ -26,6 +26,26 @@ #include <rtthread.h> #include <rtdevice.h> +static void _rt_pipe_resume_writer(struct rt_pipe_device *pipe) +{ + if (!rt_list_isempty(&pipe->suspended_write_list)) + { + rt_thread_t thread; + + RT_ASSERT(pipe->flag & RT_PIPE_FLAG_BLOCK_WR); + + /* get suspended thread */ + thread = rt_list_entry(pipe->suspended_write_list.next, + struct rt_thread, + tlist); + + /* resume the write thread */ + rt_thread_resume(thread); + + rt_schedule(); + } +} + static rt_size_t rt_pipe_read(rt_device_t dev, rt_off_t pos, void *buffer, @@ -39,13 +59,26 @@ static rt_size_t rt_pipe_read(rt_device_t dev, pipe = PIPE_DEVICE(dev); RT_ASSERT(pipe != RT_NULL); + if (!(pipe->flag & RT_PIPE_FLAG_BLOCK_RD)) + { + level = rt_hw_interrupt_disable(); + read_nbytes = rt_ringbuffer_get(&(pipe->ringbuffer), buffer, size); + + /* if the ringbuffer is empty, there won't be any writer waiting */ + if (read_nbytes) + _rt_pipe_resume_writer(pipe); + + rt_hw_interrupt_enable(level); + + return read_nbytes; + } + thread = rt_thread_self(); /* current context checking */ RT_DEBUG_NOT_IN_INTERRUPT; - do - { + do { level = rt_hw_interrupt_disable(); read_nbytes = rt_ringbuffer_get(&(pipe->ringbuffer), buffer, size); if (read_nbytes == 0) @@ -60,23 +93,8 @@ static rt_size_t rt_pipe_read(rt_device_t dev, } else { - if (!rt_list_isempty(&pipe->suspended_write_list)) - { - /* get suspended thread */ - thread = rt_list_entry(pipe->suspended_write_list.next, - struct rt_thread, - tlist); - - /* resume the write thread */ - rt_thread_resume(thread); - rt_hw_interrupt_enable(level); - - rt_schedule(); - } - else - { - rt_hw_interrupt_enable(level); - } + _rt_pipe_resume_writer(pipe); + rt_hw_interrupt_enable(level); break; } } while (read_nbytes == 0); @@ -84,7 +102,30 @@ static rt_size_t rt_pipe_read(rt_device_t dev, return read_nbytes; } -struct rt_pipe_device *_pipe = RT_NULL; +static void _rt_pipe_resume_reader(struct rt_pipe_device *pipe) +{ + if (pipe->parent.rx_indicate) + pipe->parent.rx_indicate(&pipe->parent, + rt_ringbuffer_data_len(&pipe->ringbuffer)); + + if (!rt_list_isempty(&pipe->suspended_read_list)) + { + rt_thread_t thread; + + RT_ASSERT(pipe->flag & RT_PIPE_FLAG_BLOCK_RD); + + /* get suspended thread */ + thread = rt_list_entry(pipe->suspended_read_list.next, + struct rt_thread, + tlist); + + /* resume the read thread */ + rt_thread_resume(thread); + + rt_schedule(); + } +} + static rt_size_t rt_pipe_write(rt_device_t dev, rt_off_t pos, const void *buffer, @@ -97,16 +138,32 @@ static rt_size_t rt_pipe_write(rt_device_t dev, pipe = PIPE_DEVICE(dev); RT_ASSERT(pipe != RT_NULL); - if (_pipe == RT_NULL) - _pipe = pipe; + + if ((pipe->flag & RT_PIPE_FLAG_FORCE_WR) || + !(pipe->flag & RT_PIPE_FLAG_BLOCK_WR)) + { + level = rt_hw_interrupt_disable(); + + if (pipe->flag & RT_PIPE_FLAG_FORCE_WR) + write_nbytes = rt_ringbuffer_put_force(&(pipe->ringbuffer), + buffer, size); + else + write_nbytes = rt_ringbuffer_put(&(pipe->ringbuffer), + buffer, size); + + _rt_pipe_resume_reader(pipe); + + rt_hw_interrupt_enable(level); + + return write_nbytes; + } thread = rt_thread_self(); /* current context checking */ RT_DEBUG_NOT_IN_INTERRUPT; - do - { + do { level = rt_hw_interrupt_disable(); write_nbytes = rt_ringbuffer_put(&(pipe->ringbuffer), buffer, size); if (write_nbytes == 0) @@ -122,26 +179,11 @@ static rt_size_t rt_pipe_write(rt_device_t dev, } else { - if (!rt_list_isempty(&pipe->suspended_read_list)) - { - /* get suspended thread */ - thread = rt_list_entry(pipe->suspended_read_list.next, - struct rt_thread, - tlist); - - /* resume the read thread */ - rt_thread_resume(thread); - rt_hw_interrupt_enable(level); - - rt_schedule(); - } - else - { - rt_hw_interrupt_enable(level); - } + _rt_pipe_resume_reader(pipe); + rt_hw_interrupt_enable(level); break; } - }while (write_nbytes == 0); + } while (write_nbytes == 0); return write_nbytes; } @@ -157,6 +199,7 @@ static rt_err_t rt_pipe_control(rt_device_t dev, rt_uint8_t cmd, void *args) * * @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 * @@ -164,6 +207,7 @@ static rt_err_t rt_pipe_control(rt_device_t dev, rt_uint8_t cmd, void *args) */ 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) { @@ -177,8 +221,10 @@ rt_err_t rt_pipe_init(struct rt_pipe_device *pipe, /* initialize ring buffer */ rt_ringbuffer_init(&pipe->ringbuffer, buf, size); + pipe->flag = flag; + /* create pipe */ - pipe->parent.type = RT_Device_Class_Char; + pipe->parent.type = RT_Device_Class_Pipe; pipe->parent.init = RT_NULL; pipe->parent.open = RT_NULL; pipe->parent.close = RT_NULL; @@ -204,7 +250,7 @@ rt_err_t rt_pipe_detach(struct rt_pipe_device *pipe) RTM_EXPORT(rt_pipe_detach); #ifdef RT_USING_HEAP -rt_err_t rt_pipe_create(const char *name, rt_size_t size) +rt_err_t rt_pipe_create(const char *name, enum rt_pipe_flag flag, rt_size_t size) { rt_uint8_t *rb_memptr = RT_NULL; struct rt_pipe_device *pipe = RT_NULL; @@ -223,7 +269,7 @@ rt_err_t rt_pipe_create(const char *name, rt_size_t size) return -RT_ENOMEM; } - return rt_pipe_init(pipe, name, rb_memptr, size); + return rt_pipe_init(pipe, name, flag, rb_memptr, size); } RTM_EXPORT(rt_pipe_create); diff --git a/components/drivers/src/portal.c b/components/drivers/src/portal.c new file mode 100644 index 0000000000..779812e9ca --- /dev/null +++ b/components/drivers/src/portal.c @@ -0,0 +1,256 @@ +/* + * 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 8e7e8c7895..6212b10258 100644 --- a/components/drivers/src/ringbuffer.c +++ b/components/drivers/src/ringbuffer.c @@ -44,6 +44,9 @@ void rt_ringbuffer_init(struct rt_ringbuffer *rb, } RTM_EXPORT(rt_ringbuffer_init); +/** + * put a block of data into ring buffer + */ rt_size_t rt_ringbuffer_put(struct rt_ringbuffer *rb, const rt_uint8_t *ptr, rt_uint16_t length) @@ -53,7 +56,7 @@ rt_size_t rt_ringbuffer_put(struct rt_ringbuffer *rb, RT_ASSERT(rb != RT_NULL); /* whether has enough space */ - size = RT_RINGBUFFER_EMPTY(rb); + size = rt_ringbuffer_space_len(rb); /* no space */ if (size == 0) @@ -89,6 +92,59 @@ rt_size_t rt_ringbuffer_put(struct rt_ringbuffer *rb, RTM_EXPORT(rt_ringbuffer_put); /** + * put a block of data into ring buffer + * + * When the buffer is full, it will discard the old data. + */ +rt_size_t rt_ringbuffer_put_force(struct rt_ringbuffer *rb, + const rt_uint8_t *ptr, + rt_uint16_t length) +{ + enum rt_ringbuffer_state old_state; + + RT_ASSERT(rb != RT_NULL); + + old_state = rt_ringbuffer_status(rb); + + if (length > rb->buffer_size) + length = rb->buffer_size; + + if (rb->buffer_size - rb->write_index > length) + { + /* read_index - write_index = empty space */ + memcpy(&rb->buffer_ptr[rb->write_index], ptr, length); + /* this should not cause overflow because there is enough space for + * length of data in current mirror */ + rb->write_index += length; + + if (old_state == RT_RINGBUFFER_FULL) + rb->read_index = rb->write_index; + + return length; + } + + memcpy(&rb->buffer_ptr[rb->write_index], + &ptr[0], + rb->buffer_size - rb->write_index); + memcpy(&rb->buffer_ptr[0], + &ptr[rb->buffer_size - rb->write_index], + length - (rb->buffer_size - rb->write_index)); + + /* we are going into the other side of the mirror */ + rb->write_mirror = ~rb->write_mirror; + rb->write_index = length - (rb->buffer_size - rb->write_index); + + if (old_state == RT_RINGBUFFER_FULL) + { + rb->read_mirror = ~rb->read_mirror; + rb->read_index = rb->write_index; + } + + return length; +} +RTM_EXPORT(rt_ringbuffer_put_force); + +/** * get data from ring buffer */ rt_size_t rt_ringbuffer_get(struct rt_ringbuffer *rb, @@ -100,7 +156,7 @@ rt_size_t rt_ringbuffer_get(struct rt_ringbuffer *rb, RT_ASSERT(rb != RT_NULL); /* whether has enough data */ - size = RT_RINGBUFFER_SIZE(rb); + size = rt_ringbuffer_data_len(rb); /* no data */ if (size == 0) @@ -143,7 +199,7 @@ rt_size_t rt_ringbuffer_putchar(struct rt_ringbuffer *rb, const rt_uint8_t ch) RT_ASSERT(rb != RT_NULL); /* whether has enough space */ - if (!RT_RINGBUFFER_EMPTY(rb)) + if (!rt_ringbuffer_space_len(rb)) return 0; rb->buffer_ptr[rb->write_index] = ch; @@ -164,6 +220,43 @@ rt_size_t rt_ringbuffer_putchar(struct rt_ringbuffer *rb, const rt_uint8_t ch) RTM_EXPORT(rt_ringbuffer_putchar); /** + * put a character into ring buffer + * + * When the buffer is full, it will discard one old data. + */ +rt_size_t rt_ringbuffer_putchar_force(struct rt_ringbuffer *rb, const rt_uint8_t ch) +{ + enum rt_ringbuffer_state old_state; + + RT_ASSERT(rb != RT_NULL); + + old_state = rt_ringbuffer_status(rb); + + rb->buffer_ptr[rb->write_index] = ch; + + /* flip mirror */ + if (rb->write_index == rb->buffer_size-1) + { + rb->write_mirror = ~rb->write_mirror; + rb->write_index = 0; + if (old_state == RT_RINGBUFFER_FULL) + { + rb->read_mirror = ~rb->read_mirror; + rb->read_index = rb->write_index; + } + } + else + { + rb->write_index++; + if (old_state == RT_RINGBUFFER_FULL) + rb->read_index = rb->write_index; + } + + return 1; +} +RTM_EXPORT(rt_ringbuffer_putchar_force); + +/** * get a character from a ringbuffer */ rt_size_t rt_ringbuffer_getchar(struct rt_ringbuffer *rb, rt_uint8_t *ch) @@ -171,7 +264,7 @@ rt_size_t rt_ringbuffer_getchar(struct rt_ringbuffer *rb, rt_uint8_t *ch) RT_ASSERT(rb != RT_NULL); /* ringbuffer is empty */ - if (!RT_RINGBUFFER_SIZE(rb)) + if (!rt_ringbuffer_data_len(rb)) return 0; /* put character */ diff --git a/components/drivers/usb/usbdevice/class/cdc_vcom.c b/components/drivers/usb/usbdevice/class/cdc_vcom.c index 1dee3a4d79..5f284b0294 100644 --- a/components/drivers/usb/usbdevice/class/cdc_vcom.c +++ b/components/drivers/usb/usbdevice/class/cdc_vcom.c @@ -188,7 +188,7 @@ static rt_err_t _ep_in_handler(udevice_t device, uclass_t cls, rt_size_t size) eps = (cdc_eps_t)cls->eps; level = rt_hw_interrupt_disable(); - remain = RT_RINGBUFFER_SIZE(&tx_ringbuffer); + remain = rt_ringbuffer_data_len(&tx_ringbuffer); if (remain != 0) { /* although vcom_in_sending is set in SOF handler in the very @@ -453,7 +453,7 @@ static rt_err_t _class_sof_handler(udevice_t device, uclass_t cls) eps = (cdc_eps_t)cls->eps; - size = RT_RINGBUFFER_SIZE(&tx_ringbuffer); + size = rt_ringbuffer_data_len(&tx_ringbuffer); if (size == 0) return -RT_EFULL; @@ -611,7 +611,7 @@ static int _vcom_putc(struct rt_serial_device *serial, char c) * data out soon. But we cannot rely on that and if we wait to long, just * return. */ for (cnt = 500; - RT_RINGBUFFER_EMPTY(&tx_ringbuffer) == 0 && cnt; + rt_ringbuffer_space_len(&tx_ringbuffer) == 0 && cnt; cnt--) { /*rt_kprintf("wait for %d\n", cnt);*/ @@ -628,7 +628,7 @@ static int _vcom_putc(struct rt_serial_device *serial, char c) } level = rt_hw_interrupt_disable(); - if (RT_RINGBUFFER_EMPTY(&tx_ringbuffer)) + if (rt_ringbuffer_space_len(&tx_ringbuffer)) { rt_ringbuffer_putchar(&tx_ringbuffer, c); } @@ -646,7 +646,7 @@ static int _vcom_getc(struct rt_serial_device *serial) result = -1; level = rt_hw_interrupt_disable(); - if (RT_RINGBUFFER_SIZE(&rx_ringbuffer)) + if (rt_ringbuffer_data_len(&rx_ringbuffer)) { rt_ringbuffer_getchar(&rx_ringbuffer, &ch); result = ch; |