1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * uvc_queue.c -- USB Video Class driver - Buffers management
4 *
5 * Copyright (C) 2005-2010
6 * Laurent Pinchart (laurent.pinchart@ideasonboard.com)
7 */
8
9#include <linux/atomic.h>
10#include <linux/kernel.h>
11#include <linux/mm.h>
12#include <linux/list.h>
13#include <linux/module.h>
14#include <linux/usb.h>
15#include <linux/videodev2.h>
16#include <linux/vmalloc.h>
17#include <linux/wait.h>
18#include <media/videobuf2-v4l2.h>
19#include <media/videobuf2-vmalloc.h>
20
21#include "uvcvideo.h"
22
23/* ------------------------------------------------------------------------
24 * Video buffers queue management.
25 *
26 * Video queues is initialized by uvc_queue_init(). The function performs
27 * basic initialization of the uvc_video_queue struct and never fails.
28 *
29 * Video buffers are managed by videobuf2. The driver uses a mutex to protect
30 * the videobuf2 queue operations by serializing calls to videobuf2 and a
31 * spinlock to protect the IRQ queue that holds the buffers to be processed by
32 * the driver.
33 */
34
35static inline struct uvc_buffer *uvc_vbuf_to_buffer(struct vb2_v4l2_buffer *buf)
36{
37 return container_of(buf, struct uvc_buffer, buf);
38}
39
40/*
41 * Return all queued buffers to videobuf2 in the requested state.
42 *
43 * This function must be called with the queue spinlock held.
44 */
45static void uvc_queue_return_buffers(struct uvc_video_queue *queue,
46 enum uvc_buffer_state state)
47{
48 enum vb2_buffer_state vb2_state = state == UVC_BUF_STATE_ERROR
49 ? VB2_BUF_STATE_ERROR
50 : VB2_BUF_STATE_QUEUED;
51
52 while (!list_empty(head: &queue->irqqueue)) {
53 struct uvc_buffer *buf = list_first_entry(&queue->irqqueue,
54 struct uvc_buffer,
55 queue);
56 list_del(entry: &buf->queue);
57 buf->state = state;
58 vb2_buffer_done(vb: &buf->buf.vb2_buf, state: vb2_state);
59 }
60}
61
62/* -----------------------------------------------------------------------------
63 * videobuf2 queue operations
64 */
65
66static int uvc_queue_setup(struct vb2_queue *vq,
67 unsigned int *nbuffers, unsigned int *nplanes,
68 unsigned int sizes[], struct device *alloc_devs[])
69{
70 struct uvc_video_queue *queue = vb2_get_drv_priv(q: vq);
71 struct uvc_streaming *stream;
72 unsigned int size;
73
74 switch (vq->type) {
75 case V4L2_BUF_TYPE_META_CAPTURE:
76 size = UVC_METADATA_BUF_SIZE;
77 break;
78
79 default:
80 stream = uvc_queue_to_stream(queue);
81 size = stream->ctrl.dwMaxVideoFrameSize;
82 break;
83 }
84
85 /*
86 * When called with plane sizes, validate them. The driver supports
87 * single planar formats only, and requires buffers to be large enough
88 * to store a complete frame.
89 */
90 if (*nplanes)
91 return *nplanes != 1 || sizes[0] < size ? -EINVAL : 0;
92
93 *nplanes = 1;
94 sizes[0] = size;
95 return 0;
96}
97
98static int uvc_buffer_prepare(struct vb2_buffer *vb)
99{
100 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
101 struct uvc_video_queue *queue = vb2_get_drv_priv(q: vb->vb2_queue);
102 struct uvc_buffer *buf = uvc_vbuf_to_buffer(buf: vbuf);
103
104 if (vb->type == V4L2_BUF_TYPE_VIDEO_OUTPUT &&
105 vb2_get_plane_payload(vb, plane_no: 0) > vb2_plane_size(vb, plane_no: 0)) {
106 uvc_dbg(uvc_queue_to_stream(queue)->dev, CAPTURE,
107 "[E] Bytes used out of bounds\n");
108 return -EINVAL;
109 }
110
111 if (unlikely(queue->flags & UVC_QUEUE_DISCONNECTED))
112 return -ENODEV;
113
114 buf->state = UVC_BUF_STATE_QUEUED;
115 buf->error = 0;
116 buf->mem = vb2_plane_vaddr(vb, plane_no: 0);
117 buf->length = vb2_plane_size(vb, plane_no: 0);
118 if (vb->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
119 buf->bytesused = 0;
120 else
121 buf->bytesused = vb2_get_plane_payload(vb, plane_no: 0);
122
123 return 0;
124}
125
126static void uvc_buffer_queue(struct vb2_buffer *vb)
127{
128 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
129 struct uvc_video_queue *queue = vb2_get_drv_priv(q: vb->vb2_queue);
130 struct uvc_buffer *buf = uvc_vbuf_to_buffer(buf: vbuf);
131 unsigned long flags;
132
133 spin_lock_irqsave(&queue->irqlock, flags);
134 if (likely(!(queue->flags & UVC_QUEUE_DISCONNECTED))) {
135 kref_init(kref: &buf->ref);
136 list_add_tail(new: &buf->queue, head: &queue->irqqueue);
137 } else {
138 /*
139 * If the device is disconnected return the buffer to userspace
140 * directly. The next QBUF call will fail with -ENODEV.
141 */
142 buf->state = UVC_BUF_STATE_ERROR;
143 vb2_buffer_done(vb, state: VB2_BUF_STATE_ERROR);
144 }
145
146 spin_unlock_irqrestore(lock: &queue->irqlock, flags);
147}
148
149static void uvc_buffer_finish(struct vb2_buffer *vb)
150{
151 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
152 struct uvc_video_queue *queue = vb2_get_drv_priv(q: vb->vb2_queue);
153 struct uvc_streaming *stream = uvc_queue_to_stream(queue);
154 struct uvc_buffer *buf = uvc_vbuf_to_buffer(buf: vbuf);
155
156 if (vb->state == VB2_BUF_STATE_DONE)
157 uvc_video_clock_update(stream, vbuf, buf);
158}
159
160static int uvc_start_streaming(struct vb2_queue *vq, unsigned int count)
161{
162 struct uvc_video_queue *queue = vb2_get_drv_priv(q: vq);
163 struct uvc_streaming *stream = uvc_queue_to_stream(queue);
164 int ret;
165
166 lockdep_assert_irqs_enabled();
167
168 queue->buf_used = 0;
169
170 ret = uvc_video_start_streaming(stream);
171 if (ret == 0)
172 return 0;
173
174 spin_lock_irq(lock: &queue->irqlock);
175 uvc_queue_return_buffers(queue, state: UVC_BUF_STATE_QUEUED);
176 spin_unlock_irq(lock: &queue->irqlock);
177
178 return ret;
179}
180
181static void uvc_stop_streaming(struct vb2_queue *vq)
182{
183 struct uvc_video_queue *queue = vb2_get_drv_priv(q: vq);
184
185 lockdep_assert_irqs_enabled();
186
187 if (vq->type != V4L2_BUF_TYPE_META_CAPTURE)
188 uvc_video_stop_streaming(stream: uvc_queue_to_stream(queue));
189
190 spin_lock_irq(lock: &queue->irqlock);
191 uvc_queue_return_buffers(queue, state: UVC_BUF_STATE_ERROR);
192 spin_unlock_irq(lock: &queue->irqlock);
193}
194
195static const struct vb2_ops uvc_queue_qops = {
196 .queue_setup = uvc_queue_setup,
197 .buf_prepare = uvc_buffer_prepare,
198 .buf_queue = uvc_buffer_queue,
199 .buf_finish = uvc_buffer_finish,
200 .wait_prepare = vb2_ops_wait_prepare,
201 .wait_finish = vb2_ops_wait_finish,
202 .start_streaming = uvc_start_streaming,
203 .stop_streaming = uvc_stop_streaming,
204};
205
206static const struct vb2_ops uvc_meta_queue_qops = {
207 .queue_setup = uvc_queue_setup,
208 .buf_prepare = uvc_buffer_prepare,
209 .buf_queue = uvc_buffer_queue,
210 .wait_prepare = vb2_ops_wait_prepare,
211 .wait_finish = vb2_ops_wait_finish,
212 .stop_streaming = uvc_stop_streaming,
213};
214
215int uvc_queue_init(struct uvc_video_queue *queue, enum v4l2_buf_type type,
216 int drop_corrupted)
217{
218 int ret;
219
220 queue->queue.type = type;
221 queue->queue.io_modes = VB2_MMAP | VB2_USERPTR;
222 queue->queue.drv_priv = queue;
223 queue->queue.buf_struct_size = sizeof(struct uvc_buffer);
224 queue->queue.mem_ops = &vb2_vmalloc_memops;
225 queue->queue.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC
226 | V4L2_BUF_FLAG_TSTAMP_SRC_SOE;
227 queue->queue.lock = &queue->mutex;
228
229 switch (type) {
230 case V4L2_BUF_TYPE_META_CAPTURE:
231 queue->queue.ops = &uvc_meta_queue_qops;
232 break;
233 default:
234 queue->queue.io_modes |= VB2_DMABUF;
235 queue->queue.ops = &uvc_queue_qops;
236 break;
237 }
238
239 ret = vb2_queue_init(q: &queue->queue);
240 if (ret)
241 return ret;
242
243 mutex_init(&queue->mutex);
244 spin_lock_init(&queue->irqlock);
245 INIT_LIST_HEAD(list: &queue->irqqueue);
246 queue->flags = drop_corrupted ? UVC_QUEUE_DROP_CORRUPTED : 0;
247
248 return 0;
249}
250
251void uvc_queue_release(struct uvc_video_queue *queue)
252{
253 mutex_lock(&queue->mutex);
254 vb2_queue_release(q: &queue->queue);
255 mutex_unlock(lock: &queue->mutex);
256}
257
258/* -----------------------------------------------------------------------------
259 * V4L2 queue operations
260 */
261
262int uvc_request_buffers(struct uvc_video_queue *queue,
263 struct v4l2_requestbuffers *rb)
264{
265 int ret;
266
267 mutex_lock(&queue->mutex);
268 ret = vb2_reqbufs(q: &queue->queue, req: rb);
269 mutex_unlock(lock: &queue->mutex);
270
271 return ret ? ret : rb->count;
272}
273
274int uvc_query_buffer(struct uvc_video_queue *queue, struct v4l2_buffer *buf)
275{
276 int ret;
277
278 mutex_lock(&queue->mutex);
279 ret = vb2_querybuf(q: &queue->queue, b: buf);
280 mutex_unlock(lock: &queue->mutex);
281
282 return ret;
283}
284
285int uvc_create_buffers(struct uvc_video_queue *queue,
286 struct v4l2_create_buffers *cb)
287{
288 int ret;
289
290 mutex_lock(&queue->mutex);
291 ret = vb2_create_bufs(q: &queue->queue, create: cb);
292 mutex_unlock(lock: &queue->mutex);
293
294 return ret;
295}
296
297int uvc_queue_buffer(struct uvc_video_queue *queue,
298 struct media_device *mdev, struct v4l2_buffer *buf)
299{
300 int ret;
301
302 mutex_lock(&queue->mutex);
303 ret = vb2_qbuf(q: &queue->queue, mdev, b: buf);
304 mutex_unlock(lock: &queue->mutex);
305
306 return ret;
307}
308
309int uvc_export_buffer(struct uvc_video_queue *queue,
310 struct v4l2_exportbuffer *exp)
311{
312 int ret;
313
314 mutex_lock(&queue->mutex);
315 ret = vb2_expbuf(q: &queue->queue, eb: exp);
316 mutex_unlock(lock: &queue->mutex);
317
318 return ret;
319}
320
321int uvc_dequeue_buffer(struct uvc_video_queue *queue, struct v4l2_buffer *buf,
322 int nonblocking)
323{
324 int ret;
325
326 mutex_lock(&queue->mutex);
327 ret = vb2_dqbuf(q: &queue->queue, b: buf, nonblocking);
328 mutex_unlock(lock: &queue->mutex);
329
330 return ret;
331}
332
333int uvc_queue_streamon(struct uvc_video_queue *queue, enum v4l2_buf_type type)
334{
335 int ret;
336
337 mutex_lock(&queue->mutex);
338 ret = vb2_streamon(q: &queue->queue, type);
339 mutex_unlock(lock: &queue->mutex);
340
341 return ret;
342}
343
344int uvc_queue_streamoff(struct uvc_video_queue *queue, enum v4l2_buf_type type)
345{
346 int ret;
347
348 mutex_lock(&queue->mutex);
349 ret = vb2_streamoff(q: &queue->queue, type);
350 mutex_unlock(lock: &queue->mutex);
351
352 return ret;
353}
354
355int uvc_queue_mmap(struct uvc_video_queue *queue, struct vm_area_struct *vma)
356{
357 return vb2_mmap(q: &queue->queue, vma);
358}
359
360#ifndef CONFIG_MMU
361unsigned long uvc_queue_get_unmapped_area(struct uvc_video_queue *queue,
362 unsigned long pgoff)
363{
364 return vb2_get_unmapped_area(&queue->queue, 0, 0, pgoff, 0);
365}
366#endif
367
368__poll_t uvc_queue_poll(struct uvc_video_queue *queue, struct file *file,
369 poll_table *wait)
370{
371 __poll_t ret;
372
373 mutex_lock(&queue->mutex);
374 ret = vb2_poll(q: &queue->queue, file, wait);
375 mutex_unlock(lock: &queue->mutex);
376
377 return ret;
378}
379
380/* -----------------------------------------------------------------------------
381 *
382 */
383
384/*
385 * Check if buffers have been allocated.
386 */
387int uvc_queue_allocated(struct uvc_video_queue *queue)
388{
389 int allocated;
390
391 mutex_lock(&queue->mutex);
392 allocated = vb2_is_busy(q: &queue->queue);
393 mutex_unlock(lock: &queue->mutex);
394
395 return allocated;
396}
397
398/*
399 * Cancel the video buffers queue.
400 *
401 * Cancelling the queue marks all buffers on the irq queue as erroneous,
402 * wakes them up and removes them from the queue.
403 *
404 * If the disconnect parameter is set, further calls to uvc_queue_buffer will
405 * fail with -ENODEV.
406 *
407 * This function acquires the irq spinlock and can be called from interrupt
408 * context.
409 */
410void uvc_queue_cancel(struct uvc_video_queue *queue, int disconnect)
411{
412 unsigned long flags;
413
414 spin_lock_irqsave(&queue->irqlock, flags);
415 uvc_queue_return_buffers(queue, state: UVC_BUF_STATE_ERROR);
416 /*
417 * This must be protected by the irqlock spinlock to avoid race
418 * conditions between uvc_buffer_queue and the disconnection event that
419 * could result in an interruptible wait in uvc_dequeue_buffer. Do not
420 * blindly replace this logic by checking for the UVC_QUEUE_DISCONNECTED
421 * state outside the queue code.
422 */
423 if (disconnect)
424 queue->flags |= UVC_QUEUE_DISCONNECTED;
425 spin_unlock_irqrestore(lock: &queue->irqlock, flags);
426}
427
428/*
429 * uvc_queue_get_current_buffer: Obtain the current working output buffer
430 *
431 * Buffers may span multiple packets, and even URBs, therefore the active buffer
432 * remains on the queue until the EOF marker.
433 */
434static struct uvc_buffer *
435__uvc_queue_get_current_buffer(struct uvc_video_queue *queue)
436{
437 if (list_empty(head: &queue->irqqueue))
438 return NULL;
439
440 return list_first_entry(&queue->irqqueue, struct uvc_buffer, queue);
441}
442
443struct uvc_buffer *uvc_queue_get_current_buffer(struct uvc_video_queue *queue)
444{
445 struct uvc_buffer *nextbuf;
446 unsigned long flags;
447
448 spin_lock_irqsave(&queue->irqlock, flags);
449 nextbuf = __uvc_queue_get_current_buffer(queue);
450 spin_unlock_irqrestore(lock: &queue->irqlock, flags);
451
452 return nextbuf;
453}
454
455/*
456 * uvc_queue_buffer_requeue: Requeue a buffer on our internal irqqueue
457 *
458 * Reuse a buffer through our internal queue without the need to 'prepare'.
459 * The buffer will be returned to userspace through the uvc_buffer_queue call if
460 * the device has been disconnected.
461 */
462static void uvc_queue_buffer_requeue(struct uvc_video_queue *queue,
463 struct uvc_buffer *buf)
464{
465 buf->error = 0;
466 buf->state = UVC_BUF_STATE_QUEUED;
467 buf->bytesused = 0;
468 vb2_set_plane_payload(vb: &buf->buf.vb2_buf, plane_no: 0, size: 0);
469
470 uvc_buffer_queue(vb: &buf->buf.vb2_buf);
471}
472
473static void uvc_queue_buffer_complete(struct kref *ref)
474{
475 struct uvc_buffer *buf = container_of(ref, struct uvc_buffer, ref);
476 struct vb2_buffer *vb = &buf->buf.vb2_buf;
477 struct uvc_video_queue *queue = vb2_get_drv_priv(q: vb->vb2_queue);
478
479 if ((queue->flags & UVC_QUEUE_DROP_CORRUPTED) && buf->error) {
480 uvc_queue_buffer_requeue(queue, buf);
481 return;
482 }
483
484 buf->state = buf->error ? UVC_BUF_STATE_ERROR : UVC_BUF_STATE_DONE;
485 vb2_set_plane_payload(vb: &buf->buf.vb2_buf, plane_no: 0, size: buf->bytesused);
486 vb2_buffer_done(vb: &buf->buf.vb2_buf, state: VB2_BUF_STATE_DONE);
487}
488
489/*
490 * Release a reference on the buffer. Complete the buffer when the last
491 * reference is released.
492 */
493void uvc_queue_buffer_release(struct uvc_buffer *buf)
494{
495 kref_put(kref: &buf->ref, release: uvc_queue_buffer_complete);
496}
497
498/*
499 * Remove this buffer from the queue. Lifetime will persist while async actions
500 * are still running (if any), and uvc_queue_buffer_release will give the buffer
501 * back to VB2 when all users have completed.
502 */
503struct uvc_buffer *uvc_queue_next_buffer(struct uvc_video_queue *queue,
504 struct uvc_buffer *buf)
505{
506 struct uvc_buffer *nextbuf;
507 unsigned long flags;
508
509 spin_lock_irqsave(&queue->irqlock, flags);
510 list_del(entry: &buf->queue);
511 nextbuf = __uvc_queue_get_current_buffer(queue);
512 spin_unlock_irqrestore(lock: &queue->irqlock, flags);
513
514 uvc_queue_buffer_release(buf);
515
516 return nextbuf;
517}
518

source code of linux/drivers/media/usb/uvc/uvc_queue.c