1 /*
2  * videobuf2-v4l2.c - V4L2 driver helper framework
3  *
4  * Copyright (C) 2010 Samsung Electronics
5  *
6  * Author: Pawel Osciak <pawel@osciak.com>
7  *	   Marek Szyprowski <m.szyprowski@samsung.com>
8  *
9  * The vb2_thread implementation was based on code from videobuf-dvb.c:
10  *	(c) 2004 Gerd Knorr <kraxel@bytesex.org> [SUSE Labs]
11  *
12  * This program is free software; you can redistribute it and/or modify
13  * it under the terms of the GNU General Public License as published by
14  * the Free Software Foundation.
15  */
16 
17 #include <linux/err.h>
18 #include <linux/kernel.h>
19 #include <linux/module.h>
20 #include <linux/mm.h>
21 #include <linux/poll.h>
22 #include <linux/slab.h>
23 #include <linux/sched.h>
24 #include <linux/freezer.h>
25 #include <linux/kthread.h>
26 
27 #include <media/v4l2-dev.h>
28 #include <media/v4l2-device.h>
29 #include <media/v4l2-fh.h>
30 #include <media/v4l2-event.h>
31 #include <media/v4l2-common.h>
32 
33 #include <media/videobuf2-v4l2.h>
34 
35 static int debug;
36 module_param(debug, int, 0644);
37 
38 #define dprintk(level, fmt, arg...)					      \
39 	do {								      \
40 		if (debug >= level)					      \
41 			pr_info("vb2-v4l2: %s: " fmt, __func__, ## arg); \
42 	} while (0)
43 
44 /* Flags that are set by us */
45 #define V4L2_BUFFER_MASK_FLAGS	(V4L2_BUF_FLAG_MAPPED | V4L2_BUF_FLAG_QUEUED | \
46 				 V4L2_BUF_FLAG_DONE | V4L2_BUF_FLAG_ERROR | \
47 				 V4L2_BUF_FLAG_PREPARED | \
48 				 V4L2_BUF_FLAG_IN_REQUEST | \
49 				 V4L2_BUF_FLAG_REQUEST_FD | \
50 				 V4L2_BUF_FLAG_TIMESTAMP_MASK)
51 /* Output buffer flags that should be passed on to the driver */
52 #define V4L2_BUFFER_OUT_FLAGS	(V4L2_BUF_FLAG_PFRAME | V4L2_BUF_FLAG_BFRAME | \
53 				 V4L2_BUF_FLAG_KEYFRAME | V4L2_BUF_FLAG_TIMECODE)
54 
55 /*
56  * __verify_planes_array() - verify that the planes array passed in struct
57  * v4l2_buffer from userspace can be safely used
58  */
59 static int __verify_planes_array(struct vb2_buffer *vb, const struct v4l2_buffer *b)
60 {
61 	if (!V4L2_TYPE_IS_MULTIPLANAR(b->type))
62 		return 0;
63 
64 	/* Is memory for copying plane information present? */
65 	if (b->m.planes == NULL) {
66 		dprintk(1, "multi-planar buffer passed but planes array not provided\n");
67 		return -EINVAL;
68 	}
69 
70 	if (b->length < vb->num_planes || b->length > VB2_MAX_PLANES) {
71 		dprintk(1, "incorrect planes array length, expected %d, got %d\n",
72 			vb->num_planes, b->length);
73 		return -EINVAL;
74 	}
75 
76 	return 0;
77 }
78 
79 static int __verify_planes_array_core(struct vb2_buffer *vb, const void *pb)
80 {
81 	return __verify_planes_array(vb, pb);
82 }
83 
84 /*
85  * __verify_length() - Verify that the bytesused value for each plane fits in
86  * the plane length and that the data offset doesn't exceed the bytesused value.
87  */
88 static int __verify_length(struct vb2_buffer *vb, const struct v4l2_buffer *b)
89 {
90 	unsigned int length;
91 	unsigned int bytesused;
92 	unsigned int plane;
93 
94 	if (!V4L2_TYPE_IS_OUTPUT(b->type))
95 		return 0;
96 
97 	if (V4L2_TYPE_IS_MULTIPLANAR(b->type)) {
98 		for (plane = 0; plane < vb->num_planes; ++plane) {
99 			length = (b->memory == VB2_MEMORY_USERPTR ||
100 				  b->memory == VB2_MEMORY_DMABUF)
101 			       ? b->m.planes[plane].length
102 				: vb->planes[plane].length;
103 			bytesused = b->m.planes[plane].bytesused
104 				  ? b->m.planes[plane].bytesused : length;
105 
106 			if (b->m.planes[plane].bytesused > length)
107 				return -EINVAL;
108 
109 			if (b->m.planes[plane].data_offset > 0 &&
110 			    b->m.planes[plane].data_offset >= bytesused)
111 				return -EINVAL;
112 		}
113 	} else {
114 		length = (b->memory == VB2_MEMORY_USERPTR)
115 			? b->length : vb->planes[0].length;
116 
117 		if (b->bytesused > length)
118 			return -EINVAL;
119 	}
120 
121 	return 0;
122 }
123 
124 /*
125  * __init_v4l2_vb2_buffer() - initialize the v4l2_vb2_buffer struct
126  */
127 static void __init_v4l2_vb2_buffer(struct vb2_buffer *vb)
128 {
129 	struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
130 
131 	vbuf->request_fd = -1;
132 }
133 
134 static void __copy_timestamp(struct vb2_buffer *vb, const void *pb)
135 {
136 	const struct v4l2_buffer *b = pb;
137 	struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
138 	struct vb2_queue *q = vb->vb2_queue;
139 
140 	if (q->is_output) {
141 		/*
142 		 * For output buffers copy the timestamp if needed,
143 		 * and the timecode field and flag if needed.
144 		 */
145 		if (q->copy_timestamp)
146 			vb->timestamp = timeval_to_ns(&b->timestamp);
147 		vbuf->flags |= b->flags & V4L2_BUF_FLAG_TIMECODE;
148 		if (b->flags & V4L2_BUF_FLAG_TIMECODE)
149 			vbuf->timecode = b->timecode;
150 	}
151 };
152 
153 static void vb2_warn_zero_bytesused(struct vb2_buffer *vb)
154 {
155 	static bool check_once;
156 
157 	if (check_once)
158 		return;
159 
160 	check_once = true;
161 
162 	pr_warn("use of bytesused == 0 is deprecated and will be removed in the future,\n");
163 	if (vb->vb2_queue->allow_zero_bytesused)
164 		pr_warn("use VIDIOC_DECODER_CMD(V4L2_DEC_CMD_STOP) instead.\n");
165 	else
166 		pr_warn("use the actual size instead.\n");
167 }
168 
169 static int vb2_fill_vb2_v4l2_buffer(struct vb2_buffer *vb, struct v4l2_buffer *b)
170 {
171 	struct vb2_queue *q = vb->vb2_queue;
172 	struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
173 	struct vb2_plane *planes = vbuf->planes;
174 	unsigned int plane;
175 	int ret;
176 
177 	ret = __verify_length(vb, b);
178 	if (ret < 0) {
179 		dprintk(1, "plane parameters verification failed: %d\n", ret);
180 		return ret;
181 	}
182 	if (b->field == V4L2_FIELD_ALTERNATE && q->is_output) {
183 		/*
184 		 * If the format's field is ALTERNATE, then the buffer's field
185 		 * should be either TOP or BOTTOM, not ALTERNATE since that
186 		 * makes no sense. The driver has to know whether the
187 		 * buffer represents a top or a bottom field in order to
188 		 * program any DMA correctly. Using ALTERNATE is wrong, since
189 		 * that just says that it is either a top or a bottom field,
190 		 * but not which of the two it is.
191 		 */
192 		dprintk(1, "the field is incorrectly set to ALTERNATE for an output buffer\n");
193 		return -EINVAL;
194 	}
195 	vbuf->sequence = 0;
196 	vbuf->request_fd = -1;
197 
198 	if (V4L2_TYPE_IS_MULTIPLANAR(b->type)) {
199 		switch (b->memory) {
200 		case VB2_MEMORY_USERPTR:
201 			for (plane = 0; plane < vb->num_planes; ++plane) {
202 				planes[plane].m.userptr =
203 					b->m.planes[plane].m.userptr;
204 				planes[plane].length =
205 					b->m.planes[plane].length;
206 			}
207 			break;
208 		case VB2_MEMORY_DMABUF:
209 			for (plane = 0; plane < vb->num_planes; ++plane) {
210 				planes[plane].m.fd =
211 					b->m.planes[plane].m.fd;
212 				planes[plane].length =
213 					b->m.planes[plane].length;
214 			}
215 			break;
216 		default:
217 			for (plane = 0; plane < vb->num_planes; ++plane) {
218 				planes[plane].m.offset =
219 					vb->planes[plane].m.offset;
220 				planes[plane].length =
221 					vb->planes[plane].length;
222 			}
223 			break;
224 		}
225 
226 		/* Fill in driver-provided information for OUTPUT types */
227 		if (V4L2_TYPE_IS_OUTPUT(b->type)) {
228 			/*
229 			 * Will have to go up to b->length when API starts
230 			 * accepting variable number of planes.
231 			 *
232 			 * If bytesused == 0 for the output buffer, then fall
233 			 * back to the full buffer size. In that case
234 			 * userspace clearly never bothered to set it and
235 			 * it's a safe assumption that they really meant to
236 			 * use the full plane sizes.
237 			 *
238 			 * Some drivers, e.g. old codec drivers, use bytesused == 0
239 			 * as a way to indicate that streaming is finished.
240 			 * In that case, the driver should use the
241 			 * allow_zero_bytesused flag to keep old userspace
242 			 * applications working.
243 			 */
244 			for (plane = 0; plane < vb->num_planes; ++plane) {
245 				struct vb2_plane *pdst = &planes[plane];
246 				struct v4l2_plane *psrc = &b->m.planes[plane];
247 
248 				if (psrc->bytesused == 0)
249 					vb2_warn_zero_bytesused(vb);
250 
251 				if (vb->vb2_queue->allow_zero_bytesused)
252 					pdst->bytesused = psrc->bytesused;
253 				else
254 					pdst->bytesused = psrc->bytesused ?
255 						psrc->bytesused : pdst->length;
256 				pdst->data_offset = psrc->data_offset;
257 			}
258 		}
259 	} else {
260 		/*
261 		 * Single-planar buffers do not use planes array,
262 		 * so fill in relevant v4l2_buffer struct fields instead.
263 		 * In videobuf we use our internal V4l2_planes struct for
264 		 * single-planar buffers as well, for simplicity.
265 		 *
266 		 * If bytesused == 0 for the output buffer, then fall back
267 		 * to the full buffer size as that's a sensible default.
268 		 *
269 		 * Some drivers, e.g. old codec drivers, use bytesused == 0 as
270 		 * a way to indicate that streaming is finished. In that case,
271 		 * the driver should use the allow_zero_bytesused flag to keep
272 		 * old userspace applications working.
273 		 */
274 		switch (b->memory) {
275 		case VB2_MEMORY_USERPTR:
276 			planes[0].m.userptr = b->m.userptr;
277 			planes[0].length = b->length;
278 			break;
279 		case VB2_MEMORY_DMABUF:
280 			planes[0].m.fd = b->m.fd;
281 			planes[0].length = b->length;
282 			break;
283 		default:
284 			planes[0].m.offset = vb->planes[0].m.offset;
285 			planes[0].length = vb->planes[0].length;
286 			break;
287 		}
288 
289 		planes[0].data_offset = 0;
290 		if (V4L2_TYPE_IS_OUTPUT(b->type)) {
291 			if (b->bytesused == 0)
292 				vb2_warn_zero_bytesused(vb);
293 
294 			if (vb->vb2_queue->allow_zero_bytesused)
295 				planes[0].bytesused = b->bytesused;
296 			else
297 				planes[0].bytesused = b->bytesused ?
298 					b->bytesused : planes[0].length;
299 		} else
300 			planes[0].bytesused = 0;
301 
302 	}
303 
304 	/* Zero flags that we handle */
305 	vbuf->flags = b->flags & ~V4L2_BUFFER_MASK_FLAGS;
306 	if (!vb->vb2_queue->copy_timestamp || !V4L2_TYPE_IS_OUTPUT(b->type)) {
307 		/*
308 		 * Non-COPY timestamps and non-OUTPUT queues will get
309 		 * their timestamp and timestamp source flags from the
310 		 * queue.
311 		 */
312 		vbuf->flags &= ~V4L2_BUF_FLAG_TSTAMP_SRC_MASK;
313 	}
314 
315 	if (V4L2_TYPE_IS_OUTPUT(b->type)) {
316 		/*
317 		 * For output buffers mask out the timecode flag:
318 		 * this will be handled later in vb2_qbuf().
319 		 * The 'field' is valid metadata for this output buffer
320 		 * and so that needs to be copied here.
321 		 */
322 		vbuf->flags &= ~V4L2_BUF_FLAG_TIMECODE;
323 		vbuf->field = b->field;
324 	} else {
325 		/* Zero any output buffer flags as this is a capture buffer */
326 		vbuf->flags &= ~V4L2_BUFFER_OUT_FLAGS;
327 		/* Zero last flag, this is a signal from driver to userspace */
328 		vbuf->flags &= ~V4L2_BUF_FLAG_LAST;
329 	}
330 
331 	return 0;
332 }
333 
334 static int vb2_queue_or_prepare_buf(struct vb2_queue *q, struct media_device *mdev,
335 				    struct v4l2_buffer *b, bool is_prepare,
336 				    struct media_request **p_req)
337 {
338 	const char *opname = is_prepare ? "prepare_buf" : "qbuf";
339 	struct media_request *req;
340 	struct vb2_v4l2_buffer *vbuf;
341 	struct vb2_buffer *vb;
342 	int ret;
343 
344 	if (b->type != q->type) {
345 		dprintk(1, "%s: invalid buffer type\n", opname);
346 		return -EINVAL;
347 	}
348 
349 	if (b->index >= q->num_buffers) {
350 		dprintk(1, "%s: buffer index out of range\n", opname);
351 		return -EINVAL;
352 	}
353 
354 	if (q->bufs[b->index] == NULL) {
355 		/* Should never happen */
356 		dprintk(1, "%s: buffer is NULL\n", opname);
357 		return -EINVAL;
358 	}
359 
360 	if (b->memory != q->memory) {
361 		dprintk(1, "%s: invalid memory type\n", opname);
362 		return -EINVAL;
363 	}
364 
365 	vb = q->bufs[b->index];
366 	vbuf = to_vb2_v4l2_buffer(vb);
367 	ret = __verify_planes_array(vb, b);
368 	if (ret)
369 		return ret;
370 
371 	if (!vb->prepared) {
372 		/* Copy relevant information provided by the userspace */
373 		memset(vbuf->planes, 0,
374 		       sizeof(vbuf->planes[0]) * vb->num_planes);
375 		ret = vb2_fill_vb2_v4l2_buffer(vb, b);
376 		if (ret)
377 			return ret;
378 	}
379 
380 	if (is_prepare)
381 		return 0;
382 
383 	if (!(b->flags & V4L2_BUF_FLAG_REQUEST_FD)) {
384 		if (q->uses_requests) {
385 			dprintk(1, "%s: queue uses requests\n", opname);
386 			return -EBUSY;
387 		}
388 		return 0;
389 	} else if (!q->supports_requests) {
390 		dprintk(1, "%s: queue does not support requests\n", opname);
391 		return -EACCES;
392 	} else if (q->uses_qbuf) {
393 		dprintk(1, "%s: queue does not use requests\n", opname);
394 		return -EBUSY;
395 	}
396 
397 	/*
398 	 * For proper locking when queueing a request you need to be able
399 	 * to lock access to the vb2 queue, so check that there is a lock
400 	 * that we can use. In addition p_req must be non-NULL.
401 	 */
402 	if (WARN_ON(!q->lock || !p_req))
403 		return -EINVAL;
404 
405 	/*
406 	 * Make sure this op is implemented by the driver. It's easy to forget
407 	 * this callback, but is it important when canceling a buffer in a
408 	 * queued request.
409 	 */
410 	if (WARN_ON(!q->ops->buf_request_complete))
411 		return -EINVAL;
412 
413 	if (vb->state != VB2_BUF_STATE_DEQUEUED) {
414 		dprintk(1, "%s: buffer is not in dequeued state\n", opname);
415 		return -EINVAL;
416 	}
417 
418 	if (b->request_fd < 0) {
419 		dprintk(1, "%s: request_fd < 0\n", opname);
420 		return -EINVAL;
421 	}
422 
423 	req = media_request_get_by_fd(mdev, b->request_fd);
424 	if (IS_ERR(req)) {
425 		dprintk(1, "%s: invalid request_fd\n", opname);
426 		return PTR_ERR(req);
427 	}
428 
429 	/*
430 	 * Early sanity check. This is checked again when the buffer
431 	 * is bound to the request in vb2_core_qbuf().
432 	 */
433 	if (req->state != MEDIA_REQUEST_STATE_IDLE &&
434 	    req->state != MEDIA_REQUEST_STATE_UPDATING) {
435 		dprintk(1, "%s: request is not idle\n", opname);
436 		media_request_put(req);
437 		return -EBUSY;
438 	}
439 
440 	*p_req = req;
441 	vbuf->request_fd = b->request_fd;
442 
443 	return 0;
444 }
445 
446 /*
447  * __fill_v4l2_buffer() - fill in a struct v4l2_buffer with information to be
448  * returned to userspace
449  */
450 static void __fill_v4l2_buffer(struct vb2_buffer *vb, void *pb)
451 {
452 	struct v4l2_buffer *b = pb;
453 	struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
454 	struct vb2_queue *q = vb->vb2_queue;
455 	unsigned int plane;
456 
457 	/* Copy back data such as timestamp, flags, etc. */
458 	b->index = vb->index;
459 	b->type = vb->type;
460 	b->memory = vb->memory;
461 	b->bytesused = 0;
462 
463 	b->flags = vbuf->flags;
464 	b->field = vbuf->field;
465 	b->timestamp = ns_to_timeval(vb->timestamp);
466 	b->timecode = vbuf->timecode;
467 	b->sequence = vbuf->sequence;
468 	b->reserved2 = 0;
469 	b->request_fd = 0;
470 
471 	if (q->is_multiplanar) {
472 		/*
473 		 * Fill in plane-related data if userspace provided an array
474 		 * for it. The caller has already verified memory and size.
475 		 */
476 		b->length = vb->num_planes;
477 		for (plane = 0; plane < vb->num_planes; ++plane) {
478 			struct v4l2_plane *pdst = &b->m.planes[plane];
479 			struct vb2_plane *psrc = &vb->planes[plane];
480 
481 			pdst->bytesused = psrc->bytesused;
482 			pdst->length = psrc->length;
483 			if (q->memory == VB2_MEMORY_MMAP)
484 				pdst->m.mem_offset = psrc->m.offset;
485 			else if (q->memory == VB2_MEMORY_USERPTR)
486 				pdst->m.userptr = psrc->m.userptr;
487 			else if (q->memory == VB2_MEMORY_DMABUF)
488 				pdst->m.fd = psrc->m.fd;
489 			pdst->data_offset = psrc->data_offset;
490 			memset(pdst->reserved, 0, sizeof(pdst->reserved));
491 		}
492 	} else {
493 		/*
494 		 * We use length and offset in v4l2_planes array even for
495 		 * single-planar buffers, but userspace does not.
496 		 */
497 		b->length = vb->planes[0].length;
498 		b->bytesused = vb->planes[0].bytesused;
499 		if (q->memory == VB2_MEMORY_MMAP)
500 			b->m.offset = vb->planes[0].m.offset;
501 		else if (q->memory == VB2_MEMORY_USERPTR)
502 			b->m.userptr = vb->planes[0].m.userptr;
503 		else if (q->memory == VB2_MEMORY_DMABUF)
504 			b->m.fd = vb->planes[0].m.fd;
505 	}
506 
507 	/*
508 	 * Clear any buffer state related flags.
509 	 */
510 	b->flags &= ~V4L2_BUFFER_MASK_FLAGS;
511 	b->flags |= q->timestamp_flags & V4L2_BUF_FLAG_TIMESTAMP_MASK;
512 	if (!q->copy_timestamp) {
513 		/*
514 		 * For non-COPY timestamps, drop timestamp source bits
515 		 * and obtain the timestamp source from the queue.
516 		 */
517 		b->flags &= ~V4L2_BUF_FLAG_TSTAMP_SRC_MASK;
518 		b->flags |= q->timestamp_flags & V4L2_BUF_FLAG_TSTAMP_SRC_MASK;
519 	}
520 
521 	switch (vb->state) {
522 	case VB2_BUF_STATE_QUEUED:
523 	case VB2_BUF_STATE_ACTIVE:
524 		b->flags |= V4L2_BUF_FLAG_QUEUED;
525 		break;
526 	case VB2_BUF_STATE_IN_REQUEST:
527 		b->flags |= V4L2_BUF_FLAG_IN_REQUEST;
528 		break;
529 	case VB2_BUF_STATE_ERROR:
530 		b->flags |= V4L2_BUF_FLAG_ERROR;
531 		/* fall through */
532 	case VB2_BUF_STATE_DONE:
533 		b->flags |= V4L2_BUF_FLAG_DONE;
534 		break;
535 	case VB2_BUF_STATE_PREPARING:
536 	case VB2_BUF_STATE_DEQUEUED:
537 	case VB2_BUF_STATE_REQUEUEING:
538 		/* nothing */
539 		break;
540 	}
541 
542 	if ((vb->state == VB2_BUF_STATE_DEQUEUED ||
543 	     vb->state == VB2_BUF_STATE_IN_REQUEST) &&
544 	    vb->synced && vb->prepared)
545 		b->flags |= V4L2_BUF_FLAG_PREPARED;
546 
547 	if (vb2_buffer_in_use(q, vb))
548 		b->flags |= V4L2_BUF_FLAG_MAPPED;
549 	if (vbuf->request_fd >= 0) {
550 		b->flags |= V4L2_BUF_FLAG_REQUEST_FD;
551 		b->request_fd = vbuf->request_fd;
552 	}
553 
554 	if (!q->is_output &&
555 		b->flags & V4L2_BUF_FLAG_DONE &&
556 		b->flags & V4L2_BUF_FLAG_LAST)
557 		q->last_buffer_dequeued = true;
558 }
559 
560 /*
561  * __fill_vb2_buffer() - fill a vb2_buffer with information provided in a
562  * v4l2_buffer by the userspace. It also verifies that struct
563  * v4l2_buffer has a valid number of planes.
564  */
565 static int __fill_vb2_buffer(struct vb2_buffer *vb, struct vb2_plane *planes)
566 {
567 	struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
568 	unsigned int plane;
569 
570 	if (!vb->vb2_queue->is_output || !vb->vb2_queue->copy_timestamp)
571 		vb->timestamp = 0;
572 
573 	for (plane = 0; plane < vb->num_planes; ++plane) {
574 		if (vb->vb2_queue->memory != VB2_MEMORY_MMAP) {
575 			planes[plane].m = vbuf->planes[plane].m;
576 			planes[plane].length = vbuf->planes[plane].length;
577 		}
578 		planes[plane].bytesused = vbuf->planes[plane].bytesused;
579 		planes[plane].data_offset = vbuf->planes[plane].data_offset;
580 	}
581 	return 0;
582 }
583 
584 static const struct vb2_buf_ops v4l2_buf_ops = {
585 	.verify_planes_array	= __verify_planes_array_core,
586 	.init_buffer		= __init_v4l2_vb2_buffer,
587 	.fill_user_buffer	= __fill_v4l2_buffer,
588 	.fill_vb2_buffer	= __fill_vb2_buffer,
589 	.copy_timestamp		= __copy_timestamp,
590 };
591 
592 /*
593  * vb2_querybuf() - query video buffer information
594  * @q:		videobuf queue
595  * @b:		buffer struct passed from userspace to vidioc_querybuf handler
596  *		in driver
597  *
598  * Should be called from vidioc_querybuf ioctl handler in driver.
599  * This function will verify the passed v4l2_buffer structure and fill the
600  * relevant information for the userspace.
601  *
602  * The return values from this function are intended to be directly returned
603  * from vidioc_querybuf handler in driver.
604  */
605 int vb2_querybuf(struct vb2_queue *q, struct v4l2_buffer *b)
606 {
607 	struct vb2_buffer *vb;
608 	int ret;
609 
610 	if (b->type != q->type) {
611 		dprintk(1, "wrong buffer type\n");
612 		return -EINVAL;
613 	}
614 
615 	if (b->index >= q->num_buffers) {
616 		dprintk(1, "buffer index out of range\n");
617 		return -EINVAL;
618 	}
619 	vb = q->bufs[b->index];
620 	ret = __verify_planes_array(vb, b);
621 	if (!ret)
622 		vb2_core_querybuf(q, b->index, b);
623 	return ret;
624 }
625 EXPORT_SYMBOL(vb2_querybuf);
626 
627 static void fill_buf_caps(struct vb2_queue *q, u32 *caps)
628 {
629 	*caps = V4L2_BUF_CAP_SUPPORTS_ORPHANED_BUFS;
630 	if (q->io_modes & VB2_MMAP)
631 		*caps |= V4L2_BUF_CAP_SUPPORTS_MMAP;
632 	if (q->io_modes & VB2_USERPTR)
633 		*caps |= V4L2_BUF_CAP_SUPPORTS_USERPTR;
634 	if (q->io_modes & VB2_DMABUF)
635 		*caps |= V4L2_BUF_CAP_SUPPORTS_DMABUF;
636 #ifdef CONFIG_MEDIA_CONTROLLER_REQUEST_API
637 	if (q->supports_requests)
638 		*caps |= V4L2_BUF_CAP_SUPPORTS_REQUESTS;
639 #endif
640 }
641 
642 int vb2_reqbufs(struct vb2_queue *q, struct v4l2_requestbuffers *req)
643 {
644 	int ret = vb2_verify_memory_type(q, req->memory, req->type);
645 
646 	fill_buf_caps(q, &req->capabilities);
647 	return ret ? ret : vb2_core_reqbufs(q, req->memory, &req->count);
648 }
649 EXPORT_SYMBOL_GPL(vb2_reqbufs);
650 
651 int vb2_prepare_buf(struct vb2_queue *q, struct media_device *mdev,
652 		    struct v4l2_buffer *b)
653 {
654 	int ret;
655 
656 	if (vb2_fileio_is_active(q)) {
657 		dprintk(1, "file io in progress\n");
658 		return -EBUSY;
659 	}
660 
661 	if (b->flags & V4L2_BUF_FLAG_REQUEST_FD)
662 		return -EINVAL;
663 
664 	ret = vb2_queue_or_prepare_buf(q, mdev, b, true, NULL);
665 
666 	return ret ? ret : vb2_core_prepare_buf(q, b->index, b);
667 }
668 EXPORT_SYMBOL_GPL(vb2_prepare_buf);
669 
670 int vb2_create_bufs(struct vb2_queue *q, struct v4l2_create_buffers *create)
671 {
672 	unsigned requested_planes = 1;
673 	unsigned requested_sizes[VIDEO_MAX_PLANES];
674 	struct v4l2_format *f = &create->format;
675 	int ret = vb2_verify_memory_type(q, create->memory, f->type);
676 	unsigned i;
677 
678 	fill_buf_caps(q, &create->capabilities);
679 	create->index = q->num_buffers;
680 	if (create->count == 0)
681 		return ret != -EBUSY ? ret : 0;
682 
683 	switch (f->type) {
684 	case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE:
685 	case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
686 		requested_planes = f->fmt.pix_mp.num_planes;
687 		if (requested_planes == 0 ||
688 		    requested_planes > VIDEO_MAX_PLANES)
689 			return -EINVAL;
690 		for (i = 0; i < requested_planes; i++)
691 			requested_sizes[i] =
692 				f->fmt.pix_mp.plane_fmt[i].sizeimage;
693 		break;
694 	case V4L2_BUF_TYPE_VIDEO_CAPTURE:
695 	case V4L2_BUF_TYPE_VIDEO_OUTPUT:
696 		requested_sizes[0] = f->fmt.pix.sizeimage;
697 		break;
698 	case V4L2_BUF_TYPE_VBI_CAPTURE:
699 	case V4L2_BUF_TYPE_VBI_OUTPUT:
700 		requested_sizes[0] = f->fmt.vbi.samples_per_line *
701 			(f->fmt.vbi.count[0] + f->fmt.vbi.count[1]);
702 		break;
703 	case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
704 	case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
705 		requested_sizes[0] = f->fmt.sliced.io_size;
706 		break;
707 	case V4L2_BUF_TYPE_SDR_CAPTURE:
708 	case V4L2_BUF_TYPE_SDR_OUTPUT:
709 		requested_sizes[0] = f->fmt.sdr.buffersize;
710 		break;
711 	case V4L2_BUF_TYPE_META_CAPTURE:
712 	case V4L2_BUF_TYPE_META_OUTPUT:
713 		requested_sizes[0] = f->fmt.meta.buffersize;
714 		break;
715 	default:
716 		return -EINVAL;
717 	}
718 	for (i = 0; i < requested_planes; i++)
719 		if (requested_sizes[i] == 0)
720 			return -EINVAL;
721 	return ret ? ret : vb2_core_create_bufs(q, create->memory,
722 		&create->count, requested_planes, requested_sizes);
723 }
724 EXPORT_SYMBOL_GPL(vb2_create_bufs);
725 
726 int vb2_qbuf(struct vb2_queue *q, struct media_device *mdev,
727 	     struct v4l2_buffer *b)
728 {
729 	struct media_request *req = NULL;
730 	int ret;
731 
732 	if (vb2_fileio_is_active(q)) {
733 		dprintk(1, "file io in progress\n");
734 		return -EBUSY;
735 	}
736 
737 	ret = vb2_queue_or_prepare_buf(q, mdev, b, false, &req);
738 	if (ret)
739 		return ret;
740 	ret = vb2_core_qbuf(q, b->index, b, req);
741 	if (req)
742 		media_request_put(req);
743 	return ret;
744 }
745 EXPORT_SYMBOL_GPL(vb2_qbuf);
746 
747 int vb2_dqbuf(struct vb2_queue *q, struct v4l2_buffer *b, bool nonblocking)
748 {
749 	int ret;
750 
751 	if (vb2_fileio_is_active(q)) {
752 		dprintk(1, "file io in progress\n");
753 		return -EBUSY;
754 	}
755 
756 	if (b->type != q->type) {
757 		dprintk(1, "invalid buffer type\n");
758 		return -EINVAL;
759 	}
760 
761 	ret = vb2_core_dqbuf(q, NULL, b, nonblocking);
762 
763 	/*
764 	 *  After calling the VIDIOC_DQBUF V4L2_BUF_FLAG_DONE must be
765 	 *  cleared.
766 	 */
767 	b->flags &= ~V4L2_BUF_FLAG_DONE;
768 
769 	return ret;
770 }
771 EXPORT_SYMBOL_GPL(vb2_dqbuf);
772 
773 int vb2_streamon(struct vb2_queue *q, enum v4l2_buf_type type)
774 {
775 	if (vb2_fileio_is_active(q)) {
776 		dprintk(1, "file io in progress\n");
777 		return -EBUSY;
778 	}
779 	return vb2_core_streamon(q, type);
780 }
781 EXPORT_SYMBOL_GPL(vb2_streamon);
782 
783 int vb2_streamoff(struct vb2_queue *q, enum v4l2_buf_type type)
784 {
785 	if (vb2_fileio_is_active(q)) {
786 		dprintk(1, "file io in progress\n");
787 		return -EBUSY;
788 	}
789 	return vb2_core_streamoff(q, type);
790 }
791 EXPORT_SYMBOL_GPL(vb2_streamoff);
792 
793 int vb2_expbuf(struct vb2_queue *q, struct v4l2_exportbuffer *eb)
794 {
795 	return vb2_core_expbuf(q, &eb->fd, eb->type, eb->index,
796 				eb->plane, eb->flags);
797 }
798 EXPORT_SYMBOL_GPL(vb2_expbuf);
799 
800 int vb2_queue_init(struct vb2_queue *q)
801 {
802 	/*
803 	 * Sanity check
804 	 */
805 	if (WARN_ON(!q)			  ||
806 	    WARN_ON(q->timestamp_flags &
807 		    ~(V4L2_BUF_FLAG_TIMESTAMP_MASK |
808 		      V4L2_BUF_FLAG_TSTAMP_SRC_MASK)))
809 		return -EINVAL;
810 
811 	/* Warn that the driver should choose an appropriate timestamp type */
812 	WARN_ON((q->timestamp_flags & V4L2_BUF_FLAG_TIMESTAMP_MASK) ==
813 		V4L2_BUF_FLAG_TIMESTAMP_UNKNOWN);
814 
815 	/* Warn that vb2_memory should match with v4l2_memory */
816 	if (WARN_ON(VB2_MEMORY_MMAP != (int)V4L2_MEMORY_MMAP)
817 		|| WARN_ON(VB2_MEMORY_USERPTR != (int)V4L2_MEMORY_USERPTR)
818 		|| WARN_ON(VB2_MEMORY_DMABUF != (int)V4L2_MEMORY_DMABUF))
819 		return -EINVAL;
820 
821 	if (q->buf_struct_size == 0)
822 		q->buf_struct_size = sizeof(struct vb2_v4l2_buffer);
823 
824 	q->buf_ops = &v4l2_buf_ops;
825 	q->is_multiplanar = V4L2_TYPE_IS_MULTIPLANAR(q->type);
826 	q->is_output = V4L2_TYPE_IS_OUTPUT(q->type);
827 	q->copy_timestamp = (q->timestamp_flags & V4L2_BUF_FLAG_TIMESTAMP_MASK)
828 			== V4L2_BUF_FLAG_TIMESTAMP_COPY;
829 	/*
830 	 * For compatibility with vb1: if QBUF hasn't been called yet, then
831 	 * return EPOLLERR as well. This only affects capture queues, output
832 	 * queues will always initialize waiting_for_buffers to false.
833 	 */
834 	q->quirk_poll_must_check_waiting_for_buffers = true;
835 
836 	return vb2_core_queue_init(q);
837 }
838 EXPORT_SYMBOL_GPL(vb2_queue_init);
839 
840 void vb2_queue_release(struct vb2_queue *q)
841 {
842 	vb2_core_queue_release(q);
843 }
844 EXPORT_SYMBOL_GPL(vb2_queue_release);
845 
846 __poll_t vb2_poll(struct vb2_queue *q, struct file *file, poll_table *wait)
847 {
848 	struct video_device *vfd = video_devdata(file);
849 	__poll_t req_events = poll_requested_events(wait);
850 	__poll_t res = 0;
851 
852 	if (test_bit(V4L2_FL_USES_V4L2_FH, &vfd->flags)) {
853 		struct v4l2_fh *fh = file->private_data;
854 
855 		if (v4l2_event_pending(fh))
856 			res = EPOLLPRI;
857 		else if (req_events & EPOLLPRI)
858 			poll_wait(file, &fh->wait, wait);
859 	}
860 
861 	return res | vb2_core_poll(q, file, wait);
862 }
863 EXPORT_SYMBOL_GPL(vb2_poll);
864 
865 /*
866  * The following functions are not part of the vb2 core API, but are helper
867  * functions that plug into struct v4l2_ioctl_ops, struct v4l2_file_operations
868  * and struct vb2_ops.
869  * They contain boilerplate code that most if not all drivers have to do
870  * and so they simplify the driver code.
871  */
872 
873 /* The queue is busy if there is a owner and you are not that owner. */
874 static inline bool vb2_queue_is_busy(struct video_device *vdev, struct file *file)
875 {
876 	return vdev->queue->owner && vdev->queue->owner != file->private_data;
877 }
878 
879 /* vb2 ioctl helpers */
880 
881 int vb2_ioctl_reqbufs(struct file *file, void *priv,
882 			  struct v4l2_requestbuffers *p)
883 {
884 	struct video_device *vdev = video_devdata(file);
885 	int res = vb2_verify_memory_type(vdev->queue, p->memory, p->type);
886 
887 	fill_buf_caps(vdev->queue, &p->capabilities);
888 	if (res)
889 		return res;
890 	if (vb2_queue_is_busy(vdev, file))
891 		return -EBUSY;
892 	res = vb2_core_reqbufs(vdev->queue, p->memory, &p->count);
893 	/* If count == 0, then the owner has released all buffers and he
894 	   is no longer owner of the queue. Otherwise we have a new owner. */
895 	if (res == 0)
896 		vdev->queue->owner = p->count ? file->private_data : NULL;
897 	return res;
898 }
899 EXPORT_SYMBOL_GPL(vb2_ioctl_reqbufs);
900 
901 int vb2_ioctl_create_bufs(struct file *file, void *priv,
902 			  struct v4l2_create_buffers *p)
903 {
904 	struct video_device *vdev = video_devdata(file);
905 	int res = vb2_verify_memory_type(vdev->queue, p->memory,
906 			p->format.type);
907 
908 	p->index = vdev->queue->num_buffers;
909 	fill_buf_caps(vdev->queue, &p->capabilities);
910 	/*
911 	 * If count == 0, then just check if memory and type are valid.
912 	 * Any -EBUSY result from vb2_verify_memory_type can be mapped to 0.
913 	 */
914 	if (p->count == 0)
915 		return res != -EBUSY ? res : 0;
916 	if (res)
917 		return res;
918 	if (vb2_queue_is_busy(vdev, file))
919 		return -EBUSY;
920 
921 	res = vb2_create_bufs(vdev->queue, p);
922 	if (res == 0)
923 		vdev->queue->owner = file->private_data;
924 	return res;
925 }
926 EXPORT_SYMBOL_GPL(vb2_ioctl_create_bufs);
927 
928 int vb2_ioctl_prepare_buf(struct file *file, void *priv,
929 			  struct v4l2_buffer *p)
930 {
931 	struct video_device *vdev = video_devdata(file);
932 
933 	if (vb2_queue_is_busy(vdev, file))
934 		return -EBUSY;
935 	return vb2_prepare_buf(vdev->queue, vdev->v4l2_dev->mdev, p);
936 }
937 EXPORT_SYMBOL_GPL(vb2_ioctl_prepare_buf);
938 
939 int vb2_ioctl_querybuf(struct file *file, void *priv, struct v4l2_buffer *p)
940 {
941 	struct video_device *vdev = video_devdata(file);
942 
943 	/* No need to call vb2_queue_is_busy(), anyone can query buffers. */
944 	return vb2_querybuf(vdev->queue, p);
945 }
946 EXPORT_SYMBOL_GPL(vb2_ioctl_querybuf);
947 
948 int vb2_ioctl_qbuf(struct file *file, void *priv, struct v4l2_buffer *p)
949 {
950 	struct video_device *vdev = video_devdata(file);
951 
952 	if (vb2_queue_is_busy(vdev, file))
953 		return -EBUSY;
954 	return vb2_qbuf(vdev->queue, vdev->v4l2_dev->mdev, p);
955 }
956 EXPORT_SYMBOL_GPL(vb2_ioctl_qbuf);
957 
958 int vb2_ioctl_dqbuf(struct file *file, void *priv, struct v4l2_buffer *p)
959 {
960 	struct video_device *vdev = video_devdata(file);
961 
962 	if (vb2_queue_is_busy(vdev, file))
963 		return -EBUSY;
964 	return vb2_dqbuf(vdev->queue, p, file->f_flags & O_NONBLOCK);
965 }
966 EXPORT_SYMBOL_GPL(vb2_ioctl_dqbuf);
967 
968 int vb2_ioctl_streamon(struct file *file, void *priv, enum v4l2_buf_type i)
969 {
970 	struct video_device *vdev = video_devdata(file);
971 
972 	if (vb2_queue_is_busy(vdev, file))
973 		return -EBUSY;
974 	return vb2_streamon(vdev->queue, i);
975 }
976 EXPORT_SYMBOL_GPL(vb2_ioctl_streamon);
977 
978 int vb2_ioctl_streamoff(struct file *file, void *priv, enum v4l2_buf_type i)
979 {
980 	struct video_device *vdev = video_devdata(file);
981 
982 	if (vb2_queue_is_busy(vdev, file))
983 		return -EBUSY;
984 	return vb2_streamoff(vdev->queue, i);
985 }
986 EXPORT_SYMBOL_GPL(vb2_ioctl_streamoff);
987 
988 int vb2_ioctl_expbuf(struct file *file, void *priv, struct v4l2_exportbuffer *p)
989 {
990 	struct video_device *vdev = video_devdata(file);
991 
992 	if (vb2_queue_is_busy(vdev, file))
993 		return -EBUSY;
994 	return vb2_expbuf(vdev->queue, p);
995 }
996 EXPORT_SYMBOL_GPL(vb2_ioctl_expbuf);
997 
998 /* v4l2_file_operations helpers */
999 
1000 int vb2_fop_mmap(struct file *file, struct vm_area_struct *vma)
1001 {
1002 	struct video_device *vdev = video_devdata(file);
1003 
1004 	return vb2_mmap(vdev->queue, vma);
1005 }
1006 EXPORT_SYMBOL_GPL(vb2_fop_mmap);
1007 
1008 int _vb2_fop_release(struct file *file, struct mutex *lock)
1009 {
1010 	struct video_device *vdev = video_devdata(file);
1011 
1012 	if (lock)
1013 		mutex_lock(lock);
1014 	if (file->private_data == vdev->queue->owner) {
1015 		vb2_queue_release(vdev->queue);
1016 		vdev->queue->owner = NULL;
1017 	}
1018 	if (lock)
1019 		mutex_unlock(lock);
1020 	return v4l2_fh_release(file);
1021 }
1022 EXPORT_SYMBOL_GPL(_vb2_fop_release);
1023 
1024 int vb2_fop_release(struct file *file)
1025 {
1026 	struct video_device *vdev = video_devdata(file);
1027 	struct mutex *lock = vdev->queue->lock ? vdev->queue->lock : vdev->lock;
1028 
1029 	return _vb2_fop_release(file, lock);
1030 }
1031 EXPORT_SYMBOL_GPL(vb2_fop_release);
1032 
1033 ssize_t vb2_fop_write(struct file *file, const char __user *buf,
1034 		size_t count, loff_t *ppos)
1035 {
1036 	struct video_device *vdev = video_devdata(file);
1037 	struct mutex *lock = vdev->queue->lock ? vdev->queue->lock : vdev->lock;
1038 	int err = -EBUSY;
1039 
1040 	if (!(vdev->queue->io_modes & VB2_WRITE))
1041 		return -EINVAL;
1042 	if (lock && mutex_lock_interruptible(lock))
1043 		return -ERESTARTSYS;
1044 	if (vb2_queue_is_busy(vdev, file))
1045 		goto exit;
1046 	err = vb2_write(vdev->queue, buf, count, ppos,
1047 		       file->f_flags & O_NONBLOCK);
1048 	if (vdev->queue->fileio)
1049 		vdev->queue->owner = file->private_data;
1050 exit:
1051 	if (lock)
1052 		mutex_unlock(lock);
1053 	return err;
1054 }
1055 EXPORT_SYMBOL_GPL(vb2_fop_write);
1056 
1057 ssize_t vb2_fop_read(struct file *file, char __user *buf,
1058 		size_t count, loff_t *ppos)
1059 {
1060 	struct video_device *vdev = video_devdata(file);
1061 	struct mutex *lock = vdev->queue->lock ? vdev->queue->lock : vdev->lock;
1062 	int err = -EBUSY;
1063 
1064 	if (!(vdev->queue->io_modes & VB2_READ))
1065 		return -EINVAL;
1066 	if (lock && mutex_lock_interruptible(lock))
1067 		return -ERESTARTSYS;
1068 	if (vb2_queue_is_busy(vdev, file))
1069 		goto exit;
1070 	err = vb2_read(vdev->queue, buf, count, ppos,
1071 		       file->f_flags & O_NONBLOCK);
1072 	if (vdev->queue->fileio)
1073 		vdev->queue->owner = file->private_data;
1074 exit:
1075 	if (lock)
1076 		mutex_unlock(lock);
1077 	return err;
1078 }
1079 EXPORT_SYMBOL_GPL(vb2_fop_read);
1080 
1081 __poll_t vb2_fop_poll(struct file *file, poll_table *wait)
1082 {
1083 	struct video_device *vdev = video_devdata(file);
1084 	struct vb2_queue *q = vdev->queue;
1085 	struct mutex *lock = q->lock ? q->lock : vdev->lock;
1086 	__poll_t res;
1087 	void *fileio;
1088 
1089 	/*
1090 	 * If this helper doesn't know how to lock, then you shouldn't be using
1091 	 * it but you should write your own.
1092 	 */
1093 	WARN_ON(!lock);
1094 
1095 	if (lock && mutex_lock_interruptible(lock))
1096 		return EPOLLERR;
1097 
1098 	fileio = q->fileio;
1099 
1100 	res = vb2_poll(vdev->queue, file, wait);
1101 
1102 	/* If fileio was started, then we have a new queue owner. */
1103 	if (!fileio && q->fileio)
1104 		q->owner = file->private_data;
1105 	if (lock)
1106 		mutex_unlock(lock);
1107 	return res;
1108 }
1109 EXPORT_SYMBOL_GPL(vb2_fop_poll);
1110 
1111 #ifndef CONFIG_MMU
1112 unsigned long vb2_fop_get_unmapped_area(struct file *file, unsigned long addr,
1113 		unsigned long len, unsigned long pgoff, unsigned long flags)
1114 {
1115 	struct video_device *vdev = video_devdata(file);
1116 
1117 	return vb2_get_unmapped_area(vdev->queue, addr, len, pgoff, flags);
1118 }
1119 EXPORT_SYMBOL_GPL(vb2_fop_get_unmapped_area);
1120 #endif
1121 
1122 /* vb2_ops helpers. Only use if vq->lock is non-NULL. */
1123 
1124 void vb2_ops_wait_prepare(struct vb2_queue *vq)
1125 {
1126 	mutex_unlock(vq->lock);
1127 }
1128 EXPORT_SYMBOL_GPL(vb2_ops_wait_prepare);
1129 
1130 void vb2_ops_wait_finish(struct vb2_queue *vq)
1131 {
1132 	mutex_lock(vq->lock);
1133 }
1134 EXPORT_SYMBOL_GPL(vb2_ops_wait_finish);
1135 
1136 /*
1137  * Note that this function is called during validation time and
1138  * thus the req_queue_mutex is held to ensure no request objects
1139  * can be added or deleted while validating. So there is no need
1140  * to protect the objects list.
1141  */
1142 int vb2_request_validate(struct media_request *req)
1143 {
1144 	struct media_request_object *obj;
1145 	int ret = 0;
1146 
1147 	if (!vb2_request_buffer_cnt(req))
1148 		return -ENOENT;
1149 
1150 	list_for_each_entry(obj, &req->objects, list) {
1151 		if (!obj->ops->prepare)
1152 			continue;
1153 
1154 		ret = obj->ops->prepare(obj);
1155 		if (ret)
1156 			break;
1157 	}
1158 
1159 	if (ret) {
1160 		list_for_each_entry_continue_reverse(obj, &req->objects, list)
1161 			if (obj->ops->unprepare)
1162 				obj->ops->unprepare(obj);
1163 		return ret;
1164 	}
1165 	return 0;
1166 }
1167 EXPORT_SYMBOL_GPL(vb2_request_validate);
1168 
1169 void vb2_request_queue(struct media_request *req)
1170 {
1171 	struct media_request_object *obj, *obj_safe;
1172 
1173 	/*
1174 	 * Queue all objects. Note that buffer objects are at the end of the
1175 	 * objects list, after all other object types. Once buffer objects
1176 	 * are queued, the driver might delete them immediately (if the driver
1177 	 * processes the buffer at once), so we have to use
1178 	 * list_for_each_entry_safe() to handle the case where the object we
1179 	 * queue is deleted.
1180 	 */
1181 	list_for_each_entry_safe(obj, obj_safe, &req->objects, list)
1182 		if (obj->ops->queue)
1183 			obj->ops->queue(obj);
1184 }
1185 EXPORT_SYMBOL_GPL(vb2_request_queue);
1186 
1187 MODULE_DESCRIPTION("Driver helper framework for Video for Linux 2");
1188 MODULE_AUTHOR("Pawel Osciak <pawel@osciak.com>, Marek Szyprowski");
1189 MODULE_LICENSE("GPL");
1190