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.
13 #include <linux/atomic.h>
14 #include <linux/kernel.h>
16 #include <linux/list.h>
17 #include <linux/module.h>
18 #include <linux/usb.h>
19 #include <linux/videodev2.h>
20 #include <linux/vmalloc.h>
21 #include <linux/wait.h>
23 #include <media/videobuf2-vmalloc.h>
27 /* ------------------------------------------------------------------------
28 * Video buffers queue management.
30 * Video queues is initialized by uvc_queue_init(). The function performs
31 * basic initialization of the uvc_video_queue struct and never fails.
33 * Video buffers are managed by videobuf2. The driver uses a mutex to protect
34 * the videobuf2 queue operations by serializing calls to videobuf2 and a
35 * spinlock to protect the IRQ queue that holds the buffers to be processed by
39 /* -----------------------------------------------------------------------------
40 * videobuf2 queue operations
43 static int uvc_queue_setup(struct vb2_queue
*vq
, const struct v4l2_format
*fmt
,
44 unsigned int *nbuffers
, unsigned int *nplanes
,
45 unsigned int sizes
[], void *alloc_ctxs
[])
47 struct uvc_video_queue
*queue
= vb2_get_drv_priv(vq
);
48 struct uvc_video
*video
= container_of(queue
, struct uvc_video
, queue
);
50 if (*nbuffers
> UVC_MAX_VIDEO_BUFFERS
)
51 *nbuffers
= UVC_MAX_VIDEO_BUFFERS
;
55 sizes
[0] = video
->imagesize
;
60 static int uvc_buffer_prepare(struct vb2_buffer
*vb
)
62 struct uvc_video_queue
*queue
= vb2_get_drv_priv(vb
->vb2_queue
);
63 struct uvc_buffer
*buf
= container_of(vb
, struct uvc_buffer
, buf
);
65 if (vb
->v4l2_buf
.type
== V4L2_BUF_TYPE_VIDEO_OUTPUT
&&
66 vb2_get_plane_payload(vb
, 0) > vb2_plane_size(vb
, 0)) {
67 uvc_trace(UVC_TRACE_CAPTURE
, "[E] Bytes used out of bounds.\n");
71 if (unlikely(queue
->flags
& UVC_QUEUE_DISCONNECTED
))
74 buf
->state
= UVC_BUF_STATE_QUEUED
;
75 buf
->mem
= vb2_plane_vaddr(vb
, 0);
76 buf
->length
= vb2_plane_size(vb
, 0);
77 if (vb
->v4l2_buf
.type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
)
80 buf
->bytesused
= vb2_get_plane_payload(vb
, 0);
85 static void uvc_buffer_queue(struct vb2_buffer
*vb
)
87 struct uvc_video_queue
*queue
= vb2_get_drv_priv(vb
->vb2_queue
);
88 struct uvc_buffer
*buf
= container_of(vb
, struct uvc_buffer
, buf
);
91 spin_lock_irqsave(&queue
->irqlock
, flags
);
93 if (likely(!(queue
->flags
& UVC_QUEUE_DISCONNECTED
))) {
94 list_add_tail(&buf
->queue
, &queue
->irqqueue
);
96 /* If the device is disconnected return the buffer to userspace
97 * directly. The next QBUF call will fail with -ENODEV.
99 buf
->state
= UVC_BUF_STATE_ERROR
;
100 vb2_buffer_done(&buf
->buf
, VB2_BUF_STATE_ERROR
);
103 spin_unlock_irqrestore(&queue
->irqlock
, flags
);
106 static struct vb2_ops uvc_queue_qops
= {
107 .queue_setup
= uvc_queue_setup
,
108 .buf_prepare
= uvc_buffer_prepare
,
109 .buf_queue
= uvc_buffer_queue
,
112 static int uvc_queue_init(struct uvc_video_queue
*queue
,
113 enum v4l2_buf_type type
)
117 queue
->queue
.type
= type
;
118 queue
->queue
.io_modes
= VB2_MMAP
| VB2_USERPTR
;
119 queue
->queue
.drv_priv
= queue
;
120 queue
->queue
.buf_struct_size
= sizeof(struct uvc_buffer
);
121 queue
->queue
.ops
= &uvc_queue_qops
;
122 queue
->queue
.mem_ops
= &vb2_vmalloc_memops
;
123 ret
= vb2_queue_init(&queue
->queue
);
127 mutex_init(&queue
->mutex
);
128 spin_lock_init(&queue
->irqlock
);
129 INIT_LIST_HEAD(&queue
->irqqueue
);
136 * Free the video buffers.
138 static void uvc_free_buffers(struct uvc_video_queue
*queue
)
140 mutex_lock(&queue
->mutex
);
141 vb2_queue_release(&queue
->queue
);
142 mutex_unlock(&queue
->mutex
);
146 * Allocate the video buffers.
148 static int uvc_alloc_buffers(struct uvc_video_queue
*queue
,
149 struct v4l2_requestbuffers
*rb
)
153 mutex_lock(&queue
->mutex
);
154 ret
= vb2_reqbufs(&queue
->queue
, rb
);
155 mutex_unlock(&queue
->mutex
);
157 return ret
? ret
: rb
->count
;
160 static int uvc_query_buffer(struct uvc_video_queue
*queue
,
161 struct v4l2_buffer
*buf
)
165 mutex_lock(&queue
->mutex
);
166 ret
= vb2_querybuf(&queue
->queue
, buf
);
167 mutex_unlock(&queue
->mutex
);
172 static int uvc_queue_buffer(struct uvc_video_queue
*queue
,
173 struct v4l2_buffer
*buf
)
178 mutex_lock(&queue
->mutex
);
179 ret
= vb2_qbuf(&queue
->queue
, buf
);
183 spin_lock_irqsave(&queue
->irqlock
, flags
);
184 ret
= (queue
->flags
& UVC_QUEUE_PAUSED
) != 0;
185 queue
->flags
&= ~UVC_QUEUE_PAUSED
;
186 spin_unlock_irqrestore(&queue
->irqlock
, flags
);
189 mutex_unlock(&queue
->mutex
);
194 * Dequeue a video buffer. If nonblocking is false, block until a buffer is
197 static int uvc_dequeue_buffer(struct uvc_video_queue
*queue
,
198 struct v4l2_buffer
*buf
, int nonblocking
)
202 mutex_lock(&queue
->mutex
);
203 ret
= vb2_dqbuf(&queue
->queue
, buf
, nonblocking
);
204 mutex_unlock(&queue
->mutex
);
210 * Poll the video queue.
212 * This function implements video queue polling and is intended to be used by
213 * the device poll handler.
215 static unsigned int uvc_queue_poll(struct uvc_video_queue
*queue
,
216 struct file
*file
, poll_table
*wait
)
220 mutex_lock(&queue
->mutex
);
221 ret
= vb2_poll(&queue
->queue
, file
, wait
);
222 mutex_unlock(&queue
->mutex
);
227 static int uvc_queue_mmap(struct uvc_video_queue
*queue
,
228 struct vm_area_struct
*vma
)
232 mutex_lock(&queue
->mutex
);
233 ret
= vb2_mmap(&queue
->queue
, vma
);
234 mutex_unlock(&queue
->mutex
);
243 * NO-MMU arch need this function to make mmap() work correctly.
245 static unsigned long uvc_queue_get_unmapped_area(struct uvc_video_queue
*queue
,
250 mutex_lock(&queue
->mutex
);
251 ret
= vb2_get_unmapped_area(&queue
->queue
, 0, 0, pgoff
, 0);
252 mutex_unlock(&queue
->mutex
);
258 * Cancel the video buffers queue.
260 * Cancelling the queue marks all buffers on the irq queue as erroneous,
261 * wakes them up and removes them from the queue.
263 * If the disconnect parameter is set, further calls to uvc_queue_buffer will
266 * This function acquires the irq spinlock and can be called from interrupt
269 static void uvc_queue_cancel(struct uvc_video_queue
*queue
, int disconnect
)
271 struct uvc_buffer
*buf
;
274 spin_lock_irqsave(&queue
->irqlock
, flags
);
275 while (!list_empty(&queue
->irqqueue
)) {
276 buf
= list_first_entry(&queue
->irqqueue
, struct uvc_buffer
,
278 list_del(&buf
->queue
);
279 buf
->state
= UVC_BUF_STATE_ERROR
;
280 vb2_buffer_done(&buf
->buf
, VB2_BUF_STATE_ERROR
);
282 /* This must be protected by the irqlock spinlock to avoid race
283 * conditions between uvc_queue_buffer and the disconnection event that
284 * could result in an interruptible wait in uvc_dequeue_buffer. Do not
285 * blindly replace this logic by checking for the UVC_DEV_DISCONNECTED
286 * state outside the queue code.
289 queue
->flags
|= UVC_QUEUE_DISCONNECTED
;
290 spin_unlock_irqrestore(&queue
->irqlock
, flags
);
294 * Enable or disable the video buffers queue.
296 * The queue must be enabled before starting video acquisition and must be
297 * disabled after stopping it. This ensures that the video buffers queue
298 * state can be properly initialized before buffers are accessed from the
301 * Enabling the video queue initializes parameters (such as sequence number,
302 * sync pattern, ...). If the queue is already enabled, return -EBUSY.
304 * Disabling the video queue cancels the queue and removes all buffers from
307 * This function can't be called from interrupt context. Use
308 * uvc_queue_cancel() instead.
310 static int uvc_queue_enable(struct uvc_video_queue
*queue
, int enable
)
315 mutex_lock(&queue
->mutex
);
317 ret
= vb2_streamon(&queue
->queue
, queue
->queue
.type
);
324 ret
= vb2_streamoff(&queue
->queue
, queue
->queue
.type
);
328 spin_lock_irqsave(&queue
->irqlock
, flags
);
329 INIT_LIST_HEAD(&queue
->irqqueue
);
332 * FIXME: We need to clear the DISCONNECTED flag to ensure that
333 * applications will be able to queue buffers for the next
334 * streaming run. However, clearing it here doesn't guarantee
335 * that the device will be reconnected in the meantime.
337 queue
->flags
&= ~UVC_QUEUE_DISCONNECTED
;
338 spin_unlock_irqrestore(&queue
->irqlock
, flags
);
342 mutex_unlock(&queue
->mutex
);
346 /* called with &queue_irqlock held.. */
347 static struct uvc_buffer
*uvc_queue_next_buffer(struct uvc_video_queue
*queue
,
348 struct uvc_buffer
*buf
)
350 struct uvc_buffer
*nextbuf
;
352 if ((queue
->flags
& UVC_QUEUE_DROP_INCOMPLETE
) &&
353 buf
->length
!= buf
->bytesused
) {
354 buf
->state
= UVC_BUF_STATE_QUEUED
;
355 vb2_set_plane_payload(&buf
->buf
, 0, 0);
359 list_del(&buf
->queue
);
360 if (!list_empty(&queue
->irqqueue
))
361 nextbuf
= list_first_entry(&queue
->irqqueue
, struct uvc_buffer
,
367 * FIXME: with videobuf2, the sequence number or timestamp fields
368 * are valid only for video capture devices and the UVC gadget usually
369 * is a video output device. Keeping these until the specs are clear on
372 buf
->buf
.v4l2_buf
.sequence
= queue
->sequence
++;
373 do_gettimeofday(&buf
->buf
.v4l2_buf
.timestamp
);
375 vb2_set_plane_payload(&buf
->buf
, 0, buf
->bytesused
);
376 vb2_buffer_done(&buf
->buf
, VB2_BUF_STATE_DONE
);
381 static struct uvc_buffer
*uvc_queue_head(struct uvc_video_queue
*queue
)
383 struct uvc_buffer
*buf
= NULL
;
385 if (!list_empty(&queue
->irqqueue
))
386 buf
= list_first_entry(&queue
->irqqueue
, struct uvc_buffer
,
389 queue
->flags
|= UVC_QUEUE_PAUSED
;