V4L2源代码之旅十一：videobuf主要结构体

/**
 * 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;
};