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-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 static inline struct uvc_streaming *
40 uvc_queue_to_stream(struct uvc_video_queue *queue)
42 return container_of(queue, struct uvc_streaming, queue);
46 * Return all queued buffers to videobuf2 in the requested state.
48 * This function must be called with the queue spinlock held.
50 static void uvc_queue_return_buffers(struct uvc_video_queue *queue,
51 enum uvc_buffer_state state)
53 enum vb2_buffer_state vb2_state = state == UVC_BUF_STATE_ERROR
55 : VB2_BUF_STATE_QUEUED;
57 while (!list_empty(&queue->irqqueue)) {
58 struct uvc_buffer *buf = list_first_entry(&queue->irqqueue,
61 list_del(&buf->queue);
63 vb2_buffer_done(&buf->buf, vb2_state);
67 /* -----------------------------------------------------------------------------
68 * videobuf2 queue operations
71 static int uvc_queue_setup(struct vb2_queue *vq, const struct v4l2_format *fmt,
72 unsigned int *nbuffers, unsigned int *nplanes,
73 unsigned int sizes[], void *alloc_ctxs[])
75 struct uvc_video_queue *queue = vb2_get_drv_priv(vq);
76 struct uvc_streaming *stream = uvc_queue_to_stream(queue);
78 /* Make sure the image size is large enough. */
79 if (fmt && fmt->fmt.pix.sizeimage < stream->ctrl.dwMaxVideoFrameSize)
84 sizes[0] = fmt ? fmt->fmt.pix.sizeimage
85 : stream->ctrl.dwMaxVideoFrameSize;
90 static int uvc_buffer_prepare(struct vb2_buffer *vb)
92 struct uvc_video_queue *queue = vb2_get_drv_priv(vb->vb2_queue);
93 struct uvc_buffer *buf = container_of(vb, struct uvc_buffer, buf);
95 if (vb->v4l2_buf.type == V4L2_BUF_TYPE_VIDEO_OUTPUT &&
96 vb2_get_plane_payload(vb, 0) > vb2_plane_size(vb, 0)) {
97 uvc_trace(UVC_TRACE_CAPTURE, "[E] Bytes used out of bounds.\n");
101 if (unlikely(queue->flags & UVC_QUEUE_DISCONNECTED))
104 buf->state = UVC_BUF_STATE_QUEUED;
106 buf->mem = vb2_plane_vaddr(vb, 0);
107 buf->length = vb2_plane_size(vb, 0);
108 if (vb->v4l2_buf.type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
111 buf->bytesused = vb2_get_plane_payload(vb, 0);
116 static void uvc_buffer_queue(struct vb2_buffer *vb)
118 struct uvc_video_queue *queue = vb2_get_drv_priv(vb->vb2_queue);
119 struct uvc_buffer *buf = container_of(vb, struct uvc_buffer, buf);
122 spin_lock_irqsave(&queue->irqlock, flags);
123 if (likely(!(queue->flags & UVC_QUEUE_DISCONNECTED))) {
124 list_add_tail(&buf->queue, &queue->irqqueue);
126 /* If the device is disconnected return the buffer to userspace
127 * directly. The next QBUF call will fail with -ENODEV.
129 buf->state = UVC_BUF_STATE_ERROR;
130 vb2_buffer_done(&buf->buf, VB2_BUF_STATE_ERROR);
133 spin_unlock_irqrestore(&queue->irqlock, flags);
136 static void uvc_buffer_finish(struct vb2_buffer *vb)
138 struct uvc_video_queue *queue = vb2_get_drv_priv(vb->vb2_queue);
139 struct uvc_streaming *stream = uvc_queue_to_stream(queue);
140 struct uvc_buffer *buf = container_of(vb, struct uvc_buffer, buf);
142 if (vb->state == VB2_BUF_STATE_DONE)
143 uvc_video_clock_update(stream, &vb->v4l2_buf, buf);
146 static int uvc_start_streaming(struct vb2_queue *vq, unsigned int count)
148 struct uvc_video_queue *queue = vb2_get_drv_priv(vq);
149 struct uvc_streaming *stream = uvc_queue_to_stream(queue);
155 ret = uvc_video_enable(stream, 1);
159 spin_lock_irqsave(&queue->irqlock, flags);
160 uvc_queue_return_buffers(queue, UVC_BUF_STATE_QUEUED);
161 spin_unlock_irqrestore(&queue->irqlock, flags);
166 static void uvc_stop_streaming(struct vb2_queue *vq)
168 struct uvc_video_queue *queue = vb2_get_drv_priv(vq);
169 struct uvc_streaming *stream = uvc_queue_to_stream(queue);
172 uvc_video_enable(stream, 0);
174 spin_lock_irqsave(&queue->irqlock, flags);
175 uvc_queue_return_buffers(queue, UVC_BUF_STATE_ERROR);
176 spin_unlock_irqrestore(&queue->irqlock, flags);
179 static struct vb2_ops uvc_queue_qops = {
180 .queue_setup = uvc_queue_setup,
181 .buf_prepare = uvc_buffer_prepare,
182 .buf_queue = uvc_buffer_queue,
183 .buf_finish = uvc_buffer_finish,
184 .wait_prepare = vb2_ops_wait_prepare,
185 .wait_finish = vb2_ops_wait_finish,
186 .start_streaming = uvc_start_streaming,
187 .stop_streaming = uvc_stop_streaming,
190 int uvc_queue_init(struct uvc_video_queue *queue, enum v4l2_buf_type type,
195 queue->queue.type = type;
196 queue->queue.io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF;
197 queue->queue.drv_priv = queue;
198 queue->queue.buf_struct_size = sizeof(struct uvc_buffer);
199 queue->queue.ops = &uvc_queue_qops;
200 queue->queue.mem_ops = &vb2_vmalloc_memops;
201 queue->queue.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC
202 | V4L2_BUF_FLAG_TSTAMP_SRC_SOE;
203 queue->queue.lock = &queue->mutex;
204 ret = vb2_queue_init(&queue->queue);
208 mutex_init(&queue->mutex);
209 spin_lock_init(&queue->irqlock);
210 INIT_LIST_HEAD(&queue->irqqueue);
211 queue->flags = drop_corrupted ? UVC_QUEUE_DROP_CORRUPTED : 0;
216 void uvc_queue_release(struct uvc_video_queue *queue)
218 mutex_lock(&queue->mutex);
219 vb2_queue_release(&queue->queue);
220 mutex_unlock(&queue->mutex);
223 /* -----------------------------------------------------------------------------
224 * V4L2 queue operations
227 int uvc_request_buffers(struct uvc_video_queue *queue,
228 struct v4l2_requestbuffers *rb)
232 mutex_lock(&queue->mutex);
233 ret = vb2_reqbufs(&queue->queue, rb);
234 mutex_unlock(&queue->mutex);
236 return ret ? ret : rb->count;
239 int uvc_query_buffer(struct uvc_video_queue *queue, struct v4l2_buffer *buf)
243 mutex_lock(&queue->mutex);
244 ret = vb2_querybuf(&queue->queue, buf);
245 mutex_unlock(&queue->mutex);
250 int uvc_create_buffers(struct uvc_video_queue *queue,
251 struct v4l2_create_buffers *cb)
255 mutex_lock(&queue->mutex);
256 ret = vb2_create_bufs(&queue->queue, cb);
257 mutex_unlock(&queue->mutex);
262 int uvc_queue_buffer(struct uvc_video_queue *queue, struct v4l2_buffer *buf)
266 mutex_lock(&queue->mutex);
267 ret = vb2_qbuf(&queue->queue, buf);
268 mutex_unlock(&queue->mutex);
273 int uvc_dequeue_buffer(struct uvc_video_queue *queue, struct v4l2_buffer *buf,
278 mutex_lock(&queue->mutex);
279 ret = vb2_dqbuf(&queue->queue, buf, nonblocking);
280 mutex_unlock(&queue->mutex);
285 int uvc_queue_streamon(struct uvc_video_queue *queue, enum v4l2_buf_type type)
289 mutex_lock(&queue->mutex);
290 ret = vb2_streamon(&queue->queue, type);
291 mutex_unlock(&queue->mutex);
296 int uvc_queue_streamoff(struct uvc_video_queue *queue, enum v4l2_buf_type type)
300 mutex_lock(&queue->mutex);
301 ret = vb2_streamoff(&queue->queue, type);
302 mutex_unlock(&queue->mutex);
307 int uvc_queue_mmap(struct uvc_video_queue *queue, struct vm_area_struct *vma)
309 return vb2_mmap(&queue->queue, vma);
313 unsigned long uvc_queue_get_unmapped_area(struct uvc_video_queue *queue,
316 return vb2_get_unmapped_area(&queue->queue, 0, 0, pgoff, 0);
320 unsigned int uvc_queue_poll(struct uvc_video_queue *queue, struct file *file,
325 mutex_lock(&queue->mutex);
326 ret = vb2_poll(&queue->queue, file, wait);
327 mutex_unlock(&queue->mutex);
332 /* -----------------------------------------------------------------------------
337 * Check if buffers have been allocated.
339 int uvc_queue_allocated(struct uvc_video_queue *queue)
343 mutex_lock(&queue->mutex);
344 allocated = vb2_is_busy(&queue->queue);
345 mutex_unlock(&queue->mutex);
351 * Cancel the video buffers queue.
353 * Cancelling the queue marks all buffers on the irq queue as erroneous,
354 * wakes them up and removes them from the queue.
356 * If the disconnect parameter is set, further calls to uvc_queue_buffer will
359 * This function acquires the irq spinlock and can be called from interrupt
362 void uvc_queue_cancel(struct uvc_video_queue *queue, int disconnect)
366 spin_lock_irqsave(&queue->irqlock, flags);
367 uvc_queue_return_buffers(queue, UVC_BUF_STATE_ERROR);
368 /* This must be protected by the irqlock spinlock to avoid race
369 * conditions between uvc_buffer_queue and the disconnection event that
370 * could result in an interruptible wait in uvc_dequeue_buffer. Do not
371 * blindly replace this logic by checking for the UVC_QUEUE_DISCONNECTED
372 * state outside the queue code.
375 queue->flags |= UVC_QUEUE_DISCONNECTED;
376 spin_unlock_irqrestore(&queue->irqlock, flags);
379 struct uvc_buffer *uvc_queue_next_buffer(struct uvc_video_queue *queue,
380 struct uvc_buffer *buf)
382 struct uvc_buffer *nextbuf;
385 if ((queue->flags & UVC_QUEUE_DROP_CORRUPTED) && buf->error) {
387 buf->state = UVC_BUF_STATE_QUEUED;
389 vb2_set_plane_payload(&buf->buf, 0, 0);
393 spin_lock_irqsave(&queue->irqlock, flags);
394 list_del(&buf->queue);
395 if (!list_empty(&queue->irqqueue))
396 nextbuf = list_first_entry(&queue->irqqueue, struct uvc_buffer,
400 spin_unlock_irqrestore(&queue->irqlock, flags);
402 buf->state = buf->error ? VB2_BUF_STATE_ERROR : UVC_BUF_STATE_DONE;
403 vb2_set_plane_payload(&buf->buf, 0, buf->bytesused);
404 vb2_buffer_done(&buf->buf, VB2_BUF_STATE_DONE);