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: Hans Verkuil <hans.verkuil@cisco.com>
Reviewed-by: Mauro Carvalho Chehab <mchehab+samsung@kernel.org>
Signed-off-by: Mauro Carvalho Chehab <mchehab+samsung@kernel.org>

diff --git a/drivers/media/common/videobuf2/videobuf2-core.c b/drivers/media/common/videobuf2/videobuf2-core.c
index 230f83d..a6f4e9a 100644 (file)
--- a/drivers/media/common/videobuf2/videobuf2-core.c
+++ b/drivers/media/common/videobuf2/videobuf2-core.c
@@ -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;

diff --git a/drivers/media/common/videobuf2/videobuf2-v4l2.c b/drivers/media/common/videobuf2/videobuf2-v4l2.c
index 64905d8..ea9db4b 100644 (file)
--- a/drivers/media/common/videobuf2/videobuf2-v4l2.c
+++ b/drivers/media/common/videobuf2/videobuf2-v4l2.c
@@ -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);
 

diff --git a/drivers/media/dvb-core/dvb_vb2.c b/drivers/media/dvb-core/dvb_vb2.c
index da6a8ce..f1e7f05 100644 (file)
--- a/drivers/media/dvb-core/dvb_vb2.c
+++ b/drivers/media/dvb-core/dvb_vb2.c
@@ -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);

diff --git a/include/media/videobuf2-core.h b/include/media/videobuf2-core.h
index 413b8b2..957b11c 100644 (file)
--- a/include/media/videobuf2-core.h
+++ b/include/media/videobuf2-core.h
@@ -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