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

media: videobuf2-core: integrate with media requests 



Buffers can now be prepared or queued for a request.

A buffer is unbound from the request at vb2_buffer_done time or
when the queue is cancelled.

Signed-off-by: default avatarHans Verkuil <hans.verkuil@cisco.com>
Reviewed-by: default avatarMauro Carvalho Chehab <mchehab+samsung@kernel.org>
Signed-off-by: default avatarMauro Carvalho Chehab <mchehab+samsung@kernel.org>
parent 1cf96dcc

drivers/media/common/videobuf2/videobuf2-core.c

+126 −7
Original line number Diff line number Diff line
@@ -499,8 +499,9 @@ static int __vb2_queue_free(struct vb2_queue *q, unsigned int buffers) 
			pr_info("     buf_init: %u buf_cleanup: %u buf_prepare: %u buf_finish: %u\n",

				vb->cnt_buf_init, vb->cnt_buf_cleanup,

				vb->cnt_buf_prepare, vb->cnt_buf_finish);

			pr_info("     buf_queue: %u buf_done: %u\n",

				vb->cnt_buf_queue, vb->cnt_buf_done);

			pr_info("     buf_queue: %u buf_done: %u buf_request_complete: %u\n",

				vb->cnt_buf_queue, vb->cnt_buf_done,

				vb->cnt_buf_request_complete);

			pr_info("     alloc: %u put: %u prepare: %u finish: %u mmap: %u\n",

				vb->cnt_mem_alloc, vb->cnt_mem_put,

				vb->cnt_mem_prepare, vb->cnt_mem_finish,
@@ -936,6 +937,14 @@ void vb2_buffer_done(struct vb2_buffer *vb, enum vb2_buffer_state state) 
		vb->state = state;

	}

	atomic_dec(&q->owned_by_drv_count);



	if (vb->req_obj.req) {

		/* This is not supported at the moment */

		WARN_ON(state == VB2_BUF_STATE_REQUEUEING);

		media_request_object_unbind(&vb->req_obj);

		media_request_object_put(&vb->req_obj);

	}



	spin_unlock_irqrestore(&q->done_lock, flags);



	trace_vb2_buf_done(q, vb);
@@ -1290,6 +1299,60 @@ static int __buf_prepare(struct vb2_buffer *vb) 
	return 0;

}



static int vb2_req_prepare(struct media_request_object *obj)

{

	struct vb2_buffer *vb = container_of(obj, struct vb2_buffer, req_obj);

	int ret;



	if (WARN_ON(vb->state != VB2_BUF_STATE_IN_REQUEST))

		return -EINVAL;



	mutex_lock(vb->vb2_queue->lock);

	ret = __buf_prepare(vb);

	mutex_unlock(vb->vb2_queue->lock);

	return ret;

}



static void __vb2_dqbuf(struct vb2_buffer *vb);



static void vb2_req_unprepare(struct media_request_object *obj)

{

	struct vb2_buffer *vb = container_of(obj, struct vb2_buffer, req_obj);



	mutex_lock(vb->vb2_queue->lock);

	__vb2_dqbuf(vb);

	vb->state = VB2_BUF_STATE_IN_REQUEST;

	mutex_unlock(vb->vb2_queue->lock);

	WARN_ON(!vb->req_obj.req);

}



int vb2_core_qbuf(struct vb2_queue *q, unsigned int index, void *pb,

		  struct media_request *req);



static void vb2_req_queue(struct media_request_object *obj)

{

	struct vb2_buffer *vb = container_of(obj, struct vb2_buffer, req_obj);



	mutex_lock(vb->vb2_queue->lock);

	vb2_core_qbuf(vb->vb2_queue, vb->index, NULL, NULL);

	mutex_unlock(vb->vb2_queue->lock);

}



static void vb2_req_release(struct media_request_object *obj)

{

	struct vb2_buffer *vb = container_of(obj, struct vb2_buffer, req_obj);



	if (vb->state == VB2_BUF_STATE_IN_REQUEST)

		vb->state = VB2_BUF_STATE_DEQUEUED;

}



static const struct media_request_object_ops vb2_core_req_ops = {

	.prepare = vb2_req_prepare,

	.unprepare = vb2_req_unprepare,

	.queue = vb2_req_queue,

	.release = vb2_req_release,

};



int vb2_core_prepare_buf(struct vb2_queue *q, unsigned int index, void *pb)

{

	struct vb2_buffer *vb;
@@ -1315,7 +1378,7 @@ int vb2_core_prepare_buf(struct vb2_queue *q, unsigned int index, void *pb) 


	dprintk(2, "prepare of buffer %d succeeded\n", vb->index);



	return ret;

	return 0;

}

EXPORT_SYMBOL_GPL(vb2_core_prepare_buf);
@@ -1382,7 +1445,8 @@ static int vb2_start_streaming(struct vb2_queue *q) 
	return ret;

}



int vb2_core_qbuf(struct vb2_queue *q, unsigned int index, void *pb)

int vb2_core_qbuf(struct vb2_queue *q, unsigned int index, void *pb,

		  struct media_request *req)

{

	struct vb2_buffer *vb;

	int ret;
@@ -1394,8 +1458,39 @@ int vb2_core_qbuf(struct vb2_queue *q, unsigned int index, void *pb) 


	vb = q->bufs[index];



	if (req) {

		int ret;



		if (vb->state != VB2_BUF_STATE_DEQUEUED) {

			dprintk(1, "buffer %d not in dequeued state\n",

				vb->index);

			return -EINVAL;

		}



		media_request_object_init(&vb->req_obj);



		/* Make sure the request is in a safe state for updating. */

		ret = media_request_lock_for_update(req);

		if (ret)

			return ret;

		ret = media_request_object_bind(req, &vb2_core_req_ops,

						q, true, &vb->req_obj);

		media_request_unlock_for_update(req);

		if (ret)

			return ret;



		vb->state = VB2_BUF_STATE_IN_REQUEST;

		/* Fill buffer information for the userspace */

		if (pb)

			call_void_bufop(q, fill_user_buffer, vb, pb);



		dprintk(2, "qbuf of buffer %d succeeded\n", vb->index);

		return 0;

	}



	switch (vb->state) {

	case VB2_BUF_STATE_DEQUEUED:

	case VB2_BUF_STATE_IN_REQUEST:

		if (!vb->prepared) {

			ret = __buf_prepare(vb);

			if (ret)
@@ -1601,6 +1696,11 @@ static void __vb2_dqbuf(struct vb2_buffer *vb) 
			call_void_memop(vb, unmap_dmabuf, vb->planes[i].mem_priv);

			vb->planes[i].dbuf_mapped = 0;

		}

	if (vb->req_obj.req) {

		media_request_object_unbind(&vb->req_obj);

		media_request_object_put(&vb->req_obj);

	}

	call_void_bufop(q, init_buffer, vb);

}



int vb2_core_dqbuf(struct vb2_queue *q, unsigned int *pindex, void *pb,
@@ -1714,6 +1814,25 @@ static void __vb2_queue_cancel(struct vb2_queue *q) 
	 */

	for (i = 0; i < q->num_buffers; ++i) {

		struct vb2_buffer *vb = q->bufs[i];

		struct media_request *req = vb->req_obj.req;



		/*

		 * If a request is associated with this buffer, then

		 * call buf_request_cancel() to give the driver to complete()

		 * related request objects. Otherwise those objects would

		 * never complete.

		 */

		if (req) {

			enum media_request_state state;

			unsigned long flags;



			spin_lock_irqsave(&req->lock, flags);

			state = req->state;

			spin_unlock_irqrestore(&req->lock, flags);



			if (state == MEDIA_REQUEST_STATE_QUEUED)

				call_void_vb_qop(vb, buf_request_complete, vb);

		}



		if (vb->synced) {

			unsigned int plane;
@@ -2283,7 +2402,7 @@ static int __vb2_init_fileio(struct vb2_queue *q, int read) 
		 * Queue all buffers.

		 */

		for (i = 0; i < q->num_buffers; i++) {

			ret = vb2_core_qbuf(q, i, NULL);

			ret = vb2_core_qbuf(q, i, NULL, NULL);

			if (ret)

				goto err_reqbufs;

			fileio->bufs[i].queued = 1;
@@ -2462,7 +2581,7 @@ static size_t __vb2_perform_fileio(struct vb2_queue *q, char __user *data, size_ 


		if (copy_timestamp)

			b->timestamp = ktime_get_ns();

		ret = vb2_core_qbuf(q, index, NULL);

		ret = vb2_core_qbuf(q, index, NULL, NULL);

		dprintk(5, "vb2_dbuf result: %d\n", ret);

		if (ret)

			return ret;
@@ -2565,7 +2684,7 @@ static int vb2_thread(void *data) 
		if (copy_timestamp)

			vb->timestamp = ktime_get_ns();

		if (!threadio->stop)

			ret = vb2_core_qbuf(q, vb->index, NULL);

			ret = vb2_core_qbuf(q, vb->index, NULL, NULL);

		call_void_qop(q, wait_prepare, q);

		if (ret || threadio->stop)

			break;

drivers/media/common/videobuf2/videobuf2-v4l2.c

+3 −1
Original line number Diff line number Diff line
@@ -441,6 +441,8 @@ static void __fill_v4l2_buffer(struct vb2_buffer *vb, void *pb) 
	case VB2_BUF_STATE_ACTIVE:

		b->flags |= V4L2_BUF_FLAG_QUEUED;

		break;

	case VB2_BUF_STATE_IN_REQUEST:

		break;

	case VB2_BUF_STATE_ERROR:

		b->flags |= V4L2_BUF_FLAG_ERROR;

		/* fall through */
@@ -619,7 +621,7 @@ int vb2_qbuf(struct vb2_queue *q, struct v4l2_buffer *b) 
	}



	ret = vb2_queue_or_prepare_buf(q, b, "qbuf");

	return ret ? ret : vb2_core_qbuf(q, b->index, b);

	return ret ? ret : vb2_core_qbuf(q, b->index, b, NULL);

}

EXPORT_SYMBOL_GPL(vb2_qbuf);

drivers/media/dvb-core/dvb_vb2.c

+1 −1
Original line number Diff line number Diff line
@@ -384,7 +384,7 @@ int dvb_vb2_qbuf(struct dvb_vb2_ctx *ctx, struct dmx_buffer *b) 
{

	int ret;



	ret = vb2_core_qbuf(&ctx->vb_q, b->index, b);

	ret = vb2_core_qbuf(&ctx->vb_q, b->index, b, NULL);

	if (ret) {

		dprintk(1, "[%s] index=%d errno=%d\n", ctx->name,

			b->index, ret);

include/media/videobuf2-core.h

+17 −1
Original line number Diff line number Diff line
@@ -204,6 +204,7 @@ enum vb2_io_modes { 
/**

 * enum vb2_buffer_state - current video buffer state.

 * @VB2_BUF_STATE_DEQUEUED:	buffer under userspace control.

 * @VB2_BUF_STATE_IN_REQUEST:	buffer is queued in media request.

 * @VB2_BUF_STATE_PREPARING:	buffer is being prepared in videobuf.

 * @VB2_BUF_STATE_QUEUED:	buffer queued in videobuf, but not in driver.

 * @VB2_BUF_STATE_REQUEUEING:	re-queue a buffer to the driver.
@@ -217,6 +218,7 @@ enum vb2_io_modes { 
 */

enum vb2_buffer_state {

	VB2_BUF_STATE_DEQUEUED,

	VB2_BUF_STATE_IN_REQUEST,

	VB2_BUF_STATE_PREPARING,

	VB2_BUF_STATE_QUEUED,

	VB2_BUF_STATE_REQUEUEING,
@@ -297,6 +299,7 @@ struct vb2_buffer { 
	u32		cnt_buf_finish;

	u32		cnt_buf_cleanup;

	u32		cnt_buf_queue;

	u32		cnt_buf_request_complete;



	/* This counts the number of calls to vb2_buffer_done() */

	u32		cnt_buf_done;
@@ -390,6 +393,11 @@ struct vb2_buffer { 
 *			ioctl; might be called before @start_streaming callback

 *			if user pre-queued buffers before calling

 *			VIDIOC_STREAMON().

 * @buf_request_complete: a buffer that was never queued to the driver but is

 *			associated with a queued request was canceled.

 *			The driver will have to mark associated objects in the

 *			request as completed; required if requests are

 *			supported.

 */

struct vb2_ops {

	int (*queue_setup)(struct vb2_queue *q,
@@ -408,6 +416,8 @@ struct vb2_ops { 
	void (*stop_streaming)(struct vb2_queue *q);



	void (*buf_queue)(struct vb2_buffer *vb);



	void (*buf_request_complete)(struct vb2_buffer *vb);

};



/**
@@ -765,12 +775,17 @@ int vb2_core_prepare_buf(struct vb2_queue *q, unsigned int index, void *pb); 
 * @index:	id number of the buffer

 * @pb:		buffer structure passed from userspace to

 *		v4l2_ioctl_ops->vidioc_qbuf handler in driver

 * @req:	pointer to &struct media_request, may be NULL.

 *

 * Videobuf2 core helper to implement VIDIOC_QBUF() operation. It is called

 * internally by VB2 by an API-specific handler, like ``videobuf2-v4l2.h``.

 *

 * This function:

 *

 * #) If @req is non-NULL, then the buffer will be bound to this

 *    media request and it returns. The buffer will be prepared and

 *    queued to the driver (i.e. the next two steps) when the request

 *    itself is queued.

 * #) if necessary, calls &vb2_ops->buf_prepare callback in the driver

 *    (if provided), in which driver-specific buffer initialization can

 *    be performed;
@@ -779,7 +794,8 @@ int vb2_core_prepare_buf(struct vb2_queue *q, unsigned int index, void *pb); 
 *

 * Return: returns zero on success; an error code otherwise.

 */

int vb2_core_qbuf(struct vb2_queue *q, unsigned int index, void *pb);

int vb2_core_qbuf(struct vb2_queue *q, unsigned int index, void *pb,

		  struct media_request *req);



/**

 * vb2_core_dqbuf() - Dequeue a buffer to the userspace