// include/media/v4l2-device.h
struct v4l2_device {
    struct device *dev;          // 指向底层device
    struct list_head subdevs;    // 子设备链。    struct mutex lock;           // 全局互斥。    char name[V4L2_DEVICE_NAME_SIZE]; // 设备。    struct v4l2_prio_state prio; // 优先级状态    struct kref ref;             // 引用计数
    void (*release)(struct v4l2_device *v4l2_dev); // 释放回调
};

// include/media/v4l2-subdev.h
struct v4l2_subdev {
    struct v4l2_device *v4l2_dev;   // 指向父设。    const struct v4l2_subdev_ops *ops; // 子设备操作集
    struct list_head list;          // 挂在v4l2_device.subdevs链表。    u32 flags;
    struct v4l2_subdev_platform_data *pdata;
};

// include/media/v4l2-dev.h（关键字段）
struct video_device {
    const struct v4l2_file_operations *fops;  // 文件操作
    const struct v4l2_ioctl_ops *ioctl_ops;   // ioctl操作
    struct v4l2_device *v4l2_dev;             // 指向父设。    struct device dev;                        // 内嵌device
    enum vfl_devnode_type vfl_type;           // 设备类型
    enum vfl_devnode_direction vfl_dir;       // 输入/输出方向
    int minor;                                // 次设备号
    struct vb2_queue *queue;                  // 绑定的vb2队列
    u32 device_caps;                          // 设备能力位图
};

// 文件操作，大部分直接用V4L2提供的默认实。struct v4l2_file_operations {
    struct module *owner;
    int (*open)(struct video_device *vdev);
    int (*release)(struct video_device *vdev);
    ssize_t (*read)(struct video_device *vdev, char __user *buf,
                    size_t count, loff_t *ppos);
    ssize_t (*write)(struct video_device *vdev, const char __user *buf,
                     size_t count, loff_t *ppos);
    __poll_t (*poll)(struct file *file, struct poll_table_struct *wait);
    long (*ioctl)(struct video_device *vdev, unsigned int cmd, void *arg);
    int (*mmap)(struct video_device *vdev, struct vm_area_struct *vma);
};

// ioctl操作，驱动必须实现的核心回调
struct v4l2_ioctl_ops {
    int (*vidioc_querycap)(struct file *file, void *fh,
                           struct v4l2_capability *cap);
    int (*vidioc_enum_fmt_vid_cap)(struct file *file, void *fh,
                                   struct v4l2_fmtdesc *f);
    int (*vidioc_g_fmt_vid_cap)(struct file *file, void *fh,
                                struct v4l2_format *fmt);
    int (*vidioc_s_fmt_vid_cap)(struct file *file, void *fh,
                                struct v4l2_format *fmt);
    int (*vidioc_reqbufs)(struct file *file, void *fh,
                          struct v4l2_requestbuffers *b);
    int (*vidioc_qbuf)(struct file *file, void *fh,
                       struct v4l2_buffer *b);
    int (*vidioc_dqbuf)(struct file *file, void *fh,
                        struct v4l2_buffer *b);
    int (*vidioc_streamon)(struct file *file, void *fh,
                           enum v4l2_buf_type type);
    int (*vidioc_streamoff)(struct file *file, void *fh,
                            enum v4l2_buf_type type);
    // ... 更多回调
};

// include/media/videobuf2-core.h（关键字段）
struct vb2_queue {
    enum v4l2_buf_type type;          // 缓冲区类。V4L2_BUF_TYPE_VIDEO_CAPTURE)
    enum vb2_memory memory;           // 内存类型(VB2_MEMORY_MMAP/DMABUF/USERPTR)
    struct mutex *lock;               // 队列。    const struct vb2_ops *ops;        // 驱动回调
    const struct vb2_mem_ops *mem_ops;// 内存操作
    u32 min_buffers_needed;           // 最少需要的缓冲区数
    u32 buf_struct_size;              // 驱动私有缓冲区结构大。    struct vb2_buffer *bufs[VB2_MAX_FRAME]; // 缓冲区数。    unsigned int num_buffers;         // 已分配缓冲区。};

// 驱动需要实现的vb2操作
struct vb2_ops {
    int (*queue_setup)(struct vb2_queue *q,
                       unsigned int *num_buffers,
                       unsigned int *num_planes,
                       unsigned int sizes[],
                       struct device *alloc_devs[]);
    void (*buf_queue)(struct vb2_buffer *vb);     // 缓冲区入队时调用
    int (*buf_prepare)(struct vb2_buffer *vb);    // 缓冲区准备（可选）
    void (*buf_finish)(struct vb2_buffer *vb);    // 缓冲区完成（可选）
    int (*start_streaming)(struct vb2_queue *q, unsigned int count);
    void (*stop_streaming)(struct vb2_queue *q);
    void (*buf_cleanup)(struct vb2_buffer *vb);   // 缓冲区清理（可选）
};

// 三种内存操作集，驱动选择一。struct vb2_mem_ops {
    void *(*alloc)(struct vb2_buffer *vb, struct device *dev,
                   unsigned long size);
    void (*put)(void *buf_priv);
    void *(*get_userptr)(struct vb2_buffer *vb, struct device *dev,
                         unsigned long vaddr, unsigned long size);
    void (*put_userptr)(void *buf_priv);
    struct dma_buf *(*get_dmabuf)(void *buf_priv, unsigned long flags);
    int (*mmap)(void *buf_priv, struct vm_area_struct *vma);
    // ...
};

// 初始化vb2_queue时指定DMA-contiguous
q->mem_ops = vb2_dma_contig_memops;

// vb2内部通过dma_alloc_coherent分配
// drivers/media/common/videobuf2/videobuf2-dma-contig.c
static void *vb2_dc_alloc(struct vb2_buffer *vb, struct device *dev,
                          unsigned long size)
{
    struct vb2_dc_buf *buf;
    dma_addr_t dma_addr;

    buf = kzalloc(sizeof(*buf), GFP_KERNEL);
    // 分配物理连续、cache一致的DMA缓冲。    buf->vaddr = dma_alloc_coherent(dev, size, &dma_addr,
                                    GFP_KERNEL | vb->dma_attrs);
    buf->dma_addr = dma_addr;
    buf->size = size;
    buf->dev = dev;
    return buf;
}

// v4l2_dummy_cam.c - 虚拟摄像头驱动（Linux 6.8。#include <linux/module.h>
#include <linux/platform_device.h>
#include <media/v4l2-device.h>
#include <media/v4l2-ioctl.h>
#include <media/v4l2-fh.h>
#include <media/videobuf2-v4l2.h>
#include <media/videobuf2-vmalloc.h>

#define DUMMY_CAM_WIDTH  640
#define DUMMY_CAM_HEIGHT 480
#define DUMMY_CAM_PIXFMT V4L2_PIX_FMT_YUYV
#define DUMMY_CAM_NBUFS  4

struct dummy_cam_dev {
    struct v4l2_device  v4l2_dev;
    struct video_device  vdev;
    struct vb2_queue     queue;
    struct mutex         lock;
    /* 当前帧计数，用于生成测试图案 */
    u32 frame_count;
};

/* ---- vb2_ops ---- */

static int dummy_cam_queue_setup(struct vb2_queue *q,
                                  unsigned int *nbuffers,
                                  unsigned int *nplanes,
                                  unsigned int sizes[],
                                  struct device *alloc_devs[])
{
    /* YUYV格式，每像素2字节 */
    sizes[0] = DUMMY_CAM_WIDTH * DUMMY_CAM_HEIGHT * 2;
    *nplanes = 1;
    return 0;
}

static int dummy_cam_buf_prepare(struct vb2_buffer *vb)
{
    struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
    unsigned long size = DUMMY_CAM_WIDTH * DUMMY_CAM_HEIGHT * 2;

    if (vb2_plane_size(vb, 0) < size)
        return -EINVAL;

    vb2_set_plane_payload(vb, 0, size);
    vbuf->field = V4L2_FIELD_NONE;
    return 0;
}

static void dummy_cam_buf_queue(struct vb2_buffer *vb)
{
    struct dummy_cam_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
    struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);

    /* 模拟硬件填充：生成YUYV测试图案 */
    void *vaddr = vb2_plane_vaddr(vb, 0);
    if (vaddr) {
        u8 *p = vaddr;
        u32 frame = dev->frame_count++;
        /* 简单渐变色图案，Y分量随帧号变更*/
        memset(p, (frame * 3) & 0xFF,
               DUMMY_CAM_WIDTH * DUMMY_CAM_HEIGHT * 2);
    }

    /* 立即完成，模拟硬件中断回调*/
    vbuf->sequence = dev->frame_count;
    vbuf->vb2_buf.timestamp = ktime_get_ns();
    vb2_buffer_done(&vbuf->vb2_buf, VB2_BUF_STATE_DONE);
}

static int dummy_cam_start_streaming(struct vb2_queue *q, unsigned int count)
{
    struct dummy_cam_dev *dev = vb2_get_drv_priv(q);
    dev->frame_count = 0;
    return 0;
}

static void dummy_cam_stop_streaming(struct vb2_queue *q)
{
    struct dummy_cam_dev *dev = vb2_get_drv_priv(q);
    /* 清除所有未完成的缓冲区 */
    struct vb2_buffer *vb;
    while ((vb = vb2_done_list_del(q)))
        vb2_buffer_done(vb, VB2_BUF_STATE_ERROR);
}

static const struct vb2_ops dummy_cam_vb2_ops = {
    .queue_setup     = dummy_cam_queue_setup,
    .buf_prepare     = dummy_cam_buf_prepare,
    .buf_queue       = dummy_cam_buf_queue,
    .start_streaming = dummy_cam_start_streaming,
    .stop_streaming  = dummy_cam_stop_streaming,
};

/* ---- v4l2_ioctl_ops ---- */

static int dummy_cam_querycap(struct file *file, void *fh,
                               struct v4l2_capability *cap)
{
    strscpy(cap->driver, "dummy_cam", sizeof(cap->driver));
    strscpy(cap->card, "Dummy Camera", sizeof(cap->card));
    strscpy(cap->bus_info, "platform:dummy_cam", sizeof(cap->bus_info));
    cap->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
    cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
    return 0;
}

static int dummy_cam_enum_fmt(struct file *file, void *fh,
                               struct v4l2_fmtdesc *f)
{
    if (f->index > 0)
        return -EINVAL;
    f->pixelformat = DUMMY_CAM_PIXFMT;
    return 0;
}

static int dummy_cam_g_fmt(struct file *file, void *fh,
                            struct v4l2_format *fmt)
{
    fmt->fmt.pix.width       = DUMMY_CAM_WIDTH;
    fmt->fmt.pix.height      = DUMMY_CAM_HEIGHT;
    fmt->fmt.pix.pixelformat = DUMMY_CAM_PIXFMT;
    fmt->fmt.pix.field       = V4L2_FIELD_NONE;
    fmt->fmt.pix.bytesperline = DUMMY_CAM_WIDTH * 2;
    fmt->fmt.pix.sizeimage   = DUMMY_CAM_WIDTH * DUMMY_CAM_HEIGHT * 2;
    fmt->fmt.pix.colorspace  = V4L2_COLORSPACE_SRGB;
    return 0;
}

static int dummy_cam_s_fmt(struct file *file, void *fh,
                            struct v4l2_format *fmt)
{
    /* 虚拟设备只支持一种格式，直接返回固定*/
    return dummy_cam_g_fmt(file, fh, fmt);
}

static const struct v4l2_ioctl_ops dummy_cam_ioctl_ops = {
    .vidioc_querycap       = dummy_cam_querycap,
    .vidioc_enum_fmt_vid_cap = dummy_cam_enum_fmt,
    .vidioc_g_fmt_vid_cap  = dummy_cam_g_fmt,
    .vidioc_s_fmt_vid_cap  = dummy_cam_s_fmt,
    .vidioc_reqbufs        = vb2_ioctl_reqbufs,
    .vidioc_create_bufs    = vb2_ioctl_create_bufs,
    .vidioc_qbuf           = vb2_ioctl_qbuf,
    .vidioc_dqbuf          = vb2_ioctl_dqbuf,
    .vidioc_streamon       = vb2_ioctl_streamon,
    .vidioc_streamoff      = vb2_ioctl_streamoff,
    .vidioc_expbuf         = vb2_ioctl_expbuf,
    .vidioc_mmap           = vb2_ioctl_mmap,
};

/* ---- v4l2_file_operations ---- */

static int dummy_cam_open(struct file *file)
{
    struct dummy_cam_dev *dev = video_drvdata(file);
    return v4l2_fh_open(file);
}

static int dummy_cam_release(struct file *file)
{
    return vb2_fop_release(file);
}

static const struct v4l2_file_operations dummy_cam_fops = {
    .owner   = THIS_MODULE,
    .open    = dummy_cam_open,
    .release = dummy_cam_release,
    .read    = vb2_fop_read,
    .poll    = vb2_fop_poll,
    .mmap    = vb2_fop_mmap,
    .unlocked_ioctl = video_ioctl2,
};

/* ---- probe / remove ---- */

static int dummy_cam_probe(struct platform_device *pdev)
{
    struct dummy_cam_dev *dev;
    int ret;

    dev = devm_kzalloc(&pdev->dev, sizeof(*dev), GFP_KERNEL);
    if (!dev)
        return -ENOMEM;

    mutex_init(&dev->lock);

    /* 注册v4l2_device */
    ret = v4l2_device_register(&pdev->dev, &dev->v4l2_dev);
    if (ret)
        return ret;

    /* 初始化vb2_queue */
    dev->queue.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    dev->queue.io_modes = VB2_MMAP | VB2_DMABUF | VB2_READ;
    dev->queue.dev = &pdev->dev;
    dev->queue.ops = &dummy_cam_vb2_ops;
    dev->queue.mem_ops = &vb2_vmalloc_memops;
    dev->queue.buf_struct_size = sizeof(struct vb2_v4l2_buffer);
    dev->queue.lock = &dev->lock;
    dev->queue.min_buffers_needed = 1;
    ret = vb2_queue_init(&dev->queue);
    if (ret)
        goto err_v4l2_unregister;

    /* 初始化video_device */
    dev->vdev = video_device_alloc();
    if (!dev->vdev) {
        ret = -ENOMEM;
        goto err_v4l2_unregister;
    }
    dev->vdev->v4l2_dev = &dev->v4l2_dev;
    dev->vdev->fops = &dummy_cam_fops;
    dev->vdev->ioctl_ops = &dummy_cam_ioctl_ops;
    dev->vdev->queue = &dev->queue;
    dev->vdev->lock = &dev->lock;
    dev->vdev->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
    video_set_drvdata(dev->vdev, dev);

    ret = video_register_device(dev->vdev, VFL_TYPE_VIDEO, -1);
    if (ret)
        goto err_vdev_release;

    platform_set_drvdata(pdev, dev);
    dev_info(&pdev->dev, "dummy camera registered as /dev/video%d\n",
             dev->vdev->num);
    return 0;

err_vdev_release:
    video_device_release(dev->vdev);
err_v4l2_unregister:
    v4l2_device_unregister(&dev->v4l2_dev);
    return ret;
}

static void dummy_cam_remove(struct platform_device *pdev)
{
    struct dummy_cam_dev *dev = platform_get_drvdata(pdev);

    video_unregister_device(dev->vdev);
    v4l2_device_unregister(&dev->v4l2_dev);
    mutex_destroy(&dev->lock);
}

static struct platform_driver dummy_cam_driver = {
    .probe  = dummy_cam_probe,
    .remove = dummy_cam_remove,
    .driver = {
        .name = "dummy_cam",
    },
};

module_platform_driver(dummy_cam_driver);
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Dummy V4L2 camera driver for testing");

// v4l2_capture.c - 用户空间V4L2采集示例
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <errno.h>
#include <linux/videodev2.h>

#define NBUFS 4

struct buffer {
    void   *start;
    size_t  length;
};

int main(int argc, char **argv)
{
    const char *dev_name = "/dev/video0";
    int fd = -1;
    struct buffer buffers[NBUFS];
    int i;

    /* 1. 打开设备 */
    fd = open(dev_name, O_RDWR | O_NONBLOCK);
    if (fd < 0) {
        perror("open");
        return -1;
    }

    /* 2. 查询设备能力 */
    struct v4l2_capability cap;
    if (ioctl(fd, VIDIOC_QUERYCAP, &cap) < 0) {
        perror("VIDIOC_QUERYCAP");
        goto out;
    }
    if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) {
        fprintf(stderr, "不是视频捕获设备\n");
        goto out;
    }

    /* 3. 设置格式 */
    struct v4l2_format fmt;
    memset(&fmt, 0, sizeof(fmt));
    fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    fmt.fmt.pix.width       = 640;
    fmt.fmt.pix.height      = 480;
    fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
    fmt.fmt.pix.field       = V4L2_FIELD_NONE;
    if (ioctl(fd, VIDIOC_S_FMT, &fmt) < 0) {
        perror("VIDIOC_S_FMT");
        goto out;
    }
    printf("实际格式: %dx%d, pixfmt=0x%08x\n",
           fmt.fmt.pix.width, fmt.fmt.pix.height,
           fmt.fmt.pix.pixelformat);

    /* 4. 申请缓冲*/
    struct v4l2_requestbuffers req;
    memset(&req, 0, sizeof(req));
    req.count  = NBUFS;
    req.type   = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    req.memory = V4L2_MEMORY_MMAP;
    if (ioctl(fd, VIDIOC_REQBUFS, &req) < 0) {
        perror("VIDIOC_REQBUFS");
        goto out;
    }

    /* 5. mmap映射 + QBUF入队 */
    for (i = 0; i < NBUFS; i++) {
        struct v4l2_buffer buf;
        memset(&buf, 0, sizeof(buf));
        buf.type   = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        buf.memory = V4L2_MEMORY_MMAP;
        buf.index  = i;
        if (ioctl(fd, VIDIOC_QUERYBUF, &buf) < 0) {
            perror("VIDIOC_QUERYBUF");
            goto out;
        }
        buffers[i].length = buf.length;
        buffers[i].start = mmap(NULL, buf.length,
                                PROT_READ | PROT_WRITE,
                                MAP_SHARED, fd, buf.m.offset);
        if (buffers[i].start == MAP_FAILED) {
            perror("mmap");
            goto out;
        }
        /* 入队 */
        if (ioctl(fd, VIDIOC_QBUF, &buf) < 0) {
            perror("VIDIOC_QBUF");
            goto out;
        }
    }

    /* 6. 启动采集 */
    enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    if (ioctl(fd, VIDIOC_STREAMON, &type) < 0) {
        perror("VIDIOC_STREAMON");
        goto out;
    }

    /* 7. 采集循环 */
    int frame_count = 0;
    while (frame_count < 30) {
        struct v4l2_buffer buf;
        memset(&buf, 0, sizeof(buf));
        buf.type   = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        buf.memory = V4L2_MEMORY_MMAP;

        /* 出队（阻塞等待） */
        if (ioctl(fd, VIDIOC_DQBUF, &buf) < 0) {
            if (errno == EAGAIN)
                continue;
            perror("VIDIOC_DQBUF");
            break;
        }

        printf("。%d: index=%d, bytesused=%u, seq=%u\n",
               frame_count, buf.index, buf.bytesused, buf.sequence);

        /* 此处可处理buffers[buf.index].start中的图像数据 */

        /* 重新入队 */
        if (ioctl(fd, VIDIOC_QBUF, &buf) < 0) {
            perror("VIDIOC_QBUF");
            break;
        }
        frame_count++;
    }

    /* 8. 停止采集 */
    ioctl(fd, VIDIOC_STREAMOFF, &type);

out:
    /* 9. 清理 */
    for (i = 0; i < NBUFS; i++) {
        if (buffers[i].start && buffers[i].start != MAP_FAILED)
            munmap(buffers[i].start, buffers[i].length);
    }
    if (fd >= 0)
        close(fd);
    return 0;
}

# 查看设备信息
v4l2-ctl --device=/dev/video0 --all

# 列出支持的格。v4l2-ctl --device=/dev/video0 --list-formats-ext

# 设置格式并采集一。v4l2-ctl --device=/dev/video0 \
    --set-fmt-video=width=640,height=480,pixelformat=YUYV \
    --set-parm=30 \
    --stream-mmap --stream-to=frame.yuyv --stream-count=1

# 连续采集10。v4l2-ctl --device=/dev/video0 \
    --stream-mmap --stream-to=video.yuyv --stream-count=10

V4L2采集 。[内核DMA缓冲区] 。CPU拷贝 。[用户空间缓冲区] 。CPU拷贝 。[GPU缓冲区] 。渲染显示

// 导出端（V4L2驱动。// include/linux/dma-buf.h

struct dma_buf_export_info {
    const char *exp_name;     // 导出者名。    const struct dma_buf_ops *ops; // 操作回调
    size_t size;              // 缓冲区大。    int flags;                // O_RDWR等标志    void *priv;               // 私有数据
};

// 导出dma_buf，返回fd
struct dma_buf *dma_buf_export(const struct dma_buf_export_info *exp_info);

// 导入端（GPU/DRM。// 通过fd获取dma_buf
struct dma_buf *dma_buf_get(int fd);

// 使用完毕后释。void dma_buf_put(struct dma_buf *dmabuf);

// 用户空间：从V4L2缓冲区导出DMA-BUF fd
struct v4l2_exportbuffer expbuf;
memset(&expbuf, 0, sizeof(expbuf));
expbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
expbuf.index = 0;  // 缓冲区索。expbuf.flags = O_RDWR;
if (ioctl(fd, VIDIOC_EXPBUF, &expbuf) < 0) {
    perror("VIDIOC_EXPBUF");
    return -1;
}
// expbuf.fd 就是DMA-BUF文件描述。printf("DMA-BUF fd = %d\n", expbuf.fd);

/* 驱动初始化时允许DMABUF模式 */
dev->queue.io_modes = VB2_MMAP | VB2_DMABUF | VB2_READ;

/* ioctl_ops中注册expbuf */
static const struct v4l2_ioctl_ops dummy_cam_ioctl_ops = {
    /* ... 其他回调 ... */
    .vidioc_expbuf = vb2_ioctl_expbuf,  // vb2默认实现
};

// v4l2_dmabuf_export.c - 从V4L2导出DMA-BUF fd
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <linux/videodev2.h>

int main(void)
{
    int fd = open("/dev/video0", O_RDWR);
    if (fd < 0) { perror("open"); return -1; }

    /* 申请缓冲区，使用DMABUF模式 */
    struct v4l2_requestbuffers req = {
        .count  = 4,
        .type   = V4L2_BUF_TYPE_VIDEO_CAPTURE,
        .memory = V4L2_MEMORY_MMAP,  // 内核侧仍用mmap分配
    };
    if (ioctl(fd, VIDIOC_REQBUFS, &req) < 0) {
        perror("REQBUFS");
        goto out;
    }

    /* 导出缓冲。的DMA-BUF fd */
    struct v4l2_exportbuffer expbuf = {
        .type  = V4L2_BUF_TYPE_VIDEO_CAPTURE,
        .index = 0,
        .flags = O_RDWR,
    };
    if (ioctl(fd, VIDIOC_EXPBUF, &expbuf) < 0) {
        perror("EXPBUF");
        goto out;
    }
    printf("DMA-BUF fd = %d\n", expbuf.fd);

    /* 将expbuf.fd传给GPU/DRM消费者使*/
    /* ... */

    close(expbuf.fd);
out:
    close(fd);
    return 0;
}

// GPU端导入DMA-BUF（EGL方式。#include <EGL/egl.h>
#include <EGL/eglext.h>

// 从DMA-BUF fd创建EGLImage
EGLImage create_eglimage_from_dmabuf(int dmabuf_fd, int width, int height)
{
    EGLint attribs[] = {
        EGL_WIDTH,           width,
        EGL_HEIGHT,          height,
        EGL_LINUX_DRM_FOURCC_EXT,  DRM_FORMAT_YUYV,
        EGL_DMA_BUF_PLANE0_FD_EXT,     dmabuf_fd,
        EGL_DMA_BUF_PLANE0_OFFSET_EXT, 0,
        EGL_DMA_BUF_PLANE0_PITCH_EXT,  width * 2,
        EGL_NONE,
    };

    return eglCreateImageKHR(eglGetCurrentDisplay(),
                             EGL_NO_CONTEXT,
                             EGL_LINUX_DMA_BUF_EXT,
                             (EGLClientBuffer)NULL,
                             attribs);
}

// DRM端导入DMA-BUF（drm_prime_handle方式。#include <drm/drm.h>
#include <xf86drm.h>

int import_dmabuf_to_drm(int drm_fd, int dmabuf_fd)
{
    struct drm_prime_handle prime = {
        .fd = dmabuf_fd,
        .flags = 0,
    };

    /* 将DMA-BUF fd转为DRM GEM handle */
    if (drmIoctl(drm_fd, DRM_IOCTL_PRIME_FD_TO_HANDLE, &prime) < 0) {
        perror("PRIME_FD_TO_HANDLE");
        return -1;
    }

    printf("DRM GEM handle = %u\n", prime.handle);
    /* 后续用handle做fb创建和显*/
    return prime.handle;
}

// 消费者设备（如GPU驱动）通过dma_buf_get导入
struct dma_buf *dmabuf = dma_buf_get(fd);
if (IS_ERR(dmabuf))
    return PTR_ERR(dmabuf);

// 获取dma_buf_attachment，建立设备间的映射关。struct dma_buf_attachment *attach;
attach = dma_buf_attach(dmabuf, dev);  // dev是消费者设。if (IS_ERR(attach)) {
    dma_buf_put(dmabuf);
    return PTR_ERR(attach);
}

// 获取scatter-gather表，用于DMA传输
struct sg_table *sgt;
sgt = dma_buf_map_attachment(attach, DMA_BIDIRECTIONAL);
if (IS_ERR(sgt)) {
    dma_buf_detach(dmabuf, attach);
    dma_buf_put(dmabuf);
    return PTR_ERR(sgt);
}

// 此时sgt->sgl包含物理页面信息，消费者设备的DMA引擎
// 可以直接通过sg_table访问V4L2分配的同一块物理内存
// 使用完毕后释。dma_buf_unmap_attachment(attach, sgt, DMA_BIDIRECTIONAL);
dma_buf_detach(dmabuf, attach);
dma_buf_put(dmabuf);

# 用v4l2-ctl验证设备是否能正常采。v4l2-ctl --device=/dev/video0 --stream-mmap --stream-count=5

# 检查IOMMU分组
ls /sys/kernel/iommu_groups/
# 检查设备是否在同一。cat /sys/kernel/iommu_groups/*/devices