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
39/* -----------------------------------------------------------------------------
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[])
46{
47	struct uvc_video_queue *queue = vb2_get_drv_priv(vq);
48	struct uvc_streaming *stream =
49			container_of(queue, struct uvc_streaming, queue);
50
51	if (*nbuffers > UVC_MAX_VIDEO_BUFFERS)
52		*nbuffers = UVC_MAX_VIDEO_BUFFERS;
53
54	*nplanes = 1;
55
56	sizes[0] = stream->ctrl.dwMaxVideoFrameSize;
57
58	return 0;
59}
60
61static int uvc_buffer_prepare(struct vb2_buffer *vb)
62{
63	struct uvc_video_queue *queue = vb2_get_drv_priv(vb->vb2_queue);
64	struct uvc_buffer *buf = container_of(vb, struct uvc_buffer, buf);
65
66	if (vb->v4l2_buf.type == V4L2_BUF_TYPE_VIDEO_OUTPUT &&
67	    vb2_get_plane_payload(vb, 0) > vb2_plane_size(vb, 0)) {
68		uvc_trace(UVC_TRACE_CAPTURE, "[E] Bytes used out of bounds.\n");
69		return -EINVAL;
70	}
71
72	if (unlikely(queue->flags & UVC_QUEUE_DISCONNECTED))
73		return -ENODEV;
74
75	buf->state = UVC_BUF_STATE_QUEUED;
76	buf->error = 0;
77	buf->mem = vb2_plane_vaddr(vb, 0);
78	buf->length = vb2_plane_size(vb, 0);
79	if (vb->v4l2_buf.type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
80		buf->bytesused = 0;
81	else
82		buf->bytesused = vb2_get_plane_payload(vb, 0);
83
84	return 0;
85}
86
87static void uvc_buffer_queue(struct vb2_buffer *vb)
88{
89	struct uvc_video_queue *queue = vb2_get_drv_priv(vb->vb2_queue);
90	struct uvc_buffer *buf = container_of(vb, struct uvc_buffer, buf);
91	unsigned long flags;
92
93	spin_lock_irqsave(&queue->irqlock, flags);
94	if (likely(!(queue->flags & UVC_QUEUE_DISCONNECTED))) {
95		list_add_tail(&buf->queue, &queue->irqqueue);
96	} else {
97		/* If the device is disconnected return the buffer to userspace
98		 * directly. The next QBUF call will fail with -ENODEV.
99		 */
100		buf->state = UVC_BUF_STATE_ERROR;
101		vb2_buffer_done(&buf->buf, VB2_BUF_STATE_ERROR);
102	}
103
104	spin_unlock_irqrestore(&queue->irqlock, flags);
105}
106
107static int uvc_buffer_finish(struct vb2_buffer *vb)
108{
109	struct uvc_video_queue *queue = vb2_get_drv_priv(vb->vb2_queue);
110	struct uvc_streaming *stream =
111			container_of(queue, struct uvc_streaming, queue);
112	struct uvc_buffer *buf = container_of(vb, struct uvc_buffer, buf);
113
114	uvc_video_clock_update(stream, &vb->v4l2_buf, buf);
115	return 0;
116}
117
118static struct vb2_ops uvc_queue_qops = {
119	.queue_setup = uvc_queue_setup,
120	.buf_prepare = uvc_buffer_prepare,
121	.buf_queue = uvc_buffer_queue,
122	.buf_finish = uvc_buffer_finish,
123};
124
125void uvc_queue_init(struct uvc_video_queue *queue, enum v4l2_buf_type type,
126		    int drop_corrupted)
127{
128	queue->queue.type = type;
129	queue->queue.io_modes = VB2_MMAP | VB2_USERPTR;
130	queue->queue.drv_priv = queue;
131	queue->queue.buf_struct_size = sizeof(struct uvc_buffer);
132	queue->queue.ops = &uvc_queue_qops;
133	queue->queue.mem_ops = &vb2_vmalloc_memops;
134	vb2_queue_init(&queue->queue);
135
136	mutex_init(&queue->mutex);
137	spin_lock_init(&queue->irqlock);
138	INIT_LIST_HEAD(&queue->irqqueue);
139	queue->flags = drop_corrupted ? UVC_QUEUE_DROP_CORRUPTED : 0;
140}
141
142/* -----------------------------------------------------------------------------
143 * V4L2 queue operations
144 */
145
146int uvc_alloc_buffers(struct uvc_video_queue *queue,
147		      struct v4l2_requestbuffers *rb)
148{
149	int ret;
150
151	mutex_lock(&queue->mutex);
152	ret = vb2_reqbufs(&queue->queue, rb);
153	mutex_unlock(&queue->mutex);
154
155	return ret ? ret : rb->count;
156}
157
158void uvc_free_buffers(struct uvc_video_queue *queue)
159{
160	mutex_lock(&queue->mutex);
161	vb2_queue_release(&queue->queue);
162	mutex_unlock(&queue->mutex);
163}
164
165int uvc_query_buffer(struct uvc_video_queue *queue, struct v4l2_buffer *buf)
166{
167	int ret;
168
169	mutex_lock(&queue->mutex);
170	ret = vb2_querybuf(&queue->queue, buf);
171	mutex_unlock(&queue->mutex);
172
173	return ret;
174}
175
176int uvc_queue_buffer(struct uvc_video_queue *queue, struct v4l2_buffer *buf)
177{
178	int ret;
179
180	mutex_lock(&queue->mutex);
181	ret = vb2_qbuf(&queue->queue, buf);
182	mutex_unlock(&queue->mutex);
183
184	return ret;
185}
186
187int uvc_dequeue_buffer(struct uvc_video_queue *queue, struct v4l2_buffer *buf,
188		       int nonblocking)
189{
190	int ret;
191
192	mutex_lock(&queue->mutex);
193	ret = vb2_dqbuf(&queue->queue, buf, nonblocking);
194	mutex_unlock(&queue->mutex);
195
196	return ret;
197}
198
199int uvc_queue_mmap(struct uvc_video_queue *queue, struct vm_area_struct *vma)
200{
201	int ret;
202
203	mutex_lock(&queue->mutex);
204	ret = vb2_mmap(&queue->queue, vma);
205	mutex_unlock(&queue->mutex);
206
207	return ret;
208}
209
210unsigned int uvc_queue_poll(struct uvc_video_queue *queue, struct file *file,
211			    poll_table *wait)
212{
213	unsigned int ret;
214
215	mutex_lock(&queue->mutex);
216	ret = vb2_poll(&queue->queue, file, wait);
217	mutex_unlock(&queue->mutex);
218
219	return ret;
220}
221
222/* -----------------------------------------------------------------------------
223 *
224 */
225
226/*
227 * Check if buffers have been allocated.
228 */
229int uvc_queue_allocated(struct uvc_video_queue *queue)
230{
231	int allocated;
232
233	mutex_lock(&queue->mutex);
234	allocated = vb2_is_busy(&queue->queue);
235	mutex_unlock(&queue->mutex);
236
237	return allocated;
238}
239
240#ifndef CONFIG_MMU
241/*
242 * Get unmapped area.
243 *
244 * NO-MMU arch need this function to make mmap() work correctly.
245 */
246unsigned long uvc_queue_get_unmapped_area(struct uvc_video_queue *queue,
247		unsigned long pgoff)
248{
249	struct uvc_buffer *buffer;
250	unsigned int i;
251	unsigned long ret;
252
253	mutex_lock(&queue->mutex);
254	for (i = 0; i < queue->count; ++i) {
255		buffer = &queue->buffer[i];
256		if ((buffer->buf.m.offset >> PAGE_SHIFT) == pgoff)
257			break;
258	}
259	if (i == queue->count) {
260		ret = -EINVAL;
261		goto done;
262	}
263	ret = (unsigned long)buf->mem;
264done:
265	mutex_unlock(&queue->mutex);
266	return ret;
267}
268#endif
269
270/*
271 * Enable or disable the video buffers queue.
272 *
273 * The queue must be enabled before starting video acquisition and must be
274 * disabled after stopping it. This ensures that the video buffers queue
275 * state can be properly initialized before buffers are accessed from the
276 * interrupt handler.
277 *
278 * Enabling the video queue returns -EBUSY if the queue is already enabled.
279 *
280 * Disabling the video queue cancels the queue and removes all buffers from
281 * the main queue.
282 *
283 * This function can't be called from interrupt context. Use
284 * uvc_queue_cancel() instead.
285 */
286int uvc_queue_enable(struct uvc_video_queue *queue, int enable)
287{
288	unsigned long flags;
289	int ret;
290
291	mutex_lock(&queue->mutex);
292	if (enable) {
293		ret = vb2_streamon(&queue->queue, queue->queue.type);
294		if (ret < 0)
295			goto done;
296
297		queue->buf_used = 0;
298	} else {
299		ret = vb2_streamoff(&queue->queue, queue->queue.type);
300		if (ret < 0)
301			goto done;
302
303		spin_lock_irqsave(&queue->irqlock, flags);
304		INIT_LIST_HEAD(&queue->irqqueue);
305		spin_unlock_irqrestore(&queue->irqlock, flags);
306	}
307
308done:
309	mutex_unlock(&queue->mutex);
310	return ret;
311}
312
313/*
314 * Cancel the video buffers queue.
315 *
316 * Cancelling the queue marks all buffers on the irq queue as erroneous,
317 * wakes them up and removes them from the queue.
318 *
319 * If the disconnect parameter is set, further calls to uvc_queue_buffer will
320 * fail with -ENODEV.
321 *
322 * This function acquires the irq spinlock and can be called from interrupt
323 * context.
324 */
325void uvc_queue_cancel(struct uvc_video_queue *queue, int disconnect)
326{
327	struct uvc_buffer *buf;
328	unsigned long flags;
329
330	spin_lock_irqsave(&queue->irqlock, flags);
331	while (!list_empty(&queue->irqqueue)) {
332		buf = list_first_entry(&queue->irqqueue, struct uvc_buffer,
333				       queue);
334		list_del(&buf->queue);
335		buf->state = UVC_BUF_STATE_ERROR;
336		vb2_buffer_done(&buf->buf, VB2_BUF_STATE_ERROR);
337	}
338	/* This must be protected by the irqlock spinlock to avoid race
339	 * conditions between uvc_buffer_queue and the disconnection event that
340	 * could result in an interruptible wait in uvc_dequeue_buffer. Do not
341	 * blindly replace this logic by checking for the UVC_QUEUE_DISCONNECTED
342	 * state outside the queue code.
343	 */
344	if (disconnect)
345		queue->flags |= UVC_QUEUE_DISCONNECTED;
346	spin_unlock_irqrestore(&queue->irqlock, flags);
347}
348
349struct uvc_buffer *uvc_queue_next_buffer(struct uvc_video_queue *queue,
350		struct uvc_buffer *buf)
351{
352	struct uvc_buffer *nextbuf;
353	unsigned long flags;
354
355	if ((queue->flags & UVC_QUEUE_DROP_CORRUPTED) && buf->error) {
356		buf->error = 0;
357		buf->state = UVC_BUF_STATE_QUEUED;
358		vb2_set_plane_payload(&buf->buf, 0, 0);
359		return buf;
360	}
361
362	spin_lock_irqsave(&queue->irqlock, flags);
363	list_del(&buf->queue);
364	if (!list_empty(&queue->irqqueue))
365		nextbuf = list_first_entry(&queue->irqqueue, struct uvc_buffer,
366					   queue);
367	else
368		nextbuf = NULL;
369	spin_unlock_irqrestore(&queue->irqlock, flags);
370
371	buf->state = buf->error ? VB2_BUF_STATE_ERROR : UVC_BUF_STATE_DONE;
372	vb2_set_plane_payload(&buf->buf, 0, buf->bytesused);
373	vb2_buffer_done(&buf->buf, VB2_BUF_STATE_DONE);
374
375	return nextbuf;
376}
377