Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit dce57314 authored by Hans Verkuil's avatar Hans Verkuil Committed by Mauro Carvalho Chehab
Browse files

[media] media/platform: convert drivers to use the new vb2_queue dev field 



Stop using alloc_ctx and just fill in the device pointer.

Signed-off-by: default avatarHans Verkuil <hans.verkuil@cisco.com>
Acked-by: default avatarFabien Dessenne <fabien.dessenne@st.com>
Acked-by: default avatarBenoit Parrot <bparrot@ti.com>
Reviewed-by: default avatarLaurent Pinchart <laurent.pinchart@ideasonboard.com>
Signed-off-by: default avatarMauro Carvalho Chehab <mchehab@s-opensource.com>
parent 53ddcc68

drivers/media/platform/sti/bdisp/bdisp-v4l2.c

+4 −14
Original line number Diff line number Diff line
@@ -439,7 +439,7 @@ static void bdisp_ctrls_delete(struct bdisp_ctx *ctx) 


static int bdisp_queue_setup(struct vb2_queue *vq,

			     unsigned int *nb_buf, unsigned int *nb_planes,

			     unsigned int sizes[], void *allocators[])

			     unsigned int sizes[], void *alloc_ctxs[])

{

	struct bdisp_ctx *ctx = vb2_get_drv_priv(vq);

	struct bdisp_frame *frame = ctx_get_frame(ctx, vq->type);
@@ -453,7 +453,6 @@ static int bdisp_queue_setup(struct vb2_queue *vq, 
		dev_err(ctx->bdisp_dev->dev, "Invalid format\n");

		return -EINVAL;

	}

	allocators[0] = ctx->bdisp_dev->alloc_ctx;



	if (*nb_planes)

		return sizes[0] < frame->sizeimage ? -EINVAL : 0;
@@ -553,6 +552,7 @@ static int queue_init(void *priv, 
	src_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer);

	src_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;

	src_vq->lock = &ctx->bdisp_dev->lock;

	src_vq->dev = ctx->bdisp_dev->v4l2_dev.dev;



	ret = vb2_queue_init(src_vq);

	if (ret)
@@ -567,6 +567,7 @@ static int queue_init(void *priv, 
	dst_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer);

	dst_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;

	dst_vq->lock = &ctx->bdisp_dev->lock;

	dst_vq->dev = ctx->bdisp_dev->v4l2_dev.dev;



	return vb2_queue_init(dst_vq);

}
@@ -1269,8 +1270,6 @@ static int bdisp_remove(struct platform_device *pdev) 


	bdisp_hw_free_filters(bdisp->dev);



	vb2_dma_contig_cleanup_ctx(bdisp->alloc_ctx);



	pm_runtime_disable(&pdev->dev);



	bdisp_debugfs_remove(bdisp);
@@ -1371,18 +1370,11 @@ static int bdisp_probe(struct platform_device *pdev) 
		goto err_dbg;

	}



	/* Continuous memory allocator */

	bdisp->alloc_ctx = vb2_dma_contig_init_ctx(dev);

	if (IS_ERR(bdisp->alloc_ctx)) {

		ret = PTR_ERR(bdisp->alloc_ctx);

		goto err_pm;

	}



	/* Filters */

	if (bdisp_hw_alloc_filters(bdisp->dev)) {

		dev_err(bdisp->dev, "no memory for filters\n");

		ret = -ENOMEM;

		goto err_vb2_dma;

		goto err_pm;

	}



	/* Register */
@@ -1401,8 +1393,6 @@ static int bdisp_probe(struct platform_device *pdev) 


err_filter:

	bdisp_hw_free_filters(bdisp->dev);

err_vb2_dma:

	vb2_dma_contig_cleanup_ctx(bdisp->alloc_ctx);

err_pm:

	pm_runtime_put(dev);

err_dbg:

drivers/media/platform/sti/bdisp/bdisp.h

+0 −2
Original line number Diff line number Diff line
@@ -175,7 +175,6 @@ struct bdisp_dbg { 
 * @id:         device index

 * @m2m:        memory-to-memory V4L2 device information

 * @state:      flags used to synchronize m2m and capture mode operation

 * @alloc_ctx:  videobuf2 memory allocator context

 * @clock:      IP clock

 * @regs:       registers

 * @irq_queue:  interrupt handler waitqueue
@@ -193,7 +192,6 @@ struct bdisp_dev { 
	u16                     id;

	struct bdisp_m2m_device m2m;

	unsigned long           state;

	struct vb2_alloc_ctx    *alloc_ctx;

	struct clk              *clock;

	void __iomem            *regs;

	wait_queue_head_t       irq_queue;

drivers/media/platform/ti-vpe/cal.c

+1 −14
Original line number Diff line number Diff line
@@ -287,7 +287,6 @@ struct cal_ctx { 
	/* Several counters */

	unsigned long		jiffies;



	struct vb2_alloc_ctx	*alloc_ctx;

	struct cal_dmaqueue	vidq;



	/* Input Number */
@@ -1233,7 +1232,6 @@ static int cal_queue_setup(struct vb2_queue *vq, 


	if (vq->num_buffers + *nbuffers < 3)

		*nbuffers = 3 - vq->num_buffers;

	alloc_ctxs[0] = ctx->alloc_ctx;



	if (*nplanes) {

		if (sizes[0] < size)
@@ -1551,6 +1549,7 @@ static int cal_complete_ctx(struct cal_ctx *ctx) 
	q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;

	q->lock = &ctx->mutex;

	q->min_buffers_needed = 3;

	q->dev = ctx->v4l2_dev.dev;



	ret = vb2_queue_init(q);

	if (ret)
@@ -1578,18 +1577,7 @@ static int cal_complete_ctx(struct cal_ctx *ctx) 
	v4l2_info(&ctx->v4l2_dev, "V4L2 device registered as %s\n",

		  video_device_node_name(vfd));



	ctx->alloc_ctx = vb2_dma_contig_init_ctx(vfd->v4l2_dev->dev);

	if (IS_ERR(ctx->alloc_ctx)) {

		ctx_err(ctx, "Failed to alloc vb2 context\n");

		ret = PTR_ERR(ctx->alloc_ctx);

		goto vdev_unreg;

	}



	return 0;



vdev_unreg:

	video_unregister_device(vfd);

	return ret;

}



static struct device_node *
@@ -1914,7 +1902,6 @@ static int cal_remove(struct platform_device *pdev) 
				video_device_node_name(&ctx->vdev));

			camerarx_phy_disable(ctx);

			v4l2_async_notifier_unregister(&ctx->notifier);

			vb2_dma_contig_cleanup_ctx(ctx->alloc_ctx);

			v4l2_ctrl_handler_free(&ctx->ctrl_handler);

			v4l2_device_unregister(&ctx->v4l2_dev);

			video_unregister_device(&ctx->vdev);

drivers/media/platform/ti-vpe/vpe.c

+4 −16
Original line number Diff line number Diff line
@@ -362,7 +362,6 @@ struct vpe_dev { 
	void __iomem		*base;

	struct resource		*res;



	struct vb2_alloc_ctx	*alloc_ctx;

	struct vpdma_data	*vpdma;		/* vpdma data handle */

	struct sc_data		*sc;		/* scaler data handle */

	struct csc_data		*csc;		/* csc data handle */
@@ -1807,10 +1806,8 @@ static int vpe_queue_setup(struct vb2_queue *vq, 


	*nplanes = q_data->fmt->coplanar ? 2 : 1;



	for (i = 0; i < *nplanes; i++) {

	for (i = 0; i < *nplanes; i++)

		sizes[i] = q_data->sizeimage[i];

		alloc_ctxs[i] = ctx->dev->alloc_ctx;

	}



	vpe_dbg(ctx->dev, "get %d buffer(s) of size %d", *nbuffers,

		sizes[VPE_LUMA]);
@@ -1907,6 +1904,7 @@ static int queue_init(void *priv, struct vb2_queue *src_vq, 
	src_vq->mem_ops = &vb2_dma_contig_memops;

	src_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;

	src_vq->lock = &dev->dev_mutex;

	src_vq->dev = dev->v4l2_dev.dev;



	ret = vb2_queue_init(src_vq);

	if (ret)
@@ -1921,6 +1919,7 @@ static int queue_init(void *priv, struct vb2_queue *src_vq, 
	dst_vq->mem_ops = &vb2_dma_contig_memops;

	dst_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;

	dst_vq->lock = &dev->dev_mutex;

	dst_vq->dev = dev->v4l2_dev.dev;



	return vb2_queue_init(dst_vq);

}
@@ -2161,7 +2160,6 @@ static void vpe_fw_cb(struct platform_device *pdev) 
		vpe_runtime_put(pdev);

		pm_runtime_disable(&pdev->dev);

		v4l2_m2m_release(dev->m2m_dev);

		vb2_dma_contig_cleanup_ctx(dev->alloc_ctx);

		v4l2_device_unregister(&dev->v4l2_dev);



		return;
@@ -2213,18 +2211,11 @@ static int vpe_probe(struct platform_device *pdev) 


	platform_set_drvdata(pdev, dev);



	dev->alloc_ctx = vb2_dma_contig_init_ctx(&pdev->dev);

	if (IS_ERR(dev->alloc_ctx)) {

		vpe_err(dev, "Failed to alloc vb2 context\n");

		ret = PTR_ERR(dev->alloc_ctx);

		goto v4l2_dev_unreg;

	}



	dev->m2m_dev = v4l2_m2m_init(&m2m_ops);

	if (IS_ERR(dev->m2m_dev)) {

		vpe_err(dev, "Failed to init mem2mem device\n");

		ret = PTR_ERR(dev->m2m_dev);

		goto rel_ctx;

		goto v4l2_dev_unreg;

	}



	pm_runtime_enable(&pdev->dev);
@@ -2269,8 +2260,6 @@ static int vpe_probe(struct platform_device *pdev) 
rel_m2m:

	pm_runtime_disable(&pdev->dev);

	v4l2_m2m_release(dev->m2m_dev);

rel_ctx:

	vb2_dma_contig_cleanup_ctx(dev->alloc_ctx);

v4l2_dev_unreg:

	v4l2_device_unregister(&dev->v4l2_dev);
@@ -2286,7 +2275,6 @@ static int vpe_remove(struct platform_device *pdev) 
	v4l2_m2m_release(dev->m2m_dev);

	video_unregister_device(&dev->vfd);

	v4l2_device_unregister(&dev->v4l2_dev);

	vb2_dma_contig_cleanup_ctx(dev->alloc_ctx);



	vpe_set_clock_enable(dev, 0);

	vpe_runtime_put(pdev);

drivers/media/platform/vsp1/vsp1_video.c

+2 −12
Original line number Diff line number Diff line
@@ -533,17 +533,14 @@ vsp1_video_queue_setup(struct vb2_queue *vq, 
		for (i = 0; i < *nplanes; i++) {

			if (sizes[i] < format->plane_fmt[i].sizeimage)

				return -EINVAL;

			alloc_ctxs[i] = video->alloc_ctx;

		}

		return 0;

	}



	*nplanes = format->num_planes;



	for (i = 0; i < format->num_planes; ++i) {

	for (i = 0; i < format->num_planes; ++i)

		sizes[i] = format->plane_fmt[i].sizeimage;

		alloc_ctxs[i] = video->alloc_ctx;

	}



	return 0;

}
@@ -983,12 +980,6 @@ struct vsp1_video *vsp1_video_create(struct vsp1_device *vsp1, 
	video_set_drvdata(&video->video, video);



	/* ... and the buffers queue... */

	video->alloc_ctx = vb2_dma_contig_init_ctx(video->vsp1->dev);

	if (IS_ERR(video->alloc_ctx)) {

		ret = PTR_ERR(video->alloc_ctx);

		goto error;

	}



	video->queue.type = video->type;

	video->queue.io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF;

	video->queue.lock = &video->lock;
@@ -997,6 +988,7 @@ struct vsp1_video *vsp1_video_create(struct vsp1_device *vsp1, 
	video->queue.ops = &vsp1_video_queue_qops;

	video->queue.mem_ops = &vb2_dma_contig_memops;

	video->queue.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;

	video->queue.dev = video->vsp1->dev;

	ret = vb2_queue_init(&video->queue);

	if (ret < 0) {

		dev_err(video->vsp1->dev, "failed to initialize vb2 queue\n");
@@ -1014,7 +1006,6 @@ struct vsp1_video *vsp1_video_create(struct vsp1_device *vsp1, 
	return video;



error:

	vb2_dma_contig_cleanup_ctx(video->alloc_ctx);

	vsp1_video_cleanup(video);

	return ERR_PTR(ret);

}
@@ -1024,6 +1015,5 @@ void vsp1_video_cleanup(struct vsp1_video *video) 
	if (video_is_registered(&video->video))

		video_unregister_device(&video->video);



	vb2_dma_contig_cleanup_ctx(video->alloc_ctx);

	media_entity_cleanup(&video->video.entity);

}