drivers: video: emul_imager: use the shared imager implementation

Make the emulated imager use the shared implementation of all imagers,
making shared implementation of the image sensor drivers be tested by CI.

Signed-off-by: Josuah Demangeon <[email protected]>

Author: josuah

drivers/video/video_emul_imager.c

@@ -46,27 +46,9 @@ enum emul_imager_fmt_id {
 	YUYV_320x240,
 };
 
-struct emul_imager_mode {
-	uint8_t fps;
-	/* List of registers lists to configure the various properties of the sensor.
-	 * This permits to deduplicate the list of registers in case some lare sections
-	 * are repeated across modes, such as the resolution for different FPS.
-	 */
-	const struct video_reg *regs[3];
-	/* More fields can be added according to the needs of the sensor driver */
-};
-
-struct emul_imager_config {
-	struct i2c_dt_spec i2c;
-};
-
 struct emul_imager_data {
 	/* First field is a line buffer for I/O emulation purpose */
 	uint8_t framebuffer[320 * sizeof(uint16_t)];
-	/* Other fields are shared with real hardware drivers */
-	const struct emul_imager_mode *mode;
-	enum emul_imager_fmt_id fmt_id;
-	struct video_format fmt;
 };
 
 /* All the I2C registers sent on various scenario */
@@ -108,47 +90,31 @@ static const struct video_reg emul_imager_60fps[] = {
 };
 
 /* Description of "modes", that pick lists of registesr that will be all sentto the imager */
-struct emul_imager_mode emul_imager_rgb565_320x240_modes[] = {
+static struct video_imager_mode emul_imager_rgb565_320x240_modes[] = {
 	{.fps = 15, .regs = {emul_imager_320x240, emul_imager_rgb565, emul_imager_15fps}},
 	{.fps = 30, .regs = {emul_imager_320x240, emul_imager_rgb565, emul_imager_30fps}},
 	{.fps = 60, .regs = {emul_imager_320x240, emul_imager_rgb565, emul_imager_60fps}},
 	{0},
 };
-struct emul_imager_mode emul_imager_yuyv_320x240_modes[] = {
+static struct video_imager_mode emul_imager_yuyv_320x240_modes[] = {
 	{.fps = 15, .regs = {emul_imager_320x240, emul_imager_yuyv, emul_imager_15fps}},
 	{.fps = 30, .regs = {emul_imager_320x240, emul_imager_yuyv, emul_imager_30fps}},
 	{0},
 };
 
-/* Summary of all the modes of all the frame formats, with indexes matching those of fmts[]. */
-static const struct emul_imager_mode *emul_imager_modes[] = {
+static const struct video_imager_mode *emul_imager_modes[] = {
 	[RGB565_320x240] = emul_imager_rgb565_320x240_modes,
 	[YUYV_320x240] = emul_imager_yuyv_320x240_modes,
 };
-
-/* Video device capabilities where the supported resolutions and pixel formats are listed.
- * The format ID is used as index to fetch the matching mode from the list above.
- */
-#define EMUL_IMAGER_VIDEO_FORMAT_CAP(format, width, height)                                        \
-	{                                                                                          \
-		/* For a real imager, the width and height would be macro parameters */            \
-		.pixelformat = (format),                                                           \
-		.width_min = (width),                                                              \
-		.width_max = (width),                                                              \
-		.width_step = 0,                                                                   \
-		.height_min = (height),                                                            \
-		.height_max = (height),                                                            \
-		.height_step = 0,                                                                  \
-	}
-static const struct video_format_cap fmts[] = {
-	[RGB565_320x240] = EMUL_IMAGER_VIDEO_FORMAT_CAP(VIDEO_PIX_FMT_RGB565, 320, 240),
-	[YUYV_320x240] = EMUL_IMAGER_VIDEO_FORMAT_CAP(VIDEO_PIX_FMT_YUYV, 320, 240),
+static const struct video_format_cap emul_imager_fmts[] = {
+	[RGB565_320x240] = VIDEO_IMAGER_FORMAT_CAP(VIDEO_PIX_FMT_RGB565, 320, 240),
+	[YUYV_320x240] = VIDEO_IMAGER_FORMAT_CAP(VIDEO_PIX_FMT_YUYV, 320, 240),
 	{0},
 };
 
 static int emul_imager_set_ctrl(const struct device *dev, unsigned int cid, void *value)
 {
-	const struct emul_imager_config *cfg = dev->config;
+	const struct video_imager_config *cfg = dev->config;
 
 	switch (cid) {
 	case EMUL_IMAGER_CID_CUSTOM:
@@ -160,7 +126,7 @@ static int emul_imager_set_ctrl(const struct device *dev, unsigned int cid, void
 
 static int emul_imager_get_ctrl(const struct device *dev, unsigned int cid, void *value)
 {
-	const struct emul_imager_config *cfg = dev->config;
+	const struct video_imager_config *cfg = dev->config;
 	uint32_t reg = 0;
 	int ret;
 
@@ -176,178 +142,30 @@ static int emul_imager_get_ctrl(const struct device *dev, unsigned int cid, void
 	return ret;
 }
 
-/* Customize this function according to your "struct emul_imager_mode". */
-static int emul_imager_set_mode(const struct device *dev, const struct emul_imager_mode *mode)
-{
-	const struct emul_imager_config *cfg = dev->config;
-	struct emul_imager_data *data = dev->data;
-	int ret;
-
-	if (data->mode == mode) {
-		return 0;
-	}
-
-	LOG_DBG("Applying mode %p at %d FPS", mode, mode->fps);
-
-	/* Apply all the configuration registers for that mode */
-	for (int i = 0; i < 2; i++) {
-		ret = video_write_cci_multi(&cfg->i2c, mode->regs[i]);
-		if (ret < 0) {
-			goto err;
-		}
-	}
-
-	data->mode = mode;
-	return 0;
-err:
-	LOG_ERR("Could not apply mode %p (%u FPS)", mode, mode->fps);
-	return ret;
-}
-
-static int emul_imager_set_frmival(const struct device *dev, enum video_endpoint_id ep,
-				   struct video_frmival *frmival)
-{
-	struct emul_imager_data *data = dev->data;
-	struct video_frmival_enum fie = {.format = &data->fmt, .discrete = *frmival};
-
-	if (ep != VIDEO_EP_OUT && ep != VIDEO_EP_ALL) {
-		return -EINVAL;
-	}
-
-	video_closest_frmival(dev, ep, &fie);
-	LOG_DBG("Applying frame interval number %u", fie.index);
-	return emul_imager_set_mode(dev, &emul_imager_modes[data->fmt_id][fie.index]);
-}
-
-static int emul_imager_get_frmival(const struct device *dev, enum video_endpoint_id ep,
-				   struct video_frmival *frmival)
-{
-	struct emul_imager_data *data = dev->data;
-
-	if (ep != VIDEO_EP_OUT && ep != VIDEO_EP_ALL) {
-		return -EINVAL;
-	}
-
-	frmival->numerator = 1;
-	frmival->denominator = data->mode->fps;
-	return 0;
-}
-
-static int emul_imager_enum_frmival(const struct device *dev, enum video_endpoint_id ep,
-				    struct video_frmival_enum *fie)
-{
-	const struct emul_imager_mode *mode;
-	size_t fmt_id;
-	int ret;
-
-	if (ep != VIDEO_EP_OUT && ep != VIDEO_EP_ALL) {
-		return -EINVAL;
-	}
-
-	ret = video_format_caps_index(fmts, fie->format, &fmt_id);
-	if (ret < 0) {
-		return ret;
-	}
-
-	mode = &emul_imager_modes[fmt_id][fie->index];
-
-	fie->type = VIDEO_FRMIVAL_TYPE_DISCRETE;
-	fie->discrete.numerator = 1;
-	fie->discrete.denominator = mode->fps;
-	fie->index++;
-
-	return mode->fps == 0;
-}
-
-static int emul_imager_set_fmt(const struct device *const dev, enum video_endpoint_id ep,
-			       struct video_format *fmt)
-{
-	struct emul_imager_data *data = dev->data;
-	size_t fmt_id;
-	int ret;
-
-	if (ep != VIDEO_EP_OUT && ep != VIDEO_EP_ALL) {
-		return -EINVAL;
-	}
-
-	if (memcmp(&data->fmt, fmt, sizeof(data->fmt)) == 0) {
-		return 0;
-	}
-
-	ret = video_format_caps_index(fmts, fmt, &fmt_id);
-	if (ret < 0) {
-		LOG_ERR("Format %x %ux%u not found", fmt->pixelformat, fmt->width, fmt->height);
-		return ret;
-	}
-
-	ret = emul_imager_set_mode(dev, &emul_imager_modes[fmt_id][0]);
-	if (ret < 0) {
-		return ret;
-	}
-
-	/* For the purpose of simulation, fill the image line buffer with 50% gray, this data
-	 * will be collected by the video_emul_rx driver.
-	 */
-	if (fmt->pixelformat == VIDEO_PIX_FMT_RGB565) {
-		for (int i = 0; i < fmt->width; i++) {
-			((uint16_t *)data->framebuffer)[i] = sys_cpu_to_le16(0x7bef);
-		}
-	} else {
-		memset(data->framebuffer, 0x7f, fmt->pitch);
-	}
-
-	data->fmt_id = fmt_id;
-	data->fmt = *fmt;
-	return 0;
-}
-
-static int emul_imager_get_fmt(const struct device *dev, enum video_endpoint_id ep,
-			       struct video_format *fmt)
-{
-	struct emul_imager_data *data = dev->data;
-
-	if (ep != VIDEO_EP_OUT && ep != VIDEO_EP_ALL) {
-		return -EINVAL;
-	}
-
-	*fmt = data->fmt;
-	return 0;
-}
-
-static int emul_imager_get_caps(const struct device *dev, enum video_endpoint_id ep,
-				struct video_caps *caps)
-{
-	if (ep != VIDEO_EP_OUT && ep != VIDEO_EP_ALL) {
-		return -EINVAL;
-	}
-
-	caps->format_caps = fmts;
-	return 0;
-}
-
 static int emul_imager_set_stream(const struct device *dev, bool enable)
 {
-	const struct emul_imager_config *cfg = dev->config;
+	const struct video_imager_config *cfg = dev->config;
 
 	return video_write_cci_reg(&cfg->i2c, EMUL_IMAGER_REG_CTRL, enable ? 1 : 0);
 }
 
 static DEVICE_API(video, emul_imager_driver_api) = {
+	/* Local implementation */
 	.set_ctrl = emul_imager_set_ctrl,
 	.get_ctrl = emul_imager_get_ctrl,
-	.set_frmival = emul_imager_set_frmival,
-	.get_frmival = emul_imager_get_frmival,
-	.enum_frmival = emul_imager_enum_frmival,
-	.set_format = emul_imager_set_fmt,
-	.get_format = emul_imager_get_fmt,
-	.get_caps = emul_imager_get_caps,
 	.set_stream = emul_imager_set_stream,
+	/* Default implementation */
+	.set_frmival = video_imager_set_frmival,
+	.get_frmival = video_imager_get_frmival,
+	.enum_frmival = video_imager_enum_frmival,
+	.set_format = video_imager_set_fmt,
+	.get_format = video_imager_get_fmt,
+	.get_caps = video_imager_get_caps,
 };
 
 int emul_imager_init(const struct device *dev)
 {
-	const struct emul_imager_config *cfg = dev->config;
-	struct video_format fmt;
+	const struct video_imager_config *cfg = dev->config;
 	uint32_t sensor_id;
 	int ret;
 
@@ -362,35 +180,24 @@ int emul_imager_init(const struct device *dev)
 		return ret;
 	}
 
-	ret = video_write_cci_multi(&cfg->i2c, emul_imager_init_regs);
-	if (ret < 0) {
-		LOG_ERR("Could not set initial registers");
-		return ret;
-	}
-
-	fmt.pixelformat = fmts[0].pixelformat;
-	fmt.width = fmts[0].width_min;
-	fmt.height = fmts[0].height_min;
-	fmt.pitch = fmt.width * 2;
-
-	ret = emul_imager_set_fmt(dev, VIDEO_EP_OUT, &fmt);
-	if (ret < 0) {
-		LOG_ERR("Failed to set to default format %x %ux%u",
-			fmt.pixelformat, fmt.width, fmt.height);
-	}
-
-	return 0;
+	return video_imager_init(dev, emul_imager_init_regs, 0);
 }
 
 #define EMUL_IMAGER_DEFINE(inst)                                                                   \
 	static struct emul_imager_data emul_imager_data_##inst;                                    \
                                                                                                    \
-	static const struct emul_imager_config emul_imager_cfg_##inst = {                          \
+	static struct video_imager_data video_imager_data_##inst;                                  \
+                                                                                                   \
+	static const struct video_imager_config video_imager_cfg_##inst = {                        \
 		.i2c = I2C_DT_SPEC_INST_GET(inst),                                                 \
+		.modes = emul_imager_modes,                                                        \
+		.fmts = emul_imager_fmts,                                                          \
+		.data = &video_imager_data_##inst,                                                 \
+		.write_multi = video_write_cci_multi,                                              \
 	};                                                                                         \
                                                                                                    \
 	DEVICE_DT_INST_DEFINE(inst, &emul_imager_init, NULL, &emul_imager_data_##inst,             \
-			      &emul_imager_cfg_##inst, POST_KERNEL, CONFIG_VIDEO_INIT_PRIORITY,    \
+			      &video_imager_cfg_##inst, POST_KERNEL, CONFIG_VIDEO_INIT_PRIORITY,   \
 			      &emul_imager_driver_api);
 
 DT_INST_FOREACH_STATUS_OKAY(EMUL_IMAGER_DEFINE)