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 int
enc_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));
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();
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);
q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
return vb2_queue_init(q);
}
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 fimc_lite_subdev_registered(struct v4l2_subdev *sd)
{
struct fimc_lite *fimc = v4l2_get_subdevdata(sd);
struct vb2_queue *q = &fimc->vb_queue;
struct video_device *vfd = &fimc->vfd;
int ret;
memset(vfd, 0, sizeof(*vfd));
fimc->fmt = &fimc_lite_formats[0];
fimc->out_path = FIMC_IO_DMA;
snprintf(vfd->name, sizeof(vfd->name), "fimc-lite.%d.capture",
fimc->index);
vfd->fops = &fimc_lite_fops;
vfd->ioctl_ops = &fimc_lite_ioctl_ops;
vfd->v4l2_dev = sd->v4l2_dev;
vfd->minor = -1;
vfd->release = video_device_release_empty;
vfd->lock = &fimc->lock;
fimc->ref_count = 0;
fimc->reqbufs_count = 0;
INIT_LIST_HEAD(&fimc->pending_buf_q);
INIT_LIST_HEAD(&fimc->active_buf_q);
memset(q, 0, sizeof(*q));
q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
q->io_modes = VB2_MMAP | VB2_USERPTR;
q->ops = &fimc_lite_qops;
q->mem_ops = &vb2_dma_contig_memops;
q->buf_struct_size = sizeof(struct flite_buffer);
q->drv_priv = fimc;
ret = vb2_queue_init(q);
if (ret < 0)
return ret;
fimc->vd_pad.flags = MEDIA_PAD_FL_SINK;
ret = media_entity_init(&vfd->entity, 1, &fimc->vd_pad, 0);
if (ret < 0)
return ret;
video_set_drvdata(vfd, fimc);
fimc->pipeline_ops = v4l2_get_subdev_hostdata(sd);
ret = video_register_device(vfd, VFL_TYPE_GRABBER, -1);
if (ret < 0) {
media_entity_cleanup(&vfd->entity);
fimc->pipeline_ops = NULL;
return ret;
}
v4l2_info(sd->v4l2_dev, "Registered %s as /dev/%s\n",
vfd->name, video_device_node_name(vfd));
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);
}
/*
* msm_jpegdma_queue_init - m2m_ops queue_setup callback.
* @priv: Pointer to jpegdma ctx.
* @src_vq: vb2 source queue.
* @dst_vq: vb2 destination queue.
*/
static int msm_jpegdma_queue_init(void *priv, struct vb2_queue *src_vq,
struct vb2_queue *dst_vq)
{
struct jpegdma_ctx *ctx = priv;
int ret;
src_vq->type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
src_vq->io_modes = VB2_USERPTR;
src_vq->drv_priv = ctx;
src_vq->mem_ops = &msm_jpegdma_vb2_mem_ops;
src_vq->ops = &msm_jpegdma_vb2_q_ops;
src_vq->buf_struct_size = sizeof(struct vb2_buffer);
src_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;
ret = vb2_queue_init(src_vq);
if (ret) {
dev_err(ctx->jdma_device->dev, "Can not init src queue\n");
return ret;
}
dst_vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
dst_vq->io_modes = VB2_USERPTR;
dst_vq->drv_priv = ctx;
dst_vq->mem_ops = &msm_jpegdma_vb2_mem_ops;
dst_vq->ops = &msm_jpegdma_vb2_q_ops;
dst_vq->buf_struct_size = sizeof(struct vb2_buffer);
dst_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;
ret = vb2_queue_init(dst_vq);
if (ret) {
dev_err(ctx->jdma_device->dev, "Can not init dst queue\n");
return ret;
}
return 0;
}
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;
}
int stk1160_vb2_setup(struct stk1160 *dev)
{
int rc;
struct vb2_queue *q;
q = &dev->vb_vidq;
q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
q->io_modes = VB2_READ | VB2_MMAP | VB2_USERPTR;
q->drv_priv = dev;
q->buf_struct_size = sizeof(struct stk1160_buffer);
q->ops = &stk1160_video_qops;
q->mem_ops = &vb2_vmalloc_memops;
rc = vb2_queue_init(q);
if (rc < 0)
return rc;
/* initialize video dma queue */
INIT_LIST_HEAD(&dev->avail_bufs);
return 0;
}
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;
}
