2 * uvc_queue.c -- USB Video Class driver - Buffers management
4 * Copyright (C) 2005-2010
5 * Laurent Pinchart (laurent.pinchart@ideasonboard.com)
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
14 #include <linux/atomic.h>
15 #include <linux/kernel.h>
17 #include <linux/list.h>
18 #include <linux/module.h>
19 #include <linux/usb.h>
20 #include <linux/videodev2.h>
21 #include <linux/vmalloc.h>
22 #include <linux/wait.h>
23 #include <media/videobuf2-v4l2.h>
24 #include <media/videobuf2-vmalloc.h>
28 /* ------------------------------------------------------------------------
29 * Video buffers queue management.
31 * Video queues is initialized by uvc_queue_init(). The function performs
32 * basic initialization of the uvc_video_queue struct and never fails.
34 * Video buffers are managed by videobuf2. The driver uses a mutex to protect
35 * the videobuf2 queue operations by serializing calls to videobuf2 and a
36 * spinlock to protect the IRQ queue that holds the buffers to be processed by
40 static inline struct uvc_streaming
*
41 uvc_queue_to_stream(struct uvc_video_queue
*queue
)
43 return container_of(queue
, struct uvc_streaming
, queue
);
47 * Return all queued buffers to videobuf2 in the requested state.
49 * This function must be called with the queue spinlock held.
51 static void uvc_queue_return_buffers(struct uvc_video_queue
*queue
,
52 enum uvc_buffer_state state
)
54 enum vb2_buffer_state vb2_state
= state
== UVC_BUF_STATE_ERROR
56 : VB2_BUF_STATE_QUEUED
;
58 while (!list_empty(&queue
->irqqueue
)) {
59 struct uvc_buffer
*buf
= list_first_entry(&queue
->irqqueue
,
62 list_del(&buf
->queue
);
64 vb2_buffer_done(&buf
->buf
.vb2_buf
, vb2_state
);
68 /* -----------------------------------------------------------------------------
69 * videobuf2 queue operations
72 static int uvc_queue_setup(struct vb2_queue
*vq
, const struct v4l2_format
*fmt
,
73 unsigned int *nbuffers
, unsigned int *nplanes
,
74 unsigned int sizes
[], void *alloc_ctxs
[])
76 struct uvc_video_queue
*queue
= vb2_get_drv_priv(vq
);
77 struct uvc_streaming
*stream
= uvc_queue_to_stream(queue
);
79 /* Make sure the image size is large enough. */
80 if (fmt
&& fmt
->fmt
.pix
.sizeimage
< stream
->ctrl
.dwMaxVideoFrameSize
)
85 sizes
[0] = fmt
? fmt
->fmt
.pix
.sizeimage
86 : stream
->ctrl
.dwMaxVideoFrameSize
;
91 static int uvc_buffer_prepare(struct vb2_buffer
*vb
)
93 struct vb2_v4l2_buffer
*vbuf
= to_vb2_v4l2_buffer(vb
);
94 struct uvc_video_queue
*queue
= vb2_get_drv_priv(vb
->vb2_queue
);
95 struct uvc_buffer
*buf
= container_of(vbuf
, struct uvc_buffer
, buf
);
97 if (vb
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT
&&
98 vb2_get_plane_payload(vb
, 0) > vb2_plane_size(vb
, 0)) {
99 uvc_trace(UVC_TRACE_CAPTURE
, "[E] Bytes used out of bounds.\n");
103 if (unlikely(queue
->flags
& UVC_QUEUE_DISCONNECTED
))
106 buf
->state
= UVC_BUF_STATE_QUEUED
;
108 buf
->mem
= vb2_plane_vaddr(vb
, 0);
109 buf
->length
= vb2_plane_size(vb
, 0);
110 if (vb
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
)
113 buf
->bytesused
= vb2_get_plane_payload(vb
, 0);
118 static void uvc_buffer_queue(struct vb2_buffer
*vb
)
120 struct vb2_v4l2_buffer
*vbuf
= to_vb2_v4l2_buffer(vb
);
121 struct uvc_video_queue
*queue
= vb2_get_drv_priv(vb
->vb2_queue
);
122 struct uvc_buffer
*buf
= container_of(vbuf
, struct uvc_buffer
, buf
);
125 spin_lock_irqsave(&queue
->irqlock
, flags
);
126 if (likely(!(queue
->flags
& UVC_QUEUE_DISCONNECTED
))) {
127 list_add_tail(&buf
->queue
, &queue
->irqqueue
);
129 /* If the device is disconnected return the buffer to userspace
130 * directly. The next QBUF call will fail with -ENODEV.
132 buf
->state
= UVC_BUF_STATE_ERROR
;
133 vb2_buffer_done(vb
, VB2_BUF_STATE_ERROR
);
136 spin_unlock_irqrestore(&queue
->irqlock
, flags
);
139 static void uvc_buffer_finish(struct vb2_buffer
*vb
)
141 struct vb2_v4l2_buffer
*vbuf
= to_vb2_v4l2_buffer(vb
);
142 struct uvc_video_queue
*queue
= vb2_get_drv_priv(vb
->vb2_queue
);
143 struct uvc_streaming
*stream
= uvc_queue_to_stream(queue
);
144 struct uvc_buffer
*buf
= container_of(vbuf
, struct uvc_buffer
, buf
);
146 if (vb
->state
== VB2_BUF_STATE_DONE
)
147 uvc_video_clock_update(stream
, vbuf
, buf
);
150 static int uvc_start_streaming(struct vb2_queue
*vq
, unsigned int count
)
152 struct uvc_video_queue
*queue
= vb2_get_drv_priv(vq
);
153 struct uvc_streaming
*stream
= uvc_queue_to_stream(queue
);
159 ret
= uvc_video_enable(stream
, 1);
163 spin_lock_irqsave(&queue
->irqlock
, flags
);
164 uvc_queue_return_buffers(queue
, UVC_BUF_STATE_QUEUED
);
165 spin_unlock_irqrestore(&queue
->irqlock
, flags
);
170 static void uvc_stop_streaming(struct vb2_queue
*vq
)
172 struct uvc_video_queue
*queue
= vb2_get_drv_priv(vq
);
173 struct uvc_streaming
*stream
= uvc_queue_to_stream(queue
);
176 uvc_video_enable(stream
, 0);
178 spin_lock_irqsave(&queue
->irqlock
, flags
);
179 uvc_queue_return_buffers(queue
, UVC_BUF_STATE_ERROR
);
180 spin_unlock_irqrestore(&queue
->irqlock
, flags
);
183 static struct vb2_ops uvc_queue_qops
= {
184 .queue_setup
= uvc_queue_setup
,
185 .buf_prepare
= uvc_buffer_prepare
,
186 .buf_queue
= uvc_buffer_queue
,
187 .buf_finish
= uvc_buffer_finish
,
188 .wait_prepare
= vb2_ops_wait_prepare
,
189 .wait_finish
= vb2_ops_wait_finish
,
190 .start_streaming
= uvc_start_streaming
,
191 .stop_streaming
= uvc_stop_streaming
,
194 int uvc_queue_init(struct uvc_video_queue
*queue
, enum v4l2_buf_type type
,
199 queue
->queue
.type
= type
;
200 queue
->queue
.io_modes
= VB2_MMAP
| VB2_USERPTR
| VB2_DMABUF
;
201 queue
->queue
.drv_priv
= queue
;
202 queue
->queue
.buf_struct_size
= sizeof(struct uvc_buffer
);
203 queue
->queue
.ops
= &uvc_queue_qops
;
204 queue
->queue
.mem_ops
= &vb2_vmalloc_memops
;
205 queue
->queue
.timestamp_flags
= V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC
206 | V4L2_BUF_FLAG_TSTAMP_SRC_SOE
;
207 queue
->queue
.lock
= &queue
->mutex
;
208 ret
= vb2_queue_init(&queue
->queue
);
212 mutex_init(&queue
->mutex
);
213 spin_lock_init(&queue
->irqlock
);
214 INIT_LIST_HEAD(&queue
->irqqueue
);
215 queue
->flags
= drop_corrupted
? UVC_QUEUE_DROP_CORRUPTED
: 0;
220 void uvc_queue_release(struct uvc_video_queue
*queue
)
222 mutex_lock(&queue
->mutex
);
223 vb2_queue_release(&queue
->queue
);
224 mutex_unlock(&queue
->mutex
);
227 /* -----------------------------------------------------------------------------
228 * V4L2 queue operations
231 int uvc_request_buffers(struct uvc_video_queue
*queue
,
232 struct v4l2_requestbuffers
*rb
)
236 mutex_lock(&queue
->mutex
);
237 ret
= vb2_reqbufs(&queue
->queue
, rb
);
238 mutex_unlock(&queue
->mutex
);
240 return ret
? ret
: rb
->count
;
243 int uvc_query_buffer(struct uvc_video_queue
*queue
, struct v4l2_buffer
*buf
)
247 mutex_lock(&queue
->mutex
);
248 ret
= vb2_querybuf(&queue
->queue
, buf
);
249 mutex_unlock(&queue
->mutex
);
254 int uvc_create_buffers(struct uvc_video_queue
*queue
,
255 struct v4l2_create_buffers
*cb
)
259 mutex_lock(&queue
->mutex
);
260 ret
= vb2_create_bufs(&queue
->queue
, cb
);
261 mutex_unlock(&queue
->mutex
);
266 int uvc_queue_buffer(struct uvc_video_queue
*queue
, struct v4l2_buffer
*buf
)
270 mutex_lock(&queue
->mutex
);
271 ret
= vb2_qbuf(&queue
->queue
, buf
);
272 mutex_unlock(&queue
->mutex
);
277 int uvc_export_buffer(struct uvc_video_queue
*queue
,
278 struct v4l2_exportbuffer
*exp
)
282 mutex_lock(&queue
->mutex
);
283 ret
= vb2_expbuf(&queue
->queue
, exp
);
284 mutex_unlock(&queue
->mutex
);
289 int uvc_dequeue_buffer(struct uvc_video_queue
*queue
, struct v4l2_buffer
*buf
,
294 mutex_lock(&queue
->mutex
);
295 ret
= vb2_dqbuf(&queue
->queue
, buf
, nonblocking
);
296 mutex_unlock(&queue
->mutex
);
301 int uvc_queue_streamon(struct uvc_video_queue
*queue
, enum v4l2_buf_type type
)
305 mutex_lock(&queue
->mutex
);
306 ret
= vb2_streamon(&queue
->queue
, type
);
307 mutex_unlock(&queue
->mutex
);
312 int uvc_queue_streamoff(struct uvc_video_queue
*queue
, enum v4l2_buf_type type
)
316 mutex_lock(&queue
->mutex
);
317 ret
= vb2_streamoff(&queue
->queue
, type
);
318 mutex_unlock(&queue
->mutex
);
323 int uvc_queue_mmap(struct uvc_video_queue
*queue
, struct vm_area_struct
*vma
)
325 return vb2_mmap(&queue
->queue
, vma
);
329 unsigned long uvc_queue_get_unmapped_area(struct uvc_video_queue
*queue
,
332 return vb2_get_unmapped_area(&queue
->queue
, 0, 0, pgoff
, 0);
336 unsigned int uvc_queue_poll(struct uvc_video_queue
*queue
, struct file
*file
,
341 mutex_lock(&queue
->mutex
);
342 ret
= vb2_poll(&queue
->queue
, file
, wait
);
343 mutex_unlock(&queue
->mutex
);
348 /* -----------------------------------------------------------------------------
353 * Check if buffers have been allocated.
355 int uvc_queue_allocated(struct uvc_video_queue
*queue
)
359 mutex_lock(&queue
->mutex
);
360 allocated
= vb2_is_busy(&queue
->queue
);
361 mutex_unlock(&queue
->mutex
);
367 * Cancel the video buffers queue.
369 * Cancelling the queue marks all buffers on the irq queue as erroneous,
370 * wakes them up and removes them from the queue.
372 * If the disconnect parameter is set, further calls to uvc_queue_buffer will
375 * This function acquires the irq spinlock and can be called from interrupt
378 void uvc_queue_cancel(struct uvc_video_queue
*queue
, int disconnect
)
382 spin_lock_irqsave(&queue
->irqlock
, flags
);
383 uvc_queue_return_buffers(queue
, UVC_BUF_STATE_ERROR
);
384 /* This must be protected by the irqlock spinlock to avoid race
385 * conditions between uvc_buffer_queue and the disconnection event that
386 * could result in an interruptible wait in uvc_dequeue_buffer. Do not
387 * blindly replace this logic by checking for the UVC_QUEUE_DISCONNECTED
388 * state outside the queue code.
391 queue
->flags
|= UVC_QUEUE_DISCONNECTED
;
392 spin_unlock_irqrestore(&queue
->irqlock
, flags
);
395 struct uvc_buffer
*uvc_queue_next_buffer(struct uvc_video_queue
*queue
,
396 struct uvc_buffer
*buf
)
398 struct uvc_buffer
*nextbuf
;
401 if ((queue
->flags
& UVC_QUEUE_DROP_CORRUPTED
) && buf
->error
) {
403 buf
->state
= UVC_BUF_STATE_QUEUED
;
405 vb2_set_plane_payload(&buf
->buf
.vb2_buf
, 0, 0);
409 spin_lock_irqsave(&queue
->irqlock
, flags
);
410 list_del(&buf
->queue
);
411 if (!list_empty(&queue
->irqqueue
))
412 nextbuf
= list_first_entry(&queue
->irqqueue
, struct uvc_buffer
,
416 spin_unlock_irqrestore(&queue
->irqlock
, flags
);
418 buf
->state
= buf
->error
? VB2_BUF_STATE_ERROR
: UVC_BUF_STATE_DONE
;
419 vb2_set_plane_payload(&buf
->buf
.vb2_buf
, 0, buf
->bytesused
);
420 vb2_buffer_done(&buf
->buf
.vb2_buf
, VB2_BUF_STATE_DONE
);