/** * struct vb2_mem_ops - memory handling/memory allocator operations * @alloc:    allocate video memory and, optionally, allocator private data,() *        return NULL on failure or a pointer to allocator private, *        per-buffer data on success; the returned private structure *        will then be passed as buf_priv argument to other ops in this *        structure * @put:    inform(通知) the allocator that the buffer will no longer be used; *        usually will result in the allocator freeing the buffer (if *        no other users of this buffer are present); the buf_priv *        argument is the allocator private per-buffer structure *        previously returned from the alloc callback * @get_userptr: acquire userspace memory for a hardware operation; used for *         USERPTR memory types; vaddr is the address passed to the *         videobuf layer when queuing a video buffer of USERPTR type; *         should return an allocator private per-buffer structure *         associated with the buffer on success, NULL on failure; *         the returned private structure will then be passed as buf_priv *         argument to other ops in this structure
　　　　为一个硬件操作来获取userspace memory,用于内存类型是：USERPTR；当 queing 一个USERPTR类型的video buffer，vadd 是一个被传递到videobuf layer的地址。 * @put_userptr: inform the allocator that a USERPTR buffer will no longer *         be used（通知allocator，USERPTR buffer不再使用） * @vaddr:    return a kernel virtual address to a given memory buffer *        associated with the passed private structure or NULL if no *        such mapping exists（返回内核虚拟地址） * @cookie:    return allocator specific cookie for a given memory buffer *        associated with the passed private structure or NULL if not *        available（返回allocator特定的cookie） * @num_users:    return the current number of users of a memory buffer; *        return 1 if the videobuf layer (or actually the driver using *        it) is the only user * @mmap:    setup a userspace mapping for a given memory buffer under *        the provided virtual memory region * * Required ops for USERPTR types: get_userptr, put_userptr. * Required ops for MMAP types: alloc, put, num_users, mmap. * Required ops for read/write access types: alloc, put, num_users, vaddr */struct vb2_mem_ops {    void        *(*alloc)(void *alloc_ctx, unsigned long size);    void        (*put)(void *buf_priv);    void        *(*get_userptr)(void *alloc_ctx, unsigned long vaddr,                    unsigned long size, int write);    void        (*put_userptr)(void *buf_priv);    void        *(*vaddr)(void *buf_priv);    void        *(*cookie)(void *buf_priv);    unsigned int    (*num_users)(void *buf_priv);    int        (*mmap)(void *buf_priv, struct vm_area_struct *vma);};

/** * enum vb2_io_modes - queue access methods * @VB2_MMAP:        driver supports MMAP with streaming API * @VB2_USERPTR:    driver supports USERPTR with streaming API * @VB2_READ:        driver supports read() style access * @VB2_WRITE:        driver supports write() style access */enum vb2_io_modes {    VB2_MMAP    = (1 << 0),    VB2_USERPTR    = (1 << 1),    VB2_READ    = (1 << 2),    VB2_WRITE    = (1 << 3),};

/** * enum vb2_buffer_state - current video buffer state * @VB2_BUF_STATE_DEQUEUED:    buffer under userspace control * @VB2_BUF_STATE_QUEUED:    buffer queued in videobuf, but not in driver * @VB2_BUF_STATE_ACTIVE:    buffer queued in driver and possibly used *                in a hardware operation * @VB2_BUF_STATE_DONE:        buffer returned from driver to videobuf, but *                not yet dequeued to userspace * @VB2_BUF_STATE_ERROR:    same as above, but the operation on the buffer *                has ended with an error, which will be reported *                to the userspace when it is dequeued */enum vb2_buffer_state {    VB2_BUF_STATE_DEQUEUED,   // buffer处于userspace的控制    VB2_BUF_STATE_QUEUED,     // buffer被queued到videobuf中，但是不在driver中    VB2_BUF_STATE_ACTIVE,     // buffer被queued到driver中，而且有可能硬件正在访问该buffer.    VB2_BUF_STATE_DONE,       // buffer由driver返回到videobuf中，但是还未dequeued到userspace    VB2_BUF_STATE_ERROR,      // buffer在操作过程中发生错误，而且该错误在dequeued时，报告到userspace};

/** * struct vb2_buffer - represents a video buffer * @v4l2_buf:        struct v4l2_buffer associated with this buffer; can *            be read by the driver and relevant entries can be *            changed by the driver in case of CAPTURE types *            (such as timestamp) * @v4l2_planes:    struct v4l2_planes associated with this buffer; can *            be read by the driver and relevant entries can be *            changed by the driver in case of CAPTURE types *            (such as bytesused); NOTE that even for single-planar *            types, the v4l2_planes[0] struct should be used *            instead of v4l2_buf for filling bytesused - drivers *            should use the vb2_set_plane_payload() function for that * @vb2_queue:        the queue to which this driver belongs * @num_planes:        number of planes in the buffer *            on an internal driver queue * @state:        current buffer state; do not change * @queued_entry:    entry on the queued buffers list, which holds all *            buffers queued from userspace * @done_entry:        entry on the list that stores all buffers ready to *            be dequeued to userspace * @planes:        private per-plane information; do not change * @num_planes_mapped:    number of mapped planes; do not change */struct vb2_buffer {    struct v4l2_buffer    v4l2_buf;                     // CAPTURE：可以由driver读写    struct v4l2_plane    v4l2_planes[VIDEO_MAX_PLANES]; 
　　　　　　　　　　　　// CAPTURE：可以由driver读写，（byteused）即使是对于single-planar类型，v4l2_planes[0]应该被使用而不是仅仅使用v4l2_buf的byteused。
　　　　　　　　　　　　// 驱动使用改函数vb2_set_plane_payload()设置byteused.
    struct vb2_queue    *vb2_queue;  // 该vb2_buffer所属的vb2_queue    unsigned int        num_planes;  // 该buffer有多少个planes/* Private: internal use only */    enum vb2_buffer_state    state;  // buffer的当前状态    struct list_head    queued_entry; // queued buffer 链表，保存所有从userspace queued进的buffers    struct list_head    done_entry;   // 保存所有准备 dequeued 到userspace的buffers链表    struct vb2_plane    planes[VIDEO_MAX_PLANES];  // 私有的 per-plane 信息，驱动禁止修改    unsigned int        num_planes_mapped;         // mapped plane};

/** * struct vb2_ops - driver-specific callbacks * * @queue_setup:    called from a VIDIOC_REQBUFS handler, before *            memory allocation; driver should return the required *            number of buffers in num_buffers, the required number *            of planes per buffer in num_planes; the size of each *            plane should be set in the sizes[] array and optional *            per-plane allocator specific context in alloc_ctxs[] *            array
　　　　在分配内存之前，发送VIDIOC_REQBUFS命令时调用。driver应该在该回调函数中设置num_buffers，the number of planes per buffer;每个plane的size，
　　　　有时会设置特定于不同环境的per-plane allocator。
 * @wait_prepare:    release any locks taken while calling vb2 functions; *            it is called before an ioctl needs to wait for a new *            buffer to arrive; required to avoid a deadlock in *            blocking access type
　　　　当调用vb2函数时，释放所持有的锁; 在一个需要等待一个新的buffer到来的ioctl之前调用;在阻塞访问下需要防止死锁
 * @wait_finish:    reacquire all locks released in the previous callback; *            required to continue operation after sleeping while *            waiting for a new buffer to arrive
　　　　获取所有之前释放的锁 * @buf_init:        called once after allocating a buffer (in MMAP case) *            or after acquiring a new USERPTR buffer; drivers may *            perform additional buffer-related initialization; *            initialization failure (return != 0) will prevent *            queue setup from completing successfully; optional
　　　　对于MMAP类型，分配buffer后立刻调用;对于USERPTR在获取一个buffer后调用;驱动可能执行一些附加的buffer相关的初始化; * @buf_prepare:    called every time the buffer is queued from userspace; *            drivers may perform any initialization required before *            each hardware operation in this callback; *            if an error is returned, the buffer will not be queued *            in driver; optional
　　　　每次buffer从userspace queued都会被调用，在硬件操作buffer之前，驱动可能会执行一些初始化;如果返回失败，buffer不会被queued到驱动中 * @buf_finish:        called before every dequeue of the buffer back to *            userspace; drivers may perform any operations required *            before userspace accesses the buffer; optional
　　　　每次dequeue buffer在返回 userspace 之前调用;驱动可能在 userspace 访问buffer之前做一些操作 * @buf_cleanup:    called once before the buffer is freed; drivers may *            perform any additional cleanup; optional
　　　　当buffer释放时调用，驱动可能执行一些附加的清理工作 * @start_streaming:    called once before entering ‘streaming‘ state; enables *            driver to receive buffers over buf_queue() callback * @stop_streaming:    called when ‘streaming‘ state must be disabled; driver *            should stop any DMA transactions or wait until they *            finish and give back all buffers it got from buf_queue() *            callback; may use vb2_wait_for_all_buffers() function
　　　　当‘streaming’状态被清除时调用;驱动应该停止任何DMA传输或者等待直到DMA操作结束并且返回通过buf_queue()拿到的所有的buffer。可能使用vb2_wait_for_all_buffers() * @buf_queue:        passes buffer vb to the driver; driver may start *            hardware operation on this buffer; driver should give *            the buffer back by calling vb2_buffer_done() function
　　　　将buffer传递到driver;driver可能开始对该buffer进行硬件操作;driver应该通过调用vb2_buffer_done()函数将归还buffer */struct vb2_ops {    int (*queue_setup)(struct vb2_queue *q, unsigned int *num_buffers,               unsigned int *num_planes, unsigned long sizes[],               void *alloc_ctxs[]);    void (*wait_prepare)(struct vb2_queue *q);    void (*wait_finish)(struct vb2_queue *q);    int (*buf_init)(struct vb2_buffer *vb);    int (*buf_prepare)(struct vb2_buffer *vb);    int (*buf_finish)(struct vb2_buffer *vb);    void (*buf_cleanup)(struct vb2_buffer *vb);    int (*start_streaming)(struct vb2_queue *q);    int (*stop_streaming)(struct vb2_queue *q);    void (*buf_queue)(struct vb2_buffer *vb);};

/** * struct vb2_queue - a videobuf queue * * @type:    queue type (see V4L2_BUF_TYPE_* in linux/videodev2.h * @io_modes:    supported io methods (see vb2_io_modes enum) * @io_flags:    additional io flags (see vb2_fileio_flags enum) * @ops:    driver-specific callbacks * @mem_ops:    memory allocator specific callbacks * @drv_priv:    driver private data * @buf_struct_size: size of the driver-specific buffer structure; *        "0" indicates the driver doesn‘t want to use a custom buffer *        structure type, so sizeof(struct vb2_buffer) will is used * * @memory:    current memory type used * @bufs:    videobuf buffer structures * @num_buffers: number of allocated/used buffers * @queued_list: list of buffers currently queued from userspace * @queued_count: number of buffers owned by the driver * @done_list:    list of buffers ready to be dequeued to userspace * @done_lock:    lock to protect done_list list * @done_wq:    waitqueue for processes waiting for buffers ready to be dequeued * @alloc_ctx:    memory type/allocator-specific contexts for each plane * @streaming:    current streaming state * @fileio:    file io emulator internal data, used only if emulator is active */struct vb2_queue {    enum v4l2_buf_type        type;    unsigned int            io_modes;    unsigned int            io_flags;    const struct vb2_ops        *ops;    const struct vb2_mem_ops    *mem_ops;    void                *drv_priv;    unsigned int            buf_struct_size;/* private: internal use only */    enum v4l2_memory        memory;    struct vb2_buffer        *bufs[VIDEO_MAX_FRAME];    unsigned int            num_buffers;    struct list_head        queued_list;    atomic_t            queued_count;    struct list_head        done_list;    spinlock_t            done_lock;    wait_queue_head_t        done_wq;    void                *alloc_ctx[VIDEO_MAX_PLANES];    unsigned int            streaming:1;    struct vb2_fileio_data        *fileio;};