media: vb2: Print the queue pointer in debug messages

When debugging issues that involve more than one video queue, messages
related to multiple queues get interleaved without any easy way to tell
which queue they relate to. Fix this by adding a queue name to
vb2_queue, and printing it in all debug messages in the vb2 core and
V4L2 layers. If the name isn't set by drivers, it is automatically
filled with the queue direction and address.

Signed-off-by: Laurent Pinchart <laurent.pinchart+renesas@ideasonboard.com>
Signed-off-by: Hans Verkuil <hverkuil-cisco@xs4all.nl>
Signed-off-by: Mauro Carvalho Chehab <mchehab+huawei@kernel.org>

diff --git a/drivers/media/common/videobuf2/videobuf2-core.c b/drivers/media/common/videobuf2/videobuf2-core.c
index 37d0186..abaf28e 100644 (file)
--- a/drivers/media/common/videobuf2/videobuf2-core.c
+++ b/drivers/media/common/videobuf2/videobuf2-core.c
@@ -34,10 +34,11 @@
 static int debug;
 module_param(debug, int, 0644);
 
-#define dprintk(level, fmt, arg...)                            \
-       do {                                                    \
-               if (debug >= level)                             \
-                       pr_info("%s: " fmt, __func__, ## arg);  \
+#define dprintk(q, level, fmt, arg...)                                 \
+       do {                                                            \
+               if (debug >= level)                                     \
+                       pr_info("[%s] %s: " fmt, (q)->name, __func__,   \
+                               ## arg);                                \
        } while (0)
 
 #ifdef CONFIG_VIDEO_ADV_DEBUG
@@ -51,8 +52,8 @@ module_param(debug, int, 0644);
  */
 
 #define log_memop(vb, op)                                              \
-       dprintk(2, "call_memop(%p, %d, %s)%s\n",                        \
-               (vb)->vb2_queue, (vb)->index, #op,                      \
+       dprintk((vb)->vb2_queue, 2, "call_memop(%d, %s)%s\n",           \
+               (vb)->index, #op,                                       \
                (vb)->vb2_queue->mem_ops->op ? "" : " (nop)")
 
 #define call_memop(vb, op, args...)                                    \
@@ -90,7 +91,7 @@ module_param(debug, int, 0644);
 })
 
 #define log_qop(q, op)                                                 \
-       dprintk(2, "call_qop(%p, %s)%s\n", q, #op,                      \
+       dprintk(q, 2, "call_qop(%s)%s\n", #op,                          \
                (q)->ops->op ? "" : " (nop)")
 
 #define call_qop(q, op, args...)                                       \
@@ -113,8 +114,8 @@ module_param(debug, int, 0644);
 })
 
 #define log_vb_qop(vb, op, args...)                                    \
-       dprintk(2, "call_vb_qop(%p, %d, %s)%s\n",                       \
-               (vb)->vb2_queue, (vb)->index, #op,                      \
+       dprintk((vb)->vb2_queue, 2, "call_vb_qop(%d, %s)%s\n",          \
+               (vb)->index, #op,                                       \
                (vb)->vb2_queue->ops->op ? "" : " (nop)")
 
 #define call_vb_qop(vb, op, args...)                                   \
@@ -246,7 +247,8 @@ static void __vb2_buf_mem_free(struct vb2_buffer *vb)
        for (plane = 0; plane < vb->num_planes; ++plane) {
                call_void_memop(vb, put, vb->planes[plane].mem_priv);
                vb->planes[plane].mem_priv = NULL;
-               dprintk(3, "freed plane %d of buffer %d\n", plane, vb->index);
+               dprintk(vb->vb2_queue, 3, "freed plane %d of buffer %d\n",
+                       plane, vb->index);
        }
 }
 
@@ -354,7 +356,7 @@ static void __setup_offsets(struct vb2_buffer *vb)
        for (plane = 0; plane < vb->num_planes; ++plane) {
                vb->planes[plane].m.offset = off;
 
-               dprintk(3, "buffer %d, plane %d offset 0x%08lx\n",
+               dprintk(q, 3, "buffer %d, plane %d offset 0x%08lx\n",
                                vb->index, plane, off);
 
                off += vb->planes[plane].length;
@@ -385,7 +387,7 @@ static int __vb2_queue_alloc(struct vb2_queue *q, enum vb2_memory memory,
                /* Allocate videobuf buffer structures */
                vb = kzalloc(q->buf_struct_size, GFP_KERNEL);
                if (!vb) {
-                       dprintk(1, "memory alloc for buffer struct failed\n");
+                       dprintk(q, 1, "memory alloc for buffer struct failed\n");
                        break;
                }
 
@@ -407,7 +409,7 @@ static int __vb2_queue_alloc(struct vb2_queue *q, enum vb2_memory memory,
                if (memory == VB2_MEMORY_MMAP) {
                        ret = __vb2_buf_mem_alloc(vb);
                        if (ret) {
-                               dprintk(1, "failed allocating memory for buffer %d\n",
+                               dprintk(q, 1, "failed allocating memory for buffer %d\n",
                                        buffer);
                                q->bufs[vb->index] = NULL;
                                kfree(vb);
@@ -421,7 +423,7 @@ static int __vb2_queue_alloc(struct vb2_queue *q, enum vb2_memory memory,
                         */
                        ret = call_vb_qop(vb, buf_init, vb);
                        if (ret) {
-                               dprintk(1, "buffer %d %p initialization failed\n",
+                               dprintk(q, 1, "buffer %d %p initialization failed\n",
                                        buffer, vb);
                                __vb2_buf_mem_free(vb);
                                q->bufs[vb->index] = NULL;
@@ -431,7 +433,7 @@ static int __vb2_queue_alloc(struct vb2_queue *q, enum vb2_memory memory,
                }
        }
 
-       dprintk(3, "allocated %d buffers, %d plane(s) each\n",
+       dprintk(q, 3, "allocated %d buffers, %d plane(s) each\n",
                buffer, num_planes);
 
        return buffer;
@@ -483,7 +485,7 @@ static int __vb2_queue_free(struct vb2_queue *q, unsigned int buffers)
                if (q->bufs[buffer] == NULL)
                        continue;
                if (q->bufs[buffer]->state == VB2_BUF_STATE_PREPARING) {
-                       dprintk(1, "preparing buffers, cannot free\n");
+                       dprintk(q, 1, "preparing buffers, cannot free\n");
                        return -EAGAIN;
                }
        }
@@ -661,12 +663,12 @@ int vb2_verify_memory_type(struct vb2_queue *q,
 {
        if (memory != VB2_MEMORY_MMAP && memory != VB2_MEMORY_USERPTR &&
            memory != VB2_MEMORY_DMABUF) {
-               dprintk(1, "unsupported memory type\n");
+               dprintk(q, 1, "unsupported memory type\n");
                return -EINVAL;
        }
 
        if (type != q->type) {
-               dprintk(1, "requested type is incorrect\n");
+               dprintk(q, 1, "requested type is incorrect\n");
                return -EINVAL;
        }
 
@@ -675,17 +677,17 @@ int vb2_verify_memory_type(struct vb2_queue *q,
         * are available.
         */
        if (memory == VB2_MEMORY_MMAP && __verify_mmap_ops(q)) {
-               dprintk(1, "MMAP for current setup unsupported\n");
+               dprintk(q, 1, "MMAP for current setup unsupported\n");
                return -EINVAL;
        }
 
        if (memory == VB2_MEMORY_USERPTR && __verify_userptr_ops(q)) {
-               dprintk(1, "USERPTR for current setup unsupported\n");
+               dprintk(q, 1, "USERPTR for current setup unsupported\n");
                return -EINVAL;
        }
 
        if (memory == VB2_MEMORY_DMABUF && __verify_dmabuf_ops(q)) {
-               dprintk(1, "DMABUF for current setup unsupported\n");
+               dprintk(q, 1, "DMABUF for current setup unsupported\n");
                return -EINVAL;
        }
 
@@ -695,7 +697,7 @@ int vb2_verify_memory_type(struct vb2_queue *q,
         * do the memory and type validation.
         */
        if (vb2_fileio_is_active(q)) {
-               dprintk(1, "file io in progress\n");
+               dprintk(q, 1, "file io in progress\n");
                return -EBUSY;
        }
        return 0;
@@ -717,7 +719,7 @@ static bool verify_consistency_attr(struct vb2_queue *q, bool consistent_mem)
        bool queue_is_consistent = !(q->dma_attrs & DMA_ATTR_NON_CONSISTENT);
 
        if (consistent_mem != queue_is_consistent) {
-               dprintk(1, "memory consistency model mismatch\n");
+               dprintk(q, 1, "memory consistency model mismatch\n");
                return false;
        }
        return true;
@@ -736,12 +738,12 @@ int vb2_core_reqbufs(struct vb2_queue *q, enum vb2_memory memory,
                consistent_mem = false;
 
        if (q->streaming) {
-               dprintk(1, "streaming active\n");
+               dprintk(q, 1, "streaming active\n");
                return -EBUSY;
        }
 
        if (q->waiting_in_dqbuf && *count) {
-               dprintk(1, "another dup()ped fd is waiting for a buffer\n");
+               dprintk(q, 1, "another dup()ped fd is waiting for a buffer\n");
                return -EBUSY;
        }
 
@@ -755,7 +757,7 @@ int vb2_core_reqbufs(struct vb2_queue *q, enum vb2_memory memory,
                mutex_lock(&q->mmap_lock);
                if (debug && q->memory == VB2_MEMORY_MMAP &&
                    __buffers_in_use(q))
-                       dprintk(1, "memory in use, orphaning buffers\n");
+                       dprintk(q, 1, "memory in use, orphaning buffers\n");
 
                /*
                 * Call queue_cancel to clean up any buffers in the
@@ -807,7 +809,7 @@ int vb2_core_reqbufs(struct vb2_queue *q, enum vb2_memory memory,
        allocated_buffers =
                __vb2_queue_alloc(q, memory, num_buffers, num_planes, plane_sizes);
        if (allocated_buffers == 0) {
-               dprintk(1, "memory allocation failed\n");
+               dprintk(q, 1, "memory allocation failed\n");
                return -ENOMEM;
        }
 
@@ -882,13 +884,13 @@ int vb2_core_create_bufs(struct vb2_queue *q, enum vb2_memory memory,
                consistent_mem = false;
 
        if (q->num_buffers == VB2_MAX_FRAME) {
-               dprintk(1, "maximum number of buffers already allocated\n");
+               dprintk(q, 1, "maximum number of buffers already allocated\n");
                return -ENOBUFS;
        }
 
        if (!q->num_buffers) {
                if (q->waiting_in_dqbuf && *count) {
-                       dprintk(1, "another dup()ped fd is waiting for a buffer\n");
+                       dprintk(q, 1, "another dup()ped fd is waiting for a buffer\n");
                        return -EBUSY;
                }
                memset(q->alloc_devs, 0, sizeof(q->alloc_devs));
@@ -897,7 +899,7 @@ int vb2_core_create_bufs(struct vb2_queue *q, enum vb2_memory memory,
                q->waiting_for_buffers = !q->is_output;
        } else {
                if (q->memory != memory) {
-                       dprintk(1, "memory model mismatch\n");
+                       dprintk(q, 1, "memory model mismatch\n");
                        return -EINVAL;
                }
                if (!verify_consistency_attr(q, consistent_mem))
@@ -924,7 +926,7 @@ int vb2_core_create_bufs(struct vb2_queue *q, enum vb2_memory memory,
        allocated_buffers = __vb2_queue_alloc(q, memory, num_buffers,
                                num_planes, plane_sizes);
        if (allocated_buffers == 0) {
-               dprintk(1, "memory allocation failed\n");
+               dprintk(q, 1, "memory allocation failed\n");
                return -ENOMEM;
        }
 
@@ -1013,7 +1015,7 @@ void vb2_buffer_done(struct vb2_buffer *vb, enum vb2_buffer_state state)
         */
        vb->cnt_buf_done++;
 #endif
-       dprintk(4, "done processing on buffer %d, state: %d\n",
+       dprintk(q, 4, "done processing on buffer %d, state: %d\n",
                        vb->index, state);
 
        if (state != VB2_BUF_STATE_QUEUED)
@@ -1099,12 +1101,12 @@ static int __prepare_userptr(struct vb2_buffer *vb)
                        && vb->planes[plane].length == planes[plane].length)
                        continue;
 
-               dprintk(3, "userspace address for plane %d changed, reacquiring memory\n",
+               dprintk(q, 3, "userspace address for plane %d changed, reacquiring memory\n",
                        plane);
 
                /* Check if the provided plane buffer is large enough */
                if (planes[plane].length < vb->planes[plane].min_length) {
-                       dprintk(1, "provided buffer size %u is less than setup size %u for plane %d\n",
+                       dprintk(q, 1, "provided buffer size %u is less than setup size %u for plane %d\n",
                                                planes[plane].length,
                                                vb->planes[plane].min_length,
                                                plane);
@@ -1134,7 +1136,7 @@ static int __prepare_userptr(struct vb2_buffer *vb)
                                planes[plane].m.userptr,
                                planes[plane].length, q->dma_dir);
                if (IS_ERR(mem_priv)) {
-                       dprintk(1, "failed acquiring userspace memory for plane %d\n",
+                       dprintk(q, 1, "failed acquiring userspace memory for plane %d\n",
                                plane);
                        ret = PTR_ERR(mem_priv);
                        goto err;
@@ -1161,14 +1163,14 @@ static int __prepare_userptr(struct vb2_buffer *vb)
                 */
                ret = call_vb_qop(vb, buf_init, vb);
                if (ret) {
-                       dprintk(1, "buffer initialization failed\n");
+                       dprintk(q, 1, "buffer initialization failed\n");
                        goto err;
                }
        }
 
        ret = call_vb_qop(vb, buf_prepare, vb);
        if (ret) {
-               dprintk(1, "buffer preparation failed\n");
+               dprintk(q, 1, "buffer preparation failed\n");
                call_void_vb_qop(vb, buf_cleanup, vb);
                goto err;
        }
@@ -1211,7 +1213,7 @@ static int __prepare_dmabuf(struct vb2_buffer *vb)
                struct dma_buf *dbuf = dma_buf_get(planes[plane].m.fd);
 
                if (IS_ERR_OR_NULL(dbuf)) {
-                       dprintk(1, "invalid dmabuf fd for plane %d\n",
+                       dprintk(q, 1, "invalid dmabuf fd for plane %d\n",
                                plane);
                        ret = -EINVAL;
                        goto err;
@@ -1222,7 +1224,7 @@ static int __prepare_dmabuf(struct vb2_buffer *vb)
                        planes[plane].length = dbuf->size;
 
                if (planes[plane].length < vb->planes[plane].min_length) {
-                       dprintk(1, "invalid dmabuf length %u for plane %d, minimum length %u\n",
+                       dprintk(q, 1, "invalid dmabuf length %u for plane %d, minimum length %u\n",
                                planes[plane].length, plane,
                                vb->planes[plane].min_length);
                        dma_buf_put(dbuf);
@@ -1237,7 +1239,7 @@ static int __prepare_dmabuf(struct vb2_buffer *vb)
                        continue;
                }
 
-               dprintk(3, "buffer for plane %d changed\n", plane);
+               dprintk(q, 3, "buffer for plane %d changed\n", plane);
 
                if (!reacquired) {
                        reacquired = true;
@@ -1257,7 +1259,7 @@ static int __prepare_dmabuf(struct vb2_buffer *vb)
                                q->alloc_devs[plane] ? : q->dev,
                                dbuf, planes[plane].length, q->dma_dir);
                if (IS_ERR(mem_priv)) {
-                       dprintk(1, "failed to attach dmabuf\n");
+                       dprintk(q, 1, "failed to attach dmabuf\n");
                        ret = PTR_ERR(mem_priv);
                        dma_buf_put(dbuf);
                        goto err;
@@ -1278,7 +1280,7 @@ static int __prepare_dmabuf(struct vb2_buffer *vb)
 
                ret = call_memop(vb, map_dmabuf, vb->planes[plane].mem_priv);
                if (ret) {
-                       dprintk(1, "failed to map dmabuf for plane %d\n",
+                       dprintk(q, 1, "failed to map dmabuf for plane %d\n",
                                plane);
                        goto err;
                }
@@ -1303,14 +1305,14 @@ static int __prepare_dmabuf(struct vb2_buffer *vb)
                 */
                ret = call_vb_qop(vb, buf_init, vb);
                if (ret) {
-                       dprintk(1, "buffer initialization failed\n");
+                       dprintk(q, 1, "buffer initialization failed\n");
                        goto err;
                }
        }
 
        ret = call_vb_qop(vb, buf_prepare, vb);
        if (ret) {
-               dprintk(1, "buffer preparation failed\n");
+               dprintk(q, 1, "buffer preparation failed\n");
                call_void_vb_qop(vb, buf_cleanup, vb);
                goto err;
        }
@@ -1345,7 +1347,7 @@ static int __buf_prepare(struct vb2_buffer *vb)
        int ret;
 
        if (q->error) {
-               dprintk(1, "fatal error occurred on queue\n");
+               dprintk(q, 1, "fatal error occurred on queue\n");
                return -EIO;
        }
 
@@ -1356,7 +1358,7 @@ static int __buf_prepare(struct vb2_buffer *vb)
        if (q->is_output) {
                ret = call_vb_qop(vb, buf_out_validate, vb);
                if (ret) {
-                       dprintk(1, "buffer validation failed\n");
+                       dprintk(q, 1, "buffer validation failed\n");
                        return ret;
                }
        }
@@ -1380,7 +1382,7 @@ static int __buf_prepare(struct vb2_buffer *vb)
        }
 
        if (ret) {
-               dprintk(1, "buffer preparation failed: %d\n", ret);
+               dprintk(q, 1, "buffer preparation failed: %d\n", ret);
                vb->state = orig_state;
                return ret;
        }
@@ -1488,12 +1490,12 @@ int vb2_core_prepare_buf(struct vb2_queue *q, unsigned int index, void *pb)
 
        vb = q->bufs[index];
        if (vb->state != VB2_BUF_STATE_DEQUEUED) {
-               dprintk(1, "invalid buffer state %d\n",
+               dprintk(q, 1, "invalid buffer state %d\n",
                        vb->state);
                return -EINVAL;
        }
        if (vb->prepared) {
-               dprintk(1, "buffer already prepared\n");
+               dprintk(q, 1, "buffer already prepared\n");
                return -EINVAL;
        }
 
@@ -1504,7 +1506,7 @@ int vb2_core_prepare_buf(struct vb2_queue *q, unsigned int index, void *pb)
        /* Fill buffer information for the userspace */
        call_void_bufop(q, fill_user_buffer, vb, pb);
 
-       dprintk(2, "prepare of buffer %d succeeded\n", vb->index);
+       dprintk(q, 2, "prepare of buffer %d succeeded\n", vb->index);
 
        return 0;
 }
@@ -1542,7 +1544,7 @@ static int vb2_start_streaming(struct vb2_queue *q)
 
        q->start_streaming_called = 0;
 
-       dprintk(1, "driver refused to start streaming\n");
+       dprintk(q, 1, "driver refused to start streaming\n");
        /*
         * If you see this warning, then the driver isn't cleaning up properly
         * after a failed start_streaming(). See the start_streaming()
@@ -1580,7 +1582,7 @@ int vb2_core_qbuf(struct vb2_queue *q, unsigned int index, void *pb,
        int ret;
 
        if (q->error) {
-               dprintk(1, "fatal error occurred on queue\n");
+               dprintk(q, 1, "fatal error occurred on queue\n");
                return -EIO;
        }
 
@@ -1588,14 +1590,14 @@ int vb2_core_qbuf(struct vb2_queue *q, unsigned int index, void *pb,
 
        if (!req && vb->state != VB2_BUF_STATE_IN_REQUEST &&
            q->requires_requests) {
-               dprintk(1, "qbuf requires a request\n");
+               dprintk(q, 1, "qbuf requires a request\n");
                return -EBADR;
        }
 
        if ((req && q->uses_qbuf) ||
            (!req && vb->state != VB2_BUF_STATE_IN_REQUEST &&
             q->uses_requests)) {
-               dprintk(1, "queue in wrong mode (qbuf vs requests)\n");
+               dprintk(q, 1, "queue in wrong mode (qbuf vs requests)\n");
                return -EBUSY;
        }
 
@@ -1604,7 +1606,7 @@ int vb2_core_qbuf(struct vb2_queue *q, unsigned int index, void *pb,
 
                q->uses_requests = 1;
                if (vb->state != VB2_BUF_STATE_DEQUEUED) {
-                       dprintk(1, "buffer %d not in dequeued state\n",
+                       dprintk(q, 1, "buffer %d not in dequeued state\n",
                                vb->index);
                        return -EINVAL;
                }
@@ -1612,7 +1614,7 @@ int vb2_core_qbuf(struct vb2_queue *q, unsigned int index, void *pb,
                if (q->is_output && !vb->prepared) {
                        ret = call_vb_qop(vb, buf_out_validate, vb);
                        if (ret) {
-                               dprintk(1, "buffer validation failed\n");
+                               dprintk(q, 1, "buffer validation failed\n");
                                return ret;
                        }
                }
@@ -1648,7 +1650,7 @@ int vb2_core_qbuf(struct vb2_queue *q, unsigned int index, void *pb,
                        call_void_bufop(q, fill_user_buffer, vb, pb);
                }
 
-               dprintk(2, "qbuf of buffer %d succeeded\n", vb->index);
+               dprintk(q, 2, "qbuf of buffer %d succeeded\n", vb->index);
                return 0;
        }
 
@@ -1665,10 +1667,10 @@ int vb2_core_qbuf(struct vb2_queue *q, unsigned int index, void *pb,
                }
                break;
        case VB2_BUF_STATE_PREPARING:
-               dprintk(1, "buffer still being prepared\n");
+               dprintk(q, 1, "buffer still being prepared\n");
                return -EINVAL;
        default:
-               dprintk(1, "invalid buffer state %d\n", vb->state);
+               dprintk(q, 1, "invalid buffer state %d\n", vb->state);
                return -EINVAL;
        }
 
@@ -1710,7 +1712,7 @@ int vb2_core_qbuf(struct vb2_queue *q, unsigned int index, void *pb,
                        return ret;
        }
 
-       dprintk(2, "qbuf of buffer %d succeeded\n", vb->index);
+       dprintk(q, 2, "qbuf of buffer %d succeeded\n", vb->index);
        return 0;
 }
 EXPORT_SYMBOL_GPL(vb2_core_qbuf);
@@ -1736,22 +1738,22 @@ static int __vb2_wait_for_done_vb(struct vb2_queue *q, int nonblocking)
                int ret;
 
                if (q->waiting_in_dqbuf) {
-                       dprintk(1, "another dup()ped fd is waiting for a buffer\n");
+                       dprintk(q, 1, "another dup()ped fd is waiting for a buffer\n");
                        return -EBUSY;
                }
 
                if (!q->streaming) {
-                       dprintk(1, "streaming off, will not wait for buffers\n");
+                       dprintk(q, 1, "streaming off, will not wait for buffers\n");
                        return -EINVAL;
                }
 
                if (q->error) {
-                       dprintk(1, "Queue in error state, will not wait for buffers\n");
+                       dprintk(q, 1, "Queue in error state, will not wait for buffers\n");
                        return -EIO;
                }
 
                if (q->last_buffer_dequeued) {
-                       dprintk(3, "last buffer dequeued already, will not wait for buffers\n");
+                       dprintk(q, 3, "last buffer dequeued already, will not wait for buffers\n");
                        return -EPIPE;
                }
 
@@ -1763,7 +1765,7 @@ static int __vb2_wait_for_done_vb(struct vb2_queue *q, int nonblocking)
                }
 
                if (nonblocking) {
-                       dprintk(3, "nonblocking and no buffers to dequeue, will not wait\n");
+                       dprintk(q, 3, "nonblocking and no buffers to dequeue, will not wait\n");
                        return -EAGAIN;
                }
 
@@ -1778,7 +1780,7 @@ static int __vb2_wait_for_done_vb(struct vb2_queue *q, int nonblocking)
                /*
                 * All locks have been released, it is safe to sleep now.
                 */
-               dprintk(3, "will sleep waiting for buffers\n");
+               dprintk(q, 3, "will sleep waiting for buffers\n");
                ret = wait_event_interruptible(q->done_wq,
                                !list_empty(&q->done_list) || !q->streaming ||
                                q->error);
@@ -1790,7 +1792,7 @@ static int __vb2_wait_for_done_vb(struct vb2_queue *q, int nonblocking)
                call_void_qop(q, wait_finish, q);
                q->waiting_in_dqbuf = 0;
                if (ret) {
-                       dprintk(1, "sleep was interrupted\n");
+                       dprintk(q, 1, "sleep was interrupted\n");
                        return ret;
                }
        }
@@ -1838,7 +1840,7 @@ static int __vb2_get_done_vb(struct vb2_queue *q, struct vb2_buffer **vb,
 int vb2_wait_for_all_buffers(struct vb2_queue *q)
 {
        if (!q->streaming) {
-               dprintk(1, "streaming off, will not wait for buffers\n");
+               dprintk(q, 1, "streaming off, will not wait for buffers\n");
                return -EINVAL;
        }
 
@@ -1876,13 +1878,13 @@ int vb2_core_dqbuf(struct vb2_queue *q, unsigned int *pindex, void *pb,
 
        switch (vb->state) {
        case VB2_BUF_STATE_DONE:
-               dprintk(3, "returning done buffer\n");
+               dprintk(q, 3, "returning done buffer\n");
                break;
        case VB2_BUF_STATE_ERROR:
-               dprintk(3, "returning done buffer with errors\n");
+               dprintk(q, 3, "returning done buffer with errors\n");
                break;
        default:
-               dprintk(1, "invalid buffer state\n");
+               dprintk(q, 1, "invalid buffer state\n");
                return -EINVAL;
        }
 
@@ -1913,7 +1915,7 @@ int vb2_core_dqbuf(struct vb2_queue *q, unsigned int *pindex, void *pb,
                media_request_put(vb->request);
        vb->request = NULL;
 
-       dprintk(2, "dqbuf of buffer %d, with state %d\n",
+       dprintk(q, 2, "dqbuf of buffer %d, with state %d\n",
                        vb->index, vb->state);
 
        return 0;
@@ -2029,22 +2031,22 @@ int vb2_core_streamon(struct vb2_queue *q, unsigned int type)
        int ret;
 
        if (type != q->type) {
-               dprintk(1, "invalid stream type\n");
+               dprintk(q, 1, "invalid stream type\n");
                return -EINVAL;
        }
 
        if (q->streaming) {
-               dprintk(3, "already streaming\n");
+               dprintk(q, 3, "already streaming\n");
                return 0;
        }
 
        if (!q->num_buffers) {
-               dprintk(1, "no buffers have been allocated\n");
+               dprintk(q, 1, "no buffers have been allocated\n");
                return -EINVAL;
        }
 
        if (q->num_buffers < q->min_buffers_needed) {
-               dprintk(1, "need at least %u allocated buffers\n",
+               dprintk(q, 1, "need at least %u allocated buffers\n",
                                q->min_buffers_needed);
                return -EINVAL;
        }
@@ -2064,7 +2066,7 @@ int vb2_core_streamon(struct vb2_queue *q, unsigned int type)
 
        q->streaming = 1;
 
-       dprintk(3, "successful\n");
+       dprintk(q, 3, "successful\n");
        return 0;
 }
 EXPORT_SYMBOL_GPL(vb2_core_streamon);
@@ -2080,7 +2082,7 @@ EXPORT_SYMBOL_GPL(vb2_queue_error);
 int vb2_core_streamoff(struct vb2_queue *q, unsigned int type)
 {
        if (type != q->type) {
-               dprintk(1, "invalid stream type\n");
+               dprintk(q, 1, "invalid stream type\n");
                return -EINVAL;
        }
 
@@ -2097,7 +2099,7 @@ int vb2_core_streamoff(struct vb2_queue *q, unsigned int type)
        q->waiting_for_buffers = !q->is_output;
        q->last_buffer_dequeued = false;
 
-       dprintk(3, "successful\n");
+       dprintk(q, 3, "successful\n");
        return 0;
 }
 EXPORT_SYMBOL_GPL(vb2_core_streamoff);
@@ -2140,39 +2142,39 @@ int vb2_core_expbuf(struct vb2_queue *q, int *fd, unsigned int type,
        struct dma_buf *dbuf;
 
        if (q->memory != VB2_MEMORY_MMAP) {
-               dprintk(1, "queue is not currently set up for mmap\n");
+               dprintk(q, 1, "queue is not currently set up for mmap\n");
                return -EINVAL;
        }
 
        if (!q->mem_ops->get_dmabuf) {
-               dprintk(1, "queue does not support DMA buffer exporting\n");
+               dprintk(q, 1, "queue does not support DMA buffer exporting\n");
                return -EINVAL;
        }
 
        if (flags & ~(O_CLOEXEC | O_ACCMODE)) {
-               dprintk(1, "queue does support only O_CLOEXEC and access mode flags\n");
+               dprintk(q, 1, "queue does support only O_CLOEXEC and access mode flags\n");
                return -EINVAL;
        }
 
        if (type != q->type) {
-               dprintk(1, "invalid buffer type\n");
+               dprintk(q, 1, "invalid buffer type\n");
                return -EINVAL;
        }
 
        if (index >= q->num_buffers) {
-               dprintk(1, "buffer index out of range\n");
+               dprintk(q, 1, "buffer index out of range\n");
                return -EINVAL;
        }
 
        vb = q->bufs[index];
 
        if (plane >= vb->num_planes) {
-               dprintk(1, "buffer plane out of range\n");
+               dprintk(q, 1, "buffer plane out of range\n");
                return -EINVAL;
        }
 
        if (vb2_fileio_is_active(q)) {
-               dprintk(1, "expbuf: file io in progress\n");
+               dprintk(q, 1, "expbuf: file io in progress\n");
                return -EBUSY;
        }
 
@@ -2181,20 +2183,20 @@ int vb2_core_expbuf(struct vb2_queue *q, int *fd, unsigned int type,
        dbuf = call_ptr_memop(vb, get_dmabuf, vb_plane->mem_priv,
                                flags & O_ACCMODE);
        if (IS_ERR_OR_NULL(dbuf)) {
-               dprintk(1, "failed to export buffer %d, plane %d\n",
+               dprintk(q, 1, "failed to export buffer %d, plane %d\n",
                        index, plane);
                return -EINVAL;
        }
 
        ret = dma_buf_fd(dbuf, flags & ~O_ACCMODE);
        if (ret < 0) {
-               dprintk(3, "buffer %d, plane %d failed to export (%d)\n",
+               dprintk(q, 3, "buffer %d, plane %d failed to export (%d)\n",
                        index, plane, ret);
                dma_buf_put(dbuf);
                return ret;
        }
 
-       dprintk(3, "buffer %d, plane %d exported as %d descriptor\n",
+       dprintk(q, 3, "buffer %d, plane %d exported as %d descriptor\n",
                index, plane, ret);
        *fd = ret;
 
@@ -2211,7 +2213,7 @@ int vb2_mmap(struct vb2_queue *q, struct vm_area_struct *vma)
        unsigned long length;
 
        if (q->memory != VB2_MEMORY_MMAP) {
-               dprintk(1, "queue is not currently set up for mmap\n");
+               dprintk(q, 1, "queue is not currently set up for mmap\n");
                return -EINVAL;
        }
 
@@ -2219,17 +2221,17 @@ int vb2_mmap(struct vb2_queue *q, struct vm_area_struct *vma)
         * Check memory area access mode.
         */
        if (!(vma->vm_flags & VM_SHARED)) {
-               dprintk(1, "invalid vma flags, VM_SHARED needed\n");
+               dprintk(q, 1, "invalid vma flags, VM_SHARED needed\n");
                return -EINVAL;
        }
        if (q->is_output) {
                if (!(vma->vm_flags & VM_WRITE)) {
-                       dprintk(1, "invalid vma flags, VM_WRITE needed\n");
+                       dprintk(q, 1, "invalid vma flags, VM_WRITE needed\n");
                        return -EINVAL;
                }
        } else {
                if (!(vma->vm_flags & VM_READ)) {
-                       dprintk(1, "invalid vma flags, VM_READ needed\n");
+                       dprintk(q, 1, "invalid vma flags, VM_READ needed\n");
                        return -EINVAL;
                }
        }
@@ -2237,7 +2239,7 @@ int vb2_mmap(struct vb2_queue *q, struct vm_area_struct *vma)
        mutex_lock(&q->mmap_lock);
 
        if (vb2_fileio_is_active(q)) {
-               dprintk(1, "mmap: file io in progress\n");
+               dprintk(q, 1, "mmap: file io in progress\n");
                ret = -EBUSY;
                goto unlock;
        }
@@ -2258,7 +2260,7 @@ int vb2_mmap(struct vb2_queue *q, struct vm_area_struct *vma)
         */
        length = PAGE_ALIGN(vb->planes[plane].length);
        if (length < (vma->vm_end - vma->vm_start)) {
-               dprintk(1,
+               dprintk(q, 1,
                        "MMAP invalid, as it would overflow buffer length\n");
                ret = -EINVAL;
                goto unlock;
@@ -2278,7 +2280,7 @@ unlock:
        if (ret)
                return ret;
 
-       dprintk(3, "buffer %d, plane %d successfully mapped\n", buffer, plane);
+       dprintk(q, 3, "buffer %d, plane %d successfully mapped\n", buffer, plane);
        return 0;
 }
 EXPORT_SYMBOL_GPL(vb2_mmap);
@@ -2297,7 +2299,7 @@ unsigned long vb2_get_unmapped_area(struct vb2_queue *q,
        int ret;
 
        if (q->memory != VB2_MEMORY_MMAP) {
-               dprintk(1, "queue is not currently set up for mmap\n");
+               dprintk(q, 1, "queue is not currently set up for mmap\n");
                return -EINVAL;
        }
 
@@ -2349,6 +2351,10 @@ int vb2_core_queue_init(struct vb2_queue *q)
        else
                q->dma_dir = q->is_output ? DMA_TO_DEVICE : DMA_FROM_DEVICE;
 
+       if (q->name[0] == '\0')
+               snprintf(q->name, sizeof(q->name), "%s-%p",
+                        q->is_output ? "out" : "cap", q);
+
        return 0;
 }
 EXPORT_SYMBOL_GPL(vb2_core_queue_init);
@@ -2537,7 +2543,7 @@ static int __vb2_init_fileio(struct vb2_queue *q, int read)
         */
        count = 1;
 
-       dprintk(3, "setting up file io: mode %s, count %d, read_once %d, write_immediately %d\n",
+       dprintk(q, 3, "setting up file io: mode %s, count %d, read_once %d, write_immediately %d\n",
                (read) ? "read" : "write", count, q->fileio_read_once,
                q->fileio_write_immediately);
 
@@ -2635,7 +2641,7 @@ static int __vb2_cleanup_fileio(struct vb2_queue *q)
                fileio->count = 0;
                vb2_core_reqbufs(q, fileio->memory, 0, &fileio->count);
                kfree(fileio);
-               dprintk(3, "file io emulator closed\n");
+               dprintk(q, 3, "file io emulator closed\n");
        }
        return 0;
 }
@@ -2664,7 +2670,7 @@ static size_t __vb2_perform_fileio(struct vb2_queue *q, char __user *data, size_
        unsigned index;
        int ret;
 
-       dprintk(3, "mode %s, offset %ld, count %zd, %sblocking\n",
+       dprintk(q, 3, "mode %s, offset %ld, count %zd, %sblocking\n",
                read ? "read" : "write", (long)*ppos, count,
                nonblock ? "non" : "");
 
@@ -2672,7 +2678,7 @@ static size_t __vb2_perform_fileio(struct vb2_queue *q, char __user *data, size_
                return -EINVAL;
 
        if (q->waiting_in_dqbuf) {
-               dprintk(3, "another dup()ped fd is %s\n",
+               dprintk(q, 3, "another dup()ped fd is %s\n",
                        read ? "reading" : "writing");
                return -EBUSY;
        }
@@ -2682,7 +2688,7 @@ static size_t __vb2_perform_fileio(struct vb2_queue *q, char __user *data, size_
         */
        if (!vb2_fileio_is_active(q)) {
                ret = __vb2_init_fileio(q, read);
-               dprintk(3, "vb2_init_fileio result: %d\n", ret);
+               dprintk(q, 3, "vb2_init_fileio result: %d\n", ret);
                if (ret)
                        return ret;
        }
@@ -2699,7 +2705,7 @@ static size_t __vb2_perform_fileio(struct vb2_queue *q, char __user *data, size_
                 * Call vb2_dqbuf to get buffer back.
                 */
                ret = vb2_core_dqbuf(q, &index, NULL, nonblock);
-               dprintk(5, "vb2_dqbuf result: %d\n", ret);
+               dprintk(q, 5, "vb2_dqbuf result: %d\n", ret);
                if (ret)
                        return ret;
                fileio->dq_count += 1;
@@ -2730,20 +2736,20 @@ static size_t __vb2_perform_fileio(struct vb2_queue *q, char __user *data, size_
         */
        if (buf->pos + count > buf->size) {
                count = buf->size - buf->pos;
-               dprintk(5, "reducing read count: %zd\n", count);
+               dprintk(q, 5, "reducing read count: %zd\n", count);
        }
 
        /*
         * Transfer data to userspace.
         */
-       dprintk(3, "copying %zd bytes - buffer %d, offset %u\n",
+       dprintk(q, 3, "copying %zd bytes - buffer %d, offset %u\n",
                count, index, buf->pos);
        if (read)
                ret = copy_to_user(data, buf->vaddr + buf->pos, count);
        else
                ret = copy_from_user(buf->vaddr + buf->pos, data, count);
        if (ret) {
-               dprintk(3, "error copying data\n");
+               dprintk(q, 3, "error copying data\n");
                return -EFAULT;
        }
 
@@ -2763,7 +2769,7 @@ static size_t __vb2_perform_fileio(struct vb2_queue *q, char __user *data, size_
                 * Check if this is the last buffer to read.
                 */
                if (read && fileio->read_once && fileio->dq_count == 1) {
-                       dprintk(3, "read limit reached\n");
+                       dprintk(q, 3, "read limit reached\n");
                        return __vb2_cleanup_fileio(q);
                }
 
@@ -2775,7 +2781,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, NULL);
-               dprintk(5, "vb2_dbuf result: %d\n", ret);
+               dprintk(q, 5, "vb2_dbuf result: %d\n", ret);
                if (ret)
                        return ret;
 
@@ -2862,7 +2868,7 @@ static int vb2_thread(void *data)
                        if (!threadio->stop)
                                ret = vb2_core_dqbuf(q, &index, NULL, 0);
                        call_void_qop(q, wait_prepare, q);
-                       dprintk(5, "file io: vb2_dqbuf result: %d\n", ret);
+                       dprintk(q, 5, "file io: vb2_dqbuf result: %d\n", ret);
                        if (!ret)
                                vb = q->bufs[index];
                }
@@ -2916,7 +2922,7 @@ int vb2_thread_start(struct vb2_queue *q, vb2_thread_fnc fnc, void *priv,
        threadio->priv = priv;
 
        ret = __vb2_init_fileio(q, !q->is_output);
-       dprintk(3, "file io: vb2_init_fileio result: %d\n", ret);
+       dprintk(q, 3, "file io: vb2_init_fileio result: %d\n", ret);
        if (ret)
                goto nomem;
        q->threadio = threadio;

diff --git a/drivers/media/common/videobuf2/videobuf2-v4l2.c b/drivers/media/common/videobuf2/videobuf2-v4l2.c
index 559a229..98477a8 100644 (file)
--- a/drivers/media/common/videobuf2/videobuf2-v4l2.c
+++ b/drivers/media/common/videobuf2/videobuf2-v4l2.c
@@ -35,10 +35,11 @@
 static int debug;
 module_param(debug, int, 0644);
 
-#define dprintk(level, fmt, arg...)                                          \
+#define dprintk(q, level, fmt, arg...)                                       \
        do {                                                                  \
                if (debug >= level)                                           \
-                       pr_info("vb2-v4l2: %s: " fmt, __func__, ## arg); \
+                       pr_info("vb2-v4l2: [%p] %s: " fmt,                    \
+                               (q)->name, __func__, ## arg);                 \
        } while (0)
 
 /* Flags that are set by us */
@@ -66,12 +67,14 @@ static int __verify_planes_array(struct vb2_buffer *vb, const struct v4l2_buffer
 
        /* Is memory for copying plane information present? */
        if (b->m.planes == NULL) {
-               dprintk(1, "multi-planar buffer passed but planes array not provided\n");
+               dprintk(vb->vb2_queue, 1,
+                       "multi-planar buffer passed but planes array not provided\n");
                return -EINVAL;
        }
 
        if (b->length < vb->num_planes || b->length > VB2_MAX_PLANES) {
-               dprintk(1, "incorrect planes array length, expected %d, got %d\n",
+               dprintk(vb->vb2_queue, 1,
+                       "incorrect planes array length, expected %d, got %d\n",
                        vb->num_planes, b->length);
                return -EINVAL;
        }
@@ -179,7 +182,7 @@ static int vb2_fill_vb2_v4l2_buffer(struct vb2_buffer *vb, struct v4l2_buffer *b
 
        ret = __verify_length(vb, b);
        if (ret < 0) {
-               dprintk(1, "plane parameters verification failed: %d\n", ret);
+               dprintk(q, 1, "plane parameters verification failed: %d\n", ret);
                return ret;
        }
        if (b->field == V4L2_FIELD_ALTERNATE && q->is_output) {
@@ -192,7 +195,7 @@ static int vb2_fill_vb2_v4l2_buffer(struct vb2_buffer *vb, struct v4l2_buffer *b
                 * that just says that it is either a top or a bottom field,
                 * but not which of the two it is.
                 */
-               dprintk(1, "the field is incorrectly set to ALTERNATE for an output buffer\n");
+               dprintk(q, 1, "the field is incorrectly set to ALTERNATE for an output buffer\n");
                return -EINVAL;
        }
        vbuf->sequence = 0;
@@ -395,23 +398,23 @@ static int vb2_queue_or_prepare_buf(struct vb2_queue *q, struct media_device *md
        int ret;
 
        if (b->type != q->type) {
-               dprintk(1, "%s: invalid buffer type\n", opname);
+               dprintk(q, 1, "%s: invalid buffer type\n", opname);
                return -EINVAL;
        }
 
        if (b->index >= q->num_buffers) {
-               dprintk(1, "%s: buffer index out of range\n", opname);
+               dprintk(q, 1, "%s: buffer index out of range\n", opname);
                return -EINVAL;
        }
 
        if (q->bufs[b->index] == NULL) {
                /* Should never happen */
-               dprintk(1, "%s: buffer is NULL\n", opname);
+               dprintk(q, 1, "%s: buffer is NULL\n", opname);
                return -EINVAL;
        }
 
        if (b->memory != q->memory) {
-               dprintk(1, "%s: invalid memory type\n", opname);
+               dprintk(q, 1, "%s: invalid memory type\n", opname);
                return -EINVAL;
        }
 
@@ -423,7 +426,7 @@ static int vb2_queue_or_prepare_buf(struct vb2_queue *q, struct media_device *md
 
        if (!is_prepare && (b->flags & V4L2_BUF_FLAG_REQUEST_FD) &&
            vb->state != VB2_BUF_STATE_DEQUEUED) {
-               dprintk(1, "%s: buffer is not in dequeued state\n", opname);
+               dprintk(q, 1, "%s: buffer is not in dequeued state\n", opname);
                return -EINVAL;
        }
 
@@ -442,19 +445,19 @@ static int vb2_queue_or_prepare_buf(struct vb2_queue *q, struct media_device *md
 
        if (!(b->flags & V4L2_BUF_FLAG_REQUEST_FD)) {
                if (q->requires_requests) {
-                       dprintk(1, "%s: queue requires requests\n", opname);
+                       dprintk(q, 1, "%s: queue requires requests\n", opname);
                        return -EBADR;
                }
                if (q->uses_requests) {
-                       dprintk(1, "%s: queue uses requests\n", opname);
+                       dprintk(q, 1, "%s: queue uses requests\n", opname);
                        return -EBUSY;
                }
                return 0;
        } else if (!q->supports_requests) {
-               dprintk(1, "%s: queue does not support requests\n", opname);
+               dprintk(q, 1, "%s: queue does not support requests\n", opname);
                return -EBADR;
        } else if (q->uses_qbuf) {
-               dprintk(1, "%s: queue does not use requests\n", opname);
+               dprintk(q, 1, "%s: queue does not use requests\n", opname);
                return -EBUSY;
        }
 
@@ -484,13 +487,13 @@ static int vb2_queue_or_prepare_buf(struct vb2_queue *q, struct media_device *md
                return -EINVAL;
 
        if (b->request_fd < 0) {
-               dprintk(1, "%s: request_fd < 0\n", opname);
+               dprintk(q, 1, "%s: request_fd < 0\n", opname);
                return -EINVAL;
        }
 
        req = media_request_get_by_fd(mdev, b->request_fd);
        if (IS_ERR(req)) {
-               dprintk(1, "%s: invalid request_fd\n", opname);
+               dprintk(q, 1, "%s: invalid request_fd\n", opname);
                return PTR_ERR(req);
        }
 
@@ -500,7 +503,7 @@ static int vb2_queue_or_prepare_buf(struct vb2_queue *q, struct media_device *md
         */
        if (req->state != MEDIA_REQUEST_STATE_IDLE &&
            req->state != MEDIA_REQUEST_STATE_UPDATING) {
-               dprintk(1, "%s: request is not idle\n", opname);
+               dprintk(q, 1, "%s: request is not idle\n", opname);
                media_request_put(req);
                return -EBUSY;
        }
@@ -683,12 +686,12 @@ int vb2_querybuf(struct vb2_queue *q, struct v4l2_buffer *b)
        int ret;
 
        if (b->type != q->type) {
-               dprintk(1, "wrong buffer type\n");
+               dprintk(q, 1, "wrong buffer type\n");
                return -EINVAL;
        }
 
        if (b->index >= q->num_buffers) {
-               dprintk(1, "buffer index out of range\n");
+               dprintk(q, 1, "buffer index out of range\n");
                return -EINVAL;
        }
        vb = q->bufs[b->index];
@@ -743,7 +746,7 @@ int vb2_prepare_buf(struct vb2_queue *q, struct media_device *mdev,
        int ret;
 
        if (vb2_fileio_is_active(q)) {
-               dprintk(1, "file io in progress\n");
+               dprintk(q, 1, "file io in progress\n");
                return -EBUSY;
        }
 
@@ -823,7 +826,7 @@ int vb2_qbuf(struct vb2_queue *q, struct media_device *mdev,
        int ret;
 
        if (vb2_fileio_is_active(q)) {
-               dprintk(1, "file io in progress\n");
+               dprintk(q, 1, "file io in progress\n");
                return -EBUSY;
        }
 
@@ -842,12 +845,12 @@ int vb2_dqbuf(struct vb2_queue *q, struct v4l2_buffer *b, bool nonblocking)
        int ret;
 
        if (vb2_fileio_is_active(q)) {
-               dprintk(1, "file io in progress\n");
+               dprintk(q, 1, "file io in progress\n");
                return -EBUSY;
        }
 
        if (b->type != q->type) {
-               dprintk(1, "invalid buffer type\n");
+               dprintk(q, 1, "invalid buffer type\n");
                return -EINVAL;
        }
 
@@ -871,7 +874,7 @@ EXPORT_SYMBOL_GPL(vb2_dqbuf);
 int vb2_streamon(struct vb2_queue *q, enum v4l2_buf_type type)
 {
        if (vb2_fileio_is_active(q)) {
-               dprintk(1, "file io in progress\n");
+               dprintk(q, 1, "file io in progress\n");
                return -EBUSY;
        }
        return vb2_core_streamon(q, type);
@@ -881,7 +884,7 @@ EXPORT_SYMBOL_GPL(vb2_streamon);
 int vb2_streamoff(struct vb2_queue *q, enum v4l2_buf_type type)
 {
        if (vb2_fileio_is_active(q)) {
-               dprintk(1, "file io in progress\n");
+               dprintk(q, 1, "file io in progress\n");
                return -EBUSY;
        }
        return vb2_core_streamoff(q, type);
@@ -895,7 +898,7 @@ int vb2_expbuf(struct vb2_queue *q, struct v4l2_exportbuffer *eb)
 }
 EXPORT_SYMBOL_GPL(vb2_expbuf);
 
-int vb2_queue_init(struct vb2_queue *q)
+int vb2_queue_init_name(struct vb2_queue *q, const char *name)
 {
        /*
         * Sanity check
@@ -931,8 +934,19 @@ int vb2_queue_init(struct vb2_queue *q)
         */
        q->quirk_poll_must_check_waiting_for_buffers = true;
 
+       if (name)
+               strscpy(q->name, name, sizeof(q->name));
+       else
+               q->name[0] = '\0';
+
        return vb2_core_queue_init(q);
 }
+EXPORT_SYMBOL_GPL(vb2_queue_init_name);
+
+int vb2_queue_init(struct vb2_queue *q)
+{
+       return vb2_queue_init_name(q, NULL);
+}
 EXPORT_SYMBOL_GPL(vb2_queue_init);
 
 void vb2_queue_release(struct vb2_queue *q)

diff --git a/include/media/videobuf2-core.h b/include/media/videobuf2-core.h
index 9e68fe0..52ef920 100644 (file)
--- a/include/media/videobuf2-core.h
+++ b/include/media/videobuf2-core.h
@@ -561,6 +561,8 @@ struct vb2_buf_ops {
  *             when a buffer with the %V4L2_BUF_FLAG_LAST is dequeued.
  * @fileio:    file io emulator internal data, used only if emulator is active
  * @threadio:  thread io internal data, used only if thread is active
+ * @name:      queue name, used for logging purpose. Initialized automatically
+ *             if left empty by drivers.
  */
 struct vb2_queue {
        unsigned int                    type;
@@ -622,6 +624,8 @@ struct vb2_queue {
        struct vb2_fileio_data          *fileio;
        struct vb2_threadio_data        *threadio;
 
+       char                            name[32];
+
 #ifdef CONFIG_VIDEO_ADV_DEBUG
        /*
         * Counters for how often these queue-related ops are

diff --git a/include/media/videobuf2-v4l2.h b/include/media/videobuf2-v4l2.h
index 59bf33a..b7b5a9c 100644 (file)
--- a/include/media/videobuf2-v4l2.h
+++ b/include/media/videobuf2-v4l2.h
@@ -237,6 +237,19 @@ int vb2_streamoff(struct vb2_queue *q, enum v4l2_buf_type type);
 int __must_check vb2_queue_init(struct vb2_queue *q);
 
 /**
+ * vb2_queue_init_name() - initialize a videobuf2 queue with a name
+ * @q:         pointer to &struct vb2_queue with videobuf2 queue.
+ * @name:      the queue name
+ *
+ * This function initializes the vb2_queue exactly like vb2_queue_init(),
+ * and additionally sets the queue name. The queue name is used for logging
+ * purpose, and should uniquely identify the queue within the context of the
+ * device it belongs to. This is useful to attribute kernel log messages to the
+ * right queue for m2m devices or other devices that handle multiple queues.
+ */
+int __must_check vb2_queue_init_name(struct vb2_queue *q, const char *name);
+
+/**
  * vb2_queue_release() - stop streaming, release the queue and free memory
  * @q:         pointer to &struct vb2_queue with videobuf2 queue.
  *