[media] vb2: add out-fence support to QBUF

If V4L2_BUF_FLAG_OUT_FENCE flag is present on the QBUF call we create
an out_fence and send its fd to userspace on the fence_fd field as a
return arg for the QBUF call.

The fence is signaled on buffer_done(), when the job on the buffer is
finished.

v9:	- remove in-fences changes from this patch (Alex Courbot)
	- improve fence context creation (Hans Verkuil)
	- clean up out fences if vb2_core_qbuf() fails (Hans Verkuil)

v8:
	- return 0 as fence_fd if OUT_FENCE flag not used (Mauro)
	- fix crash when checking not using fences in vb2_buffer_done()

v7:
	- merge patch that add the infrastructure to out-fences into
	this one (Alex Courbot)
	- Do not install the fd if there is no fence. (Alex Courbot)
	- do not report error on requeueing, just WARN_ON_ONCE() (Hans)

v6
	- get rid of the V4L2_EVENT_OUT_FENCE event. We always keep the
	ordering in vb2 for queueing in the driver, so the event is not
	necessary anymore and the out_fence_fd is sent back to userspace
	on QBUF call return arg
	- do not allow requeueing with out-fences, instead mark the
	  buffer
	with an error and wake up to userspace.
	- send the out_fence_fd back to userspace on the fence_fd field

v5:
	- delay fd_install to DQ_EVENT (Hans)
	- if queue is fully ordered send OUT_FENCE event right away
	(Brian)
	- rename 'q->ordered' to 'q->ordered_in_driver'
	- merge change to implement OUT_FENCE event here

v4:
	- return the out_fence_fd in the BUF_QUEUED event(Hans)

v3:	- add WARN_ON_ONCE(q->ordered) on requeueing (Hans)
	- set the OUT_FENCE flag if there is a fence pending (Hans)
	- call fd_install() after vb2_core_qbuf() (Hans)
	- clean up fence if vb2_core_qbuf() fails (Hans)
	- add list to store sync_file and fence for the next queued
	  buffer

v2: check if the queue is ordered.

Change-Id: I5c63827350c67ba703ce6a2b2fb4818bcc721846
Signed-off-by: Gustavo Padovan <gustavo.padovan@collabora.com>
Signed-off-by: Janghyuck Kim <janghyuck.kim@samsung.com>

diff --git a/drivers/media/v4l2-core/videobuf2-core.c b/drivers/media/v4l2-core/videobuf2-core.c
index f445feacc80e3c29ddedeaea6fa874ee94e6329e..131133cba30df1a5edea67d1770d27b397ce07ad 100644 (file)
--- a/drivers/media/v4l2-core/videobuf2-core.c
+++ b/drivers/media/v4l2-core/videobuf2-core.c
@@ -23,6 +23,7 @@
 #include <linux/sched.h>
 #include <linux/freezer.h>
 #include <linux/kthread.h>
+#include <linux/sync_file.h>
 
 #include <media/videobuf2-core.h>
 #include <media/v4l2-mc.h>
@@ -351,6 +352,7 @@ static int __vb2_queue_alloc(struct vb2_queue *q, enum vb2_memory memory,
                        vb->planes[plane].length = plane_sizes[plane];
                        vb->planes[plane].min_length = plane_sizes[plane];
                }
+               vb->out_fence_fd = -1;
                q->bufs[vb->index] = vb;
 
                /* Allocate video buffer memory for the MMAP type */
@@ -926,10 +928,22 @@ static void vb2_process_buffer_done(struct vb2_buffer *vb, enum vb2_buffer_state
        case VB2_BUF_STATE_QUEUED:
                return;
        case VB2_BUF_STATE_REQUEUEING:
+               /* Requeuing with explicit synchronization, spit warning */
+               WARN_ON_ONCE(vb->out_fence);
+
                if (q->start_streaming_called)
                        __enqueue_in_driver(vb);
                return;
        default:
+               if (vb->out_fence) {
+                       if (state == VB2_BUF_STATE_ERROR)
+                               dma_fence_set_error(vb->out_fence, -EFAULT);
+                       dma_fence_signal(vb->out_fence);
+                       dma_fence_put(vb->out_fence);
+                       vb->out_fence = NULL;
+                       vb->out_fence_fd = -1;
+               }
+
                /* Inform any processes that may be waiting for buffers */
                wake_up(&q->done_wq);
                break;
@@ -1474,6 +1488,7 @@ int vb2_core_qbuf(struct vb2_queue *q, unsigned int index, void *pb,
        list_add_tail(&vb->queued_entry, &q->queued_list);
        q->queued_count++;
        q->waiting_for_buffers = false;
+       q->queueing_started = 1;
        vb->state = VB2_BUF_STATE_QUEUED;
        vb->in_fence = in_fence;
 
@@ -1537,6 +1552,11 @@ int vb2_core_qbuf(struct vb2_queue *q, unsigned int index, void *pb,
        if (pb)
                call_void_bufop(q, fill_user_buffer, vb, pb);
 
+       if (vb->out_fence) {
+               fd_install(vb->out_fence_fd, vb->sync_file->file);
+               vb->sync_file = NULL;
+       }
+
        dprintk(2, "qbuf of buffer %d succeeded\n", vb->index);
        return 0;
 
@@ -1544,6 +1564,16 @@ unlock:
        spin_unlock_irqrestore(&vb->fence_cb_lock, flags);
 
 err:
+       if (vb->sync_file) {
+               put_unused_fd(vb->out_fence_fd);
+               vb->out_fence_fd = -1;
+
+               dma_fence_put(vb->out_fence);
+
+               fput(vb->sync_file->file);
+               vb->sync_file = NULL;
+       }
+
        /* Fill buffer information for the userspace */
        if (pb)
                call_void_bufop(q, fill_user_buffer, vb, pb);
@@ -1793,6 +1823,7 @@ static void __vb2_queue_cancel(struct vb2_queue *q)
        q->start_streaming_called = 0;
        q->queued_count = 0;
        q->error = 0;
+       q->queueing_started = 0;
 
        list_for_each_entry(vb, &q->queued_list, queued_entry) {
                spin_lock_irqsave(&vb->fence_cb_lock, flags);
@@ -2136,6 +2167,7 @@ int vb2_core_queue_init(struct vb2_queue *q)
        spin_lock_init(&q->done_lock);
        mutex_init(&q->mmap_lock);
        init_waitqueue_head(&q->done_wq);
+       spin_lock_init(&q->out_fence_lock);
 
        if (q->buf_struct_size == 0)
                q->buf_struct_size = sizeof(struct vb2_buffer);
@@ -2681,6 +2713,62 @@ static int vb2_thread(void *data)
        return 0;
 }
 
+static inline const char *vb2_fence_get_driver_name(struct dma_fence *fence)
+{
+       return "vb2_fence";
+}
+
+static inline const char *vb2_fence_get_timeline_name(struct dma_fence *fence)
+{
+       return "vb2_fence_timeline";
+}
+
+static inline bool vb2_fence_enable_signaling(struct dma_fence *fence)
+{
+       return true;
+}
+
+static const struct dma_fence_ops vb2_fence_ops = {
+       .get_driver_name = vb2_fence_get_driver_name,
+       .get_timeline_name = vb2_fence_get_timeline_name,
+       .enable_signaling = vb2_fence_enable_signaling,
+       .wait = dma_fence_default_wait,
+};
+
+int vb2_setup_out_fence(struct vb2_queue *q, unsigned int index)
+{
+       struct vb2_buffer *vb;
+
+       vb = q->bufs[index];
+
+       vb->out_fence_fd = get_unused_fd_flags(O_CLOEXEC);
+
+       if (call_qop(q, is_unordered, q) || !q->queueing_started)
+               q->out_fence_context = dma_fence_context_alloc(1);
+
+       vb->out_fence = kzalloc(sizeof(*vb->out_fence), GFP_KERNEL);
+       if (!vb->out_fence)
+               return -ENOMEM;
+
+       dma_fence_init(vb->out_fence, &vb2_fence_ops, &q->out_fence_lock,
+                      q->out_fence_context, 1);
+       if (!vb->out_fence) {
+               put_unused_fd(vb->out_fence_fd);
+               return -ENOMEM;
+       }
+
+       vb->sync_file = sync_file_create(vb->out_fence);
+       if (!vb->sync_file) {
+               put_unused_fd(vb->out_fence_fd);
+               dma_fence_put(vb->out_fence);
+               vb->out_fence = NULL;
+               return -ENOMEM;
+       }
+
+       return 0;
+}
+EXPORT_SYMBOL_GPL(vb2_setup_out_fence);
+
 /*
  * This function should not be used for anything else but the videobuf2-dvb
  * support. If you think you have another good use-case for this, then please

diff --git a/drivers/media/v4l2-core/videobuf2-v4l2.c b/drivers/media/v4l2-core/videobuf2-v4l2.c
index 439cb592082832dc4de5930b9b8d1aec39d285d6..f1e85756947f1aca638e0bff444eb04b539d6e51 100644 (file)
--- a/drivers/media/v4l2-core/videobuf2-v4l2.c
+++ b/drivers/media/v4l2-core/videobuf2-v4l2.c
@@ -216,7 +216,12 @@ static void __fill_v4l2_buffer(struct vb2_buffer *vb, void *pb)
        b->timecode = vbuf->timecode;
        b->sequence = vbuf->sequence;
        b->reserved2 = vbuf->reserved2;
-       b->reserved = 0;
+
+       if (b->flags & V4L2_BUF_FLAG_OUT_FENCE) {
+               b->fence_fd = vb->out_fence_fd;
+       } else {
+               b->fence_fd = 0;
+       }
 
        if (vb->in_fence)
                b->flags |= V4L2_BUF_FLAG_IN_FENCE;
@@ -495,6 +500,10 @@ int vb2_querybuf(struct vb2_queue *q, struct v4l2_buffer *b)
        ret = __verify_planes_array(vb, b);
        if (!ret)
                vb2_core_querybuf(q, b->index, b);
+
+       /* Do not return the out-fence fd on querybuf */
+       if (vb->out_fence)
+               b->fence_fd = -1;
        return ret;
 }
 EXPORT_SYMBOL(vb2_querybuf);
@@ -599,6 +608,15 @@ int vb2_qbuf(struct vb2_queue *q, struct v4l2_buffer *b)
                }
        }
 
+       if (b->flags & V4L2_BUF_FLAG_OUT_FENCE) {
+               ret = vb2_setup_out_fence(q, b->index);
+               if (ret) {
+                       dprintk(1, "failed to set up out-fence\n");
+                       dma_fence_put(in_fence);
+                       return ret;
+               }
+       }
+
        return vb2_core_qbuf(q, b->index, b, in_fence);
 }
 EXPORT_SYMBOL_GPL(vb2_qbuf);

diff --git a/include/media/videobuf2-core.h b/include/media/videobuf2-core.h
index ab10bfc701b4a913897203d29a7a154abd649035..360c9abc2dd7cb11949c115466e90b8aa7a131f7 100644 (file)
--- a/include/media/videobuf2-core.h
+++ b/include/media/videobuf2-core.h
@@ -259,6 +259,10 @@ struct vb2_buffer {
         *                      using the buffer (queueing to the driver)
         * fence_cb:            fence callback information
         * fence_cb_lock:       protect callback signal/remove
+        * out_fence_fd:        the out_fence_fd to be shared with userspace.
+        * out_fence:           the out-fence associated with the buffer once
+        *                      it is queued to the driver.
+        * sync_file:           the sync file to wrap the out fence
         */
        enum vb2_buffer_state   state;
 
@@ -269,6 +273,10 @@ struct vb2_buffer {
        struct dma_fence_cb     fence_cb;
        spinlock_t              fence_cb_lock;
 
+       int                     out_fence_fd;
+       struct dma_fence        *out_fence;
+       struct sync_file        *sync_file;
+
 #ifdef CONFIG_VIDEO_ADV_DEBUG
        /*
         * Counters for how often these buffer-related ops are
@@ -565,6 +573,10 @@ struct vb2_queue {
        unsigned int                    is_output:1;
        unsigned int                    copy_timestamp:1;
        unsigned int                    last_buffer_dequeued:1;
+       unsigned int                    queueing_started:1;
+
+       u64                             out_fence_context;
+       spinlock_t                      out_fence_lock;
 
        struct vb2_fileio_data          *fileio;
        struct vb2_threadio_data        *threadio;
@@ -735,6 +747,16 @@ int vb2_core_create_bufs(struct vb2_queue *q, enum vb2_memory memory,
  */
 int vb2_core_prepare_buf(struct vb2_queue *q, unsigned int index, void *pb);
 
+/**
+ * vb2_setup_out_fence() - setup new out-fence
+ * @q:         The vb2_queue where to setup it
+ * @index:     index of the buffer
+ *
+ * Setup the file descriptor, the fence and the sync_file for the next
+ * buffer to be queued and add everything to the tail of the q->out_fence_list.
+ */
+int vb2_setup_out_fence(struct vb2_queue *q, unsigned int index);
+
 /**
  * vb2_core_qbuf() - Queue a buffer from userspace
  *