[WIP]drivers: video: Implement buffer management with RTIO backend

- Application side nearly unchanged, except a call to video_release_buf()
  after finishing with the full buffer to queue it back to sqe. RTIO is
  opaque to application.
- Driver just needs to hold an io_q and deal a bit with the buffer from
  sqe in isr. No need to implement rtio_iodev_api's submit()
- The video subsystem does everything needed for buffer management.

Signed-off-by: Phi Bang Nguyen <[email protected]>
Co-developed-by: Josuah Demangeon <[email protected]>

Author: ngphibang

drivers/video/Kconfig

@@ -8,6 +8,7 @@
 #
 menuconfig VIDEO
 	bool "Video drivers"
+	imply RTIO
 	help
 	  Enable support for the VIDEO.
 

drivers/video/video_common.c

@@ -13,10 +13,12 @@
 #include <zephyr/drivers/video-controls.h>
 #include <zephyr/kernel.h>
 #include <zephyr/logging/log.h>
+#include <zephyr/rtio/rtio.h>
 #include <zephyr/sys/byteorder.h>
 #include <zephyr/sys/util.h>
 
 #include "video_common.h"
+#include "video_device.h"
 
 LOG_MODULE_REGISTER(video_common, CONFIG_VIDEO_LOG_LEVEL);
 
@@ -125,24 +127,73 @@ int video_request_buffers(uint8_t count, size_t size, enum video_buf_type type)
 	return 0;
 }
 
+RTIO_DEFINE(rtio, CONFIG_VIDEO_BUFFER_POOL_NUM_MAX, CONFIG_VIDEO_BUFFER_POOL_NUM_MAX);
+
 int video_enqueue(const struct device *dev, uint8_t index)
 {
-	const struct video_driver_api *api = (const struct video_driver_api *)dev->api;
-
 	__ASSERT_NO_MSG(dev != NULL);
 
-	api = (const struct video_driver_api *)dev->api;
-	if (api->enqueue == NULL) {
-		return -ENOSYS;
-	}
-
 	if (video_buf[index].state != VIDEO_BUF_STATE_DONE) {
 		return -EINVAL;
 	}
 
 	video_buf[index].state = VIDEO_BUF_STATE_QUEUED;
 
-	return api->enqueue(dev, &video_buf[index]);
+	/* RTIO submission */
+	struct rtio_iodev *ri = video_find_iodev(dev);
+	struct rtio_sqe *sqe = rtio_sqe_acquire(&rtio);
+
+	__ASSERT_NO_MSG(ri != NULL);
+	__ASSERT_NO_MSG(sqe != NULL);
+
+	rtio_sqe_prep_read(sqe, ri, RTIO_PRIO_NORM, video_buf[index].buffer,
+			   video_buf[index].size, &video_buf[index]);
+
+	sqe->flags |= RTIO_SQE_MULTISHOT;
+
+	/* Do not wait for complete */
+	rtio_submit(&rtio, 0);
+
+	return 0;
+}
+
+int video_dequeue(struct video_buffer **buf)
+{
+	struct rtio_cqe *cqe = rtio_cqe_consume_block(&rtio);
+	*buf = cqe->userdata;
+
+	if (cqe->result < 0) {
+		LOG_ERR("I/O operation failed");
+		return cqe->result;
+	}
+
+	return 0;
+}
+
+void video_release_buf()
+{
+	/* Buffer will be re-queued thanks to RTIO_SQE_MULTISHOT */
+	rtio_cqe_release(&rtio, rtio_cqe_consume_block(&rtio));
+}
+
+struct video_buffer *video_get_buf_sqe(struct mpsc *io_q)
+{
+	struct mpsc_node *node = mpsc_pop(io_q);
+	if (node == NULL) {
+		return NULL;
+	}
+
+	struct rtio_iodev_sqe *iodev_sqe = CONTAINER_OF(node, struct rtio_iodev_sqe, q);
+	struct rtio_sqe *sqe = &iodev_sqe->sqe;
+
+	if (sqe->op != RTIO_OP_RX) {
+		LOG_ERR("Invalid operation %d of length %u for submission %p", sqe->op,
+			sqe->rx.buf_len, (void *)iodev_sqe);
+		rtio_iodev_sqe_err(iodev_sqe, -EINVAL);
+		return NULL;
+	}
+
+	return sqe->userdata;
 }
 
 int video_format_caps_index(const struct video_format_cap *fmts, const struct video_format *fmt,

drivers/video/video_device.c

@@ -4,6 +4,8 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+#include <zephyr/rtio/rtio.h>
+
 #include "video_device.h"
 
 struct video_device *video_find_vdev(const struct device *dev)
@@ -20,3 +22,32 @@ struct video_device *video_find_vdev(const struct device *dev)
 
 	return NULL;
 }
+
+struct rtio_iodev *video_find_iodev(const struct device *dev)
+{
+	struct video_interface *vi;
+
+	if (!dev) {
+		return NULL;
+	}
+
+	STRUCT_SECTION_FOREACH(rtio_iodev, ri) {
+		vi = ri->data;
+		if (vi->dev == dev) {
+			return ri;
+		}
+	}
+
+	return NULL;
+}
+
+static void video_iodev_submit(struct rtio_iodev_sqe *iodev_sqe)
+{
+	struct video_interface *vi = iodev_sqe->sqe.iodev->data;
+
+	mpsc_push(vi->io_q, &iodev_sqe->q);
+}
+
+const struct rtio_iodev_api _video_iodev_api = {
+	.submit = video_iodev_submit,
+};

drivers/video/video_device.h

@@ -8,6 +8,7 @@
 #define ZEPHYR_INCLUDE_DRIVERS_VIDEO_VIDEO_DEVICE_H_
 
 #include <zephyr/device.h>
+#include <zephyr/rtio/rtio.h>
 #include <zephyr/sys/dlist.h>
 
 struct video_device {
@@ -18,20 +19,28 @@ struct video_device {
 
 struct video_interface {
 	const struct device *dev;
+	struct mpsc *io_q;
 };
 
+extern const struct rtio_iodev_api _video_iodev_api;
+
 #define VIDEO_DEVICE_DEFINE(name, device, source)                                                  \
 	static STRUCT_SECTION_ITERABLE(video_device, name) = {                                     \
 		.dev = device,                                                                     \
 		.src_dev = source,                                                                 \
 		.ctrls = SYS_DLIST_STATIC_INIT(&name.ctrls),                                       \
 	}
 
-#define VIDEO_INTERFACE_DEFINE(name, device)                                                            \
-	static STRUCT_SECTION_ITERABLE(video_interface, name) = {                                \
+#define VIDEO_INTERFACE_DEFINE(name, device, io_queue)                                             \
+	static STRUCT_SECTION_ITERABLE(video_interface, name) = {                                  \
 		.dev = device,                                                                     \
-	}
+		.io_q = io_queue,                                                                  \
+	};                                                                                         \
+	RTIO_IODEV_DEFINE(name##_iodev, &_video_iodev_api, &name)
 
 struct video_device *video_find_vdev(const struct device *dev);
+struct rtio_iodev *video_find_iodev(const struct device *dev);
+
+struct video_buffer *video_get_buf_sqe(struct mpsc *io_q);
 
 #endif /* ZEPHYR_INCLUDE_DRIVERS_VIDEO_VIDEO_DEVICE_H_ */