blob: 7ce27e35550b7e50c887764b53f6907e4fc5864d [file] [log] [blame]
Laurent Pinchartcdda4792010-05-02 20:57:41 +02001/*
2 * uvc_queue.c -- USB Video Class driver - Buffers management
3 *
4 * Copyright (C) 2005-2010
5 * Laurent Pinchart (laurent.pinchart@ideasonboard.com)
6 *
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.
Laurent Pinchartcdda4792010-05-02 20:57:41 +020011 */
12
Bhupesh Sharmad6925222013-03-28 15:11:52 +053013#include <linux/atomic.h>
Laurent Pinchartcdda4792010-05-02 20:57:41 +020014#include <linux/kernel.h>
15#include <linux/mm.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>
Bhupesh Sharmad6925222013-03-28 15:11:52 +053022
23#include <media/videobuf2-vmalloc.h>
Laurent Pinchartcdda4792010-05-02 20:57:41 +020024
25#include "uvc.h"
26
27/* ------------------------------------------------------------------------
28 * Video buffers queue management.
29 *
30 * Video queues is initialized by uvc_queue_init(). The function performs
31 * basic initialization of the uvc_video_queue struct and never fails.
32 *
Bhupesh Sharmad6925222013-03-28 15:11:52 +053033 * 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
36 * the driver.
Laurent Pinchartcdda4792010-05-02 20:57:41 +020037 */
38
Bhupesh Sharmad6925222013-03-28 15:11:52 +053039/* -----------------------------------------------------------------------------
40 * videobuf2 queue operations
41 */
42
43static 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[])
Laurent Pinchartcdda4792010-05-02 20:57:41 +020046{
Bhupesh Sharmad6925222013-03-28 15:11:52 +053047 struct uvc_video_queue *queue = vb2_get_drv_priv(vq);
48 struct uvc_video *video = container_of(queue, struct uvc_video, queue);
49
50 if (*nbuffers > UVC_MAX_VIDEO_BUFFERS)
51 *nbuffers = UVC_MAX_VIDEO_BUFFERS;
52
53 *nplanes = 1;
54
55 sizes[0] = video->imagesize;
56
57 return 0;
Laurent Pinchartcdda4792010-05-02 20:57:41 +020058}
59
Bhupesh Sharmad6925222013-03-28 15:11:52 +053060static int uvc_buffer_prepare(struct vb2_buffer *vb)
Laurent Pinchart5d9955f2010-07-10 16:13:05 -030061{
Bhupesh Sharmad6925222013-03-28 15:11:52 +053062 struct uvc_video_queue *queue = vb2_get_drv_priv(vb->vb2_queue);
63 struct uvc_buffer *buf = container_of(vb, struct uvc_buffer, buf);
Laurent Pinchart5d9955f2010-07-10 16:13:05 -030064
Bhupesh Sharmad6925222013-03-28 15:11:52 +053065 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");
68 return -EINVAL;
Laurent Pinchart5d9955f2010-07-10 16:13:05 -030069 }
70
Bhupesh Sharmad6925222013-03-28 15:11:52 +053071 if (unlikely(queue->flags & UVC_QUEUE_DISCONNECTED))
72 return -ENODEV;
73
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)
78 buf->bytesused = 0;
79 else
80 buf->bytesused = vb2_get_plane_payload(vb, 0);
81
82 return 0;
83}
84
85static void uvc_buffer_queue(struct vb2_buffer *vb)
86{
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);
89 unsigned long flags;
90
91 spin_lock_irqsave(&queue->irqlock, flags);
92
93 if (likely(!(queue->flags & UVC_QUEUE_DISCONNECTED))) {
94 list_add_tail(&buf->queue, &queue->irqqueue);
95 } else {
96 /* If the device is disconnected return the buffer to userspace
97 * directly. The next QBUF call will fail with -ENODEV.
98 */
99 buf->state = UVC_BUF_STATE_ERROR;
100 vb2_buffer_done(&buf->buf, VB2_BUF_STATE_ERROR);
Laurent Pinchart5d9955f2010-07-10 16:13:05 -0300101 }
102
Bhupesh Sharmad6925222013-03-28 15:11:52 +0530103 spin_unlock_irqrestore(&queue->irqlock, flags);
104}
105
106static struct vb2_ops uvc_queue_qops = {
107 .queue_setup = uvc_queue_setup,
108 .buf_prepare = uvc_buffer_prepare,
109 .buf_queue = uvc_buffer_queue,
110};
111
112static int uvc_queue_init(struct uvc_video_queue *queue,
113 enum v4l2_buf_type type)
114{
115 int ret;
116
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);
124 if (ret)
125 return ret;
126
127 mutex_init(&queue->mutex);
128 spin_lock_init(&queue->irqlock);
129 INIT_LIST_HEAD(&queue->irqqueue);
130 queue->flags = 0;
131
Laurent Pinchart5d9955f2010-07-10 16:13:05 -0300132 return 0;
133}
134
135/*
Bhupesh Sharmad6925222013-03-28 15:11:52 +0530136 * Free the video buffers.
Laurent Pinchartcdda4792010-05-02 20:57:41 +0200137 */
Bhupesh Sharmad6925222013-03-28 15:11:52 +0530138static void uvc_free_buffers(struct uvc_video_queue *queue)
Laurent Pinchartcdda4792010-05-02 20:57:41 +0200139{
Laurent Pinchartcdda4792010-05-02 20:57:41 +0200140 mutex_lock(&queue->mutex);
Bhupesh Sharmad6925222013-03-28 15:11:52 +0530141 vb2_queue_release(&queue->queue);
Laurent Pinchartcdda4792010-05-02 20:57:41 +0200142 mutex_unlock(&queue->mutex);
Laurent Pinchartcdda4792010-05-02 20:57:41 +0200143}
144
145/*
Bhupesh Sharmad6925222013-03-28 15:11:52 +0530146 * Allocate the video buffers.
Laurent Pinchartcdda4792010-05-02 20:57:41 +0200147 */
Bhupesh Sharmad6925222013-03-28 15:11:52 +0530148static int uvc_alloc_buffers(struct uvc_video_queue *queue,
149 struct v4l2_requestbuffers *rb)
Laurent Pinchartcdda4792010-05-02 20:57:41 +0200150{
Bhupesh Sharmad6925222013-03-28 15:11:52 +0530151 int ret;
Laurent Pinchartcdda4792010-05-02 20:57:41 +0200152
153 mutex_lock(&queue->mutex);
Bhupesh Sharmad6925222013-03-28 15:11:52 +0530154 ret = vb2_reqbufs(&queue->queue, rb);
Laurent Pinchartcdda4792010-05-02 20:57:41 +0200155 mutex_unlock(&queue->mutex);
Bhupesh Sharmad6925222013-03-28 15:11:52 +0530156
157 return ret ? ret : rb->count;
158}
159
160static int uvc_query_buffer(struct uvc_video_queue *queue,
161 struct v4l2_buffer *buf)
162{
163 int ret;
164
165 mutex_lock(&queue->mutex);
166 ret = vb2_querybuf(&queue->queue, buf);
167 mutex_unlock(&queue->mutex);
168
Laurent Pinchartcdda4792010-05-02 20:57:41 +0200169 return ret;
170}
171
Bhupesh Sharmad6925222013-03-28 15:11:52 +0530172static int uvc_queue_buffer(struct uvc_video_queue *queue,
173 struct v4l2_buffer *buf)
Laurent Pinchartcdda4792010-05-02 20:57:41 +0200174{
Bhupesh Sharmad6925222013-03-28 15:11:52 +0530175 unsigned long flags;
176 int ret;
Laurent Pinchartcdda4792010-05-02 20:57:41 +0200177
Bhupesh Sharmad6925222013-03-28 15:11:52 +0530178 mutex_lock(&queue->mutex);
179 ret = vb2_qbuf(&queue->queue, buf);
180 spin_lock_irqsave(&queue->irqlock, flags);
181 ret = (queue->flags & UVC_QUEUE_PAUSED) != 0;
182 queue->flags &= ~UVC_QUEUE_PAUSED;
183 spin_unlock_irqrestore(&queue->irqlock, flags);
184 mutex_unlock(&queue->mutex);
185
186 return ret;
Laurent Pinchartcdda4792010-05-02 20:57:41 +0200187}
188
189/*
190 * Dequeue a video buffer. If nonblocking is false, block until a buffer is
191 * available.
192 */
Bhupesh Sharmad6925222013-03-28 15:11:52 +0530193static int uvc_dequeue_buffer(struct uvc_video_queue *queue,
194 struct v4l2_buffer *buf, int nonblocking)
Laurent Pinchartcdda4792010-05-02 20:57:41 +0200195{
Bhupesh Sharmad6925222013-03-28 15:11:52 +0530196 int ret;
Laurent Pinchartcdda4792010-05-02 20:57:41 +0200197
198 mutex_lock(&queue->mutex);
Bhupesh Sharmad6925222013-03-28 15:11:52 +0530199 ret = vb2_dqbuf(&queue->queue, buf, nonblocking);
Laurent Pinchartcdda4792010-05-02 20:57:41 +0200200 mutex_unlock(&queue->mutex);
Bhupesh Sharmad6925222013-03-28 15:11:52 +0530201
Laurent Pinchartcdda4792010-05-02 20:57:41 +0200202 return ret;
203}
204
205/*
206 * Poll the video queue.
207 *
208 * This function implements video queue polling and is intended to be used by
209 * the device poll handler.
210 */
Bhupesh Sharmad6925222013-03-28 15:11:52 +0530211static unsigned int uvc_queue_poll(struct uvc_video_queue *queue,
212 struct file *file, poll_table *wait)
Laurent Pinchartcdda4792010-05-02 20:57:41 +0200213{
Bhupesh Sharmad6925222013-03-28 15:11:52 +0530214 unsigned int ret;
Laurent Pinchartcdda4792010-05-02 20:57:41 +0200215
216 mutex_lock(&queue->mutex);
Bhupesh Sharmad6925222013-03-28 15:11:52 +0530217 ret = vb2_poll(&queue->queue, file, wait);
Laurent Pinchartcdda4792010-05-02 20:57:41 +0200218 mutex_unlock(&queue->mutex);
Bhupesh Sharmad6925222013-03-28 15:11:52 +0530219
220 return ret;
Laurent Pinchartcdda4792010-05-02 20:57:41 +0200221}
222
Bhupesh Sharmad6925222013-03-28 15:11:52 +0530223static int uvc_queue_mmap(struct uvc_video_queue *queue,
224 struct vm_area_struct *vma)
Laurent Pinchartcdda4792010-05-02 20:57:41 +0200225{
Bhupesh Sharmad6925222013-03-28 15:11:52 +0530226 int ret;
Laurent Pinchartcdda4792010-05-02 20:57:41 +0200227
228 mutex_lock(&queue->mutex);
Bhupesh Sharmad6925222013-03-28 15:11:52 +0530229 ret = vb2_mmap(&queue->queue, vma);
Laurent Pinchartcdda4792010-05-02 20:57:41 +0200230 mutex_unlock(&queue->mutex);
Bhupesh Sharmad6925222013-03-28 15:11:52 +0530231
Laurent Pinchartcdda4792010-05-02 20:57:41 +0200232 return ret;
233}
234
Bhupesh Sharma2f1d5702013-03-28 15:11:53 +0530235#ifndef CONFIG_MMU
236/*
237 * Get unmapped area.
238 *
239 * NO-MMU arch need this function to make mmap() work correctly.
240 */
241static unsigned long uvc_queue_get_unmapped_area(struct uvc_video_queue *queue,
242 unsigned long pgoff)
243{
244 unsigned long ret;
245
246 mutex_lock(&queue->mutex);
247 ret = vb2_get_unmapped_area(&queue->queue, 0, 0, pgoff, 0);
248 mutex_unlock(&queue->mutex);
249 return ret;
250}
251#endif
252
Laurent Pinchartcdda4792010-05-02 20:57:41 +0200253/*
Laurent Pinchart5d9955f2010-07-10 16:13:05 -0300254 * Cancel the video buffers queue.
255 *
256 * Cancelling the queue marks all buffers on the irq queue as erroneous,
257 * wakes them up and removes them from the queue.
258 *
259 * If the disconnect parameter is set, further calls to uvc_queue_buffer will
260 * fail with -ENODEV.
261 *
262 * This function acquires the irq spinlock and can be called from interrupt
263 * context.
264 */
265static void uvc_queue_cancel(struct uvc_video_queue *queue, int disconnect)
266{
267 struct uvc_buffer *buf;
268 unsigned long flags;
269
270 spin_lock_irqsave(&queue->irqlock, flags);
271 while (!list_empty(&queue->irqqueue)) {
272 buf = list_first_entry(&queue->irqqueue, struct uvc_buffer,
273 queue);
274 list_del(&buf->queue);
275 buf->state = UVC_BUF_STATE_ERROR;
Bhupesh Sharmad6925222013-03-28 15:11:52 +0530276 vb2_buffer_done(&buf->buf, VB2_BUF_STATE_ERROR);
Laurent Pinchart5d9955f2010-07-10 16:13:05 -0300277 }
278 /* This must be protected by the irqlock spinlock to avoid race
279 * conditions between uvc_queue_buffer and the disconnection event that
280 * could result in an interruptible wait in uvc_dequeue_buffer. Do not
281 * blindly replace this logic by checking for the UVC_DEV_DISCONNECTED
282 * state outside the queue code.
283 */
284 if (disconnect)
285 queue->flags |= UVC_QUEUE_DISCONNECTED;
286 spin_unlock_irqrestore(&queue->irqlock, flags);
287}
288
289/*
Laurent Pinchartcdda4792010-05-02 20:57:41 +0200290 * Enable or disable the video buffers queue.
291 *
292 * The queue must be enabled before starting video acquisition and must be
293 * disabled after stopping it. This ensures that the video buffers queue
294 * state can be properly initialized before buffers are accessed from the
295 * interrupt handler.
296 *
297 * Enabling the video queue initializes parameters (such as sequence number,
298 * sync pattern, ...). If the queue is already enabled, return -EBUSY.
299 *
300 * Disabling the video queue cancels the queue and removes all buffers from
301 * the main queue.
302 *
303 * This function can't be called from interrupt context. Use
304 * uvc_queue_cancel() instead.
305 */
Laurent Pinchart5d9955f2010-07-10 16:13:05 -0300306static int uvc_queue_enable(struct uvc_video_queue *queue, int enable)
Laurent Pinchartcdda4792010-05-02 20:57:41 +0200307{
Bhupesh Sharmad6925222013-03-28 15:11:52 +0530308 unsigned long flags;
Laurent Pinchartcdda4792010-05-02 20:57:41 +0200309 int ret = 0;
310
311 mutex_lock(&queue->mutex);
312 if (enable) {
Bhupesh Sharmad6925222013-03-28 15:11:52 +0530313 ret = vb2_streamon(&queue->queue, queue->queue.type);
314 if (ret < 0)
Laurent Pinchartcdda4792010-05-02 20:57:41 +0200315 goto done;
Bhupesh Sharmad6925222013-03-28 15:11:52 +0530316
Laurent Pinchartcdda4792010-05-02 20:57:41 +0200317 queue->sequence = 0;
Laurent Pinchartcdda4792010-05-02 20:57:41 +0200318 queue->buf_used = 0;
319 } else {
Bhupesh Sharmad6925222013-03-28 15:11:52 +0530320 ret = vb2_streamoff(&queue->queue, queue->queue.type);
321 if (ret < 0)
322 goto done;
Laurent Pinchartcdda4792010-05-02 20:57:41 +0200323
Bhupesh Sharmad6925222013-03-28 15:11:52 +0530324 spin_lock_irqsave(&queue->irqlock, flags);
325 INIT_LIST_HEAD(&queue->irqqueue);
Laurent Pinchartcdda4792010-05-02 20:57:41 +0200326
Bhupesh Sharmad6925222013-03-28 15:11:52 +0530327 /*
328 * FIXME: We need to clear the DISCONNECTED flag to ensure that
329 * applications will be able to queue buffers for the next
330 * streaming run. However, clearing it here doesn't guarantee
331 * that the device will be reconnected in the meantime.
332 */
333 queue->flags &= ~UVC_QUEUE_DISCONNECTED;
334 spin_unlock_irqrestore(&queue->irqlock, flags);
Laurent Pinchartcdda4792010-05-02 20:57:41 +0200335 }
336
337done:
338 mutex_unlock(&queue->mutex);
339 return ret;
340}
341
Bhupesh Sharma95faf822012-03-22 00:50:37 -0300342/* called with &queue_irqlock held.. */
Bhupesh Sharmad6925222013-03-28 15:11:52 +0530343static struct uvc_buffer *uvc_queue_next_buffer(struct uvc_video_queue *queue,
344 struct uvc_buffer *buf)
Laurent Pinchartcdda4792010-05-02 20:57:41 +0200345{
346 struct uvc_buffer *nextbuf;
Laurent Pinchartcdda4792010-05-02 20:57:41 +0200347
348 if ((queue->flags & UVC_QUEUE_DROP_INCOMPLETE) &&
Bhupesh Sharmad6925222013-03-28 15:11:52 +0530349 buf->length != buf->bytesused) {
Laurent Pinchartcdda4792010-05-02 20:57:41 +0200350 buf->state = UVC_BUF_STATE_QUEUED;
Bhupesh Sharmad6925222013-03-28 15:11:52 +0530351 vb2_set_plane_payload(&buf->buf, 0, 0);
Laurent Pinchartcdda4792010-05-02 20:57:41 +0200352 return buf;
353 }
354
Laurent Pinchartcdda4792010-05-02 20:57:41 +0200355 list_del(&buf->queue);
356 if (!list_empty(&queue->irqqueue))
357 nextbuf = list_first_entry(&queue->irqqueue, struct uvc_buffer,
358 queue);
359 else
360 nextbuf = NULL;
Laurent Pinchartcdda4792010-05-02 20:57:41 +0200361
Bhupesh Sharmad6925222013-03-28 15:11:52 +0530362 /*
363 * FIXME: with videobuf2, the sequence number or timestamp fields
364 * are valid only for video capture devices and the UVC gadget usually
365 * is a video output device. Keeping these until the specs are clear on
366 * this aspect.
367 */
368 buf->buf.v4l2_buf.sequence = queue->sequence++;
369 do_gettimeofday(&buf->buf.v4l2_buf.timestamp);
Laurent Pinchartcdda4792010-05-02 20:57:41 +0200370
Bhupesh Sharmad6925222013-03-28 15:11:52 +0530371 vb2_set_plane_payload(&buf->buf, 0, buf->bytesused);
372 vb2_buffer_done(&buf->buf, VB2_BUF_STATE_DONE);
373
Laurent Pinchartcdda4792010-05-02 20:57:41 +0200374 return nextbuf;
375}
376
Laurent Pinchart5d9955f2010-07-10 16:13:05 -0300377static struct uvc_buffer *uvc_queue_head(struct uvc_video_queue *queue)
Laurent Pinchartcdda4792010-05-02 20:57:41 +0200378{
379 struct uvc_buffer *buf = NULL;
380
381 if (!list_empty(&queue->irqqueue))
382 buf = list_first_entry(&queue->irqqueue, struct uvc_buffer,
383 queue);
384 else
385 queue->flags |= UVC_QUEUE_PAUSED;
386
387 return buf;
388}
389