summaryrefslogtreecommitdiff
path: root/components/drivers/src
diff options
context:
space:
mode:
authorWBI\nxf44444 <[email protected]>2022-01-26 01:43:05 +0800
committerWBI\nxf44444 <[email protected]>2022-01-26 01:43:05 +0800
commit8b0f50b7e211ee32ab08ba085ecd74588c3a3c63 (patch)
tree75440be5ecd30cc1403a9387851c0530ed057981 /components/drivers/src
parent3be35fecae513b07c35bd6f3992bf7824434bdd6 (diff)
parent32a5668593c578b85560338c29d76f3a252c8dbc (diff)
Update i2c driver, add read ACK and BUS status check
Diffstat (limited to 'components/drivers/src')
-rw-r--r--components/drivers/src/SConscript13
-rw-r--r--components/drivers/src/completion.c131
-rw-r--r--components/drivers/src/dataqueue.c414
-rw-r--r--components/drivers/src/pipe.c576
-rw-r--r--components/drivers/src/ringblk_buf.c554
-rw-r--r--components/drivers/src/ringbuffer.c396
-rw-r--r--components/drivers/src/waitqueue.c130
-rw-r--r--components/drivers/src/workqueue.c429
8 files changed, 0 insertions, 2643 deletions
diff --git a/components/drivers/src/SConscript b/components/drivers/src/SConscript
deleted file mode 100644
index 9f921ec509..0000000000
--- a/components/drivers/src/SConscript
+++ /dev/null
@@ -1,13 +0,0 @@
-from building import *
-
-cwd = GetCurrentDir()
-src = Glob('*.c')
-CPPPATH = [cwd + '/../include']
-
-if not GetDepend('RT_USING_HEAP'):
- SrcRemove(src, 'dataqueue.c')
- SrcRemove(src, 'pipe.c')
-
-group = DefineGroup('DeviceDrivers', src, depend = ['RT_USING_DEVICE_IPC'], CPPPATH = CPPPATH)
-
-Return('group')
diff --git a/components/drivers/src/completion.c b/components/drivers/src/completion.c
deleted file mode 100644
index 9e461e49ce..0000000000
--- a/components/drivers/src/completion.c
+++ /dev/null
@@ -1,131 +0,0 @@
-/*
- * Copyright (c) 2006-2018, RT-Thread Development Team
- *
- * SPDX-License-Identifier: Apache-2.0
- *
- * Change Logs:
- * Date Author Notes
- * 2012-09-30 Bernard first version.
- */
-
-#include <rthw.h>
-#include <rtthread.h>
-#include <rtdevice.h>
-
-#define RT_COMPLETED 1
-#define RT_UNCOMPLETED 0
-
-void rt_completion_init(struct rt_completion *completion)
-{
- rt_base_t level;
- RT_ASSERT(completion != RT_NULL);
-
- level = rt_hw_interrupt_disable();
- completion->flag = RT_UNCOMPLETED;
- rt_list_init(&completion->suspended_list);
- rt_hw_interrupt_enable(level);
-}
-RTM_EXPORT(rt_completion_init);
-
-rt_err_t rt_completion_wait(struct rt_completion *completion,
- rt_int32_t timeout)
-{
- rt_err_t result;
- rt_base_t level;
- rt_thread_t thread;
- RT_ASSERT(completion != RT_NULL);
-
- result = RT_EOK;
- thread = rt_thread_self();
-
- level = rt_hw_interrupt_disable();
- if (completion->flag != RT_COMPLETED)
- {
- /* only one thread can suspend on complete */
- RT_ASSERT(rt_list_isempty(&(completion->suspended_list)));
-
- if (timeout == 0)
- {
- result = -RT_ETIMEOUT;
- goto __exit;
- }
- else
- {
- /* reset thread error number */
- thread->error = RT_EOK;
-
- /* suspend thread */
- rt_thread_suspend(thread);
- /* add to suspended list */
- rt_list_insert_before(&(completion->suspended_list),
- &(thread->tlist));
-
- /* current context checking */
- RT_DEBUG_NOT_IN_INTERRUPT;
-
- /* start timer */
- if (timeout > 0)
- {
- /* reset the timeout of thread timer and start it */
- rt_timer_control(&(thread->thread_timer),
- RT_TIMER_CTRL_SET_TIME,
- &timeout);
- rt_timer_start(&(thread->thread_timer));
- }
- /* enable interrupt */
- rt_hw_interrupt_enable(level);
-
- /* do schedule */
- rt_schedule();
-
- /* thread is waked up */
- result = thread->error;
-
- level = rt_hw_interrupt_disable();
- }
- }
- /* clean completed flag */
- completion->flag = RT_UNCOMPLETED;
-
-__exit:
- rt_hw_interrupt_enable(level);
-
- return result;
-}
-RTM_EXPORT(rt_completion_wait);
-
-void rt_completion_done(struct rt_completion *completion)
-{
- rt_base_t level;
- RT_ASSERT(completion != RT_NULL);
-
- if (completion->flag == RT_COMPLETED)
- return;
-
- level = rt_hw_interrupt_disable();
- completion->flag = RT_COMPLETED;
-
- if (!rt_list_isempty(&(completion->suspended_list)))
- {
- /* there is one thread in suspended list */
- struct rt_thread *thread;
-
- /* get thread entry */
- thread = rt_list_entry(completion->suspended_list.next,
- struct rt_thread,
- tlist);
-
- /* resume it */
- rt_thread_resume(thread);
- rt_hw_interrupt_enable(level);
-
- /* perform a schedule */
- rt_schedule();
- }
- else
- {
- rt_hw_interrupt_enable(level);
- }
-}
-RTM_EXPORT(rt_completion_done);
-
diff --git a/components/drivers/src/dataqueue.c b/components/drivers/src/dataqueue.c
deleted file mode 100644
index 1651417bb9..0000000000
--- a/components/drivers/src/dataqueue.c
+++ /dev/null
@@ -1,414 +0,0 @@
-/*
- * Copyright (c) 2006-2018, RT-Thread Development Team
- *
- * SPDX-License-Identifier: Apache-2.0
- *
- * Change Logs:
- * Date Author Notes
- * 2012-09-30 Bernard first version.
- * 2016-10-31 armink fix some resume push and pop thread bugs
- */
-
-#include <rtthread.h>
-#include <rtdevice.h>
-#include <rthw.h>
-
-#define DATAQUEUE_MAGIC 0xbead0e0e
-
-struct rt_data_item
-{
- const void *data_ptr;
- rt_size_t data_size;
-};
-
-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_ASSERT(queue != RT_NULL);
- RT_ASSERT(size > 0);
-
- queue->evt_notify = evt_notify;
-
- queue->magic = DATAQUEUE_MAGIC;
- queue->size = size;
- queue->lwm = lwm;
-
- queue->get_index = 0;
- queue->put_index = 0;
- queue->is_empty = 1;
- queue->is_full = 0;
-
- rt_list_init(&(queue->suspended_push_list));
- rt_list_init(&(queue->suspended_pop_list));
-
- queue->queue = (struct rt_data_item *)rt_malloc(sizeof(struct rt_data_item) * size);
- if (queue->queue == RT_NULL)
- {
- return -RT_ENOMEM;
- }
-
- return RT_EOK;
-}
-RTM_EXPORT(rt_data_queue_init);
-
-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_ubase_t level;
- rt_thread_t thread;
- rt_err_t result;
-
- RT_ASSERT(queue != RT_NULL);
- RT_ASSERT(queue->magic == DATAQUEUE_MAGIC);
-
- result = RT_EOK;
- thread = rt_thread_self();
-
- level = rt_hw_interrupt_disable();
- while (queue->is_full)
- {
- /* queue is full */
- if (timeout == 0)
- {
- result = -RT_ETIMEOUT;
-
- goto __exit;
- }
-
- /* current context checking */
- RT_DEBUG_NOT_IN_INTERRUPT;
-
- /* reset thread error number */
- thread->error = RT_EOK;
-
- /* suspend thread on the push list */
- rt_thread_suspend(thread);
- rt_list_insert_before(&(queue->suspended_push_list), &(thread->tlist));
- /* start timer */
- if (timeout > 0)
- {
- /* reset the timeout of thread timer and start it */
- rt_timer_control(&(thread->thread_timer),
- RT_TIMER_CTRL_SET_TIME,
- &timeout);
- rt_timer_start(&(thread->thread_timer));
- }
-
- /* enable interrupt */
- rt_hw_interrupt_enable(level);
-
- /* do schedule */
- rt_schedule();
-
- /* thread is waked up */
- result = thread->error;
- level = rt_hw_interrupt_disable();
- if (result != RT_EOK) goto __exit;
- }
-
- queue->queue[queue->put_index].data_ptr = data_ptr;
- queue->queue[queue->put_index].data_size = data_size;
- queue->put_index += 1;
- if (queue->put_index == queue->size)
- {
- queue->put_index = 0;
- }
- queue->is_empty = 0;
- if (queue->put_index == queue->get_index)
- {
- queue->is_full = 1;
- }
-
- /* there is at least one thread in suspended list */
- if (!rt_list_isempty(&(queue->suspended_pop_list)))
- {
- /* get thread entry */
- thread = rt_list_entry(queue->suspended_pop_list.next,
- struct rt_thread,
- tlist);
-
- /* resume it */
- rt_thread_resume(thread);
- rt_hw_interrupt_enable(level);
-
- /* perform a schedule */
- rt_schedule();
-
- return result;
- }
-
-__exit:
- rt_hw_interrupt_enable(level);
- if ((result == RT_EOK) && queue->evt_notify != RT_NULL)
- {
- queue->evt_notify(queue, RT_DATAQUEUE_EVENT_PUSH);
- }
-
- return result;
-}
-RTM_EXPORT(rt_data_queue_push);
-
-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_ubase_t level;
- rt_thread_t thread;
- rt_err_t result;
-
- RT_ASSERT(queue != RT_NULL);
- RT_ASSERT(queue->magic == DATAQUEUE_MAGIC);
- RT_ASSERT(data_ptr != RT_NULL);
- RT_ASSERT(size != RT_NULL);
-
- result = RT_EOK;
- thread = rt_thread_self();
-
- level = rt_hw_interrupt_disable();
- while (queue->is_empty)
- {
- /* queue is empty */
- if (timeout == 0)
- {
- result = -RT_ETIMEOUT;
- goto __exit;
- }
-
- /* current context checking */
- RT_DEBUG_NOT_IN_INTERRUPT;
-
- /* reset thread error number */
- thread->error = RT_EOK;
-
- /* suspend thread on the pop list */
- rt_thread_suspend(thread);
- rt_list_insert_before(&(queue->suspended_pop_list), &(thread->tlist));
- /* start timer */
- if (timeout > 0)
- {
- /* reset the timeout of thread timer and start it */
- rt_timer_control(&(thread->thread_timer),
- RT_TIMER_CTRL_SET_TIME,
- &timeout);
- rt_timer_start(&(thread->thread_timer));
- }
-
- /* enable interrupt */
- rt_hw_interrupt_enable(level);
-
- /* do schedule */
- rt_schedule();
-
- /* thread is waked up */
- result = thread->error;
- level = rt_hw_interrupt_disable();
- if (result != RT_EOK)
- goto __exit;
- }
-
- *data_ptr = queue->queue[queue->get_index].data_ptr;
- *size = queue->queue[queue->get_index].data_size;
- queue->get_index += 1;
- if (queue->get_index == queue->size)
- {
- queue->get_index = 0;
- }
- queue->is_full = 0;
- if (queue->put_index == queue->get_index)
- {
- queue->is_empty = 1;
- }
-
- if (rt_data_queue_len(queue) <= queue->lwm)
- {
- /* there is at least one thread in suspended list */
- if (!rt_list_isempty(&(queue->suspended_push_list)))
- {
- /* get thread entry */
- thread = rt_list_entry(queue->suspended_push_list.next,
- struct rt_thread,
- tlist);
-
- /* resume it */
- rt_thread_resume(thread);
- rt_hw_interrupt_enable(level);
-
- /* perform a schedule */
- rt_schedule();
- }
- else
- {
- rt_hw_interrupt_enable(level);
- }
-
- if (queue->evt_notify != RT_NULL)
- queue->evt_notify(queue, RT_DATAQUEUE_EVENT_LWM);
-
- return result;
- }
-
-__exit:
- rt_hw_interrupt_enable(level);
- if ((result == RT_EOK) && (queue->evt_notify != RT_NULL))
- {
- queue->evt_notify(queue, RT_DATAQUEUE_EVENT_POP);
- }
-
- return result;
-}
-RTM_EXPORT(rt_data_queue_pop);
-
-rt_err_t rt_data_queue_peek(struct rt_data_queue *queue,
- const void** data_ptr,
- rt_size_t *size)
-{
- rt_ubase_t level;
-
- RT_ASSERT(queue != RT_NULL);
- RT_ASSERT(queue->magic == DATAQUEUE_MAGIC);
-
- if (queue->is_empty)
- {
- return -RT_EEMPTY;
- }
-
- level = rt_hw_interrupt_disable();
-
- *data_ptr = queue->queue[queue->get_index].data_ptr;
- *size = queue->queue[queue->get_index].data_size;
-
- rt_hw_interrupt_enable(level);
-
- return RT_EOK;
-}
-RTM_EXPORT(rt_data_queue_peek);
-
-void rt_data_queue_reset(struct rt_data_queue *queue)
-{
- rt_ubase_t level;
- struct rt_thread *thread;
-
- RT_ASSERT(queue != RT_NULL);
- RT_ASSERT(queue->magic == DATAQUEUE_MAGIC);
-
- level = rt_hw_interrupt_disable();
-
- queue->get_index = 0;
- queue->put_index = 0;
- queue->is_empty = 1;
- queue->is_full = 0;
-
- rt_hw_interrupt_enable(level);
-
- rt_enter_critical();
- /* wakeup all suspend threads */
-
- /* resume on pop list */
- while (!rt_list_isempty(&(queue->suspended_pop_list)))
- {
- /* disable interrupt */
- level = rt_hw_interrupt_disable();
-
- /* get next suspend thread */
- thread = rt_list_entry(queue->suspended_pop_list.next,
- struct rt_thread,
- tlist);
- /* set error code to RT_ERROR */
- thread->error = -RT_ERROR;
-
- /*
- * resume thread
- * In rt_thread_resume function, it will remove current thread from
- * suspend list
- */
- rt_thread_resume(thread);
-
- /* enable interrupt */
- rt_hw_interrupt_enable(level);
- }
-
- /* resume on push list */
- while (!rt_list_isempty(&(queue->suspended_push_list)))
- {
- /* disable interrupt */
- level = rt_hw_interrupt_disable();
-
- /* get next suspend thread */
- thread = rt_list_entry(queue->suspended_push_list.next,
- struct rt_thread,
- tlist);
- /* set error code to RT_ERROR */
- thread->error = -RT_ERROR;
-
- /*
- * resume thread
- * In rt_thread_resume function, it will remove current thread from
- * suspend list
- */
- rt_thread_resume(thread);
-
- /* enable interrupt */
- rt_hw_interrupt_enable(level);
- }
- rt_exit_critical();
-
- rt_schedule();
-}
-RTM_EXPORT(rt_data_queue_reset);
-
-rt_err_t rt_data_queue_deinit(struct rt_data_queue *queue)
-{
- rt_ubase_t level;
-
- RT_ASSERT(queue != RT_NULL);
- RT_ASSERT(queue->magic == DATAQUEUE_MAGIC);
-
- /* wakeup all suspend threads */
- rt_data_queue_reset(queue);
-
- level = rt_hw_interrupt_disable();
- queue->magic = 0;
- rt_hw_interrupt_enable(level);
-
- rt_free(queue->queue);
-
- return RT_EOK;
-}
-RTM_EXPORT(rt_data_queue_deinit);
-
-rt_uint16_t rt_data_queue_len(struct rt_data_queue *queue)
-{
- rt_ubase_t level;
- rt_int16_t len;
-
- RT_ASSERT(queue != RT_NULL);
- RT_ASSERT(queue->magic == DATAQUEUE_MAGIC);
-
- if (queue->is_empty)
- {
- return 0;
- }
-
- level = rt_hw_interrupt_disable();
-
- if (queue->put_index > queue->get_index)
- {
- len = queue->put_index - queue->get_index;
- }
- else
- {
- len = queue->size + queue->put_index - queue->get_index;
- }
-
- rt_hw_interrupt_enable(level);
-
- return len;
-}
-RTM_EXPORT(rt_data_queue_len);
-
diff --git a/components/drivers/src/pipe.c b/components/drivers/src/pipe.c
deleted file mode 100644
index bd392cba2b..0000000000
--- a/components/drivers/src/pipe.c
+++ /dev/null
@@ -1,576 +0,0 @@
-/*
- * Copyright (c) 2006-2018, RT-Thread Development Team
- *
- * SPDX-License-Identifier: Apache-2.0
- *
- * Change Logs:
- * Date Author Notes
- * 2012-09-30 Bernard first version.
- * 2017-11-08 JasonJiaJie fix memory leak issue when close a pipe.
- */
-#include <rthw.h>
-#include <rtdevice.h>
-#include <stdint.h>
-
-#if defined(RT_USING_POSIX)
-#include <dfs_file.h>
-#include <dfs_posix.h>
-#include <dfs_poll.h>
-
-static int pipe_fops_open(struct dfs_fd *fd)
-{
- int rc = 0;
- rt_device_t device;
- rt_pipe_t *pipe;
-
- pipe = (rt_pipe_t *)fd->data;
- if (!pipe) return -1;
-
- device = &(pipe->parent);
- rt_mutex_take(&(pipe->lock), RT_WAITING_FOREVER);
-
- if (device->ref_count == 0)
- {
- pipe->fifo = rt_ringbuffer_create(pipe->bufsz);
- if (pipe->fifo == RT_NULL)
- {
- rc = -RT_ENOMEM;
- goto __exit;
- }
- }
-
- 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 ++;
-
-__exit:
- rt_mutex_release(&(pipe->lock));
-
- return rc;
-}
-
-static int pipe_fops_close(struct dfs_fd *fd)
-{
- rt_device_t device;
- rt_pipe_t *pipe;
-
- pipe = (rt_pipe_t *)fd->data;
- if (!pipe) return -1;
-
- device = &(pipe->parent);
- rt_mutex_take(&(pipe->lock), RT_WAITING_FOREVER);
-
- 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;
- }
-
- if (pipe->writers == 0)
- {
- rt_wqueue_wakeup(&(pipe->reader_queue), (void*)(POLLIN | POLLERR | POLLHUP));
- }
-
- if (pipe->readers == 0)
- {
- rt_wqueue_wakeup(&(pipe->writer_queue), (void*)(POLLOUT | POLLERR | POLLHUP));
- }
-
- if (device->ref_count == 1)
- {
- if (pipe->fifo != RT_NULL)
- rt_ringbuffer_destroy(pipe->fifo);
- pipe->fifo = RT_NULL;
- }
- device->ref_count --;
-
- rt_mutex_release(&(pipe->lock));
-
- if (device->ref_count == 0 && pipe->is_named == RT_FALSE)
- {
- /* delete the unamed pipe */
- rt_pipe_delete(device->parent.name);
- }
-
- return 0;
-}
-
-static int pipe_fops_ioctl(struct dfs_fd *fd, int cmd, void *args)
-{
- rt_pipe_t *pipe;
- int ret = 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 ret;
-}
-
-static int pipe_fops_read(struct dfs_fd *fd, void *buf, size_t count)
-{
- int len = 0;
- rt_pipe_t *pipe;
-
- pipe = (rt_pipe_t *)fd->data;
-
- /* no process has the pipe open for writing, return end-of-file */
- if (pipe->writers == 0)
- return 0;
-
- rt_mutex_take(&(pipe->lock), RT_WAITING_FOREVER);
-
- 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_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 int pipe_fops_write(struct dfs_fd *fd, const void *buf, size_t count)
-{
- int len;
- rt_pipe_t *pipe;
- int wakeup = 0;
- int ret = 0;
- uint8_t *pbuf;
-
- pipe = (rt_pipe_t *)fd->data;
-
- if (pipe->readers == 0)
- {
- ret = -EPIPE;
- goto out;
- }
-
- if (count == 0)
- return 0;
-
- 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
- {
- if (fd->flags & O_NONBLOCK)
- {
- if (ret == 0)
- {
- ret = -EAGAIN;
- }
-
- break;
- }
- }
-
- 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);
- }
- rt_mutex_release(&pipe->lock);
-
- if (wakeup)
- {
- rt_wqueue_wakeup(&(pipe->reader_queue), (void*)POLLIN);
- }
-
-out:
- return ret;
-}
-
-static int pipe_fops_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;
- }
-
- if (mode & 1)
- {
- if (rt_ringbuffer_data_len(pipe->fifo) != 0)
- {
- mask |= POLLIN;
- }
- if (pipe->writers == 0)
- {
- mask |= POLLHUP;
- }
- }
-
- if (mode & 2)
- {
- if (rt_ringbuffer_space_len(pipe->fifo) != 0)
- {
- mask |= POLLOUT;
- }
- if (pipe->readers == 0)
- {
- mask |= POLLERR;
- }
- }
-
- return mask;
-}
-
-static const struct dfs_file_ops pipe_fops =
-{
- pipe_fops_open,
- pipe_fops_close,
- pipe_fops_ioctl,
- pipe_fops_read,
- pipe_fops_write,
- RT_NULL,
- RT_NULL,
- RT_NULL,
- pipe_fops_poll,
-};
-#endif /* end of RT_USING_POSIX */
-
-rt_err_t rt_pipe_open (rt_device_t device, rt_uint16_t oflag)
-{
- rt_pipe_t *pipe = (rt_pipe_t *)device;
- rt_err_t ret = RT_EOK;
-
- if (device == RT_NULL)
- {
- ret = -RT_EINVAL;
- goto __exit;
- }
-
- rt_mutex_take(&(pipe->lock), RT_WAITING_FOREVER);
-
- if (pipe->fifo == RT_NULL)
- {
- pipe->fifo = rt_ringbuffer_create(pipe->bufsz);
- if (pipe->fifo == RT_NULL)
- {
- ret = -RT_ENOMEM;
- }
- }
-
- rt_mutex_release(&(pipe->lock));
-
-__exit:
- return ret;
-}
-
-rt_err_t rt_pipe_close (rt_device_t device)
-{
- rt_pipe_t *pipe = (rt_pipe_t *)device;
-
- if (device == RT_NULL) return -RT_EINVAL;
- rt_mutex_take(&(pipe->lock), RT_WAITING_FOREVER);
-
- if (device->ref_count == 1)
- {
- rt_ringbuffer_destroy(pipe->fifo);
- pipe->fifo = RT_NULL;
- }
-
- rt_mutex_release(&(pipe->lock));
-
- return RT_EOK;
-}
-
-rt_size_t rt_pipe_read (rt_device_t device, rt_off_t pos, void *buffer, rt_size_t count)
-{
- uint8_t *pbuf;
- rt_size_t read_bytes = 0;
- rt_pipe_t *pipe = (rt_pipe_t *)device;
-
- if (device == RT_NULL)
- {
- rt_set_errno(-EINVAL);
- return 0;
- }
- if (count == 0) return 0;
-
- pbuf = (uint8_t*)buffer;
- rt_mutex_take(&(pipe->lock), RT_WAITING_FOREVER);
-
- while (read_bytes < count)
- {
- int len = rt_ringbuffer_get(pipe->fifo, &pbuf[read_bytes], count - read_bytes);
- if (len <= 0) break;
-
- read_bytes += len;
- }
- rt_mutex_release(&pipe->lock);
-
- return read_bytes;
-}
-
-rt_size_t rt_pipe_write (rt_device_t device, rt_off_t pos, const void *buffer, rt_size_t count)
-{
- uint8_t *pbuf;
- rt_size_t write_bytes = 0;
- rt_pipe_t *pipe = (rt_pipe_t *)device;
-
- if (device == RT_NULL)
- {
- rt_set_errno(-EINVAL);
- return 0;
- }
- if (count == 0) return 0;
-
- pbuf = (uint8_t*)buffer;
- rt_mutex_take(&pipe->lock, -1);
-
- while (write_bytes < count)
- {
- int len = rt_ringbuffer_put(pipe->fifo, &pbuf[write_bytes], count - write_bytes);
- if (len <= 0) break;
-
- write_bytes += len;
- }
- rt_mutex_release(&pipe->lock);
-
- return write_bytes;
-}
-
-rt_err_t rt_pipe_control(rt_device_t dev, int cmd, void *args)
-{
- return RT_EOK;
-}
-
-#ifdef RT_USING_DEVICE_OPS
-const static struct rt_device_ops pipe_ops =
-{
- RT_NULL,
- rt_pipe_open,
- rt_pipe_close,
- rt_pipe_read,
- rt_pipe_write,
- rt_pipe_control,
-};
-#endif
-
-rt_pipe_t *rt_pipe_create(const char *name, int bufsz)
-{
- rt_pipe_t *pipe;
- rt_device_t dev;
-
- pipe = (rt_pipe_t *)rt_malloc(sizeof(rt_pipe_t));
- if (pipe == RT_NULL) return RT_NULL;
-
- rt_memset(pipe, 0, sizeof(rt_pipe_t));
- pipe->is_named = RT_TRUE; /* initialize as a named pipe */
- rt_mutex_init(&(pipe->lock), name, RT_IPC_FLAG_FIFO);
- rt_wqueue_init(&(pipe->reader_queue));
- rt_wqueue_init(&(pipe->writer_queue));
-
- RT_ASSERT(bufsz < 0xFFFF);
- pipe->bufsz = bufsz;
-
- dev = &(pipe->parent);
- dev->type = RT_Device_Class_Pipe;
-#ifdef RT_USING_DEVICE_OPS
- dev->ops = &pipe_ops;
-#else
- dev->init = RT_NULL;
- dev->open = rt_pipe_open;
- dev->read = rt_pipe_read;
- dev->write = rt_pipe_write;
- dev->close = rt_pipe_close;
- dev->control = rt_pipe_control;
-#endif
-
- dev->rx_indicate = RT_NULL;
- dev->tx_complete = RT_NULL;
-
- if (rt_device_register(&(pipe->parent), name, RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_REMOVABLE) != 0)
- {
- rt_free(pipe);
- return RT_NULL;
- }
-#ifdef RT_USING_POSIX
- dev->fops = (void*)&pipe_fops;
-#endif
-
- return pipe;
-}
-
-int rt_pipe_delete(const char *name)
-{
- 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);
-
- /* close fifo ringbuffer */
- if (pipe->fifo)
- {
- rt_ringbuffer_destroy(pipe->fifo);
- pipe->fifo = RT_NULL;
- }
- rt_free(pipe);
- }
- else
- {
- result = -ENODEV;
- }
- }
- else
- {
- result = -ENODEV;
- }
-
- return result;
-}
-
-#ifdef RT_USING_POSIX
-int pipe(int fildes[2])
-{
- rt_pipe_t *pipe;
- char dname[8];
- char dev_name[32];
- static int pipeno = 0;
-
- rt_snprintf(dname, sizeof(dname), "pipe%d", pipeno++);
-
- pipe = rt_pipe_create(dname, PIPE_BUFSZ);
- if (pipe == RT_NULL)
- {
- return -1;
- }
-
- pipe->is_named = RT_FALSE; /* unamed pipe */
- rt_snprintf(dev_name, sizeof(dev_name), "/dev/%s", dname);
- fildes[0] = open(dev_name, O_RDONLY, 0);
- if (fildes[0] < 0)
- {
- return -1;
- }
-
- fildes[1] = open(dev_name, O_WRONLY, 0);
- if (fildes[1] < 0)
- {
- close(fildes[0]);
- return -1;
- }
-
- return 0;
-}
-
-int mkfifo(const char *path, mode_t mode)
-{
- rt_pipe_t *pipe;
-
- pipe = rt_pipe_create(path, PIPE_BUFSZ);
- if (pipe == RT_NULL)
- {
- return -1;
- }
-
- return 0;
-}
-#endif
diff --git a/components/drivers/src/ringblk_buf.c b/components/drivers/src/ringblk_buf.c
deleted file mode 100644
index 7d83149c5e..0000000000
--- a/components/drivers/src/ringblk_buf.c
+++ /dev/null
@@ -1,554 +0,0 @@
-/*
- * Copyright (c) 2006-2018, RT-Thread Development Team
- *
- * SPDX-License-Identifier: Apache-2.0
- *
- * Change Logs:
- * Date Author Notes
- * 2018-08-25 armink the first version
- */
-
-#include <rthw.h>
-#include <rtthread.h>
-#include <rtdevice.h>
-
-/**
- * ring block buffer object initialization
- *
- * @param rbb ring block buffer object
- * @param buf buffer
- * @param buf_size buffer size
- * @param block_set block set
- * @param blk_max_num max block number
- *
- * @note When your application need align access, please make the buffer address is aligned.
- */
-void rt_rbb_init(rt_rbb_t rbb, rt_uint8_t *buf, rt_size_t buf_size, rt_rbb_blk_t block_set, rt_size_t blk_max_num)
-{
- rt_size_t i;
-
- RT_ASSERT(rbb);
- RT_ASSERT(buf);
- RT_ASSERT(block_set);
-
- rbb->buf = buf;
- rbb->buf_size = buf_size;
- rbb->blk_set = block_set;
- rbb->blk_max_num = blk_max_num;
- rt_slist_init(&rbb->blk_list);
- /* initialize block status */
- for (i = 0; i < blk_max_num; i++)
- {
- block_set[i].status = RT_RBB_BLK_UNUSED;
- }
-}
-RTM_EXPORT(rt_rbb_init);
-
-/**
- * ring block buffer object create
- *
- * @param buf_size buffer size
- * @param blk_max_num max block number
- *
- * @return != NULL: ring block buffer object
- * NULL: create failed
- */
-rt_rbb_t rt_rbb_create(rt_size_t buf_size, rt_size_t blk_max_num)
-{
- rt_rbb_t rbb = NULL;
- rt_uint8_t *buf;
- rt_rbb_blk_t blk_set;
-
- rbb = (rt_rbb_t)rt_malloc(sizeof(struct rt_rbb));
- if (!rbb)
- {
- return NULL;
- }
-
- buf = (rt_uint8_t *)rt_malloc(buf_size);
- if (!buf)
- {
- rt_free(rbb);
- return NULL;
- }
-
- blk_set = (rt_rbb_blk_t)rt_malloc(sizeof(struct rt_rbb_blk) * blk_max_num);
- if (!blk_set)
- {
- rt_free(buf);
- rt_free(rbb);
- return NULL;
- }
-
- rt_rbb_init(rbb, buf, buf_size, blk_set, blk_max_num);
-
- return rbb;
-}
-RTM_EXPORT(rt_rbb_create);
-
-/**
- * ring block buffer object destroy
- *
- * @param rbb ring block buffer object
- */
-void rt_rbb_destroy(rt_rbb_t rbb)
-{
- RT_ASSERT(rbb);
-
- rt_free(rbb->buf);
- rt_free(rbb->blk_set);
- rt_free(rbb);
-
-}
-RTM_EXPORT(rt_rbb_destroy);
-
-static rt_rbb_blk_t find_empty_blk_in_set(rt_rbb_t rbb)
-{
- rt_size_t i;
-
- RT_ASSERT(rbb);
-
- for (i = 0; i < rbb->blk_max_num; i ++)
- {
- if (rbb->blk_set[i].status == RT_RBB_BLK_UNUSED)
- {
- return &rbb->blk_set[i];
- }
- }
-
- return NULL;
-}
-
-/**
- * Allocate a block by given size. The block will add to blk_list when allocate success.
- *
- * @param rbb ring block buffer object
- * @param blk_size block size
- *
- * @note When your application need align access, please make the blk_szie is aligned.
- *
- * @return != NULL: allocated block
- * NULL: allocate failed
- */
-rt_rbb_blk_t rt_rbb_blk_alloc(rt_rbb_t rbb, rt_size_t blk_size)
-{
- rt_base_t level;
- rt_size_t empty1 = 0, empty2 = 0;
- rt_rbb_blk_t head, tail, new_rbb = NULL;
-
- RT_ASSERT(rbb);
- RT_ASSERT(blk_size < (1L << 24));
-
- level = rt_hw_interrupt_disable();
-
- new_rbb = find_empty_blk_in_set(rbb);
-
- if (rt_slist_len(&rbb->blk_list) < rbb->blk_max_num && new_rbb)
- {
- if (rt_slist_len(&rbb->blk_list) > 0)
- {
- head = rt_slist_first_entry(&rbb->blk_list, struct rt_rbb_blk, list);
- tail = rt_slist_tail_entry(&rbb->blk_list, struct rt_rbb_blk, list);
- if (head->buf <= tail->buf)
- {
- /**
- * head tail
- * +--------------------------------------+-----------------+------------------+
- * | empty2 | block1 | block2 | block3 | empty1 |
- * +--------------------------------------+-----------------+------------------+
- * rbb->buf
- */
- empty1 = (rbb->buf + rbb->buf_size) - (tail->buf + tail->size);
- empty2 = head->buf - rbb->buf;
-
- if (empty1 >= blk_size)
- {
- rt_slist_append(&rbb->blk_list, &new_rbb->list);
- new_rbb->status = RT_RBB_BLK_INITED;
- new_rbb->buf = tail->buf + tail->size;
- new_rbb->size = blk_size;
- }
- else if (empty2 >= blk_size)
- {
- rt_slist_append(&rbb->blk_list, &new_rbb->list);
- new_rbb->status = RT_RBB_BLK_INITED;
- new_rbb->buf = rbb->buf;
- new_rbb->size = blk_size;
- }
- else
- {
- /* no space */
- new_rbb = NULL;
- }
- }
- else
- {
- /**
- * tail head
- * +----------------+-------------------------------------+--------+-----------+
- * | block3 | empty1 | block1 | block2 |
- * +----------------+-------------------------------------+--------+-----------+
- * rbb->buf
- */
- empty1 = head->buf - (tail->buf + tail->size);
-
- if (empty1 >= blk_size)
- {
- rt_slist_append(&rbb->blk_list, &new_rbb->list);
- new_rbb->status = RT_RBB_BLK_INITED;
- new_rbb->buf = tail->buf + tail->size;
- new_rbb->size = blk_size;
- }
- else
- {
- /* no space */
- new_rbb = NULL;
- }
- }
- }
- else
- {
- /* the list is empty */
- rt_slist_append(&rbb->blk_list, &new_rbb->list);
- new_rbb->status = RT_RBB_BLK_INITED;
- new_rbb->buf = rbb->buf;
- new_rbb->size = blk_size;
- }
- }
- else
- {
- new_rbb = NULL;
- }
-
- rt_hw_interrupt_enable(level);
-
- return new_rbb;
-}
-RTM_EXPORT(rt_rbb_blk_alloc);
-
-/**
- * put a block to ring block buffer object
- *
- * @param block the block
- */
-void rt_rbb_blk_put(rt_rbb_blk_t block)
-{
- RT_ASSERT(block);
- RT_ASSERT(block->status == RT_RBB_BLK_INITED);
-
- block->status = RT_RBB_BLK_PUT;
-}
-RTM_EXPORT(rt_rbb_blk_put);
-
-/**
- * get a block from the ring block buffer object
- *
- * @param rbb ring block buffer object
- *
- * @return != NULL: block
- * NULL: get failed
- */
-rt_rbb_blk_t rt_rbb_blk_get(rt_rbb_t rbb)
-{
- rt_base_t level;
- rt_rbb_blk_t block = NULL;
- rt_slist_t *node;
-
- RT_ASSERT(rbb);
-
- if (rt_slist_isempty(&rbb->blk_list))
- return 0;
-
- level = rt_hw_interrupt_disable();
-
- for (node = rt_slist_first(&rbb->blk_list); node; node = rt_slist_next(node))
- {
- block = rt_slist_entry(node, struct rt_rbb_blk, list);
- if (block->status == RT_RBB_BLK_PUT)
- {
- block->status = RT_RBB_BLK_GET;
- goto __exit;
- }
- }
- /* not found */
- block = NULL;
-
-__exit:
-
- rt_hw_interrupt_enable(level);
-
- return block;
-}
-RTM_EXPORT(rt_rbb_blk_get);
-
-/**
- * return the block size
- *
- * @param block the block
- *
- * @return block size
- */
-rt_size_t rt_rbb_blk_size(rt_rbb_blk_t block)
-{
- RT_ASSERT(block);
-
- return block->size;
-}
-RTM_EXPORT(rt_rbb_blk_size);
-
-/**
- * return the block buffer
- *
- * @param block the block
- *
- * @return block buffer
- */
-rt_uint8_t *rt_rbb_blk_buf(rt_rbb_blk_t block)
-{
- RT_ASSERT(block);
-
- return block->buf;
-}
-RTM_EXPORT(rt_rbb_blk_buf);
-
-/**
- * free the block
- *
- * @param rbb ring block buffer object
- * @param block the block
- */
-void rt_rbb_blk_free(rt_rbb_t rbb, rt_rbb_blk_t block)
-{
- rt_base_t level;
-
- RT_ASSERT(rbb);
- RT_ASSERT(block);
- RT_ASSERT(block->status != RT_RBB_BLK_UNUSED);
-
- level = rt_hw_interrupt_disable();
-
- /* remove it on rbb block list */
- rt_slist_remove(&rbb->blk_list, &block->list);
-
- block->status = RT_RBB_BLK_UNUSED;
-
- rt_hw_interrupt_enable(level);
-}
-RTM_EXPORT(rt_rbb_blk_free);
-
-/**
- * get a continuous block to queue by given size
- *
- * tail head
- * +------------------+---------------+--------+----------+--------+
- * | block3 | empty1 | block1 | block2 |fragment|
- * +------------------+------------------------+----------+--------+
- * |<-- return_size -->| |
- * |<--- queue_data_len --->|
- *
- * tail head
- * +------------------+---------------+--------+----------+--------+
- * | block3 | empty1 | block1 | block2 |fragment|
- * +------------------+------------------------+----------+--------+
- * |<-- return_size -->| out of len(b1+b2+b3) |
- * |<-------------------- queue_data_len -------------------->|
- *
- * @param rbb ring block buffer object
- * @param queue_data_len The max queue data size, and the return size must less then it.
- * @param queue continuous block queue
- *
- * @return the block queue data total size
- */
-rt_size_t rt_rbb_blk_queue_get(rt_rbb_t rbb, rt_size_t queue_data_len, rt_rbb_blk_queue_t blk_queue)
-{
- rt_base_t level;
- rt_size_t data_total_size = 0;
- rt_slist_t *node;
- rt_rbb_blk_t last_block = NULL, block;
-
- RT_ASSERT(rbb);
- RT_ASSERT(blk_queue);
-
- if (rt_slist_isempty(&rbb->blk_list))
- return 0;
-
- level = rt_hw_interrupt_disable();
-
- for (node = rt_slist_first(&rbb->blk_list); node; node = rt_slist_next(node))
- {
- if (!last_block)
- {
- last_block = rt_slist_entry(node, struct rt_rbb_blk, list);
- if (last_block->status == RT_RBB_BLK_PUT)
- {
- /* save the first put status block to queue */
- blk_queue->blocks = last_block;
- blk_queue->blk_num = 0;
- }
- else
- {
- /* the first block must be put status */
- last_block = NULL;
- continue;
- }
- }
- else
- {
- block = rt_slist_entry(node, struct rt_rbb_blk, list);
- /*
- * these following conditions will break the loop:
- * 1. the current block is not put status
- * 2. the last block and current block is not continuous
- * 3. the data_total_size will out of range
- */
- if (block->status != RT_RBB_BLK_PUT ||
- last_block->buf > block->buf ||
- data_total_size + block->size > queue_data_len)
- {
- break;
- }
- /* backup last block */
- last_block = block;
- }
- /* remove current block */
- rt_slist_remove(&rbb->blk_list, &last_block->list);
- data_total_size += last_block->size;
- last_block->status = RT_RBB_BLK_GET;
- blk_queue->blk_num++;
- }
-
- rt_hw_interrupt_enable(level);
-
- return data_total_size;
-}
-RTM_EXPORT(rt_rbb_blk_queue_get);
-
-/**
- * get all block length on block queue
- *
- * @param blk_queue the block queue
- *
- * @return total length
- */
-rt_size_t rt_rbb_blk_queue_len(rt_rbb_blk_queue_t blk_queue)
-{
- rt_size_t i, data_total_size = 0;
-
- RT_ASSERT(blk_queue);
-
- for (i = 0; i < blk_queue->blk_num; i++)
- {
- data_total_size += blk_queue->blocks[i].size;
- }
-
- return data_total_size;
-}
-RTM_EXPORT(rt_rbb_blk_queue_len);
-
-/**
- * return the block queue buffer
- *
- * @param blk_queue the block queue
- *
- * @return block queue buffer
- */
-rt_uint8_t *rt_rbb_blk_queue_buf(rt_rbb_blk_queue_t blk_queue)
-{
- RT_ASSERT(blk_queue);
-
- return blk_queue->blocks[0].buf;
-}
-RTM_EXPORT(rt_rbb_blk_queue_buf);
-
-/**
- * free the block queue
- *
- * @param rbb ring block buffer object
- * @param blk_queue the block queue
- */
-void rt_rbb_blk_queue_free(rt_rbb_t rbb, rt_rbb_blk_queue_t blk_queue)
-{
- rt_size_t i;
-
- RT_ASSERT(rbb);
- RT_ASSERT(blk_queue);
-
- for (i = 0; i < blk_queue->blk_num; i++)
- {
- rt_rbb_blk_free(rbb, &blk_queue->blocks[i]);
- }
-}
-RTM_EXPORT(rt_rbb_blk_queue_free);
-
-/**
- * The put status and buffer continuous blocks can be make a block queue.
- * This function will return the length which from next can be make block queue.
- *
- * @param rbb ring block buffer object
- *
- * @return the next can be make block queue's length
- */
-rt_size_t rt_rbb_next_blk_queue_len(rt_rbb_t rbb)
-{
- rt_base_t level;
- rt_size_t data_len = 0;
- rt_slist_t *node;
- rt_rbb_blk_t last_block = NULL, block;
-
- RT_ASSERT(rbb);
-
- if (rt_slist_isempty(&rbb->blk_list))
- return 0;
-
- level = rt_hw_interrupt_disable();
-
- for (node = rt_slist_first(&rbb->blk_list); node; node = rt_slist_next(node))
- {
- if (!last_block)
- {
- last_block = rt_slist_entry(node, struct rt_rbb_blk, list);
- if (last_block->status != RT_RBB_BLK_PUT)
- {
- /* the first block must be put status */
- last_block = NULL;
- continue;
- }
- }
- else
- {
- block = rt_slist_entry(node, struct rt_rbb_blk, list);
- /*
- * these following conditions will break the loop:
- * 1. the current block is not put status
- * 2. the last block and current block is not continuous
- */
- if (block->status != RT_RBB_BLK_PUT || last_block->buf > block->buf)
- {
- break;
- }
- /* backup last block */
- last_block = block;
- }
- data_len += last_block->size;
- }
-
- rt_hw_interrupt_enable(level);
-
- return data_len;
-}
-RTM_EXPORT(rt_rbb_next_blk_queue_len);
-
-/**
- * get the ring block buffer object buffer size
- *
- * @param rbb ring block buffer object
- *
- * @return buffer size
- */
-rt_size_t rt_rbb_get_buf_size(rt_rbb_t rbb)
-{
- RT_ASSERT(rbb);
-
- return rbb->buf_size;
-}
-RTM_EXPORT(rt_rbb_get_buf_size);
diff --git a/components/drivers/src/ringbuffer.c b/components/drivers/src/ringbuffer.c
deleted file mode 100644
index 88afd19506..0000000000
--- a/components/drivers/src/ringbuffer.c
+++ /dev/null
@@ -1,396 +0,0 @@
-/*
- * Copyright (c) 2006-2018, RT-Thread Development Team
- *
- * SPDX-License-Identifier: Apache-2.0
- *
- * Change Logs:
- * 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);
-
- /* initialize read and write index */
- rb->read_mirror = rb->read_index = 0;
- rb->write_mirror = rb->write_index = 0;
-
- /* set buffer pool and size */
- rb->buffer_ptr = pool;
- rb->buffer_size = RT_ALIGN_DOWN(size, RT_ALIGN_SIZE);
-}
-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)
-{
- rt_uint16_t size;
-
- RT_ASSERT(rb != RT_NULL);
-
- /* whether has enough space */
- size = rt_ringbuffer_space_len(rb);
-
- /* no space */
- if (size == 0)
- return 0;
-
- /* drop some data */
- if (size < length)
- length = 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;
- 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);
-
- return length;
-}
-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)
-{
- rt_uint16_t space_length;
-
- RT_ASSERT(rb != RT_NULL);
-
- space_length = rt_ringbuffer_space_len(rb);
-
- if (length > rb->buffer_size)
- {
- ptr = &ptr[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 (length > space_length)
- 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 (length > space_length)
- {
- 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,
- rt_uint8_t *ptr,
- rt_uint16_t length)
-{
- rt_size_t size;
-
- RT_ASSERT(rb != RT_NULL);
-
- /* whether has enough data */
- size = rt_ringbuffer_data_len(rb);
-
- /* no data */
- if (size == 0)
- return 0;
-
- /* less data */
- if (size < length)
- length = size;
-
- if (rb->buffer_size - rb->read_index > length)
- {
- /* copy all of data */
- memcpy(ptr, &rb->buffer_ptr[rb->read_index], length);
- /* this should not cause overflow because there is enough space for
- * length of data in current mirror */
- rb->read_index += length;
- return length;
- }
-
- memcpy(&ptr[0],
- &rb->buffer_ptr[rb->read_index],
- rb->buffer_size - rb->read_index);
- memcpy(&ptr[rb->buffer_size - rb->read_index],
- &rb->buffer_ptr[0],
- length - (rb->buffer_size - rb->read_index));
-
- /* we are going into the other side of the mirror */
- rb->read_mirror = ~rb->read_mirror;
- rb->read_index = length - (rb->buffer_size - rb->read_index);
-
- return length;
-}
-RTM_EXPORT(rt_ringbuffer_get);
-
-/**
- * peak data from ring buffer
- */
-rt_size_t rt_ringbuffer_peak(struct rt_ringbuffer *rb, rt_uint8_t **ptr)
-{
- RT_ASSERT(rb != RT_NULL);
-
- *ptr = RT_NULL;
-
- /* whether has enough data */
- rt_size_t size = rt_ringbuffer_data_len(rb);
-
- /* no data */
- if (size == 0)
- return 0;
-
- *ptr = &rb->buffer_ptr[rb->read_index];
-
- if(rb->buffer_size - rb->read_index > size)
- {
- rb->read_index += size;
- return size;
- }
-
- size = rb->buffer_size - rb->read_index;
-
- /* we are going into the other side of the mirror */
- rb->read_mirror = ~rb->read_mirror;
- rb->read_index = 0;
-
- return size;
-}
-RTM_EXPORT(rt_ringbuffer_peak);
-
-/**
- * put a character into ring buffer
- */
-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_space_len(rb))
- return 0;
-
- 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;
- }
- else
- {
- rb->write_index++;
- }
-
- return 1;
-}
-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)
-{
- RT_ASSERT(rb != RT_NULL);
-
- /* ringbuffer is empty */
- if (!rt_ringbuffer_data_len(rb))
- return 0;
-
- /* put character */
- *ch = rb->buffer_ptr[rb->read_index];
-
- if (rb->read_index == rb->buffer_size-1)
- {
- rb->read_mirror = ~rb->read_mirror;
- rb->read_index = 0;
- }
- else
- {
- rb->read_index++;
- }
-
- return 1;
-}
-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 = (struct rt_ringbuffer *)rt_malloc(sizeof(struct rt_ringbuffer));
- if (rb == RT_NULL)
- goto exit;
-
- pool = (rt_uint8_t *)rt_malloc(size);
- if (pool == RT_NULL)
- {
- rt_free(rb);
- rb = RT_NULL;
- 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
deleted file mode 100644
index 02240edbdf..0000000000
--- a/components/drivers/src/waitqueue.c
+++ /dev/null
@@ -1,130 +0,0 @@
-/*
- * Copyright (c) 2006-2018, RT-Thread Development Team
- *
- * SPDX-License-Identifier: Apache-2.0
- *
- * Change Logs:
- * Date Author Notes
- * 2018/06/26 Bernard Fix the wait queue issue when wakeup a soon
- * to blocked thread.
- */
-
-#include <stdint.h>
-
-#include <rthw.h>
-#include <rtdevice.h>
-#include <rtservice.h>
-
-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->waiting_list), &(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;
-
- rt_list_t *queue_list;
- struct rt_list_node *node;
- struct rt_wqueue_node *entry;
-
- queue_list = &(queue->waiting_list);
-
- level = rt_hw_interrupt_disable();
- /* set wakeup flag in the queue */
- queue->flag = RT_WQ_FLAG_WAKEUP;
-
- if (!(rt_list_isempty(queue_list)))
- {
- for (node = queue_list->next; node != queue_list; 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_thread_self();
- rt_timer_t tmr = &(tid->thread_timer);
- struct rt_wqueue_node __wait;
- rt_base_t level;
-
- /* current context checking */
- RT_DEBUG_NOT_IN_INTERRUPT;
-
- 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);
-
- level = rt_hw_interrupt_disable();
- if (queue->flag == RT_WQ_FLAG_WAKEUP)
- {
- /* already wakeup */
- goto __exit_wakeup;
- }
-
- rt_wqueue_add(queue, &__wait);
- 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_hw_interrupt_enable(level);
-
- rt_schedule();
-
- level = rt_hw_interrupt_disable();
-
-__exit_wakeup:
- queue->flag = 0;
- rt_hw_interrupt_enable(level);
-
- rt_wqueue_remove(&__wait);
-
- return 0;
-}
diff --git a/components/drivers/src/workqueue.c b/components/drivers/src/workqueue.c
deleted file mode 100644
index 2b5630d8d0..0000000000
--- a/components/drivers/src/workqueue.c
+++ /dev/null
@@ -1,429 +0,0 @@
-/*
- * Copyright (c) 2006-2018, RT-Thread Development Team
- *
- * SPDX-License-Identifier: Apache-2.0
- *
- * Change Logs:
- * Date Author Notes
- * 2017-02-27 bernard fix the re-work issue.
- */
-
-#include <rthw.h>
-#include <rtthread.h>
-#include <rtdevice.h>
-
-#ifdef RT_USING_HEAP
-
-static void _delayed_work_timeout_handler(void *parameter);
-
-rt_inline rt_err_t _workqueue_work_completion(struct rt_workqueue *queue)
-{
- rt_err_t result;
-
- rt_enter_critical();
- while (1)
- {
- /* try to take condition semaphore */
- result = rt_sem_trytake(&(queue->sem));
- if (result == -RT_ETIMEOUT)
- {
- /* it's timeout, release this semaphore */
- rt_sem_release(&(queue->sem));
- }
- else if (result == RT_EOK)
- {
- /* keep the sem value = 0 */
- result = RT_EOK;
- break;
- }
- else
- {
- result = -RT_ERROR;
- break;
- }
- }
- rt_exit_critical();
-
- return result;
-}
-
-static void _workqueue_thread_entry(void *parameter)
-{
- rt_base_t level;
- struct rt_work *work;
- struct rt_workqueue *queue;
-
- queue = (struct rt_workqueue *) parameter;
- RT_ASSERT(queue != RT_NULL);
-
- while (1)
- {
- if (rt_list_isempty(&(queue->work_list)))
- {
- /* no software timer exist, suspend self. */
- rt_thread_suspend(rt_thread_self());
- rt_schedule();
- }
-
- /* we have work to do with. */
- level = rt_hw_interrupt_disable();
- work = rt_list_entry(queue->work_list.next, struct rt_work, list);
- rt_list_remove(&(work->list));
- queue->work_current = work;
- work->flags &= ~RT_WORK_STATE_PENDING;
- work->workqueue = RT_NULL;
- rt_hw_interrupt_enable(level);
-
- /* do work */
- work->work_func(work, work->work_data);
- level = rt_hw_interrupt_disable();
- /* clean current work */
- queue->work_current = RT_NULL;
- rt_hw_interrupt_enable(level);
-
- /* ack work completion */
- _workqueue_work_completion(queue);
- }
-}
-
-static rt_err_t _workqueue_submit_work(struct rt_workqueue *queue, struct rt_work *work)
-{
- rt_base_t level;
-
- level = rt_hw_interrupt_disable();
- if (work->flags & RT_WORK_STATE_PENDING)
- {
- rt_hw_interrupt_enable(level);
- return -RT_EBUSY;
- }
-
- if (queue->work_current == work)
- {
- rt_hw_interrupt_enable(level);
- return -RT_EBUSY;
- }
-
- /* NOTE: the work MUST be initialized firstly */
- rt_list_remove(&(work->list));
-
- rt_list_insert_after(queue->work_list.prev, &(work->list));
- work->flags |= RT_WORK_STATE_PENDING;
-
- /* whether the workqueue is doing work */
- if (queue->work_current == RT_NULL)
- {
- rt_hw_interrupt_enable(level);
- /* resume work thread */
- rt_thread_resume(queue->work_thread);
- rt_schedule();
- }
- else
- {
- rt_hw_interrupt_enable(level);
- }
-
- return RT_EOK;
-}
-
-static rt_err_t _workqueue_cancel_work(struct rt_workqueue *queue, struct rt_work *work)
-{
- rt_base_t level;
-
- level = rt_hw_interrupt_disable();
- if (queue->work_current == work)
- {
- rt_hw_interrupt_enable(level);
- return -RT_EBUSY;
- }
- rt_list_remove(&(work->list));
- work->flags &= ~RT_WORK_STATE_PENDING;
- rt_hw_interrupt_enable(level);
-
- return RT_EOK;
-}
-
-static rt_err_t _workqueue_cancel_delayed_work(struct rt_work *work)
-{
- rt_base_t level;
- int ret = RT_EOK;
-
- if (!work->workqueue)
- {
- ret = -EINVAL;
- goto __exit;
- }
-
- if (work->flags & RT_WORK_STATE_PENDING)
- {
- /* Remove from the queue if already submitted */
- ret = _workqueue_cancel_work(work->workqueue, work);
- if (ret)
- {
- goto __exit;
- }
- }
- else
- {
- if (work->flags & RT_WORK_STATE_SUBMITTING)
- {
- level = rt_hw_interrupt_disable();
- rt_timer_stop(&(work->timer));
- rt_timer_detach(&(work->timer));
- work->flags &= ~RT_WORK_STATE_SUBMITTING;
- rt_hw_interrupt_enable(level);
- }
- }
-
- level = rt_hw_interrupt_disable();
- /* Detach from workqueue */
- work->workqueue = RT_NULL;
- work->flags &= ~(RT_WORK_STATE_PENDING);
- rt_hw_interrupt_enable(level);
-
-__exit:
- return ret;
-}
-
-static rt_err_t _workqueue_submit_delayed_work(struct rt_workqueue *queue,
- struct rt_work *work, rt_tick_t ticks)
-{
- rt_base_t level;
- rt_err_t ret = RT_EOK;
-
- /* Work cannot be active in multiple queues */
- if (work->workqueue && work->workqueue != queue)
- {
- ret = -RT_EINVAL;
- goto __exit;
- }
-
- /* Cancel if work has been submitted */
- if (work->workqueue == queue)
- {
- ret = _workqueue_cancel_delayed_work(work);
- if (ret < 0)
- {
- goto __exit;
- }
- }
-
- level = rt_hw_interrupt_disable();
- /* Attach workqueue so the timeout callback can submit it */
- work->workqueue = queue;
- rt_hw_interrupt_enable(level);
-
- if (!ticks)
- {
- /* Submit work if no ticks is 0 */
- ret = _workqueue_submit_work(work->workqueue, work);
- }
- else
- {
- level = rt_hw_interrupt_disable();
- /* Add timeout */
- work->flags |= RT_WORK_STATE_SUBMITTING;
- rt_timer_init(&(work->timer), "work", _delayed_work_timeout_handler, work, ticks,
- RT_TIMER_FLAG_ONE_SHOT | RT_TIMER_FLAG_SOFT_TIMER);
- rt_hw_interrupt_enable(level);
- rt_timer_start(&(work->timer));
- }
-
-__exit:
- return ret;
-}
-
-static void _delayed_work_timeout_handler(void *parameter)
-{
- struct rt_work *delayed_work;
- rt_base_t level;
-
- delayed_work = (struct rt_work *)parameter;
- level = rt_hw_interrupt_disable();
- rt_timer_stop(&(delayed_work->timer));
- rt_timer_detach(&(delayed_work->timer));
- delayed_work->flags &= ~RT_WORK_STATE_SUBMITTING;
- delayed_work->type &= ~RT_WORK_TYPE_DELAYED;
- rt_hw_interrupt_enable(level);
- _workqueue_submit_work(delayed_work->workqueue, delayed_work);
-}
-
-struct rt_workqueue *rt_workqueue_create(const char *name, rt_uint16_t stack_size, rt_uint8_t priority)
-{
- struct rt_workqueue *queue = RT_NULL;
-
- queue = (struct rt_workqueue *)RT_KERNEL_MALLOC(sizeof(struct rt_workqueue));
- if (queue != RT_NULL)
- {
- /* initialize work list */
- rt_list_init(&(queue->work_list));
- queue->work_current = RT_NULL;
- rt_sem_init(&(queue->sem), "wqueue", 0, RT_IPC_FLAG_FIFO);
-
- /* create the work thread */
- queue->work_thread = rt_thread_create(name, _workqueue_thread_entry, queue, stack_size, priority, 10);
- if (queue->work_thread == RT_NULL)
- {
- RT_KERNEL_FREE(queue);
- return RT_NULL;
- }
-
- rt_thread_startup(queue->work_thread);
- }
-
- return queue;
-}
-
-rt_err_t rt_workqueue_destroy(struct rt_workqueue *queue)
-{
- RT_ASSERT(queue != RT_NULL);
-
- rt_thread_delete(queue->work_thread);
- RT_KERNEL_FREE(queue);
-
- return RT_EOK;
-}
-
-rt_err_t rt_workqueue_dowork(struct rt_workqueue *queue, struct rt_work *work)
-{
- RT_ASSERT(queue != RT_NULL);
- RT_ASSERT(work != RT_NULL);
-
- return _workqueue_submit_work(queue, work);
-}
-
-rt_err_t rt_workqueue_submit_work(struct rt_workqueue *queue, struct rt_work *work, rt_tick_t time)
-{
- RT_ASSERT(queue != RT_NULL);
- RT_ASSERT(work != RT_NULL);
-
- if (time > 0)
- {
- work->type |= RT_WORK_TYPE_DELAYED;
- }
-
- if (work->type & RT_WORK_TYPE_DELAYED)
- {
- return _workqueue_submit_delayed_work(queue, work, time);
- }
- else
- {
- return _workqueue_submit_work(queue, work);
- }
-}
-
-rt_err_t rt_workqueue_critical_work(struct rt_workqueue *queue, struct rt_work *work)
-{
- rt_base_t level;
- RT_ASSERT(queue != RT_NULL);
- RT_ASSERT(work != RT_NULL);
-
- level = rt_hw_interrupt_disable();
- if (queue->work_current == work)
- {
- rt_hw_interrupt_enable(level);
- return -RT_EBUSY;
- }
-
- /* NOTE: the work MUST be initialized firstly */
- rt_list_remove(&(work->list));
-
- rt_list_insert_after(queue->work_list.prev, &(work->list));
- if (queue->work_current == RT_NULL)
- {
- rt_hw_interrupt_enable(level);
- /* resume work thread */
- rt_thread_resume(queue->work_thread);
- rt_schedule();
- }
- else rt_hw_interrupt_enable(level);
-
- return RT_EOK;
-}
-
-rt_err_t rt_workqueue_cancel_work(struct rt_workqueue *queue, struct rt_work *work)
-{
- RT_ASSERT(queue != RT_NULL);
- RT_ASSERT(work != RT_NULL);
-
- if (work->type & RT_WORK_TYPE_DELAYED)
- {
- return _workqueue_cancel_delayed_work(work);
- }
- else
- {
- return _workqueue_cancel_work(queue, work);
- }
-}
-
-rt_err_t rt_workqueue_cancel_work_sync(struct rt_workqueue *queue, struct rt_work *work)
-{
- rt_base_t level;
-
- RT_ASSERT(queue != RT_NULL);
- RT_ASSERT(work != RT_NULL);
-
- level = rt_hw_interrupt_disable();
- if (queue->work_current == work) /* it's current work in the queue */
- {
- /* wait for work completion */
- rt_sem_take(&(queue->sem), RT_WAITING_FOREVER);
- }
- else
- {
- rt_list_remove(&(work->list));
- }
- work->flags &= ~RT_WORK_STATE_PENDING;
- rt_hw_interrupt_enable(level);
-
- return RT_EOK;
-}
-
-rt_err_t rt_workqueue_cancel_all_work(struct rt_workqueue *queue)
-{
- struct rt_list_node *node, *next;
- RT_ASSERT(queue != RT_NULL);
-
- rt_enter_critical();
- for (node = queue->work_list.next; node != &(queue->work_list); node = next)
- {
- next = node->next;
- rt_list_remove(node);
- }
- rt_exit_critical();
-
- return RT_EOK;
-}
-
-void rt_delayed_work_init(struct rt_delayed_work *work, void (*work_func)(struct rt_work *work,
- void *work_data), void *work_data)
-{
- rt_work_init(&work->work, work_func, work_data);
-}
-
-#ifdef RT_USING_SYSTEM_WORKQUEUE
-static struct rt_workqueue *sys_workq;
-
-rt_err_t rt_work_submit(struct rt_work *work, rt_tick_t time)
-{
- return rt_workqueue_submit_work(sys_workq, work, time);
-}
-
-rt_err_t rt_work_cancel(struct rt_work *work)
-{
- return rt_workqueue_cancel_work(sys_workq, work);
-}
-
-int rt_work_sys_workqueue_init(void)
-{
- if (sys_workq != RT_NULL)
- return 0;
-
- sys_workq = rt_workqueue_create("sys_work", RT_SYSTEM_WORKQUEUE_STACKSIZE,
- RT_SYSTEM_WORKQUEUE_PRIORITY);
-
- return RT_EOK;
-}
-
-INIT_PREV_EXPORT(rt_work_sys_workqueue_init);
-#endif
-#endif