1/*
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.
11 *
12 */
13
14#include <linux/atomic.h>
15#include <linux/kernel.h>
16#include <linux/mm.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>
24
25#include "uvcvideo.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 *
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
36 * the driver.
37 */
38
39static inline struct uvc_streaming *
40uvc_queue_to_stream(struct uvc_video_queue *queue)
41{
42	return container_of(queue, struct uvc_streaming, queue);
43}
44
45/*
46 * Return all queued buffers to videobuf2 in the requested state.
47 *
48 * This function must be called with the queue spinlock held.
49 */
50static void uvc_queue_return_buffers(struct uvc_video_queue *queue,
51			       enum uvc_buffer_state state)
52{
53	enum vb2_buffer_state vb2_state = state == UVC_BUF_STATE_ERROR
54					? VB2_BUF_STATE_ERROR
55					: VB2_BUF_STATE_QUEUED;
56
57	while (!list_empty(&queue->irqqueue)) {
58		struct uvc_buffer *buf = list_first_entry(&queue->irqqueue,
59							  struct uvc_buffer,
60							  queue);
61		list_del(&buf->queue);
62		buf->state = state;
63		vb2_buffer_done(&buf->buf, vb2_state);
64	}
65}
66
67/* -----------------------------------------------------------------------------
68 * videobuf2 queue operations
69 */
70
71static 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[])
74{
75	struct uvc_video_queue *queue = vb2_get_drv_priv(vq);
76	struct uvc_streaming *stream = uvc_queue_to_stream(queue);
77
78	/* Make sure the image size is large enough. */
79	if (fmt && fmt->fmt.pix.sizeimage < stream->ctrl.dwMaxVideoFrameSize)
80		return -EINVAL;
81
82	*nplanes = 1;
83
84	sizes[0] = fmt ? fmt->fmt.pix.sizeimage
85		 : stream->ctrl.dwMaxVideoFrameSize;
86
87	return 0;
88}
89
90static int uvc_buffer_prepare(struct vb2_buffer *vb)
91{
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);
94
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");
98		return -EINVAL;
99	}
100
101	if (unlikely(queue->flags & UVC_QUEUE_DISCONNECTED))
102		return -ENODEV;
103
104	buf->state = UVC_BUF_STATE_QUEUED;
105	buf->error = 0;
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)
109		buf->bytesused = 0;
110	else
111		buf->bytesused = vb2_get_plane_payload(vb, 0);
112
113	return 0;
114}
115
116static void uvc_buffer_queue(struct vb2_buffer *vb)
117{
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);
120	unsigned long flags;
121
122	spin_lock_irqsave(&queue->irqlock, flags);
123	if (likely(!(queue->flags & UVC_QUEUE_DISCONNECTED))) {
124		list_add_tail(&buf->queue, &queue->irqqueue);
125	} else {
126		/* If the device is disconnected return the buffer to userspace
127		 * directly. The next QBUF call will fail with -ENODEV.
128		 */
129		buf->state = UVC_BUF_STATE_ERROR;
130		vb2_buffer_done(&buf->buf, VB2_BUF_STATE_ERROR);
131	}
132
133	spin_unlock_irqrestore(&queue->irqlock, flags);
134}
135
136static void uvc_buffer_finish(struct vb2_buffer *vb)
137{
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);
141
142	if (vb->state == VB2_BUF_STATE_DONE)
143		uvc_video_clock_update(stream, &vb->v4l2_buf, buf);
144}
145
146static int uvc_start_streaming(struct vb2_queue *vq, unsigned int count)
147{
148	struct uvc_video_queue *queue = vb2_get_drv_priv(vq);
149	struct uvc_streaming *stream = uvc_queue_to_stream(queue);
150	unsigned long flags;
151	int ret;
152
153	queue->buf_used = 0;
154
155	ret = uvc_video_enable(stream, 1);
156	if (ret == 0)
157		return 0;
158
159	spin_lock_irqsave(&queue->irqlock, flags);
160	uvc_queue_return_buffers(queue, UVC_BUF_STATE_QUEUED);
161	spin_unlock_irqrestore(&queue->irqlock, flags);
162
163	return ret;
164}
165
166static void uvc_stop_streaming(struct vb2_queue *vq)
167{
168	struct uvc_video_queue *queue = vb2_get_drv_priv(vq);
169	struct uvc_streaming *stream = uvc_queue_to_stream(queue);
170	unsigned long flags;
171
172	uvc_video_enable(stream, 0);
173
174	spin_lock_irqsave(&queue->irqlock, flags);
175	uvc_queue_return_buffers(queue, UVC_BUF_STATE_ERROR);
176	spin_unlock_irqrestore(&queue->irqlock, flags);
177}
178
179static 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,
188};
189
190int uvc_queue_init(struct uvc_video_queue *queue, enum v4l2_buf_type type,
191		    int drop_corrupted)
192{
193	int ret;
194
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);
205	if (ret)
206		return ret;
207
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;
212
213	return 0;
214}
215
216void uvc_queue_release(struct uvc_video_queue *queue)
217{
218	mutex_lock(&queue->mutex);
219	vb2_queue_release(&queue->queue);
220	mutex_unlock(&queue->mutex);
221}
222
223/* -----------------------------------------------------------------------------
224 * V4L2 queue operations
225 */
226
227int uvc_request_buffers(struct uvc_video_queue *queue,
228			struct v4l2_requestbuffers *rb)
229{
230	int ret;
231
232	mutex_lock(&queue->mutex);
233	ret = vb2_reqbufs(&queue->queue, rb);
234	mutex_unlock(&queue->mutex);
235
236	return ret ? ret : rb->count;
237}
238
239int uvc_query_buffer(struct uvc_video_queue *queue, struct v4l2_buffer *buf)
240{
241	int ret;
242
243	mutex_lock(&queue->mutex);
244	ret = vb2_querybuf(&queue->queue, buf);
245	mutex_unlock(&queue->mutex);
246
247	return ret;
248}
249
250int uvc_create_buffers(struct uvc_video_queue *queue,
251		       struct v4l2_create_buffers *cb)
252{
253	int ret;
254
255	mutex_lock(&queue->mutex);
256	ret = vb2_create_bufs(&queue->queue, cb);
257	mutex_unlock(&queue->mutex);
258
259	return ret;
260}
261
262int uvc_queue_buffer(struct uvc_video_queue *queue, struct v4l2_buffer *buf)
263{
264	int ret;
265
266	mutex_lock(&queue->mutex);
267	ret = vb2_qbuf(&queue->queue, buf);
268	mutex_unlock(&queue->mutex);
269
270	return ret;
271}
272
273int uvc_dequeue_buffer(struct uvc_video_queue *queue, struct v4l2_buffer *buf,
274		       int nonblocking)
275{
276	int ret;
277
278	mutex_lock(&queue->mutex);
279	ret = vb2_dqbuf(&queue->queue, buf, nonblocking);
280	mutex_unlock(&queue->mutex);
281
282	return ret;
283}
284
285int uvc_queue_streamon(struct uvc_video_queue *queue, enum v4l2_buf_type type)
286{
287	int ret;
288
289	mutex_lock(&queue->mutex);
290	ret = vb2_streamon(&queue->queue, type);
291	mutex_unlock(&queue->mutex);
292
293	return ret;
294}
295
296int uvc_queue_streamoff(struct uvc_video_queue *queue, enum v4l2_buf_type type)
297{
298	int ret;
299
300	mutex_lock(&queue->mutex);
301	ret = vb2_streamoff(&queue->queue, type);
302	mutex_unlock(&queue->mutex);
303
304	return ret;
305}
306
307int uvc_queue_mmap(struct uvc_video_queue *queue, struct vm_area_struct *vma)
308{
309	return vb2_mmap(&queue->queue, vma);
310}
311
312#ifndef CONFIG_MMU
313unsigned long uvc_queue_get_unmapped_area(struct uvc_video_queue *queue,
314		unsigned long pgoff)
315{
316	return vb2_get_unmapped_area(&queue->queue, 0, 0, pgoff, 0);
317}
318#endif
319
320unsigned int uvc_queue_poll(struct uvc_video_queue *queue, struct file *file,
321			    poll_table *wait)
322{
323	unsigned int ret;
324
325	mutex_lock(&queue->mutex);
326	ret = vb2_poll(&queue->queue, file, wait);
327	mutex_unlock(&queue->mutex);
328
329	return ret;
330}
331
332/* -----------------------------------------------------------------------------
333 *
334 */
335
336/*
337 * Check if buffers have been allocated.
338 */
339int uvc_queue_allocated(struct uvc_video_queue *queue)
340{
341	int allocated;
342
343	mutex_lock(&queue->mutex);
344	allocated = vb2_is_busy(&queue->queue);
345	mutex_unlock(&queue->mutex);
346
347	return allocated;
348}
349
350/*
351 * Cancel the video buffers queue.
352 *
353 * Cancelling the queue marks all buffers on the irq queue as erroneous,
354 * wakes them up and removes them from the queue.
355 *
356 * If the disconnect parameter is set, further calls to uvc_queue_buffer will
357 * fail with -ENODEV.
358 *
359 * This function acquires the irq spinlock and can be called from interrupt
360 * context.
361 */
362void uvc_queue_cancel(struct uvc_video_queue *queue, int disconnect)
363{
364	unsigned long flags;
365
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.
373	 */
374	if (disconnect)
375		queue->flags |= UVC_QUEUE_DISCONNECTED;
376	spin_unlock_irqrestore(&queue->irqlock, flags);
377}
378
379struct uvc_buffer *uvc_queue_next_buffer(struct uvc_video_queue *queue,
380		struct uvc_buffer *buf)
381{
382	struct uvc_buffer *nextbuf;
383	unsigned long flags;
384
385	if ((queue->flags & UVC_QUEUE_DROP_CORRUPTED) && buf->error) {
386		buf->error = 0;
387		buf->state = UVC_BUF_STATE_QUEUED;
388		buf->bytesused = 0;
389		vb2_set_plane_payload(&buf->buf, 0, 0);
390		return buf;
391	}
392
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,
397					   queue);
398	else
399		nextbuf = NULL;
400	spin_unlock_irqrestore(&queue->irqlock, flags);
401
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);
405
406	return nextbuf;
407}
408