自学教程：C++ vb2_queue_init函数代码示例

static int queue_init(void *priv, struct vb2_queue *src_vq,		      struct vb2_queue *dst_vq){	struct fimc_ctx *ctx = priv;	int ret;	memset(src_vq, 0, sizeof(*src_vq));	src_vq->type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;	src_vq->io_modes = VB2_MMAP | VB2_USERPTR;	src_vq->drv_priv = ctx;	src_vq->ops = &fimc_qops;	src_vq->mem_ops = &vb2_dma_contig_memops;	src_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer);	ret = vb2_queue_init(src_vq);	if (ret)		return ret;	memset(dst_vq, 0, sizeof(*dst_vq));	dst_vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;	dst_vq->io_modes = VB2_MMAP | VB2_USERPTR;	dst_vq->drv_priv = ctx;	dst_vq->ops = &fimc_qops;	dst_vq->mem_ops = &vb2_dma_contig_memops;	dst_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer);	return vb2_queue_init(dst_vq);}

static int queue_init(void *priv, struct vb2_queue *src_vq,						struct vb2_queue *dst_vq){	struct g2d_ctx *ctx = priv;	int ret;	src_vq->type = V4L2_BUF_TYPE_VIDEO_OUTPUT;	src_vq->io_modes = VB2_MMAP | VB2_USERPTR;	src_vq->drv_priv = ctx;	src_vq->ops = &g2d_qops;	src_vq->mem_ops = &vb2_dma_contig_memops;	src_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer);	src_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;	src_vq->lock = &ctx->dev->mutex;	ret = vb2_queue_init(src_vq);	if (ret)		return ret;	dst_vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;	dst_vq->io_modes = VB2_MMAP | VB2_USERPTR;	dst_vq->drv_priv = ctx;	dst_vq->ops = &g2d_qops;	dst_vq->mem_ops = &vb2_dma_contig_memops;	dst_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer);	dst_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;	dst_vq->lock = &ctx->dev->mutex;	return vb2_queue_init(dst_vq);}

static int queue_init(void *priv, struct vb2_queue *src_vq,		      struct vb2_queue *dst_vq){	struct gsc_ctx *ctx = priv;	int ret;	memset(src_vq, 0, sizeof(*src_vq));	src_vq->name = kasprintf(GFP_KERNEL, "%s-src", dev_name(&ctx->gsc_dev->pdev->dev));	src_vq->type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;	src_vq->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF;	src_vq->drv_priv = ctx;	src_vq->ops = &gsc_m2m_qops;	src_vq->mem_ops = ctx->gsc_dev->vb2->ops;	src_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer);	ret = vb2_queue_init(src_vq);	if (ret)		return ret;	memset(dst_vq, 0, sizeof(*dst_vq));	dst_vq->name = kasprintf(GFP_KERNEL, "%s-dst", dev_name(&ctx->gsc_dev->pdev->dev));	dst_vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;	dst_vq->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF;	dst_vq->drv_priv = ctx;	dst_vq->ops = &gsc_m2m_qops;	dst_vq->mem_ops = ctx->gsc_dev->vb2->ops;	dst_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer);	return vb2_queue_init(dst_vq);}

/** * m2m specific */static int m2m_queue_init(void *priv, struct vb2_queue *src_vq,        struct vb2_queue *dst_vq){    struct nxp_video *me = priv;    int ret;    memset(src_vq, 0, sizeof(*src_vq));    src_vq->name = kasprintf(GFP_KERNEL, "%s-src", me->name);    src_vq->type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;    src_vq->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF;    src_vq->drv_priv = me;    src_vq->ops = &nxp_vb2_ops;    src_vq->mem_ops = &vb2_ion_memops;    src_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer);    ret = vb2_queue_init(src_vq);    if (ret) {        pr_err("%s: failed to vb2_queue_init(src_vq)/n", __func__);        return ret;    }    memset(dst_vq, 0, sizeof(*dst_vq));    dst_vq->name = kasprintf(GFP_KERNEL, "%s-dst", me->name);    dst_vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;    dst_vq->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF;    dst_vq->drv_priv = me;    dst_vq->ops = &nxp_vb2_ops;    dst_vq->mem_ops = &vb2_ion_memops;    dst_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer);    return vb2_queue_init(dst_vq);}

static int hx_queue_init_enc(void *priv, struct vb2_queue *src_vq,		      struct vb2_queue *dst_vq){	struct jpeg_ctx *ctx = priv;	int ret;	memset(src_vq, 0, sizeof(*src_vq));	src_vq->type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;	src_vq->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF;	src_vq->drv_priv = ctx;	src_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer);	src_vq->ops = &jpeg_hx_enc_vb2_qops;	src_vq->mem_ops = ctx->dev->vb2->ops;	ret = vb2_queue_init(src_vq);	if (ret)		return ret;	memset(dst_vq, 0, sizeof(*dst_vq));	dst_vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;	dst_vq->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF;	dst_vq->drv_priv = ctx;	dst_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer);	dst_vq->ops = &jpeg_hx_enc_vb2_qops;	dst_vq->mem_ops = ctx->dev->vb2->ops;	return vb2_queue_init(dst_vq);}

static int queue_init(void *priv, struct vb2_queue *src_vq,			struct vb2_queue *dst_vq){	struct gsc_ctx *ctx = priv;	int ret;	memset(src_vq, 0, sizeof(*src_vq));	src_vq->type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;	src_vq->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF;	src_vq->drv_priv = ctx;	src_vq->ops = &gsc_m2m_qops;	src_vq->mem_ops = &vb2_dma_contig_memops;	src_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer);	src_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;	src_vq->lock = &ctx->gsc_dev->lock;	src_vq->dev = &ctx->gsc_dev->pdev->dev;	ret = vb2_queue_init(src_vq);	if (ret)		return ret;	memset(dst_vq, 0, sizeof(*dst_vq));	dst_vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;	dst_vq->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF;	dst_vq->drv_priv = ctx;	dst_vq->ops = &gsc_m2m_qops;	dst_vq->mem_ops = &vb2_dma_contig_memops;	dst_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer);	dst_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;	dst_vq->lock = &ctx->gsc_dev->lock;	dst_vq->dev = &ctx->gsc_dev->pdev->dev;	return vb2_queue_init(dst_vq);}

static int queue_init(void *priv, struct vb2_queue *vbq_src,	struct vb2_queue *vbq_dst){	int ret = 0;	struct fimc_is_video_ctx *vctx = priv;	BUG_ON(!vctx);	if (vctx->type == FIMC_IS_VIDEO_TYPE_OUTPUT) {		BUG_ON(!vbq_src);		vbq_src->type		= V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;		vbq_src->io_modes	= VB2_MMAP | VB2_USERPTR | VB2_DMABUF;		vbq_src->drv_priv	= vctx;		vbq_src->ops		= vctx->vb2_ops;		vbq_src->mem_ops	= vctx->mem_ops;		vb2_queue_init(vbq_src);		vctx->q_src.vbq = vbq_src;	} else if (vctx->type == FIMC_IS_VIDEO_TYPE_CAPTURE) {		BUG_ON(!vbq_dst);		vbq_dst->type		= V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;		vbq_dst->io_modes	= VB2_MMAP | VB2_USERPTR | VB2_DMABUF;		vbq_dst->drv_priv	= vctx;		vbq_dst->ops		= vctx->vb2_ops;		vbq_dst->mem_ops	= vctx->mem_ops;		vb2_queue_init(vbq_dst);		vctx->q_dst.vbq = vbq_dst;	} else if (vctx->type == FIMC_IS_VIDEO_TYPE_M2M) {		BUG_ON(!vbq_src);		BUG_ON(!vbq_dst);		vbq_src->type		= V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;		vbq_src->io_modes	= VB2_MMAP | VB2_USERPTR | VB2_DMABUF;		vbq_src->drv_priv	= vctx;		vbq_src->ops		= vctx->vb2_ops;		vbq_src->mem_ops	= vctx->mem_ops;		vb2_queue_init(vbq_src);		vctx->q_src.vbq = vbq_src;		vbq_dst->type		= V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;		vbq_dst->io_modes	= VB2_MMAP | VB2_USERPTR | VB2_DMABUF;		vbq_dst->drv_priv	= vctx;		vbq_dst->ops		= vctx->vb2_ops;		vbq_dst->mem_ops	= vctx->mem_ops;		vb2_queue_init(vbq_dst);		vctx->q_dst.vbq = vbq_dst;	} else {		merr("video type is invalid(%d)", vctx, vctx->type);		ret = -EINVAL;	}	return ret;}

static intenc_queue_init(void *priv, struct vb2_queue *src_vq, struct vb2_queue *dst_vq){	struct rockchip_vpu_ctx *ctx = priv;	int ret;	src_vq->type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;	src_vq->io_modes = VB2_MMAP | VB2_DMABUF;	src_vq->drv_priv = ctx;	src_vq->ops = &rockchip_vpu_enc_queue_ops;	src_vq->mem_ops = &vb2_dma_contig_memops;	/*	 * Driver does mostly sequential access, so sacrifice TLB efficiency	 * for faster allocation. Also, no CPU access on the source queue,	 * so no kernel mapping needed.	 */	src_vq->dma_attrs = DMA_ATTR_ALLOC_SINGLE_PAGES |			    DMA_ATTR_NO_KERNEL_MAPPING;	src_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer);	src_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;	src_vq->lock = &ctx->dev->vpu_mutex;	src_vq->dev = ctx->dev->v4l2_dev.dev;	ret = vb2_queue_init(src_vq);	if (ret)		return ret;	/*	 * The CAPTURE queue doesn't need dma memory,	 * as the CPU needs to create the JPEG frames,	 * from the hardware-produced JPEG payload.	 *	 * For the DMA destination buffer, we use	 * a bounce buffer.	 */	dst_vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;	dst_vq->io_modes = VB2_MMAP | VB2_DMABUF;	dst_vq->drv_priv = ctx;	dst_vq->ops = &rockchip_vpu_enc_queue_ops;	dst_vq->mem_ops = &vb2_vmalloc_memops;	dst_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer);	dst_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;	dst_vq->lock = &ctx->dev->vpu_mutex;	dst_vq->dev = ctx->dev->v4l2_dev.dev;	return vb2_queue_init(dst_vq);}

int usbtv_video_init(struct usbtv *usbtv){	int ret;	(void)usbtv_configure_for_norm(usbtv, V4L2_STD_525_60);	spin_lock_init(&usbtv->buflock);	mutex_init(&usbtv->v4l2_lock);	mutex_init(&usbtv->vb2q_lock);	INIT_LIST_HEAD(&usbtv->bufs);	/* videobuf2 structure */	usbtv->vb2q.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;	usbtv->vb2q.io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ;	usbtv->vb2q.drv_priv = usbtv;	usbtv->vb2q.buf_struct_size = sizeof(struct usbtv_buf);	usbtv->vb2q.ops = &usbtv_vb2_ops;	usbtv->vb2q.mem_ops = &vb2_vmalloc_memops;	usbtv->vb2q.timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;	usbtv->vb2q.lock = &usbtv->vb2q_lock;	ret = vb2_queue_init(&usbtv->vb2q);	if (ret < 0) {		dev_warn(usbtv->dev, "Could not initialize videobuf2 queue/n");		return ret;	}	/* v4l2 structure */	usbtv->v4l2_dev.release = usbtv_release;	ret = v4l2_device_register(usbtv->dev, &usbtv->v4l2_dev);	if (ret < 0) {		dev_warn(usbtv->dev, "Could not register v4l2 device/n");		goto v4l2_fail;	}	/* Video structure */	strlcpy(usbtv->vdev.name, "usbtv", sizeof(usbtv->vdev.name));	usbtv->vdev.v4l2_dev = &usbtv->v4l2_dev;	usbtv->vdev.release = video_device_release_empty;	usbtv->vdev.fops = &usbtv_fops;	usbtv->vdev.ioctl_ops = &usbtv_ioctl_ops;	usbtv->vdev.tvnorms = USBTV_TV_STD;	usbtv->vdev.queue = &usbtv->vb2q;	usbtv->vdev.lock = &usbtv->v4l2_lock;	set_bit(V4L2_FL_USE_FH_PRIO, &usbtv->vdev.flags);	video_set_drvdata(&usbtv->vdev, usbtv);	ret = video_register_device(&usbtv->vdev, VFL_TYPE_GRABBER, -1);	if (ret < 0) {		dev_warn(usbtv->dev, "Could not register video device/n");		goto vdev_fail;	}	return 0;vdev_fail:	v4l2_device_unregister(&usbtv->v4l2_dev);v4l2_fail:	vb2_queue_release(&usbtv->vb2q);	return ret;}

static int queue_setup(struct vb2_queue *vq, const struct v4l2_format *pfmt,		unsigned int *nbuffers, unsigned int *nplanes,		unsigned int sizes[], void *alloc_ctxs[]){	struct mxr_layer *layer = vb2_get_drv_priv(vq);	const struct mxr_format *fmt = layer->fmt;	int i;	struct mxr_device *mdev = layer->mdev;	struct v4l2_plane_pix_format planes[3];	mxr_dbg(mdev, "%s/n", __func__);	/* checking if format was configured */	if (fmt == NULL)		return -EINVAL;	mxr_dbg(mdev, "fmt = %s/n", fmt->name);	mxr_mplane_fill(planes, fmt, layer->geo.src.full_width,		layer->geo.src.full_height);	*nplanes = fmt->num_subframes;	for (i = 0; i < fmt->num_subframes; ++i) {		alloc_ctxs[i] = layer->mdev->alloc_ctx;		sizes[i] = planes[i].sizeimage;		mxr_dbg(mdev, "size[%d] = %08x/n", i, sizes[i]);	}	if (*nbuffers == 0)		*nbuffers = 1;	vb2_queue_init(vq);	return 0;}

static int gsc_capture_queue_setup(struct vb2_queue *vq,			const struct v4l2_format *fmt, unsigned int *num_buffers,			unsigned int *num_planes, unsigned int sizes[],			void *allocators[]){	struct gsc_ctx *ctx = vq->drv_priv;	struct gsc_fmt *ffmt = ctx->d_frame.fmt;	int i, ret = 0;	if (!ffmt)		return -EINVAL;	*num_planes = ffmt->num_planes;	for (i = 0; i < ffmt->num_planes; i++) {		sizes[i] = get_plane_size(&ctx->d_frame, i);		allocators[i] = ctx->gsc_dev->alloc_ctx;	}	ret = vb2_queue_init(vq);	if (ret) {		gsc_err("failed to init vb2_queue");		return ret;	}	return 0;}

static int camera_v4l2_vb2_q_init(struct file *filep){	struct camera_v4l2_private *sp = fh_to_private(filep->private_data);	struct vb2_queue *q = &sp->vb2_q;	memset(q, 0, sizeof(struct vb2_queue));	/* free up this buffer when stream is done */	q->drv_priv =		kzalloc(sizeof(struct msm_v4l2_format_data), GFP_KERNEL);	if (!q->drv_priv) {		pr_err("%s : memory not available/n", __func__);		return -ENOMEM;	}	q->mem_ops = msm_vb2_get_q_mem_ops();	q->ops = msm_vb2_get_q_ops();	/* default queue type */	q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;	q->io_modes = VB2_USERPTR;	q->io_flags = 0;	q->buf_struct_size = sizeof(struct msm_vb2_buffer);	vb2_queue_init(q);	return 0;}

int uvc_queue_init(struct uvc_video_queue *queue, enum v4l2_buf_type type,		    int drop_corrupted){	int ret;	queue->queue.type = type;	queue->queue.io_modes = VB2_MMAP | VB2_USERPTR;	queue->queue.drv_priv = queue;	queue->queue.buf_struct_size = sizeof(struct uvc_buffer);	queue->queue.mem_ops = &vb2_vmalloc_memops;	queue->queue.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC		| V4L2_BUF_FLAG_TSTAMP_SRC_SOE;	queue->queue.lock = &queue->mutex;	switch (type) {	case V4L2_BUF_TYPE_META_CAPTURE:		queue->queue.ops = &uvc_meta_queue_qops;		break;	default:		queue->queue.io_modes |= VB2_DMABUF;		queue->queue.ops = &uvc_queue_qops;		break;	}	ret = vb2_queue_init(&queue->queue);	if (ret)		return ret;	mutex_init(&queue->mutex);	spin_lock_init(&queue->irqlock);	INIT_LIST_HEAD(&queue->irqqueue);	queue->flags = drop_corrupted ? UVC_QUEUE_DROP_CORRUPTED : 0;	return 0;}

static int queue_init(struct hva_ctx *ctx, struct vb2_queue *vq){	vq->io_modes = VB2_MMAP | VB2_DMABUF;	vq->drv_priv = ctx;	vq->ops = &hva_qops;	vq->mem_ops = &vb2_dma_contig_memops;	vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;	vq->lock = &ctx->hva_dev->lock;	return vb2_queue_init(vq);}

static int mx3_camera_init_videobuf(struct vb2_queue *q,				     struct soc_camera_device *icd){	q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;	q->io_modes = VB2_MMAP | VB2_USERPTR;	q->drv_priv = icd;	q->ops = &mx3_videobuf_ops;	q->mem_ops = &vb2_dma_contig_memops;	q->buf_struct_size = sizeof(struct mx3_camera_buffer);	return vb2_queue_init(q);}

int smi2021_vb2_setup(struct smi2021 *smi2021){	smi2021->vb2q.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;	smi2021->vb2q.io_modes = VB2_READ | VB2_MMAP | VB2_USERPTR;	smi2021->vb2q.drv_priv = smi2021;	smi2021->vb2q.buf_struct_size = sizeof(struct smi2021_buf);	smi2021->vb2q.ops = &smi2021_vb2_ops;	smi2021->vb2q.mem_ops = &vb2_vmalloc_memops;	smi2021->vb2q.timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;	smi2021->vb2q.lock = &smi2021->vb2q_lock;	return vb2_queue_init(&smi2021->vb2q);}

static int unicam_camera_init_videobuf(struct vb2_queue *q,				       struct soc_camera_device *icd){	dprintk("-enter");	q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;	q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ;	q->drv_priv = icd;	q->ops = &unicam_videobuf_ops;	q->mem_ops = &vb2_dma_contig_memops;	q->buf_struct_size = sizeof(struct unicam_camera_buffer);	dprintk("-exit");	return vb2_queue_init(q);}

static int queue_init(void *priv, struct vb2_queue *src_vq,		      struct vb2_queue *dst_vq){	struct gsc_ctx *ctx = priv;	int ret;	memset(src_vq, 0, sizeof(*src_vq));	src_vq->type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;	src_vq->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF;	src_vq->drv_priv = ctx;	src_vq->ops = &gsc_m2m_qops;	src_vq->mem_ops = ctx->gsc_dev->vb2->ops;	src_vq->timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_COPY;	src_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer);	ret = vb2_queue_init(src_vq);	if (ret) {		gsc_err("failed to init vb2_queue");		return ret;	}	memset(dst_vq, 0, sizeof(*dst_vq));	dst_vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;	dst_vq->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF;	dst_vq->drv_priv = ctx;	dst_vq->ops = &gsc_m2m_qops;	dst_vq->mem_ops = ctx->gsc_dev->vb2->ops;	dst_vq->timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_COPY;	dst_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer);	ret = vb2_queue_init(dst_vq);	if (ret) {		gsc_err("failed to init vb2_queue");		return ret;	}	return ret;}

int mtk_vcodec_enc_queue_init(void *priv, struct vb2_queue *src_vq,			      struct vb2_queue *dst_vq){	struct mtk_vcodec_ctx *ctx = priv;	int ret;	/* Note: VB2_USERPTR works with dma-contig because mt8173	 * support iommu	 * https://patchwork.kernel.org/patch/8335461/	 * https://patchwork.kernel.org/patch/7596181/	 */	src_vq->type		= V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;	src_vq->io_modes	= VB2_DMABUF | VB2_MMAP | VB2_USERPTR;	src_vq->drv_priv	= ctx;	src_vq->buf_struct_size = sizeof(struct mtk_video_enc_buf);	src_vq->ops		= &mtk_venc_vb2_ops;	src_vq->mem_ops		= &vb2_dma_contig_memops;	src_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;	src_vq->lock		= &ctx->dev->dev_mutex;	src_vq->dev		= &ctx->dev->plat_dev->dev;	ret = vb2_queue_init(src_vq);	if (ret)		return ret;	dst_vq->type		= V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;	dst_vq->io_modes	= VB2_DMABUF | VB2_MMAP | VB2_USERPTR;	dst_vq->drv_priv	= ctx;	dst_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer);	dst_vq->ops		= &mtk_venc_vb2_ops;	dst_vq->mem_ops		= &vb2_dma_contig_memops;	dst_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;	dst_vq->lock		= &ctx->dev->dev_mutex;	dst_vq->dev		= &ctx->dev->plat_dev->dev;	return vb2_queue_init(dst_vq);}

void videobuf2_queue_pmem_contig_init(struct vb2_queue *q,					enum v4l2_buf_type type,					const struct vb2_ops *ops,					unsigned int size,					void *priv){	memset(q, 0, sizeof(struct vb2_queue));	q->mem_ops = &msm_vb2_mem_ops;	q->ops = ops;	q->drv_priv = priv;	q->type = type;	q->io_modes = VB2_MMAP | VB2_USERPTR;	q->io_flags = 0;	q->buf_struct_size = size;	vb2_queue_init(q);}

int vc_out_videobuf2_setup( struct vc_device * dev ){	int ret;	struct vb2_queue * q;		PRINT_DEBUG( "setting up videobuf2 queue/n" );	q = &dev->vb_out_vidq;    q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;    q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ;    q->drv_priv = dev;    q->buf_struct_size = sizeof(struct vc_out_buffer);    q->timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;    q->ops = &vc_vb2_ops;    q->mem_ops = &vb2_vmalloc_memops;    ret = vb2_queue_init(q);	return ret;}

static int unicam_camera_init_videobuf(struct vb2_queue *q,				       struct soc_camera_device *icd){	pr_debug("-enter");	q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;	q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ;	q->drv_priv = icd;	q->ops = &unicam_videobuf_ops;#if defined(CONFIG_VIDEOBUF2_DMA_RESERVED)	pr_info("Unicam uses vb2-dma-reserved/n");	q->mem_ops = &vb2_dma_reserved_memops;#elif defined(CONFIG_VIDEOBUF2_DMA_CONTIG)	pr_info("Unicam uses vb2-dma-contig/n");	q->mem_ops = &vb2_dma_contig_memops;#endif	q->buf_struct_size = sizeof(struct unicam_camera_buffer);	pr_debug("-exit");	return vb2_queue_init(q);}

static hwcam_user_t*hwcam_user_create_instance(        hwcam_dev_t* cam){	int ret = 0;	hwcam_user_t* user;	if(!cam){		return NULL;	}	user = kzalloc(sizeof(hwcam_user_t), GFP_KERNEL);	if (!user) {		return NULL;    }    user->intf.vtbl = &s_vtbl_hwcam_user;    kref_init(&user->ref);	v4l2_fh_init(&user->eq, cam->vdev);	v4l2_fh_add(&user->eq);    user->f_format_valid = 0;    memset(&user->format, 0, sizeof(user->format));    user->vb2q.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;    user->vb2q.ops = &s_qops_hwcam_vbuf;    user->vb2q.mem_ops = &s_mops_hwcam_vbuf;    user->vb2q.io_modes = VB2_USERPTR;    user->vb2q.io_flags = 0;    user->vb2q.buf_struct_size = sizeof(hwcam_vbuf_t);    user->vb2q.drv_priv = user;    user->vb2q.timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_COPY;//add by wind    ret = vb2_queue_init(&user->vb2q);    if(ret)    {        HWCAM_CFG_ERR("queue init fail./n");	 return NULL;    }    HWCAM_CFG_INFO("instance(0x%p). /n", user);    return user;}

static int uvc_queue_init(struct uvc_video_queue *queue,			  enum v4l2_buf_type type){	int ret;	queue->queue.type = type;	queue->queue.io_modes = VB2_MMAP | VB2_USERPTR;	queue->queue.drv_priv = queue;	queue->queue.buf_struct_size = sizeof(struct uvc_buffer);	queue->queue.ops = &uvc_queue_qops;	queue->queue.mem_ops = &vb2_vmalloc_memops;	ret = vb2_queue_init(&queue->queue);	if (ret)		return ret;	mutex_init(&queue->mutex);	spin_lock_init(&queue->irqlock);	INIT_LIST_HEAD(&queue->irqqueue);	queue->flags = 0;	return 0;}

static int queue_init(void *priv, struct vb2_queue *vbq,	struct vb2_queue *vbq_dst){	int ret = 0;	struct fimc_is_video_ctx *vctx = priv;	struct fimc_is_video *video;	u32 type;	BUG_ON(!vctx);	BUG_ON(!GET_VIDEO(vctx));	BUG_ON(!vbq);	video = GET_VIDEO(vctx);	if (video->type == FIMC_IS_VIDEO_TYPE_CAPTURE)		type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;	else		type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;	vbq->type		= type;	vbq->io_modes		= VB2_MMAP | VB2_USERPTR | VB2_DMABUF;	vbq->drv_priv		= vctx;	vbq->ops		= vctx->vb2_ops;	vbq->mem_ops		= vctx->mem_ops;#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,9,0))	vbq->timestamp_type	= V4L2_BUF_FLAG_TIMESTAMP_COPY;#endif	ret = vb2_queue_init(vbq);	if (ret) {		err("vb2_queue_init fail(%d)", ret);		goto p_err;	}	vctx->queue.vbq = vbq;p_err:	return ret;}

int uvc_queue_init(struct uvc_video_queue *queue, enum v4l2_buf_type type,		    int drop_corrupted){	int ret;	queue->queue.type = type;	queue->queue.io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF;	queue->queue.drv_priv = queue;	queue->queue.buf_struct_size = sizeof(struct uvc_buffer);	queue->queue.ops = &uvc_queue_qops;	queue->queue.mem_ops = &vb2_vmalloc_memops;	ret = vb2_queue_init(&queue->queue);	if (ret)		return ret;	mutex_init(&queue->mutex);	spin_lock_init(&queue->irqlock);	INIT_LIST_HEAD(&queue->irqqueue);	queue->flags = drop_corrupted ? UVC_QUEUE_DROP_CORRUPTED : 0;	return 0;}