summaryrefslogtreecommitdiff
path: root/components/drivers/include/ipc
diff options
context:
space:
mode:
Diffstat (limited to 'components/drivers/include/ipc')
-rw-r--r--components/drivers/include/ipc/completion.h23
-rw-r--r--components/drivers/include/ipc/dataqueue.h53
-rw-r--r--components/drivers/include/ipc/pipe.h36
-rw-r--r--components/drivers/include/ipc/poll.h53
-rw-r--r--components/drivers/include/ipc/ringbuffer.h88
-rw-r--r--components/drivers/include/ipc/waitqueue.h39
-rw-r--r--components/drivers/include/ipc/workqueue.h41
7 files changed, 333 insertions, 0 deletions
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
+
generated by cgit v1.3.1 (git 2.54.0) at 2026-10-30 18:55:22 +0000