[include/uapi/linux/videodev2.h]
    // перечисление типа videobuf2
    enum v4l2_buf_type {
        V4L2_BUF_TYPE_VIDEO_CAPTURE        = 1,  // Получение изображения
        V4L2_BUF_TYPE_VIDEO_OUTPUT         = 2,  // Вывод изображения
        V4L2_BUF_TYPE_VIDEO_OVERLAY        = 3,
        V4L2_BUF_TYPE_VBI_CAPTURE          = 4,
        V4L2_BUF_TYPE_VBI_OUTPUT           = 5,
        V4L2_BUF_TYPE_SLICED_VBI_CAPTURE   = 6,
        V4L2_BUF_TYPE_SLICED_VBI_OUTPUT    = 7,
    #if 1
        V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY = 8, /* Experimental */
    #endif
        V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE = 9,
        V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE  = 10,
        V4L2_BUF_TYPE_SDR_CAPTURE          = 11,
    };
    // тип буфера
    enum v4l2_memory {
        V4L2_MEMORY_MMAP             = 1,// Памятькартографирование        V4L2_MEMORY_USERPTR          = 2,  // указатель пользовательского пространства
        V4L2_MEMORY_OVERLAY          = 3,// Памятьперекрытие        V4L2_MEMORY_DMABUF           = 4,  // DMAПамять
    };
    /* Timestamp type */
    #define V4L2_BUF_FLAG_TIMESTAMP_MASK  0x0000e000
    #define V4L2_BUF_FLAG_TIMESTAMP_UNKNOWN  0x00000000
    // Временная метка возрастающего типа, в Ядро monotonic Временная метка, созданная на временной шкале часов.
    #define V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC 0x00002000
    #define V4L2_BUF_FLAG_TIMESTAMP_COPY  0x00004000
    /* Timestamp sources. */
    #define V4L2_BUF_FLAG_TSTAMP_SRC_MASK  0x00070000
    #define V4L2_BUF_FLAG_TSTAMP_SRC_EOF  0x00000000
    #define V4L2_BUF_FLAG_TSTAMP_SRC_SOE  0x00010000

    [include/media/videobuf2-core.h]
    enum vb2_io_modes {
        VB2_MMAP = (1 << 0),  // Драйвер поддерживает API потоковой передачи mmap.
        VB2_USERPTR = (1 << 1),  // Драйвер поддерживает API потоковой передачи в режиме указателя пользователя.
        VB2_READ = (1 << 2),  // Драйвер поддерживает доступ read().
        VB2_WRITE = (1 << 3),  // Драйвер поддерживает доступ write().
        VB2_DMABUF = (1 << 4),  // Драйвер поддерживает API потоковой передачи DMABUF.
    };
    struct vb2_queue {
        enum v4l2_buf_type  type;      // Тип videobuf2, см. перечисление Перечисление v4l2_buf_type
        unsigned int  io_modes;        // Поддерживаемые режимы ввода-вывода, см. перечисление. Перечисление vb2_io_modes
        unsigned  fileio_read_once:1;  // Сообщить об EOF после чтения первого буфера 
        unsigned  fileio_write_immediately:1;  // Данные, записанные посредством записи, добавляются в очередь буфера.
        unsigned  allow_zero_bytesused:1;
        // защитить структуру Блокировка мьютекса vb2_queue сериализует операции буферной очереди. Если драйвер действительно имеет блокировку мьютекса,
        // Для него можно установить значение NULL, и API основного уровня videobuf2 не использует эту блокировку.
        struct mutex  *lock;         
        const struct vb2_ops  *ops;          // В драйвере реализована функция обратного вызова
        const struct vb2_mem_ops  *mem_ops;  // Требуется дозатор Память Функция
        void    *drv_priv;       // Управляйте личными данными
        // Размер структуры буфера драйвера. Если он равен 0, это означает, что драйвер не определяет свою собственную структуру буфера. Используйте sizeof(struct. vb2_buffer)
        unsigned int  buf_struct_size;       
        // Флаг метки времени, см. определения макросов V4L2_BUF_FLAG_TIMESTAMP_XX и V4L2_BUF_FLAG_TSTAMP_SRC_XX.
        u32    timestamp_flags;
        // Флаг Память при выделении буфера, обычно 0, также используется GFP_DMA или __GFP_DMA32, чтобы принудительно выделить Память явной области Память.
        gfp_t    gfp_flags;
        u32    min_buffers_needed;  // Минимальное количество буферов, необходимое перед обработкой потока данных
        // Частные блокировки, защищающие выделение, освобождение и сопоставление буферов.
        struct mutex   mmap_lock;
        // В настоящее время используется тип буфера,Значениеenum перечисление v4l2_memory
        enum v4l2_memory  memory;
        struct vb2_buffer  *bufs[VIDEO_MAX_FRAME];  // Сохраните адрес выделенного буфера
        unsigned int   num_buffers;  // Количество выделенных буферов
        struct list_head  queued_list;  // Связанный список буферов в пользовательском пространстве
        unsigned int   queued_count; // Количество готовых буферов в очереди
        atomic_t  owned_by_drv_count;         // Количество буферов, принадлежащих драйверу
        struct list_head  done_list;  // Буфер в этом связанном списке заполнен данными и может быть исключен из очереди и использован пользовательским пространством.  
        spinlock_t  done_lock;        // Спин-блокировка, защищающая связанный список Done_list
        wait_queue_head_t  done_wq;   // Очередь ожидания ожидает освобождения буфера из очереди
        void  *alloc_ctx[VIDEO_MAX_PLANES]; 
        unsigned int  plane_sizes[VIDEO_MAX_PLANES];
        unsigned int  streaming:1;  // Текущее состояние потока
        unsigned int  start_streaming_called:1;  // start_streaming() был успешно вызван
        unsigned int  error:1;  // struct Произошла фатальная ошибка в vb2_queue.
        unsigned int  waiting_for_buffers:1;  // Используется в функции опроса, чтобы проверить, ожидают ли данные еще
        ......
    };

    // Драйвер требует четко определенной функции для работы vb2_queue.
    [include/media/videobuf2-core.h]
    struct vb2_ops {
        // Установите параметры, связанные с очередью буфера
        int (*queue_setup)(struct vb2_queue *q, const struct v4l2_format *fmt,
                unsigned int *num_buffers, unsigned int *num_planes,
                unsigned int sizes[], void *alloc_ctxs[]);
        // Снимите все блокировки при вызове ioctl, чтобы дождаться нового буфера и избежать взаимоблокировки при блокировке.
        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);
        // Его необходимо вызывать каждый раз, когда буфер выводится из очереди в пользовательское пространство, и драйвер может получить доступ к буферу или изменить его.
        void (*buf_finish)(struct vb2_buffer *vb);
        // После вызова буфер освобождается, и драйвер может выполнить некоторую работу по очистке.
        void (*buf_cleanup)(struct vb2_buffer *vb);
        // После вызова поток переходит в открытое состояние. Перед вызовом драйвер должен сначала вызвать buf_queue, чтобы получить буфер.
        int (*start_streaming)(struct vb2_queue *q, unsigned int count);
        // После вызова поток переходит в закрытое состояние, и драйверу необходимо остановить передачу DMA или дождаться завершения работы и постановки всех буферов в очередь.
        void (*stop_streaming)(struct vb2_queue *q);
        // Буфер добавляется в очередь драйвера
        void (*buf_queue)(struct vb2_buffer *vb);
    };

    [include/media/videobuf2-core.h]
    enum vb2_buffer_state {  // Перечисление статуса буфера
        VB2_BUF_STATE_DEQUEUED,  // Удаление буфера из очереди, под контролем пользовательского пространства, состояние по умолчанию
        VB2_BUF_STATE_PREPARING, // videobuf2 готовит буфер
        VB2_BUF_STATE_PREPARED,  // буфер готов
        VB2_BUF_STATE_QUEUED,    // Буфер помещен в очередь и находится в videobuf2, а не в драйвере.
        VB2_BUF_STATE_ACTIVE,    // Буфер находится в драйвере
        VB2_BUF_STATE_DONE,      // Буфер возвращается из драйвера в videobuf2, но еще не исключен из очереди в пространство пользователя.
        VB2_BUF_STATE_ERROR,     // Возникает ошибка. При исключении из очереди в пространство пользователя будет сообщено об ошибке.
    };
    struct vb2_buffer {  // дескриптор видеобуфера
        struct v4l2_buffer v4l2_buf;  // Соответствующий буфер может быть прочитан драйвером
        // Может быть прочитан и записан драйвером (используется в байтах) даже для одноплоскостных типов, v4l2_planes[0] должен быть
        // Используйте byted вместо просто v4l2_buf.
     // Драйвер использует vb2_set_plane_payload() для установки байтов.
        struct v4l2_plane v4l2_planes[VIDEO_MAX_PLANES];
        struct vb2_queue *vb2_queue;  // vb2_queue, к которому принадлежит vb2_buffer
        unsigned int  num_planes;  // Сколько плоскостей имеет этот буфер?
        enum vb2_buffer_state state;   // Текущее состояние буфера
        // queued Буферный связанный список, сохраняет все данные из пользовательского пространства. буферы в очереди
        struct list_head queued_entry;
        // Сохраните все буферы, которые будут исключены из очереди в связанный список пользовательского пространства. 
        struct list_head done_entry;
        // Частная информация для каждого самолета, водителю запрещено ее изменять.
        struct vb2_plane planes[VIDEO_MAX_PLANES];
        ......
    };
    // выделить структуру Если vb2_buffer имеет тип V4L2_MEMORY_MMAP, будет выделена дополнительная Память.
    // Данные изображения хранятся в дополнительно выделенной Память, а дополнительно выделенный указатель Память хранится в структуре.
    struct vb2_plane {
        void  *mem_priv;        //Сохранение одного кадра данных изображения (для режима типа MMAP)
        struct  dma_buf *dbuf;  //(для режима типа DMA)
        unsigned int  dbuf_mapped;
    };

    // struct v4l2_buffer используется для указания и описания буфера кадра, который может установить приложение.
    struct v4l2_buffer {
        __u32   index;  // номер буфера
        __u32   type;   // Тип буфера, состоящий из перечисления определение v4l2_buf_type
        // Количество байтов, занимаемых данными в буфере (полезная нагрузка), неиспользуемых (установлено в 0) для многоплоскостных буферов.
        __u32   bytesused;
        // Бит флага, см. определение макроса V4L2_BUF_FLAG_XX, общие значения — V4L2_BUF_FLAG_MAPPED, 
        // V4L2_BUF_FLAG_QUEUED и V4L2_BUF_FLAG_DONE соответственно означают, что текущий кэш сопоставлен и
        // Кэш может собирать данные, кеш может извлекать данные
        __u32   flags;  
        __u32   field;
        struct timeval  timestamp;  // Временная метка видеокадра
        struct v4l2_timecode timecode;  // временной код
        __u32   sequence;  // Порядковый номер кадра
        __u32   memory;  // enum перечисление определение v4l2_memory
        union {
            // V4L2_MEMORY_MMAP, с устройства, которое необходимо сопоставить смещение от головы памяти к головке данных
            __u32           offset;
            // V4L2_MEMORY_USERPTR,указатель пользовательского пробел указывает на этот буфер
            unsigned long   userptr;
            // for multiplanar buffers; userspace pointer to the array of plane
            // info structs for this buffer
            struct v4l2_plane *planes;
            // V4L2_MEMORY_DMABUF, с этим дескриптором связан дескриптор пользовательского пространства
            __s32  fd;
        } m;
        // Для одноплоскостного указывает количество байтов в буфере.
        // Для многоплоскостности буферы означают плоскости количество элементов в массиве
        __u32   length;
        __u32   reserved2;
        __u32   reserved;
    };

    [include/linux/dma-direction.h]
    enum dma_data_direction {   // Направление передачи данных DMA
        DMA_BIDIRECTIONAL = 0,  // двусторонний
        DMA_TO_DEVICE = 1,      // Перенос на устройство
        DMA_FROM_DEVICE = 2,    // Передача с устройства
        DMA_NONE = 3,
    };    
    [include/media/videobuf2-core.h]
    // Буфер Память, операции обработки и выделения, набор функций       
    struct vb2_mem_ops {
        // Выделить видео Память и распределитель личных данных (необязательно)
        void *(*alloc)(void *alloc_ctx, unsigned long size,
                enum dma_data_direction dma_dir, gfp_t gfp_flags);
        // Сообщите распределителю, что этот буфер больше не используется. Если другой пользователь его не использует, распределитель освободит этот блок.
        void (*put)(void *buf_priv);
        struct dma_buf *(*get_dmabuf)(void *buf_priv, unsigned long flags);
        // получатьуказатель пользовательского пространствазаостренный Память,существоватьV4L2_MEMORY_USERPTRиспользуется в шаблоне
        void *(*get_userptr)(void *alloc_ctx, unsigned long vaddr,
                unsigned long size, enum dma_data_direction dma_dir);
        // Сообщите распределителю, что буфер USERPTR больше не используется.
        void (*put_userptr)(void *buf_priv);
        // Буфер вызывается каждый раз, когда он добавляется в очередь из пользовательского пространства, что полезно для синхронизации кэша.
        void (*prepare)(void *buf_priv);
        // Буфер вызывается каждый раз, когда он добавляется в пространство пользователя из очереди Ядро.
        void (*finish)(void *buf_priv);
        // Добавить общую структуру для аппаратных операций. dma_buf, используется в режиме V4L2_MEMORY_DMABUF
        // alloc_ctx — контекст выделения, dbuf — общий dma_buf
        void *(*attach_dmabuf)(void *alloc_ctx, struct dma_buf *dbuf,
                unsigned long size, enum dma_data_direction dma_dir);
        // Уведомить экспортера буфера о том, что текущий DMABUF больше не используется.
        void (*detach_dmabuf)(void *buf_priv);
        // Запросить доступ к DMABUF у распределителя. Распределитель этого DMABUF уведомит драйвер о том, что DMABUF будет использоваться.
        int (*map_dmabuf)(void *buf_priv);
        // Освободите контроль доступа к DMABUF. Распределитель этого DMABUF уведомит драйвер о том, что DMABUF был использован.
        void (*unmap_dmabuf)(void *buf_priv);
        // Возвращает виртуальный адрес Ядро данного буфера, связанного с частной структурой данных.
        void *(*vaddr)(void *buf_priv);
        // Возвращает файл cookie, определенный распределителем, для данного буфера.
        void *(*cookie)(void *buf_priv);    
        // Возвращает текущего пользователя этого буфера. Если используется только слой videobuf2, верните 1.
        unsigned int (*num_users)(void *buf_priv);
        // Устанавливает сопоставление пользовательского пространства с областью виртуального адреса данного буфера.
        int (*mmap)(void *buf_priv, struct vm_area_struct *vma);
    };

    [include/media/videobuf2-core.h]
    Структура данных очереди q-буфера указатель vb2_queue
    Возвращаемое значение равно -0 в случае успеха; если оно меньше 0, произойдет ошибка.
    int vb2_queue_init(struct vb2_queue *q)
    {
        // Следующие элементы должны быть установлены, иначе будет возвращена ошибка -EINVAL.
        if (WARN_ON(!q) || WARN_ON(!q->ops) || WARN_ON(!q->mem_ops) ||
            WARN_ON(!q->type) || WARN_ON(!q->io_modes) ||
            WARN_ON(!q->ops->queue_setup) || WARN_ON(!q->ops->buf_queue) ||
            WARN_ON(q->timestamp_flags & ~(V4L2_BUF_FLAG_TIMESTAMP_MASK |
                V4L2_BUF_FLAG_TSTAMP_SRC_MASK)))
            return -EINVAL;

        // Водитель должен выбрать подходящую временную метку, иначе Ядро выдаст предупреждение.
        WARN_ON((q->timestamp_flags & V4L2_BUF_FLAG_TIMESTAMP_MASK) ==
            V4L2_BUF_FLAG_TIMESTAMP_UNKNOWN);

        INIT_LIST_HEAD(&q->queued_list);  // Инициализировать узел связанного списка Queueed_list
        INIT_LIST_HEAD(&q->done_list);    // Инициализировать узел связанного списка Done_list
        spin_lock_init(&q->done_lock);    // Инициализировать спин-блокировку
        mutex_init(&q->mmap_lock);        // Инициализировать блокировку мьютекса
        init_waitqueue_head(&q->done_wq); // Инициализировать заголовок очереди ожидания
        // Если драйвер размера буфера не установлен, Ядро инициализируется значением по умолчанию.
        if (q->buf_struct_size == 0)
            q->buf_struct_size = sizeof(struct vb2_buffer);
        return 0;
    }

    [include/media/videobuf2-core.h]
    // Структура данных очереди q-буфера указатель vb2_queue
    // req — структура, в которой хранится информация, необходимая для обращения к буферу. Приложению необходимо установить элементы внутри.
    // Возвращаемое значение равно -0 в случае успеха; если оно меньше 0, произойдет ошибка.
    int vb2_reqbufs(struct vb2_queue *q, struct v4l2_requestbuffers *req);
    [include/uapi/linux/videodev2.h]
    struct v4l2_requestbuffers {
        __u32  count;       // Количество буферов, к которым применяется один кадр изображения, соответствует одному буферу.
        __u32  type;  // тип буфера,Камера V4L2_BUF_TYPE_VIDEO_CAPTURE.
        __u32  memory;  // Обычно V4L2_MEMORY_MMAP или V4L2_MEMORY_USERPTR.
        __u32  reserved[2]; // бронировать
    };

    vb2_reqbufs
      // Проверьте память буфера типибуфер Тип правильный?
        ->__verify_memory_type
        ->__reqbufs
            // Количество запрошенных буферов равно 0 или количество буферов в очереди буферов не равно 0 или
            // Если примененный тип буфера несовместим с типом буфера в очереди буферов, требуется дополнительная обработка.
            if (req->count == 0 || q->num_buffers != 0 || q->memory != req->memory) {
                mutex_lock(&q->mmap_lock);
                // Если тип Память — V4L2_MEMORY_MMAP и буфер используется, то ошибка будет возвращена напрямую.
                if (q->memory == V4L2_MEMORY_MMAP && __buffers_in_use(q)) {
                    mutex_unlock(&q->mmap_lock);
                    return -EBUSY;
                }
                // Если буфер находится в состоянии ПОДГОТОВЛЕНО или В ОЧЕРЕДИ, его необходимо очистить.
                // Обычно такая ситуация возникает, когда буфер применяется, но STREAMON не вызывается.
                __vb2_queue_cancel(q);
                // Освободить выделенный буфер
                ret = __vb2_queue_free(q, q->num_buffers);
                mutex_unlock(&q->mmap_lock);
            }
            // Количество буферов — это меньшее из числа, запрошенного приложением, а максимальное количество VIDEO_MAX_FRAME определяется как 32.
            num_buffers = min_t(unsigned int, req->count, VIDEO_MAX_FRAME);
            // Количество буферов — это большее из num_buffers и минимальное необходимое количество буферов.
            num_buffers = max_t(unsigned int, num_buffers, q->min_buffers_needed);
            // Установите модель буфера «Память» в очереди буферов. Модель «Память» должна соответствовать модели, применяемой приложением.
            q->memory = req->memory;
            // Обратный вызов функции query_setup, предоставляемой драйвером, функция, предоставляемая imx6ull, — mx6s_videobuf_setup.
            // водить машинуфункция Нужно установитьnum_buffers、num_buffers、q->plane_sizesиq->alloc_ctx
            call_qop(...queue_setup...)
            // Выделить буфер
            ->__vb2_queue_alloc
            // нравиться Количество выделенных буферовменьше, чем требуется для выделенияизколичество,Нужно позвонить еще разводить машинупоставлятьизqueue_setupфункция
            if (!ret && allocated_buffers < num_buffers) {
                num_buffers = allocated_buffers;
                // Если драйвер может справиться с этой ситуацией, он не вернет ошибку. Если он не может ее обработать, он вернет ошибку.
                // mx6s_videobuf_setup не имеет этой функции
                ret = call_qop(q, queue_setup, q, NULL, &num_buffers,
                        &num_planes, q->plane_sizes, q->alloc_ctx);
                if (!ret && allocated_buffers < num_buffers)
                    ret = -ENOMEM;
            }
            ->mutex_lock(&q->mmap_lock);  // Доступ к общему участнику буфера требует синхронизации.
            // настраивать Количество выделенных буферов
            q->num_buffers = allocated_buffers;
            ->mutex_unlock(&q->mmap_lock);
            req->count = allocated_buffers  // Вернуть количество в приложение выделенных буферов

    static int mx6s_videobuf_setup(struct vb2_queue *vq,
                const struct v4l2_format *fmt,
                unsigned int *count, unsigned int *num_planes,
                unsigned int sizes[], void *alloc_ctxs[])
    {
        struct mx6s_csi_dev *csi_dev = vb2_get_drv_priv(vq);
        alloc_ctxs[0] = csi_dev->alloc_ctx;  // установить alloc_ctxs
        sizes[0] = csi_dev->pix.sizeimage;   // Установите plane_sizes в соответствии с размером изображения.
        if (0 == *count)  // Если количество переданных буферов равно 0, ему присваивается значение 32.
            *count = 32;
        // Если num_planes равно 0 и общее количество Память, занимаемое буфером, превышает указанное максимальное значение, количество буферов будет пересчитано.
        // Максимальное значение — 64 МБ, MAX_VIDEO_MEM определяется как 64.
        if (!*num_planes && sizes[0] * *count > MAX_VIDEO_MEM * 1024 * 1024)
            // Затем количество буферов рассчитывается по максимальному Память
            *count = (MAX_VIDEO_MEM * 1024 * 1024) / sizes[0];
        *num_planes = 1;  // Установите количество самолетов на 1.
        return 0;
    }

    static int __vb2_queue_alloc(struct vb2_queue *q, enum v4l2_memory memory,
                    unsigned int num_buffers, unsigned int num_planes)
    {
        unsigned int buffer;
        struct vb2_buffer *vb;
        int ret;
        // Всего выделено num_buffers буферов.
        for (buffer = 0; buffer < num_buffers; ++buffer) {
            // Выделить буфер,Размер буфера — buf_struct_size.,Обычно устанавливается водителем,
            // Для платформы imx6ull установлено значение sizeof(struct mx6s_buffer)
            vb = kzalloc(q->buf_struct_size, GFP_KERNEL);

            // Если оно многоплоскостное буферы, длина буфера хранит количество плоскостей
            if (V4L2_TYPE_IS_MULTIPLANAR(q->type))
                vb->v4l2_buf.length = num_planes;

            vb->state = VB2_BUF_STATE_DEQUEUED;  // Установить статус буфера
            vb->vb2_queue = q;  // Установите очередь буферов для управления буферами
            vb->num_planes = num_planes;  // Установите количество самолетов
            vb->v4l2_buf.index = q->num_buffers + buffer;  // Установить номер буфера
            vb->v4l2_buf.type = q->type;   // настраиватьтип буфера
            vb->v4l2_buf.memory = memory;  // Установить тип буфера

            // Для типа V4L2_MEMORY_MMAP также необходимо выделить дополнительную Память для сохранения данных изображения.
            // Затем, отображаясь в пользовательском пространстве, пользователи могут напрямую читать данные в дополнительном Память.
            if (memory == V4L2_MEMORY_MMAP) {
                
                // ******Выделение хранилища данных изображения Памятьфункция******
                ->__vb2_buf_mem_alloc(vb);
                    // Для каждого буфера выделите num_planes дополнительных блоков Память
                    for (plane = 0; plane < vb->num_planes; ++plane) {
                        // Выделенный размер Память выровнен по странице.
                        unsigned long size = PAGE_ALIGN(q->plane_sizes[plane]);
                        // Вызовите allocфункцию, предоставленную драйвером, чтобы выделить Память,
                        // Платформа imx6ull вызывает функцию vb2_dc_alloc
                        mem_priv = call_ptr_memop(vb, alloc, q->alloc_ctx[plane],
                                    size, dma_dir, q->gfp_flags);
                        // Сохраните дополнительно выделенную Память в члене mem_priv.
                        vb->planes[plane].mem_priv = mem_priv;
                        // сохранить длину
                        vb->v4l2_planes[plane].length = q->plane_sizes[plane];
                    }

                // Вызов функции buf_init, предоставляемой драйвером для инициализации, которая не предусмотрена imx6ull.
                ->call_vb_qop(vb, buf_init, vb);
            }
            // Сохранить адрес буфера
            q->bufs[q->num_buffers + buffer] = vb;
        }
        // Установите длину каждой плоскости всех буферов
        ->__setup_lengths(q, buffer);
            vb->v4l2_planes[plane].length = q->plane_sizes[plane]
        // Для типа MMAP также необходимо установить смещение. Каждое смещение плоскости каждого буфера отличается.
        if (memory == V4L2_MEMORY_MMAP)
            ->__setup_offsets(q, buffer);
        return buffer;
    }

    [drivers\media\v4l2-core\videobuf2-dma-contig.c]
    struct vb2_dc_buf {
        struct device  *dev;
        void  *vaddr;          // Память виртуальный адрес
        unsigned long  size;   // Памятьразмер        dma_addr_t  dma_addr;  // Памятьфизический адрес
        enum dma_data_direction  dma_dir;  // Направление передачи DMA
        struct sg_table  *dma_sgt;  // SG связанные с DMA
        /* Переменные, связанные с MMAP */
        struct vb2_vmarea_handler  handler;
        atomic_t  refcount;
        struct sg_table  *sgt_base;
        struct vm_area_struct  *vma; // Переменные, связанные с USERPTR
        struct dma_buf_attachment  *db_attach;  // Переменные, связанные с DMABUF
    };
    static void *vb2_dc_alloc(void *alloc_ctx, unsigned long size,
                enum dma_data_direction dma_dir, gfp_t gfp_flags)
    {
        struct vb2_dc_conf *conf = alloc_ctx;
        struct device *dev = conf->dev;
        struct vb2_dc_buf *buf;
        // Сначала выделите структуру Структура vb2_dc_buf
        buf = kzalloc(sizeof *buf, GFP_KERNEL);
        // Затем выделите буфер для хранения данных изображения. Физический и виртуальный адреса этого буфера являются смежными.
        buf->vaddr = dma_alloc_coherent(dev, size, &buf->dma_addr, GFP_KERNEL | gfp_flags);
        buf->dev = get_device(dev);  // Установить указатель родительского устройства
        buf->size = size;  // Размер буфера для хранения данных изображения
        buf->dma_dir = dma_dir;  // Записывать Направление передачи DMA
        // установить структуру Структура vb2_vmarea_handler
        buf->handler.refcount = &buf->refcount;
        buf->handler.put = vb2_dc_put;  // перезвонитьфункция        buf->handler.arg = buf;  // Параметры функции обратного вызова
        atomic_inc(&buf->refcount);  // Увеличьте счетчик ссылок и освободите буфер, когда счетчик ссылок достигнет 0.
        return buf;  // Возвращает назначенный адрес vb2_dc_buf
    }

    [include/media/videobuf2-core.h]
    // Структура данных очереди q-буфера указатель vb2_queue
    // b-v4l2_buffer указатель на структуру, Ядро хранит в нем информацию о буфере
    // Возвращаемое значение равно -0 в случае успеха; если оно меньше 0, произойдет ошибка.
    int vb2_querybuf(struct vb2_queue *q, struct v4l2_buffer *b);

    [include/media/videobuf2-core.h]
    // Структура данных очереди q-буфера указатель vb2_queue
    // b-v4l2_buffer указатель структуры
    // Возвращаемое значение равно -0 в случае успеха; если оно меньше 0, произойдет ошибка.
    int vb2_qbuf(struct vb2_queue *q, struct v4l2_buffer *b);

    vb2_qbuf
        ->vb2_internal_qbuf
            // Получить адрес буфера соответствующего числа
            vb = q->bufs[b->index];
            // Проверьте состояние буфера, только VB2_BUF_STATE_DEQUEUED и
            // Состояние VB2_BUF_STATE_PREPARED можно добавить в очередь кэша драйвера.
            switch (vb->state) {
            case VB2_BUF_STATE_DEQUEUED:

                -> __buf_prepare(vb, b);
                    ->__verify_length;  // Проверьте длину данных
                    vb->state = VB2_BUF_STATE_PREPARING;  // Установить статус буферадляPREPARING
                    vb->v4l2_buf.timestamp.tv_sec = 0;  // Очистить временную метку
                    vb->v4l2_buf.timestamp.tv_usec = 0;
                    vb->v4l2_buf.sequence = 0;  // Установите серийный номер на 0

                    ->__qbuf_mmap(vb, b);    // Вызов типа V4L2_MEMORY_MMAP
                        ->__fill_vb2_buffer  // Заполните данные и проверьте
                        // Вызов buf_prepareфункция, платформа imx6ull вызывает mx6s_videobuf_prepareфункция
                        // Основная функция — установить полезную нагрузку и проверить правильность виртуального адреса буфера.
                        call_vb_qop(vb, buf_prepare, vb) 
                    ->__qbuf_userptr(vb, b);  // Вызов типа V4L2_MEMORY_USERPTR
                        ->__fill_vb2_buffer   // Заполните данные и проверьте
                        // Вызовите функцию обратного вызова get_userptr, предоставляемую драйвером,
                        // Платформа imx6ull вызывает функцию обратного вызова vb2_dc_get_userptr
                        call_ptr_memop(...get_userptr...);
                        // Вызов buf_prepareфункция, платформа imx6ull вызывает mx6s_videobuf_prepareфункция
                        call_vb_qop(vb, buf_prepare, vb);
                    // dmabuf в настоящее время не представлен и не будет обсуждаться.
                    ->__qbuf_dmabuf(vb, b);  // Вызов типа V4L2_MEMORY_DMABUF
                break;

            case VB2_BUF_STATE_PREPARED:
                break;
            // videobuf2 готовит буфер,нельзя добавить вводить машинуизочередь кэша
            // __buf_prepareфункция установит внутреннее состояние VB2_BUF_STATE_PREPARING
            case VB2_BUF_STATE_PREPARING:
                return -EINVAL;
            default:
                return -EINVAL;
            }
            // Повесьте буфер, переданный приложением, в связанный списокqueued_list.
            list_add_tail(&vb->queued_entry, &q->queued_list)
            q->queued_count++;  // Увеличьте количество буферов в списке очереди_списка на 1.
            vb->state = VB2_BUF_STATE_QUEUED;

            // Если был вызван VIDIOC_STREAMON, буфер необходимо добавить в очередь буферов драйвера.
            if (q->start_streaming_called)  
                // Подвешивание буфера к imx6ull В связанном списке захвата структуры драйвера устройства CSI.
                ->__enqueue_in_driver(vb);

            __fill_v4l2_buffer(vb, b);  // Наполните пользовательское пространство информацией

    static int mx6s_videobuf_prepare(struct vb2_buffer *vb)
    {
        struct mx6s_csi_dev *csi_dev = vb2_get_drv_priv(vb->vb2_queue);
        int ret = 0;
        // Установите полезную нагрузку, полезная нагрузка — это размер изображения.
        vb2_set_plane_payload(vb, 0, csi_dev->pix.sizeimage);
            // Эффективное количество байтов в буфере — это размер изображения.
            vb->v4l2_planes[plane_no].bytesused = size
        // Проверьте, существует ли виртуальный адрес буфера и правильно ли установлена ​​полезная нагрузка.
        if (vb2_plane_vaddr(vb, 0) &&
            vb2_get_plane_payload(vb, 0) > vb2_plane_size(vb, 0)) {
            ret = -EINVAL;
            goto out;
        }
        return 0;
    out:
        return ret;
    }

    // Получить виртуальный адрес самолета
    vb2_plane_vaddr(vb, 0);
        // Вызовите функцию vaddr, предоставленную драйвером, и платформа imx6ull вызовет vb2_dc_vaddr.
        call_ptr_memop(vb, vaddr, vb->planes[plane_no].mem_priv)
        ->vb2_dc_vaddr
            return buf->vaddr  // Возвращает виртуальный адрес, по которому хранится изображение Память.

    [include/media/videobuf2-core.h]
    // Структура данных очереди q-буфера указатель vb2_queue
    // type-тип буфера
    // Возвращаемое значение равно -0 в случае успеха; если оно меньше 0, произойдет ошибка.
    int vb2_streamon(struct vb2_queue *q, enum v4l2_buf_type type);

    vb2_streamon
        ->vb2_internal_streamon
            ->vb2_start_streaming
                // Добавьте в драйвер все буферы из очереди_list.
                list_for_each_entry(vb, &q->queued_list, queued_entry)
                    __enqueue_in_driver
                        vb->state = VB2_BUF_STATE_ACTIVE  // Установить статус буфера
                        atomic_inc(&q->owned_by_drv_count)  // Увеличьте количество буферов использования драйверов
                        // Вызов функции подготовки для каждой плоскости буфера
                        all_void_memop(vb, prepare, vb->planes[plane].mem_priv)
                        ->vb2_dc_prepare  // Платформа imx6ull вызывает функцию vb2_dc_prepareфункция.
                            // буфер синхронизации
                            ->dma_sync_sg_for_device
                        // вызов функции buf_queue
                        call_void_vb_qop(vb, buf_queue, vb)
                        ->mx6s_videobuf_queue
                            ->spin_lock_irqsave  // Замок
                            // Подвешивание буфера к imx6ull В связанном списке захвата структуры драйвера устройства CSI.
                            list_add_tail(&buf->internal.queue, &csi_dev->capture)
                            ->spin_unlock_irqrestore  // Разблокировать
                q->start_streaming_called = 1  // Установить VIDIOC_STREAMON был вызван флаг
                // Обратный вызов start_streamingфункции в драйвере, видеоустройство начинает работать
                call_qop(q, start_streaming, q, atomic_read(&q->owned_by_drv_count))
                ->mx6s_start_streaming  // Платформа imx6ull вызывает функцию mx6s_start_streaming.
                    ->mx6s_csi_enable   // включить устройство,начинать Получение изображения
            q->streaming = 1;  // Установить флаг открытия потока

    [include/media/videobuf2-core.h]
    // Структура данных очереди q-буфера указатель vb2_queue
    // b-v4l2_buffer указатель структуры
    // флаг неблокирующей блокировки,в соответствии сfile->f_flags & Решение O_NONBLOCK
    // Возвращаемое значение равно -0 в случае успеха; если оно меньше 0, произойдет ошибка.
    int vb2_dqbuf(struct vb2_queue *q, struct v4l2_buffer *b, bool nonblocking);

    vb2_dqbuf
        ->vb2_internal_dqbuf
            // Подождите, пока буфер станет доступным. Если буфер доступен, верните 0.
            // Если неблокировка и буфер недоступен, будет возвращена ошибка -EAGAIN.
            // Заблокировано и нет доступного буфера, спать и ждать
            ->__vb2_wait_for_done_vb
                // буфер ожидания ожидания
                call_void_qop(q, wait_prepare, q)
                ->vb2_ops_wait_prepare  // wait_prepare в конечном итоге вызывает функцию vb2_ops_wait_prepare
                ->vb2_ops_wait_prepare
                    ->mutex_unlock(vq->lock);  // разблокировать замок
                ->wait_event_interruptible     // буфер ожидания ожидания Доступный
                // Буфер пробуждается, когда он доступен, выполняется функция wait_finish и, наконец, вызывается функция vb2_ops_wait_finish.
                call_void_qop(q, wait_finish, q)
                ->vb2_ops_wait_finish
                    ->mutex_lock(vq->lock);            // Получить блокировку
            ->spin_lock_irqsave(&q->done_lock, flags)  // Получить спин-блокировку
            // Получить доступный буфер в списке Done_list.
            list_first_entry(&q->done_list, struct vb2_buffer, done_entry)
            ->__verify_planes_array  // Убедитесь, что все плоскости в извлеченном буфере доступны.
            list_del(&(*vb)->done_entry)  // Если все плоскости в буфере доступны, удалите буфер из списка Done_list.
            spin_unlock_irqrestore(&q->done_lock, flags)  // Освободить спин-блокировку
        // Вызов функции buf_finish, платформа imx6ull не реализована
        call_void_vb_qop(vb, buf_finish, vb)
        ->__fill_v4l2_buffer(vb, b)  // Заполнить информацию о буфере удаления из очереди в пользовательское пространство
        list_del(&vb->queued_entry); // Удалите буфер из связанного спискаqueued_entry.
        q->queued_count--;  // Уменьшить буфер очереди на 1.
        ->__vb2_dqbuf
            vb->state = VB2_BUF_STATE_DEQUEUED;  // Установите буфер в состояние VB2_BUF_STATE_DEQUEUED.

    [include/media/videobuf2-core.h]
    // Структура данных очереди q-буфера указатель vb2_queue
    // type-тип буфера
    // Возвращаемое значение равно -0 в случае успеха; если оно меньше 0, произойдет ошибка.
    int vb2_streamoff(struct vb2_queue *q, enum v4l2_buf_type type);

    vb2_streamoff
        ->vb2_internal_streamoff
            // отменить буфер
            ->__vb2_queue_cancel
                // Вызовите функцию, предоставленную драйвером, чтобы остановить поток.
                call_void_qop(q, stop_streaming, q)
                ->mx6s_stop_streaming
                    ->mx6s_csi_disable  // Выключите устройство видеозахвата
                q->streaming = 0;  // Очистить флаг открытия потока
                q->start_streaming_called = 0;  // Очистить флаг вызова VIDIOC_STREAMON
                q->queued_count = 0;  // Очистить счетчик буфера очереди
                q->error = 0;
                INIT_LIST_HEAD(&q->queued_list)  // Очистить список очереди
                INIT_LIST_HEAD(&q->done_list)    // Очистить список завершения
                ->atomic_set(&q->owned_by_drv_count, 0)  // Установите счетчик ссылок драйвера на 0.
                ->wake_up_all(&q->done_wq)  // Разбудить поток, ожидающий в очереди буфера
                ->__vb2_dqbuf(vb)  // Удалить все буферы из очереди в пользовательское пространство
                    vb->state = VB2_BUF_STATE_DEQUEUED

    [include/media/videobuf2-core.h]
    // Структура данных очереди q-буфера указатель vb2_queue
    // vma-virtual Указатель структуры управления областью Память
    // Возвращаемое значение равно -0 в случае успеха; если оно меньше 0, произойдет ошибка.
    int vb2_mmap(struct vb2_queue *q, struct vm_area_struct *vma);

    vb2_mmap
        // Получить смещение буферной плоскости
        ->__find_plane_by_offset
        PAGE_ALIGN  // mmap требует, чтобы Память было выровнено по страницам
        ->mutex_lock(&q->mmap_lock)  // Получить блокировку mmap_lock
        // Вызов mmapфункции, предоставляемой драйвером
        call_memop(vb, mmap, vb->planes[plane].mem_priv, vma)
        ->vb2_dc_mmap  // Платформа imx6ull вызывает vb2_dc_mmap для сопоставления Память.
            ->dma_mmap_coherent  // DMAПамять сопоставление согласованности
            // Установить виртуальную Память не может расширяться и ядро флаг дампа
            vma->vm_flags  |= VM_DONTEXPAND | VM_DONTDUMP;
         vma->vm_private_data = &buf->handler;  // Установить личные данные
         vma->vm_ops  = &vb2_common_vm_ops;  // Как настроить виртуальную Памятьфункция
            vma->vm_ops->open(vma);  // Открыть виртуальную Память
        ->mutex_unlock(&q->mmap_lock);  // Снимите блокировку mmap_lock

    [include/media/videobuf2-core.h]
    // Структура данных очереди q-буфера указатель vb2_queue
    // data - указатель буфера пользовательского пространства
    // count - количество прочитанных байтов данных
    // ppos — указатель смещения файла
    // неблокирующий-неблокирующий флаг
    // Возвращаемое значение — количество успешно прочитанных байт, если оно больше или равно 0, если меньше 0, то произойдет ошибка.
    size_t vb2_read(struct vb2_queue *q, char __user *data, size_t count,
      loff_t *ppos, int nonblocking);

    [include/media/videobuf2-core.h]
    // Структура данных очереди q-буфера указатель vb2_queue
    // Возвращаемое значение — нет
    void vb2_queue_release(struct vb2_queue *q);

    void vb2_queue_release(struct vb2_queue *q)
    {
        __vb2_cleanup_fileio(q);  // Освободите ресурсы, занятые симулятором файлового ввода-вывода.
        __vb2_queue_cancel(q);    // Выйти и остановить потоки
        mutex_lock(&q->mmap_lock);
        // Освободить буфер Память
        __vb2_queue_free(q, q->num_buffers);
        mutex_unlock(&q->mmap_lock);
    }