video.h

Go to the documentation of this file.

/*
 * Copyright (c) 2019 Linaro Limited.
 * Copyright 2025 NXP
 * Copyright (c) 2025 STMicroelectronics
 * SPDX-FileCopyrightText: Copyright The Zephyr Project Contributors
 * SPDX-License-Identifier: Apache-2.0
 */

 
#ifndef ZEPHYR_INCLUDE_DRIVERS_VIDEO_H
#define ZEPHYR_INCLUDE_DRIVERS_VIDEO_H

 
#include <stddef.h>
#include <stdint.h>
 
#include <zephyr/device.h>
#include <zephyr/kernel.h>
#include <zephyr/sys/dlist.h>
#include <zephyr/types.h>
#include <zephyr/video/video.h>
 
#ifdef __cplusplus
extern "C" {
#endif

struct video_device {
        const struct device *dev;
        const struct device *src_dev;
        sys_dlist_t ctrls;
};

struct video_device *video_find_vdev(const struct device *dev);


#define VIDEO_CTRL_FLAG_READ_ONLY  BIT(0)
#define VIDEO_CTRL_FLAG_WRITE_ONLY BIT(1)
#define VIDEO_CTRL_FLAG_VOLATILE   BIT(2)
#define VIDEO_CTRL_FLAG_INACTIVE   BIT(3)
#define VIDEO_CTRL_FLAG_UPDATE     BIT(4)

enum video_ctrl_type {
        VIDEO_CTRL_TYPE_BOOLEAN = 1,
        VIDEO_CTRL_TYPE_INTEGER = 2,
        VIDEO_CTRL_TYPE_INTEGER64 = 3,
        VIDEO_CTRL_TYPE_MENU = 4,
        VIDEO_CTRL_TYPE_STRING = 5,
        VIDEO_CTRL_TYPE_INTEGER_MENU = 6,
};

struct video_ctrl {
        struct video_ctrl *cluster;
        uint8_t cluster_sz;
        bool is_auto;
        bool has_volatiles;

        const struct video_device *vdev;
        uint32_t id;
        enum video_ctrl_type type;
        unsigned long flags;
        struct video_ctrl_range range;
        union {
                int32_t val;
                int64_t val64;
        };
        union {
                const char *const *menu;
                const int64_t *int_menu;
        };
        sys_dnode_t node;
};



typedef int (*video_api_format_t)(const struct device *dev, struct video_format *fmt);

typedef int (*video_api_frmival_t)(const struct device *dev, struct video_frmival *frmival);

typedef int (*video_api_enum_frmival_t)(const struct device *dev, struct video_frmival_enum *fie);

typedef int (*video_api_enqueue_t)(const struct device *dev, struct video_buffer *buf);

typedef int (*video_api_dequeue_t)(const struct device *dev, struct video_buffer **buf,
                                   k_timeout_t timeout);

typedef int (*video_api_flush_t)(const struct device *dev, bool cancel);

typedef int (*video_api_set_stream_t)(const struct device *dev, bool enable,
                                      enum video_buf_type type);

typedef int (*video_api_ctrl_t)(const struct device *dev, uint32_t cid);

typedef int (*video_api_get_caps_t)(const struct device *dev, struct video_caps *caps);

typedef int (*video_api_transform_cap_t)(const struct device *const dev,
                                         const struct video_format_cap *const cap,
                                         struct video_format_cap *const res_cap,
                                         enum video_buf_type type, uint16_t ind);

typedef int (*video_api_set_signal_t)(const struct device *dev, struct k_poll_signal *sig);

typedef int (*video_api_selection_t)(const struct device *dev, struct video_selection *sel);

__subsystem struct video_driver_api {
        video_api_format_t set_format;
        video_api_format_t get_format;
        video_api_set_stream_t set_stream;
        video_api_get_caps_t get_caps;
        video_api_enqueue_t enqueue;
        video_api_dequeue_t dequeue;
        video_api_flush_t flush;
        video_api_ctrl_t set_ctrl;
        video_api_ctrl_t get_volatile_ctrl;
        video_api_set_signal_t set_signal;
        video_api_frmival_t set_frmival;
        video_api_frmival_t get_frmival;
        video_api_enum_frmival_t enum_frmival;
        video_api_selection_t set_selection;
        video_api_selection_t get_selection;
        video_api_transform_cap_t transform_cap;
};


static inline int video_driver_set_format(const struct device *dev, struct video_format *fmt)
{
        const struct video_driver_api *api = DEVICE_API_GET(video, dev);
 
        if (api->set_format == NULL) {
                return -ENOSYS;
        }
 
        return api->set_format(dev, fmt);
}

static inline int video_driver_get_format(const struct device *dev, struct video_format *fmt)
{
        const struct video_driver_api *api = DEVICE_API_GET(video, dev);
 
        if (api->get_format == NULL) {
                return -ENOSYS;
        }
 
        return api->get_format(dev, fmt);
}

static inline int video_driver_set_frmival(const struct device *dev, struct video_frmival *frmival)
{
        const struct video_driver_api *api = DEVICE_API_GET(video, dev);
 
        if (api->set_frmival == NULL) {
                return -ENOSYS;
        }
 
        return api->set_frmival(dev, frmival);
}

static inline int video_driver_get_frmival(const struct device *dev, struct video_frmival *frmival)
{
        const struct video_driver_api *api = DEVICE_API_GET(video, dev);
 
        if (api->get_frmival == NULL) {
                return -ENOSYS;
        }
 
        return api->get_frmival(dev, frmival);
}

static inline int video_driver_enum_frmival(const struct device *dev,
                                            struct video_frmival_enum *fie)
{
        const struct video_driver_api *api = DEVICE_API_GET(video, dev);
 
        if (api->enum_frmival == NULL) {
                return -ENOSYS;
        }
 
        return api->enum_frmival(dev, fie);
}

static inline int video_driver_enqueue(const struct device *dev, struct video_buffer *vbuf)
{
        const struct video_driver_api *api = DEVICE_API_GET(video, dev);
 
        if (api->enqueue == NULL) {
                return -ENOSYS;
        }
 
        return api->enqueue(dev, vbuf);
}

static inline int video_driver_dequeue(const struct device *dev, struct video_buffer **vbuf,
                                       k_timeout_t timeout)
{
        const struct video_driver_api *api = DEVICE_API_GET(video, dev);
 
        if (api->dequeue == NULL) {
                return -ENOSYS;
        }
 
        return api->dequeue(dev, vbuf, timeout);
}

static inline int video_driver_flush(const struct device *dev, bool cancel)
{
        const struct video_driver_api *api = DEVICE_API_GET(video, dev);
 
        if (api->flush == NULL) {
                return -ENOSYS;
        }
 
        return api->flush(dev, cancel);
}

static inline int video_driver_set_stream(const struct device *dev, bool enable,
                                          enum video_buf_type type)
{
        const struct video_driver_api *api = DEVICE_API_GET(video, dev);
 
        if (api->set_stream == NULL) {
                return -ENOSYS;
        }
 
        return api->set_stream(dev, enable, type);
}

static inline int video_driver_get_volatile_ctrl(const struct device *dev, uint32_t cid)
{
        const struct video_driver_api *api = DEVICE_API_GET(video, dev);
 
        if (api->get_volatile_ctrl == NULL) {
                return -ENOSYS;
        }
 
        return api->get_volatile_ctrl(dev, cid);
}

static inline int video_driver_set_ctrl(const struct device *dev, uint32_t cid)
{
        const struct video_driver_api *api = DEVICE_API_GET(video, dev);
 
        if (api->set_ctrl == NULL) {
                return -ENOSYS;
        }
 
        return api->set_ctrl(dev, cid);
}

static inline int video_driver_get_caps(const struct device *dev, struct video_caps *caps)
{
        const struct video_driver_api *api = DEVICE_API_GET(video, dev);
 
        if (api->get_caps == NULL) {
                return -ENOSYS;
        }
 
        return api->get_caps(dev, caps);
}

static inline int video_driver_transform_cap(const struct device *const dev,
                                             const struct video_format_cap *const cap,
                                             struct video_format_cap *const res_cap,
                                             enum video_buf_type type, uint16_t ind)
{
        const struct video_driver_api *api = DEVICE_API_GET(video, dev);
 
        if (api->transform_cap == NULL) {
                return -ENOSYS;
        }
 
        return api->transform_cap(dev, cap, res_cap, type, ind);
}

static inline int video_driver_set_signal(const struct device *dev, struct k_poll_signal *sig)
{
        const struct video_driver_api *api = DEVICE_API_GET(video, dev);
 
        if (api->set_signal == NULL) {
                return -ENOSYS;
        }
 
        return api->set_signal(dev, sig);
}

static inline int video_driver_set_selection(const struct device *dev, struct video_selection *sel)
{
        const struct video_driver_api *api = DEVICE_API_GET(video, dev);
 
        if (api->set_selection == NULL) {
                return -ENOSYS;
        }
 
        return api->set_selection(dev, sel);
}

static inline int video_driver_get_selection(const struct device *dev, struct video_selection *sel)
{
        const struct video_driver_api *api = DEVICE_API_GET(video, dev);
 
        if (api->get_selection == NULL) {
                return -ENOSYS;
        }
 
        return api->get_selection(dev, sel);
}


#define VIDEO_MIPI_CSI2_DT_NULL                 0x10
#define VIDEO_MIPI_CSI2_DT_BLANKING             0x11
#define VIDEO_MIPI_CSI2_DT_EMBEDDED_8           0x12
#define VIDEO_MIPI_CSI2_DT_YUV420_8             0x18
#define VIDEO_MIPI_CSI2_DT_YUV420_10            0x19
#define VIDEO_MIPI_CSI2_DT_YUV420_CSPS_8        0x1c
#define VIDEO_MIPI_CSI2_DT_YUV420_CSPS_10       0x1d
#define VIDEO_MIPI_CSI2_DT_YUV422_8             0x1e
#define VIDEO_MIPI_CSI2_DT_YUV422_10            0x1f
#define VIDEO_MIPI_CSI2_DT_RGB444               0x20
#define VIDEO_MIPI_CSI2_DT_RGB555               0x21
#define VIDEO_MIPI_CSI2_DT_RGB565               0x22
#define VIDEO_MIPI_CSI2_DT_RGB666               0x23
#define VIDEO_MIPI_CSI2_DT_RGB888               0x24
#define VIDEO_MIPI_CSI2_DT_RAW6                 0x28
#define VIDEO_MIPI_CSI2_DT_RAW7                 0x29
#define VIDEO_MIPI_CSI2_DT_RAW8                 0x2a
#define VIDEO_MIPI_CSI2_DT_RAW10                0x2b
#define VIDEO_MIPI_CSI2_DT_RAW12                0x2c
#define VIDEO_MIPI_CSI2_DT_RAW14                0x2d

static inline uint8_t video_mipi_data_type(uint32_t pixfmt)
{
        switch (pixfmt) {
        case VIDEO_PIX_FMT_GREY:
        case VIDEO_PIX_FMT_SBGGR8:
        case VIDEO_PIX_FMT_SGBRG8:
        case VIDEO_PIX_FMT_SGRBG8:
        case VIDEO_PIX_FMT_SRGGB8:
                return VIDEO_MIPI_CSI2_DT_RAW8;
        case VIDEO_PIX_FMT_Y10P:
        case VIDEO_PIX_FMT_SBGGR10P:
        case VIDEO_PIX_FMT_SGBRG10P:
        case VIDEO_PIX_FMT_SGRBG10P:
        case VIDEO_PIX_FMT_SRGGB10P:
                return VIDEO_MIPI_CSI2_DT_RAW10;
        case VIDEO_PIX_FMT_Y12P:
        case VIDEO_PIX_FMT_SBGGR12P:
        case VIDEO_PIX_FMT_SGBRG12P:
        case VIDEO_PIX_FMT_SGRBG12P:
        case VIDEO_PIX_FMT_SRGGB12P:
                return VIDEO_MIPI_CSI2_DT_RAW12;
        case VIDEO_PIX_FMT_Y14P:
        case VIDEO_PIX_FMT_SBGGR14P:
        case VIDEO_PIX_FMT_SGBRG14P:
        case VIDEO_PIX_FMT_SGRBG14P:
        case VIDEO_PIX_FMT_SRGGB14P:
                return VIDEO_MIPI_CSI2_DT_RAW14;
        case VIDEO_PIX_FMT_UYVY:
                return VIDEO_MIPI_CSI2_DT_YUV422_8;
        case VIDEO_PIX_FMT_RGB565:
                return VIDEO_MIPI_CSI2_DT_RGB565;
        case VIDEO_PIX_FMT_RGB24:
                return VIDEO_MIPI_CSI2_DT_RGB888;
        default:
                return VIDEO_MIPI_CSI2_DT_NULL;
        }
}

#define VIDEO_MIPI_CSI2_DT_USER(n)      (0x30 + (n))

 
#ifdef __cplusplus
}
#endif

 
#endif /* ZEPHYR_INCLUDE_DRIVERS_VIDEO_H */