[media] media: videobuf2: Replace videobuf2-core with videobuf2-v4l2
[sfrench/cifs-2.6.git] / drivers / media / v4l2-core / videobuf2-core.c
1 /*
2  * videobuf2-core.c - video buffer 2 core 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-fh.h>
29 #include <media/v4l2-event.h>
30 #include <media/v4l2-common.h>
31 #include <media/videobuf2-v4l2.h>
32
33 #include <trace/events/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: %s: " fmt, __func__, ## arg); \
42         } while (0)
43
44 #ifdef CONFIG_VIDEO_ADV_DEBUG
45
46 /*
47  * If advanced debugging is on, then count how often each op is called
48  * successfully, which can either be per-buffer or per-queue.
49  *
50  * This makes it easy to check that the 'init' and 'cleanup'
51  * (and variations thereof) stay balanced.
52  */
53
54 #define log_memop(vb, op)                                               \
55         dprintk(2, "call_memop(%p, %d, %s)%s\n",                        \
56                 (vb)->vb2_queue, (vb)->v4l2_buf.index, #op,             \
57                 (vb)->vb2_queue->mem_ops->op ? "" : " (nop)")
58
59 #define call_memop(vb, op, args...)                                     \
60 ({                                                                      \
61         struct vb2_queue *_q = (vb)->vb2_queue;                         \
62         int err;                                                        \
63                                                                         \
64         log_memop(vb, op);                                              \
65         err = _q->mem_ops->op ? _q->mem_ops->op(args) : 0;              \
66         if (!err)                                                       \
67                 (vb)->cnt_mem_ ## op++;                                 \
68         err;                                                            \
69 })
70
71 #define call_ptr_memop(vb, op, args...)                                 \
72 ({                                                                      \
73         struct vb2_queue *_q = (vb)->vb2_queue;                         \
74         void *ptr;                                                      \
75                                                                         \
76         log_memop(vb, op);                                              \
77         ptr = _q->mem_ops->op ? _q->mem_ops->op(args) : NULL;           \
78         if (!IS_ERR_OR_NULL(ptr))                                       \
79                 (vb)->cnt_mem_ ## op++;                                 \
80         ptr;                                                            \
81 })
82
83 #define call_void_memop(vb, op, args...)                                \
84 ({                                                                      \
85         struct vb2_queue *_q = (vb)->vb2_queue;                         \
86                                                                         \
87         log_memop(vb, op);                                              \
88         if (_q->mem_ops->op)                                            \
89                 _q->mem_ops->op(args);                                  \
90         (vb)->cnt_mem_ ## op++;                                         \
91 })
92
93 #define log_qop(q, op)                                                  \
94         dprintk(2, "call_qop(%p, %s)%s\n", q, #op,                      \
95                 (q)->ops->op ? "" : " (nop)")
96
97 #define call_qop(q, op, args...)                                        \
98 ({                                                                      \
99         int err;                                                        \
100                                                                         \
101         log_qop(q, op);                                                 \
102         err = (q)->ops->op ? (q)->ops->op(args) : 0;                    \
103         if (!err)                                                       \
104                 (q)->cnt_ ## op++;                                      \
105         err;                                                            \
106 })
107
108 #define call_void_qop(q, op, args...)                                   \
109 ({                                                                      \
110         log_qop(q, op);                                                 \
111         if ((q)->ops->op)                                               \
112                 (q)->ops->op(args);                                     \
113         (q)->cnt_ ## op++;                                              \
114 })
115
116 #define log_vb_qop(vb, op, args...)                                     \
117         dprintk(2, "call_vb_qop(%p, %d, %s)%s\n",                       \
118                 (vb)->vb2_queue, (vb)->v4l2_buf.index, #op,             \
119                 (vb)->vb2_queue->ops->op ? "" : " (nop)")
120
121 #define call_vb_qop(vb, op, args...)                                    \
122 ({                                                                      \
123         int err;                                                        \
124                                                                         \
125         log_vb_qop(vb, op);                                             \
126         err = (vb)->vb2_queue->ops->op ?                                \
127                 (vb)->vb2_queue->ops->op(args) : 0;                     \
128         if (!err)                                                       \
129                 (vb)->cnt_ ## op++;                                     \
130         err;                                                            \
131 })
132
133 #define call_void_vb_qop(vb, op, args...)                               \
134 ({                                                                      \
135         log_vb_qop(vb, op);                                             \
136         if ((vb)->vb2_queue->ops->op)                                   \
137                 (vb)->vb2_queue->ops->op(args);                         \
138         (vb)->cnt_ ## op++;                                             \
139 })
140
141 #else
142
143 #define call_memop(vb, op, args...)                                     \
144         ((vb)->vb2_queue->mem_ops->op ?                                 \
145                 (vb)->vb2_queue->mem_ops->op(args) : 0)
146
147 #define call_ptr_memop(vb, op, args...)                                 \
148         ((vb)->vb2_queue->mem_ops->op ?                                 \
149                 (vb)->vb2_queue->mem_ops->op(args) : NULL)
150
151 #define call_void_memop(vb, op, args...)                                \
152         do {                                                            \
153                 if ((vb)->vb2_queue->mem_ops->op)                       \
154                         (vb)->vb2_queue->mem_ops->op(args);             \
155         } while (0)
156
157 #define call_qop(q, op, args...)                                        \
158         ((q)->ops->op ? (q)->ops->op(args) : 0)
159
160 #define call_void_qop(q, op, args...)                                   \
161         do {                                                            \
162                 if ((q)->ops->op)                                       \
163                         (q)->ops->op(args);                             \
164         } while (0)
165
166 #define call_vb_qop(vb, op, args...)                                    \
167         ((vb)->vb2_queue->ops->op ? (vb)->vb2_queue->ops->op(args) : 0)
168
169 #define call_void_vb_qop(vb, op, args...)                               \
170         do {                                                            \
171                 if ((vb)->vb2_queue->ops->op)                           \
172                         (vb)->vb2_queue->ops->op(args);                 \
173         } while (0)
174
175 #endif
176
177 /* Flags that are set by the vb2 core */
178 #define V4L2_BUFFER_MASK_FLAGS  (V4L2_BUF_FLAG_MAPPED | V4L2_BUF_FLAG_QUEUED | \
179                                  V4L2_BUF_FLAG_DONE | V4L2_BUF_FLAG_ERROR | \
180                                  V4L2_BUF_FLAG_PREPARED | \
181                                  V4L2_BUF_FLAG_TIMESTAMP_MASK)
182 /* Output buffer flags that should be passed on to the driver */
183 #define V4L2_BUFFER_OUT_FLAGS   (V4L2_BUF_FLAG_PFRAME | V4L2_BUF_FLAG_BFRAME | \
184                                  V4L2_BUF_FLAG_KEYFRAME | V4L2_BUF_FLAG_TIMECODE)
185
186 static void __vb2_queue_cancel(struct vb2_queue *q);
187 static void __enqueue_in_driver(struct vb2_buffer *vb);
188
189 /**
190  * __vb2_buf_mem_alloc() - allocate video memory for the given buffer
191  */
192 static int __vb2_buf_mem_alloc(struct vb2_buffer *vb)
193 {
194         struct vb2_queue *q = vb->vb2_queue;
195         enum dma_data_direction dma_dir =
196                 V4L2_TYPE_IS_OUTPUT(q->type) ? DMA_TO_DEVICE : DMA_FROM_DEVICE;
197         void *mem_priv;
198         int plane;
199
200         /*
201          * Allocate memory for all planes in this buffer
202          * NOTE: mmapped areas should be page aligned
203          */
204         for (plane = 0; plane < vb->num_planes; ++plane) {
205                 unsigned long size = PAGE_ALIGN(q->plane_sizes[plane]);
206
207                 mem_priv = call_ptr_memop(vb, alloc, q->alloc_ctx[plane],
208                                       size, dma_dir, q->gfp_flags);
209                 if (IS_ERR_OR_NULL(mem_priv))
210                         goto free;
211
212                 /* Associate allocator private data with this plane */
213                 vb->planes[plane].mem_priv = mem_priv;
214                 vb->v4l2_planes[plane].length = q->plane_sizes[plane];
215         }
216
217         return 0;
218 free:
219         /* Free already allocated memory if one of the allocations failed */
220         for (; plane > 0; --plane) {
221                 call_void_memop(vb, put, vb->planes[plane - 1].mem_priv);
222                 vb->planes[plane - 1].mem_priv = NULL;
223         }
224
225         return -ENOMEM;
226 }
227
228 /**
229  * __vb2_buf_mem_free() - free memory of the given buffer
230  */
231 static void __vb2_buf_mem_free(struct vb2_buffer *vb)
232 {
233         unsigned int plane;
234
235         for (plane = 0; plane < vb->num_planes; ++plane) {
236                 call_void_memop(vb, put, vb->planes[plane].mem_priv);
237                 vb->planes[plane].mem_priv = NULL;
238                 dprintk(3, "freed plane %d of buffer %d\n", plane,
239                         vb->v4l2_buf.index);
240         }
241 }
242
243 /**
244  * __vb2_buf_userptr_put() - release userspace memory associated with
245  * a USERPTR buffer
246  */
247 static void __vb2_buf_userptr_put(struct vb2_buffer *vb)
248 {
249         unsigned int plane;
250
251         for (plane = 0; plane < vb->num_planes; ++plane) {
252                 if (vb->planes[plane].mem_priv)
253                         call_void_memop(vb, put_userptr, vb->planes[plane].mem_priv);
254                 vb->planes[plane].mem_priv = NULL;
255         }
256 }
257
258 /**
259  * __vb2_plane_dmabuf_put() - release memory associated with
260  * a DMABUF shared plane
261  */
262 static void __vb2_plane_dmabuf_put(struct vb2_buffer *vb, struct vb2_plane *p)
263 {
264         if (!p->mem_priv)
265                 return;
266
267         if (p->dbuf_mapped)
268                 call_void_memop(vb, unmap_dmabuf, p->mem_priv);
269
270         call_void_memop(vb, detach_dmabuf, p->mem_priv);
271         dma_buf_put(p->dbuf);
272         memset(p, 0, sizeof(*p));
273 }
274
275 /**
276  * __vb2_buf_dmabuf_put() - release memory associated with
277  * a DMABUF shared buffer
278  */
279 static void __vb2_buf_dmabuf_put(struct vb2_buffer *vb)
280 {
281         unsigned int plane;
282
283         for (plane = 0; plane < vb->num_planes; ++plane)
284                 __vb2_plane_dmabuf_put(vb, &vb->planes[plane]);
285 }
286
287 /**
288  * __setup_lengths() - setup initial lengths for every plane in
289  * every buffer on the queue
290  */
291 static void __setup_lengths(struct vb2_queue *q, unsigned int n)
292 {
293         unsigned int buffer, plane;
294         struct vb2_buffer *vb;
295
296         for (buffer = q->num_buffers; buffer < q->num_buffers + n; ++buffer) {
297                 vb = q->bufs[buffer];
298                 if (!vb)
299                         continue;
300
301                 for (plane = 0; plane < vb->num_planes; ++plane)
302                         vb->v4l2_planes[plane].length = q->plane_sizes[plane];
303         }
304 }
305
306 /**
307  * __setup_offsets() - setup unique offsets ("cookies") for every plane in
308  * every buffer on the queue
309  */
310 static void __setup_offsets(struct vb2_queue *q, unsigned int n)
311 {
312         unsigned int buffer, plane;
313         struct vb2_buffer *vb;
314         unsigned long off;
315
316         if (q->num_buffers) {
317                 struct v4l2_plane *p;
318                 vb = q->bufs[q->num_buffers - 1];
319                 p = &vb->v4l2_planes[vb->num_planes - 1];
320                 off = PAGE_ALIGN(p->m.mem_offset + p->length);
321         } else {
322                 off = 0;
323         }
324
325         for (buffer = q->num_buffers; buffer < q->num_buffers + n; ++buffer) {
326                 vb = q->bufs[buffer];
327                 if (!vb)
328                         continue;
329
330                 for (plane = 0; plane < vb->num_planes; ++plane) {
331                         vb->v4l2_planes[plane].m.mem_offset = off;
332
333                         dprintk(3, "buffer %d, plane %d offset 0x%08lx\n",
334                                         buffer, plane, off);
335
336                         off += vb->v4l2_planes[plane].length;
337                         off = PAGE_ALIGN(off);
338                 }
339         }
340 }
341
342 /**
343  * __vb2_queue_alloc() - allocate videobuf buffer structures and (for MMAP type)
344  * video buffer memory for all buffers/planes on the queue and initializes the
345  * queue
346  *
347  * Returns the number of buffers successfully allocated.
348  */
349 static int __vb2_queue_alloc(struct vb2_queue *q, enum v4l2_memory memory,
350                              unsigned int num_buffers, unsigned int num_planes)
351 {
352         unsigned int buffer;
353         struct vb2_buffer *vb;
354         int ret;
355
356         for (buffer = 0; buffer < num_buffers; ++buffer) {
357                 /* Allocate videobuf buffer structures */
358                 vb = kzalloc(q->buf_struct_size, GFP_KERNEL);
359                 if (!vb) {
360                         dprintk(1, "memory alloc for buffer struct failed\n");
361                         break;
362                 }
363
364                 /* Length stores number of planes for multiplanar buffers */
365                 if (V4L2_TYPE_IS_MULTIPLANAR(q->type))
366                         vb->v4l2_buf.length = num_planes;
367
368                 vb->state = VB2_BUF_STATE_DEQUEUED;
369                 vb->vb2_queue = q;
370                 vb->num_planes = num_planes;
371                 vb->v4l2_buf.index = q->num_buffers + buffer;
372                 vb->v4l2_buf.type = q->type;
373                 vb->v4l2_buf.memory = memory;
374
375                 /* Allocate video buffer memory for the MMAP type */
376                 if (memory == V4L2_MEMORY_MMAP) {
377                         ret = __vb2_buf_mem_alloc(vb);
378                         if (ret) {
379                                 dprintk(1, "failed allocating memory for "
380                                                 "buffer %d\n", buffer);
381                                 kfree(vb);
382                                 break;
383                         }
384                         /*
385                          * Call the driver-provided buffer initialization
386                          * callback, if given. An error in initialization
387                          * results in queue setup failure.
388                          */
389                         ret = call_vb_qop(vb, buf_init, vb);
390                         if (ret) {
391                                 dprintk(1, "buffer %d %p initialization"
392                                         " failed\n", buffer, vb);
393                                 __vb2_buf_mem_free(vb);
394                                 kfree(vb);
395                                 break;
396                         }
397                 }
398
399                 q->bufs[q->num_buffers + buffer] = vb;
400         }
401
402         __setup_lengths(q, buffer);
403         if (memory == V4L2_MEMORY_MMAP)
404                 __setup_offsets(q, buffer);
405
406         dprintk(1, "allocated %d buffers, %d plane(s) each\n",
407                         buffer, num_planes);
408
409         return buffer;
410 }
411
412 /**
413  * __vb2_free_mem() - release all video buffer memory for a given queue
414  */
415 static void __vb2_free_mem(struct vb2_queue *q, unsigned int buffers)
416 {
417         unsigned int buffer;
418         struct vb2_buffer *vb;
419
420         for (buffer = q->num_buffers - buffers; buffer < q->num_buffers;
421              ++buffer) {
422                 vb = q->bufs[buffer];
423                 if (!vb)
424                         continue;
425
426                 /* Free MMAP buffers or release USERPTR buffers */
427                 if (q->memory == V4L2_MEMORY_MMAP)
428                         __vb2_buf_mem_free(vb);
429                 else if (q->memory == V4L2_MEMORY_DMABUF)
430                         __vb2_buf_dmabuf_put(vb);
431                 else
432                         __vb2_buf_userptr_put(vb);
433         }
434 }
435
436 /**
437  * __vb2_queue_free() - free buffers at the end of the queue - video memory and
438  * related information, if no buffers are left return the queue to an
439  * uninitialized state. Might be called even if the queue has already been freed.
440  */
441 static int __vb2_queue_free(struct vb2_queue *q, unsigned int buffers)
442 {
443         unsigned int buffer;
444
445         /*
446          * Sanity check: when preparing a buffer the queue lock is released for
447          * a short while (see __buf_prepare for the details), which would allow
448          * a race with a reqbufs which can call this function. Removing the
449          * buffers from underneath __buf_prepare is obviously a bad idea, so we
450          * check if any of the buffers is in the state PREPARING, and if so we
451          * just return -EAGAIN.
452          */
453         for (buffer = q->num_buffers - buffers; buffer < q->num_buffers;
454              ++buffer) {
455                 if (q->bufs[buffer] == NULL)
456                         continue;
457                 if (q->bufs[buffer]->state == VB2_BUF_STATE_PREPARING) {
458                         dprintk(1, "preparing buffers, cannot free\n");
459                         return -EAGAIN;
460                 }
461         }
462
463         /* Call driver-provided cleanup function for each buffer, if provided */
464         for (buffer = q->num_buffers - buffers; buffer < q->num_buffers;
465              ++buffer) {
466                 struct vb2_buffer *vb = q->bufs[buffer];
467
468                 if (vb && vb->planes[0].mem_priv)
469                         call_void_vb_qop(vb, buf_cleanup, vb);
470         }
471
472         /* Release video buffer memory */
473         __vb2_free_mem(q, buffers);
474
475 #ifdef CONFIG_VIDEO_ADV_DEBUG
476         /*
477          * Check that all the calls were balances during the life-time of this
478          * queue. If not (or if the debug level is 1 or up), then dump the
479          * counters to the kernel log.
480          */
481         if (q->num_buffers) {
482                 bool unbalanced = q->cnt_start_streaming != q->cnt_stop_streaming ||
483                                   q->cnt_wait_prepare != q->cnt_wait_finish;
484
485                 if (unbalanced || debug) {
486                         pr_info("vb2: counters for queue %p:%s\n", q,
487                                 unbalanced ? " UNBALANCED!" : "");
488                         pr_info("vb2:     setup: %u start_streaming: %u stop_streaming: %u\n",
489                                 q->cnt_queue_setup, q->cnt_start_streaming,
490                                 q->cnt_stop_streaming);
491                         pr_info("vb2:     wait_prepare: %u wait_finish: %u\n",
492                                 q->cnt_wait_prepare, q->cnt_wait_finish);
493                 }
494                 q->cnt_queue_setup = 0;
495                 q->cnt_wait_prepare = 0;
496                 q->cnt_wait_finish = 0;
497                 q->cnt_start_streaming = 0;
498                 q->cnt_stop_streaming = 0;
499         }
500         for (buffer = 0; buffer < q->num_buffers; ++buffer) {
501                 struct vb2_buffer *vb = q->bufs[buffer];
502                 bool unbalanced = vb->cnt_mem_alloc != vb->cnt_mem_put ||
503                                   vb->cnt_mem_prepare != vb->cnt_mem_finish ||
504                                   vb->cnt_mem_get_userptr != vb->cnt_mem_put_userptr ||
505                                   vb->cnt_mem_attach_dmabuf != vb->cnt_mem_detach_dmabuf ||
506                                   vb->cnt_mem_map_dmabuf != vb->cnt_mem_unmap_dmabuf ||
507                                   vb->cnt_buf_queue != vb->cnt_buf_done ||
508                                   vb->cnt_buf_prepare != vb->cnt_buf_finish ||
509                                   vb->cnt_buf_init != vb->cnt_buf_cleanup;
510
511                 if (unbalanced || debug) {
512                         pr_info("vb2:   counters for queue %p, buffer %d:%s\n",
513                                 q, buffer, unbalanced ? " UNBALANCED!" : "");
514                         pr_info("vb2:     buf_init: %u buf_cleanup: %u buf_prepare: %u buf_finish: %u\n",
515                                 vb->cnt_buf_init, vb->cnt_buf_cleanup,
516                                 vb->cnt_buf_prepare, vb->cnt_buf_finish);
517                         pr_info("vb2:     buf_queue: %u buf_done: %u\n",
518                                 vb->cnt_buf_queue, vb->cnt_buf_done);
519                         pr_info("vb2:     alloc: %u put: %u prepare: %u finish: %u mmap: %u\n",
520                                 vb->cnt_mem_alloc, vb->cnt_mem_put,
521                                 vb->cnt_mem_prepare, vb->cnt_mem_finish,
522                                 vb->cnt_mem_mmap);
523                         pr_info("vb2:     get_userptr: %u put_userptr: %u\n",
524                                 vb->cnt_mem_get_userptr, vb->cnt_mem_put_userptr);
525                         pr_info("vb2:     attach_dmabuf: %u detach_dmabuf: %u map_dmabuf: %u unmap_dmabuf: %u\n",
526                                 vb->cnt_mem_attach_dmabuf, vb->cnt_mem_detach_dmabuf,
527                                 vb->cnt_mem_map_dmabuf, vb->cnt_mem_unmap_dmabuf);
528                         pr_info("vb2:     get_dmabuf: %u num_users: %u vaddr: %u cookie: %u\n",
529                                 vb->cnt_mem_get_dmabuf,
530                                 vb->cnt_mem_num_users,
531                                 vb->cnt_mem_vaddr,
532                                 vb->cnt_mem_cookie);
533                 }
534         }
535 #endif
536
537         /* Free videobuf buffers */
538         for (buffer = q->num_buffers - buffers; buffer < q->num_buffers;
539              ++buffer) {
540                 kfree(q->bufs[buffer]);
541                 q->bufs[buffer] = NULL;
542         }
543
544         q->num_buffers -= buffers;
545         if (!q->num_buffers) {
546                 q->memory = 0;
547                 INIT_LIST_HEAD(&q->queued_list);
548         }
549         return 0;
550 }
551
552 /**
553  * __verify_planes_array() - verify that the planes array passed in struct
554  * v4l2_buffer from userspace can be safely used
555  */
556 static int __verify_planes_array(struct vb2_buffer *vb, const struct v4l2_buffer *b)
557 {
558         if (!V4L2_TYPE_IS_MULTIPLANAR(b->type))
559                 return 0;
560
561         /* Is memory for copying plane information present? */
562         if (NULL == b->m.planes) {
563                 dprintk(1, "multi-planar buffer passed but "
564                            "planes array not provided\n");
565                 return -EINVAL;
566         }
567
568         if (b->length < vb->num_planes || b->length > VIDEO_MAX_PLANES) {
569                 dprintk(1, "incorrect planes array length, "
570                            "expected %d, got %d\n", vb->num_planes, b->length);
571                 return -EINVAL;
572         }
573
574         return 0;
575 }
576
577 /**
578  * __verify_length() - Verify that the bytesused value for each plane fits in
579  * the plane length and that the data offset doesn't exceed the bytesused value.
580  */
581 static int __verify_length(struct vb2_buffer *vb, const struct v4l2_buffer *b)
582 {
583         unsigned int length;
584         unsigned int bytesused;
585         unsigned int plane;
586
587         if (!V4L2_TYPE_IS_OUTPUT(b->type))
588                 return 0;
589
590         if (V4L2_TYPE_IS_MULTIPLANAR(b->type)) {
591                 for (plane = 0; plane < vb->num_planes; ++plane) {
592                         length = (b->memory == V4L2_MEMORY_USERPTR ||
593                                   b->memory == V4L2_MEMORY_DMABUF)
594                                ? b->m.planes[plane].length
595                                : vb->v4l2_planes[plane].length;
596                         bytesused = b->m.planes[plane].bytesused
597                                   ? b->m.planes[plane].bytesused : length;
598
599                         if (b->m.planes[plane].bytesused > length)
600                                 return -EINVAL;
601
602                         if (b->m.planes[plane].data_offset > 0 &&
603                             b->m.planes[plane].data_offset >= bytesused)
604                                 return -EINVAL;
605                 }
606         } else {
607                 length = (b->memory == V4L2_MEMORY_USERPTR)
608                        ? b->length : vb->v4l2_planes[0].length;
609                 bytesused = b->bytesused ? b->bytesused : length;
610
611                 if (b->bytesused > length)
612                         return -EINVAL;
613         }
614
615         return 0;
616 }
617
618 /**
619  * __buffer_in_use() - return true if the buffer is in use and
620  * the queue cannot be freed (by the means of REQBUFS(0)) call
621  */
622 static bool __buffer_in_use(struct vb2_queue *q, struct vb2_buffer *vb)
623 {
624         unsigned int plane;
625         for (plane = 0; plane < vb->num_planes; ++plane) {
626                 void *mem_priv = vb->planes[plane].mem_priv;
627                 /*
628                  * If num_users() has not been provided, call_memop
629                  * will return 0, apparently nobody cares about this
630                  * case anyway. If num_users() returns more than 1,
631                  * we are not the only user of the plane's memory.
632                  */
633                 if (mem_priv && call_memop(vb, num_users, mem_priv) > 1)
634                         return true;
635         }
636         return false;
637 }
638
639 /**
640  * __buffers_in_use() - return true if any buffers on the queue are in use and
641  * the queue cannot be freed (by the means of REQBUFS(0)) call
642  */
643 static bool __buffers_in_use(struct vb2_queue *q)
644 {
645         unsigned int buffer;
646         for (buffer = 0; buffer < q->num_buffers; ++buffer) {
647                 if (__buffer_in_use(q, q->bufs[buffer]))
648                         return true;
649         }
650         return false;
651 }
652
653 /**
654  * __fill_v4l2_buffer() - fill in a struct v4l2_buffer with information to be
655  * returned to userspace
656  */
657 static void __fill_v4l2_buffer(struct vb2_buffer *vb, struct v4l2_buffer *b)
658 {
659         struct vb2_queue *q = vb->vb2_queue;
660
661         /* Copy back data such as timestamp, flags, etc. */
662         memcpy(b, &vb->v4l2_buf, offsetof(struct v4l2_buffer, m));
663         b->reserved2 = vb->v4l2_buf.reserved2;
664         b->reserved = vb->v4l2_buf.reserved;
665
666         if (V4L2_TYPE_IS_MULTIPLANAR(q->type)) {
667                 /*
668                  * Fill in plane-related data if userspace provided an array
669                  * for it. The caller has already verified memory and size.
670                  */
671                 b->length = vb->num_planes;
672                 memcpy(b->m.planes, vb->v4l2_planes,
673                         b->length * sizeof(struct v4l2_plane));
674         } else {
675                 /*
676                  * We use length and offset in v4l2_planes array even for
677                  * single-planar buffers, but userspace does not.
678                  */
679                 b->length = vb->v4l2_planes[0].length;
680                 b->bytesused = vb->v4l2_planes[0].bytesused;
681                 if (q->memory == V4L2_MEMORY_MMAP)
682                         b->m.offset = vb->v4l2_planes[0].m.mem_offset;
683                 else if (q->memory == V4L2_MEMORY_USERPTR)
684                         b->m.userptr = vb->v4l2_planes[0].m.userptr;
685                 else if (q->memory == V4L2_MEMORY_DMABUF)
686                         b->m.fd = vb->v4l2_planes[0].m.fd;
687         }
688
689         /*
690          * Clear any buffer state related flags.
691          */
692         b->flags &= ~V4L2_BUFFER_MASK_FLAGS;
693         b->flags |= q->timestamp_flags & V4L2_BUF_FLAG_TIMESTAMP_MASK;
694         if ((q->timestamp_flags & V4L2_BUF_FLAG_TIMESTAMP_MASK) !=
695             V4L2_BUF_FLAG_TIMESTAMP_COPY) {
696                 /*
697                  * For non-COPY timestamps, drop timestamp source bits
698                  * and obtain the timestamp source from the queue.
699                  */
700                 b->flags &= ~V4L2_BUF_FLAG_TSTAMP_SRC_MASK;
701                 b->flags |= q->timestamp_flags & V4L2_BUF_FLAG_TSTAMP_SRC_MASK;
702         }
703
704         switch (vb->state) {
705         case VB2_BUF_STATE_QUEUED:
706         case VB2_BUF_STATE_ACTIVE:
707                 b->flags |= V4L2_BUF_FLAG_QUEUED;
708                 break;
709         case VB2_BUF_STATE_ERROR:
710                 b->flags |= V4L2_BUF_FLAG_ERROR;
711                 /* fall through */
712         case VB2_BUF_STATE_DONE:
713                 b->flags |= V4L2_BUF_FLAG_DONE;
714                 break;
715         case VB2_BUF_STATE_PREPARED:
716                 b->flags |= V4L2_BUF_FLAG_PREPARED;
717                 break;
718         case VB2_BUF_STATE_PREPARING:
719         case VB2_BUF_STATE_DEQUEUED:
720         case VB2_BUF_STATE_REQUEUEING:
721                 /* nothing */
722                 break;
723         }
724
725         if (__buffer_in_use(q, vb))
726                 b->flags |= V4L2_BUF_FLAG_MAPPED;
727 }
728
729 /**
730  * vb2_querybuf() - query video buffer information
731  * @q:          videobuf queue
732  * @b:          buffer struct passed from userspace to vidioc_querybuf handler
733  *              in driver
734  *
735  * Should be called from vidioc_querybuf ioctl handler in driver.
736  * This function will verify the passed v4l2_buffer structure and fill the
737  * relevant information for the userspace.
738  *
739  * The return values from this function are intended to be directly returned
740  * from vidioc_querybuf handler in driver.
741  */
742 int vb2_querybuf(struct vb2_queue *q, struct v4l2_buffer *b)
743 {
744         struct vb2_buffer *vb;
745         int ret;
746
747         if (b->type != q->type) {
748                 dprintk(1, "wrong buffer type\n");
749                 return -EINVAL;
750         }
751
752         if (b->index >= q->num_buffers) {
753                 dprintk(1, "buffer index out of range\n");
754                 return -EINVAL;
755         }
756         vb = q->bufs[b->index];
757         ret = __verify_planes_array(vb, b);
758         if (!ret)
759                 __fill_v4l2_buffer(vb, b);
760         return ret;
761 }
762 EXPORT_SYMBOL(vb2_querybuf);
763
764 /**
765  * __verify_userptr_ops() - verify that all memory operations required for
766  * USERPTR queue type have been provided
767  */
768 static int __verify_userptr_ops(struct vb2_queue *q)
769 {
770         if (!(q->io_modes & VB2_USERPTR) || !q->mem_ops->get_userptr ||
771             !q->mem_ops->put_userptr)
772                 return -EINVAL;
773
774         return 0;
775 }
776
777 /**
778  * __verify_mmap_ops() - verify that all memory operations required for
779  * MMAP queue type have been provided
780  */
781 static int __verify_mmap_ops(struct vb2_queue *q)
782 {
783         if (!(q->io_modes & VB2_MMAP) || !q->mem_ops->alloc ||
784             !q->mem_ops->put || !q->mem_ops->mmap)
785                 return -EINVAL;
786
787         return 0;
788 }
789
790 /**
791  * __verify_dmabuf_ops() - verify that all memory operations required for
792  * DMABUF queue type have been provided
793  */
794 static int __verify_dmabuf_ops(struct vb2_queue *q)
795 {
796         if (!(q->io_modes & VB2_DMABUF) || !q->mem_ops->attach_dmabuf ||
797             !q->mem_ops->detach_dmabuf  || !q->mem_ops->map_dmabuf ||
798             !q->mem_ops->unmap_dmabuf)
799                 return -EINVAL;
800
801         return 0;
802 }
803
804 /**
805  * __verify_memory_type() - Check whether the memory type and buffer type
806  * passed to a buffer operation are compatible with the queue.
807  */
808 static int __verify_memory_type(struct vb2_queue *q,
809                 enum v4l2_memory memory, enum v4l2_buf_type type)
810 {
811         if (memory != V4L2_MEMORY_MMAP && memory != V4L2_MEMORY_USERPTR &&
812             memory != V4L2_MEMORY_DMABUF) {
813                 dprintk(1, "unsupported memory type\n");
814                 return -EINVAL;
815         }
816
817         if (type != q->type) {
818                 dprintk(1, "requested type is incorrect\n");
819                 return -EINVAL;
820         }
821
822         /*
823          * Make sure all the required memory ops for given memory type
824          * are available.
825          */
826         if (memory == V4L2_MEMORY_MMAP && __verify_mmap_ops(q)) {
827                 dprintk(1, "MMAP for current setup unsupported\n");
828                 return -EINVAL;
829         }
830
831         if (memory == V4L2_MEMORY_USERPTR && __verify_userptr_ops(q)) {
832                 dprintk(1, "USERPTR for current setup unsupported\n");
833                 return -EINVAL;
834         }
835
836         if (memory == V4L2_MEMORY_DMABUF && __verify_dmabuf_ops(q)) {
837                 dprintk(1, "DMABUF for current setup unsupported\n");
838                 return -EINVAL;
839         }
840
841         /*
842          * Place the busy tests at the end: -EBUSY can be ignored when
843          * create_bufs is called with count == 0, but count == 0 should still
844          * do the memory and type validation.
845          */
846         if (vb2_fileio_is_active(q)) {
847                 dprintk(1, "file io in progress\n");
848                 return -EBUSY;
849         }
850         return 0;
851 }
852
853 /**
854  * __reqbufs() - Initiate streaming
855  * @q:          videobuf2 queue
856  * @req:        struct passed from userspace to vidioc_reqbufs handler in driver
857  *
858  * Should be called from vidioc_reqbufs ioctl handler of a driver.
859  * This function:
860  * 1) verifies streaming parameters passed from the userspace,
861  * 2) sets up the queue,
862  * 3) negotiates number of buffers and planes per buffer with the driver
863  *    to be used during streaming,
864  * 4) allocates internal buffer structures (struct vb2_buffer), according to
865  *    the agreed parameters,
866  * 5) for MMAP memory type, allocates actual video memory, using the
867  *    memory handling/allocation routines provided during queue initialization
868  *
869  * If req->count is 0, all the memory will be freed instead.
870  * If the queue has been allocated previously (by a previous vb2_reqbufs) call
871  * and the queue is not busy, memory will be reallocated.
872  *
873  * The return values from this function are intended to be directly returned
874  * from vidioc_reqbufs handler in driver.
875  */
876 static int __reqbufs(struct vb2_queue *q, struct v4l2_requestbuffers *req)
877 {
878         unsigned int num_buffers, allocated_buffers, num_planes = 0;
879         int ret;
880
881         if (q->streaming) {
882                 dprintk(1, "streaming active\n");
883                 return -EBUSY;
884         }
885
886         if (req->count == 0 || q->num_buffers != 0 || q->memory != req->memory) {
887                 /*
888                  * We already have buffers allocated, so first check if they
889                  * are not in use and can be freed.
890                  */
891                 mutex_lock(&q->mmap_lock);
892                 if (q->memory == V4L2_MEMORY_MMAP && __buffers_in_use(q)) {
893                         mutex_unlock(&q->mmap_lock);
894                         dprintk(1, "memory in use, cannot free\n");
895                         return -EBUSY;
896                 }
897
898                 /*
899                  * Call queue_cancel to clean up any buffers in the PREPARED or
900                  * QUEUED state which is possible if buffers were prepared or
901                  * queued without ever calling STREAMON.
902                  */
903                 __vb2_queue_cancel(q);
904                 ret = __vb2_queue_free(q, q->num_buffers);
905                 mutex_unlock(&q->mmap_lock);
906                 if (ret)
907                         return ret;
908
909                 /*
910                  * In case of REQBUFS(0) return immediately without calling
911                  * driver's queue_setup() callback and allocating resources.
912                  */
913                 if (req->count == 0)
914                         return 0;
915         }
916
917         /*
918          * Make sure the requested values and current defaults are sane.
919          */
920         num_buffers = min_t(unsigned int, req->count, VIDEO_MAX_FRAME);
921         num_buffers = max_t(unsigned int, num_buffers, q->min_buffers_needed);
922         memset(q->plane_sizes, 0, sizeof(q->plane_sizes));
923         memset(q->alloc_ctx, 0, sizeof(q->alloc_ctx));
924         q->memory = req->memory;
925
926         /*
927          * Ask the driver how many buffers and planes per buffer it requires.
928          * Driver also sets the size and allocator context for each plane.
929          */
930         ret = call_qop(q, queue_setup, q, NULL, &num_buffers, &num_planes,
931                        q->plane_sizes, q->alloc_ctx);
932         if (ret)
933                 return ret;
934
935         /* Finally, allocate buffers and video memory */
936         allocated_buffers = __vb2_queue_alloc(q, req->memory, num_buffers, num_planes);
937         if (allocated_buffers == 0) {
938                 dprintk(1, "memory allocation failed\n");
939                 return -ENOMEM;
940         }
941
942         /*
943          * There is no point in continuing if we can't allocate the minimum
944          * number of buffers needed by this vb2_queue.
945          */
946         if (allocated_buffers < q->min_buffers_needed)
947                 ret = -ENOMEM;
948
949         /*
950          * Check if driver can handle the allocated number of buffers.
951          */
952         if (!ret && allocated_buffers < num_buffers) {
953                 num_buffers = allocated_buffers;
954
955                 ret = call_qop(q, queue_setup, q, NULL, &num_buffers,
956                                &num_planes, q->plane_sizes, q->alloc_ctx);
957
958                 if (!ret && allocated_buffers < num_buffers)
959                         ret = -ENOMEM;
960
961                 /*
962                  * Either the driver has accepted a smaller number of buffers,
963                  * or .queue_setup() returned an error
964                  */
965         }
966
967         mutex_lock(&q->mmap_lock);
968         q->num_buffers = allocated_buffers;
969
970         if (ret < 0) {
971                 /*
972                  * Note: __vb2_queue_free() will subtract 'allocated_buffers'
973                  * from q->num_buffers.
974                  */
975                 __vb2_queue_free(q, allocated_buffers);
976                 mutex_unlock(&q->mmap_lock);
977                 return ret;
978         }
979         mutex_unlock(&q->mmap_lock);
980
981         /*
982          * Return the number of successfully allocated buffers
983          * to the userspace.
984          */
985         req->count = allocated_buffers;
986         q->waiting_for_buffers = !V4L2_TYPE_IS_OUTPUT(q->type);
987
988         return 0;
989 }
990
991 /**
992  * vb2_reqbufs() - Wrapper for __reqbufs() that also verifies the memory and
993  * type values.
994  * @q:          videobuf2 queue
995  * @req:        struct passed from userspace to vidioc_reqbufs handler in driver
996  */
997 int vb2_reqbufs(struct vb2_queue *q, struct v4l2_requestbuffers *req)
998 {
999         int ret = __verify_memory_type(q, req->memory, req->type);
1000
1001         return ret ? ret : __reqbufs(q, req);
1002 }
1003 EXPORT_SYMBOL_GPL(vb2_reqbufs);
1004
1005 /**
1006  * __create_bufs() - Allocate buffers and any required auxiliary structs
1007  * @q:          videobuf2 queue
1008  * @create:     creation parameters, passed from userspace to vidioc_create_bufs
1009  *              handler in driver
1010  *
1011  * Should be called from vidioc_create_bufs ioctl handler of a driver.
1012  * This function:
1013  * 1) verifies parameter sanity
1014  * 2) calls the .queue_setup() queue operation
1015  * 3) performs any necessary memory allocations
1016  *
1017  * The return values from this function are intended to be directly returned
1018  * from vidioc_create_bufs handler in driver.
1019  */
1020 static int __create_bufs(struct vb2_queue *q, struct v4l2_create_buffers *create)
1021 {
1022         unsigned int num_planes = 0, num_buffers, allocated_buffers;
1023         int ret;
1024
1025         if (q->num_buffers == VIDEO_MAX_FRAME) {
1026                 dprintk(1, "maximum number of buffers already allocated\n");
1027                 return -ENOBUFS;
1028         }
1029
1030         if (!q->num_buffers) {
1031                 memset(q->plane_sizes, 0, sizeof(q->plane_sizes));
1032                 memset(q->alloc_ctx, 0, sizeof(q->alloc_ctx));
1033                 q->memory = create->memory;
1034                 q->waiting_for_buffers = !V4L2_TYPE_IS_OUTPUT(q->type);
1035         }
1036
1037         num_buffers = min(create->count, VIDEO_MAX_FRAME - q->num_buffers);
1038
1039         /*
1040          * Ask the driver, whether the requested number of buffers, planes per
1041          * buffer and their sizes are acceptable
1042          */
1043         ret = call_qop(q, queue_setup, q, &create->format, &num_buffers,
1044                        &num_planes, q->plane_sizes, q->alloc_ctx);
1045         if (ret)
1046                 return ret;
1047
1048         /* Finally, allocate buffers and video memory */
1049         allocated_buffers = __vb2_queue_alloc(q, create->memory, num_buffers,
1050                                 num_planes);
1051         if (allocated_buffers == 0) {
1052                 dprintk(1, "memory allocation failed\n");
1053                 return -ENOMEM;
1054         }
1055
1056         /*
1057          * Check if driver can handle the so far allocated number of buffers.
1058          */
1059         if (allocated_buffers < num_buffers) {
1060                 num_buffers = allocated_buffers;
1061
1062                 /*
1063                  * q->num_buffers contains the total number of buffers, that the
1064                  * queue driver has set up
1065                  */
1066                 ret = call_qop(q, queue_setup, q, &create->format, &num_buffers,
1067                                &num_planes, q->plane_sizes, q->alloc_ctx);
1068
1069                 if (!ret && allocated_buffers < num_buffers)
1070                         ret = -ENOMEM;
1071
1072                 /*
1073                  * Either the driver has accepted a smaller number of buffers,
1074                  * or .queue_setup() returned an error
1075                  */
1076         }
1077
1078         mutex_lock(&q->mmap_lock);
1079         q->num_buffers += allocated_buffers;
1080
1081         if (ret < 0) {
1082                 /*
1083                  * Note: __vb2_queue_free() will subtract 'allocated_buffers'
1084                  * from q->num_buffers.
1085                  */
1086                 __vb2_queue_free(q, allocated_buffers);
1087                 mutex_unlock(&q->mmap_lock);
1088                 return -ENOMEM;
1089         }
1090         mutex_unlock(&q->mmap_lock);
1091
1092         /*
1093          * Return the number of successfully allocated buffers
1094          * to the userspace.
1095          */
1096         create->count = allocated_buffers;
1097
1098         return 0;
1099 }
1100
1101 /**
1102  * vb2_create_bufs() - Wrapper for __create_bufs() that also verifies the
1103  * memory and type values.
1104  * @q:          videobuf2 queue
1105  * @create:     creation parameters, passed from userspace to vidioc_create_bufs
1106  *              handler in driver
1107  */
1108 int vb2_create_bufs(struct vb2_queue *q, struct v4l2_create_buffers *create)
1109 {
1110         int ret = __verify_memory_type(q, create->memory, create->format.type);
1111
1112         create->index = q->num_buffers;
1113         if (create->count == 0)
1114                 return ret != -EBUSY ? ret : 0;
1115         return ret ? ret : __create_bufs(q, create);
1116 }
1117 EXPORT_SYMBOL_GPL(vb2_create_bufs);
1118
1119 /**
1120  * vb2_plane_vaddr() - Return a kernel virtual address of a given plane
1121  * @vb:         vb2_buffer to which the plane in question belongs to
1122  * @plane_no:   plane number for which the address is to be returned
1123  *
1124  * This function returns a kernel virtual address of a given plane if
1125  * such a mapping exist, NULL otherwise.
1126  */
1127 void *vb2_plane_vaddr(struct vb2_buffer *vb, unsigned int plane_no)
1128 {
1129         if (plane_no > vb->num_planes || !vb->planes[plane_no].mem_priv)
1130                 return NULL;
1131
1132         return call_ptr_memop(vb, vaddr, vb->planes[plane_no].mem_priv);
1133
1134 }
1135 EXPORT_SYMBOL_GPL(vb2_plane_vaddr);
1136
1137 /**
1138  * vb2_plane_cookie() - Return allocator specific cookie for the given plane
1139  * @vb:         vb2_buffer to which the plane in question belongs to
1140  * @plane_no:   plane number for which the cookie is to be returned
1141  *
1142  * This function returns an allocator specific cookie for a given plane if
1143  * available, NULL otherwise. The allocator should provide some simple static
1144  * inline function, which would convert this cookie to the allocator specific
1145  * type that can be used directly by the driver to access the buffer. This can
1146  * be for example physical address, pointer to scatter list or IOMMU mapping.
1147  */
1148 void *vb2_plane_cookie(struct vb2_buffer *vb, unsigned int plane_no)
1149 {
1150         if (plane_no >= vb->num_planes || !vb->planes[plane_no].mem_priv)
1151                 return NULL;
1152
1153         return call_ptr_memop(vb, cookie, vb->planes[plane_no].mem_priv);
1154 }
1155 EXPORT_SYMBOL_GPL(vb2_plane_cookie);
1156
1157 /**
1158  * vb2_buffer_done() - inform videobuf that an operation on a buffer is finished
1159  * @vb:         vb2_buffer returned from the driver
1160  * @state:      either VB2_BUF_STATE_DONE if the operation finished successfully,
1161  *              VB2_BUF_STATE_ERROR if the operation finished with an error or
1162  *              VB2_BUF_STATE_QUEUED if the driver wants to requeue buffers.
1163  *              If start_streaming fails then it should return buffers with state
1164  *              VB2_BUF_STATE_QUEUED to put them back into the queue.
1165  *
1166  * This function should be called by the driver after a hardware operation on
1167  * a buffer is finished and the buffer may be returned to userspace. The driver
1168  * cannot use this buffer anymore until it is queued back to it by videobuf
1169  * by the means of buf_queue callback. Only buffers previously queued to the
1170  * driver by buf_queue can be passed to this function.
1171  *
1172  * While streaming a buffer can only be returned in state DONE or ERROR.
1173  * The start_streaming op can also return them in case the DMA engine cannot
1174  * be started for some reason. In that case the buffers should be returned with
1175  * state QUEUED.
1176  */
1177 void vb2_buffer_done(struct vb2_buffer *vb, enum vb2_buffer_state state)
1178 {
1179         struct vb2_queue *q = vb->vb2_queue;
1180         unsigned long flags;
1181         unsigned int plane;
1182
1183         if (WARN_ON(vb->state != VB2_BUF_STATE_ACTIVE))
1184                 return;
1185
1186         if (WARN_ON(state != VB2_BUF_STATE_DONE &&
1187                     state != VB2_BUF_STATE_ERROR &&
1188                     state != VB2_BUF_STATE_QUEUED &&
1189                     state != VB2_BUF_STATE_REQUEUEING))
1190                 state = VB2_BUF_STATE_ERROR;
1191
1192 #ifdef CONFIG_VIDEO_ADV_DEBUG
1193         /*
1194          * Although this is not a callback, it still does have to balance
1195          * with the buf_queue op. So update this counter manually.
1196          */
1197         vb->cnt_buf_done++;
1198 #endif
1199         dprintk(4, "done processing on buffer %d, state: %d\n",
1200                         vb->v4l2_buf.index, state);
1201
1202         /* sync buffers */
1203         for (plane = 0; plane < vb->num_planes; ++plane)
1204                 call_void_memop(vb, finish, vb->planes[plane].mem_priv);
1205
1206         spin_lock_irqsave(&q->done_lock, flags);
1207         if (state == VB2_BUF_STATE_QUEUED ||
1208             state == VB2_BUF_STATE_REQUEUEING) {
1209                 vb->state = VB2_BUF_STATE_QUEUED;
1210         } else {
1211                 /* Add the buffer to the done buffers list */
1212                 list_add_tail(&vb->done_entry, &q->done_list);
1213                 vb->state = state;
1214         }
1215         atomic_dec(&q->owned_by_drv_count);
1216         spin_unlock_irqrestore(&q->done_lock, flags);
1217
1218         trace_vb2_buf_done(q, vb);
1219
1220         switch (state) {
1221         case VB2_BUF_STATE_QUEUED:
1222                 return;
1223         case VB2_BUF_STATE_REQUEUEING:
1224                 if (q->start_streaming_called)
1225                         __enqueue_in_driver(vb);
1226                 return;
1227         default:
1228                 /* Inform any processes that may be waiting for buffers */
1229                 wake_up(&q->done_wq);
1230                 break;
1231         }
1232 }
1233 EXPORT_SYMBOL_GPL(vb2_buffer_done);
1234
1235 /**
1236  * vb2_discard_done() - discard all buffers marked as DONE
1237  * @q:          videobuf2 queue
1238  *
1239  * This function is intended to be used with suspend/resume operations. It
1240  * discards all 'done' buffers as they would be too old to be requested after
1241  * resume.
1242  *
1243  * Drivers must stop the hardware and synchronize with interrupt handlers and/or
1244  * delayed works before calling this function to make sure no buffer will be
1245  * touched by the driver and/or hardware.
1246  */
1247 void vb2_discard_done(struct vb2_queue *q)
1248 {
1249         struct vb2_buffer *vb;
1250         unsigned long flags;
1251
1252         spin_lock_irqsave(&q->done_lock, flags);
1253         list_for_each_entry(vb, &q->done_list, done_entry)
1254                 vb->state = VB2_BUF_STATE_ERROR;
1255         spin_unlock_irqrestore(&q->done_lock, flags);
1256 }
1257 EXPORT_SYMBOL_GPL(vb2_discard_done);
1258
1259 static void vb2_warn_zero_bytesused(struct vb2_buffer *vb)
1260 {
1261         static bool check_once;
1262
1263         if (check_once)
1264                 return;
1265
1266         check_once = true;
1267         WARN_ON(1);
1268
1269         pr_warn("use of bytesused == 0 is deprecated and will be removed in the future,\n");
1270         if (vb->vb2_queue->allow_zero_bytesused)
1271                 pr_warn("use VIDIOC_DECODER_CMD(V4L2_DEC_CMD_STOP) instead.\n");
1272         else
1273                 pr_warn("use the actual size instead.\n");
1274 }
1275
1276 /**
1277  * __fill_vb2_buffer() - fill a vb2_buffer with information provided in a
1278  * v4l2_buffer by the userspace. The caller has already verified that struct
1279  * v4l2_buffer has a valid number of planes.
1280  */
1281 static void __fill_vb2_buffer(struct vb2_buffer *vb, const struct v4l2_buffer *b,
1282                                 struct v4l2_plane *v4l2_planes)
1283 {
1284         unsigned int plane;
1285
1286         if (V4L2_TYPE_IS_MULTIPLANAR(b->type)) {
1287                 if (b->memory == V4L2_MEMORY_USERPTR) {
1288                         for (plane = 0; plane < vb->num_planes; ++plane) {
1289                                 v4l2_planes[plane].m.userptr =
1290                                         b->m.planes[plane].m.userptr;
1291                                 v4l2_planes[plane].length =
1292                                         b->m.planes[plane].length;
1293                         }
1294                 }
1295                 if (b->memory == V4L2_MEMORY_DMABUF) {
1296                         for (plane = 0; plane < vb->num_planes; ++plane) {
1297                                 v4l2_planes[plane].m.fd =
1298                                         b->m.planes[plane].m.fd;
1299                                 v4l2_planes[plane].length =
1300                                         b->m.planes[plane].length;
1301                         }
1302                 }
1303
1304                 /* Fill in driver-provided information for OUTPUT types */
1305                 if (V4L2_TYPE_IS_OUTPUT(b->type)) {
1306                         /*
1307                          * Will have to go up to b->length when API starts
1308                          * accepting variable number of planes.
1309                          *
1310                          * If bytesused == 0 for the output buffer, then fall
1311                          * back to the full buffer size. In that case
1312                          * userspace clearly never bothered to set it and
1313                          * it's a safe assumption that they really meant to
1314                          * use the full plane sizes.
1315                          *
1316                          * Some drivers, e.g. old codec drivers, use bytesused == 0
1317                          * as a way to indicate that streaming is finished.
1318                          * In that case, the driver should use the
1319                          * allow_zero_bytesused flag to keep old userspace
1320                          * applications working.
1321                          */
1322                         for (plane = 0; plane < vb->num_planes; ++plane) {
1323                                 struct v4l2_plane *pdst = &v4l2_planes[plane];
1324                                 struct v4l2_plane *psrc = &b->m.planes[plane];
1325
1326                                 if (psrc->bytesused == 0)
1327                                         vb2_warn_zero_bytesused(vb);
1328
1329                                 if (vb->vb2_queue->allow_zero_bytesused)
1330                                         pdst->bytesused = psrc->bytesused;
1331                                 else
1332                                         pdst->bytesused = psrc->bytesused ?
1333                                                 psrc->bytesused : pdst->length;
1334                                 pdst->data_offset = psrc->data_offset;
1335                         }
1336                 }
1337         } else {
1338                 /*
1339                  * Single-planar buffers do not use planes array,
1340                  * so fill in relevant v4l2_buffer struct fields instead.
1341                  * In videobuf we use our internal V4l2_planes struct for
1342                  * single-planar buffers as well, for simplicity.
1343                  *
1344                  * If bytesused == 0 for the output buffer, then fall back
1345                  * to the full buffer size as that's a sensible default.
1346                  *
1347                  * Some drivers, e.g. old codec drivers, use bytesused == 0 as
1348                  * a way to indicate that streaming is finished. In that case,
1349                  * the driver should use the allow_zero_bytesused flag to keep
1350                  * old userspace applications working.
1351                  */
1352                 if (b->memory == V4L2_MEMORY_USERPTR) {
1353                         v4l2_planes[0].m.userptr = b->m.userptr;
1354                         v4l2_planes[0].length = b->length;
1355                 }
1356
1357                 if (b->memory == V4L2_MEMORY_DMABUF) {
1358                         v4l2_planes[0].m.fd = b->m.fd;
1359                         v4l2_planes[0].length = b->length;
1360                 }
1361
1362                 if (V4L2_TYPE_IS_OUTPUT(b->type)) {
1363                         if (b->bytesused == 0)
1364                                 vb2_warn_zero_bytesused(vb);
1365
1366                         if (vb->vb2_queue->allow_zero_bytesused)
1367                                 v4l2_planes[0].bytesused = b->bytesused;
1368                         else
1369                                 v4l2_planes[0].bytesused = b->bytesused ?
1370                                         b->bytesused : v4l2_planes[0].length;
1371                 } else
1372                         v4l2_planes[0].bytesused = 0;
1373
1374         }
1375
1376         /* Zero flags that the vb2 core handles */
1377         vb->v4l2_buf.flags = b->flags & ~V4L2_BUFFER_MASK_FLAGS;
1378         if ((vb->vb2_queue->timestamp_flags & V4L2_BUF_FLAG_TIMESTAMP_MASK) !=
1379             V4L2_BUF_FLAG_TIMESTAMP_COPY || !V4L2_TYPE_IS_OUTPUT(b->type)) {
1380                 /*
1381                  * Non-COPY timestamps and non-OUTPUT queues will get
1382                  * their timestamp and timestamp source flags from the
1383                  * queue.
1384                  */
1385                 vb->v4l2_buf.flags &= ~V4L2_BUF_FLAG_TSTAMP_SRC_MASK;
1386         }
1387
1388         if (V4L2_TYPE_IS_OUTPUT(b->type)) {
1389                 /*
1390                  * For output buffers mask out the timecode flag:
1391                  * this will be handled later in vb2_internal_qbuf().
1392                  * The 'field' is valid metadata for this output buffer
1393                  * and so that needs to be copied here.
1394                  */
1395                 vb->v4l2_buf.flags &= ~V4L2_BUF_FLAG_TIMECODE;
1396                 vb->v4l2_buf.field = b->field;
1397         } else {
1398                 /* Zero any output buffer flags as this is a capture buffer */
1399                 vb->v4l2_buf.flags &= ~V4L2_BUFFER_OUT_FLAGS;
1400         }
1401 }
1402
1403 /**
1404  * __qbuf_mmap() - handle qbuf of an MMAP buffer
1405  */
1406 static int __qbuf_mmap(struct vb2_buffer *vb, const struct v4l2_buffer *b)
1407 {
1408         __fill_vb2_buffer(vb, b, vb->v4l2_planes);
1409         return call_vb_qop(vb, buf_prepare, vb);
1410 }
1411
1412 /**
1413  * __qbuf_userptr() - handle qbuf of a USERPTR buffer
1414  */
1415 static int __qbuf_userptr(struct vb2_buffer *vb, const struct v4l2_buffer *b)
1416 {
1417         struct v4l2_plane planes[VIDEO_MAX_PLANES];
1418         struct vb2_queue *q = vb->vb2_queue;
1419         void *mem_priv;
1420         unsigned int plane;
1421         int ret;
1422         enum dma_data_direction dma_dir =
1423                 V4L2_TYPE_IS_OUTPUT(q->type) ? DMA_TO_DEVICE : DMA_FROM_DEVICE;
1424         bool reacquired = vb->planes[0].mem_priv == NULL;
1425
1426         memset(planes, 0, sizeof(planes[0]) * vb->num_planes);
1427         /* Copy relevant information provided by the userspace */
1428         __fill_vb2_buffer(vb, b, planes);
1429
1430         for (plane = 0; plane < vb->num_planes; ++plane) {
1431                 /* Skip the plane if already verified */
1432                 if (vb->v4l2_planes[plane].m.userptr &&
1433                     vb->v4l2_planes[plane].m.userptr == planes[plane].m.userptr
1434                     && vb->v4l2_planes[plane].length == planes[plane].length)
1435                         continue;
1436
1437                 dprintk(3, "userspace address for plane %d changed, "
1438                                 "reacquiring memory\n", plane);
1439
1440                 /* Check if the provided plane buffer is large enough */
1441                 if (planes[plane].length < q->plane_sizes[plane]) {
1442                         dprintk(1, "provided buffer size %u is less than "
1443                                                 "setup size %u for plane %d\n",
1444                                                 planes[plane].length,
1445                                                 q->plane_sizes[plane], plane);
1446                         ret = -EINVAL;
1447                         goto err;
1448                 }
1449
1450                 /* Release previously acquired memory if present */
1451                 if (vb->planes[plane].mem_priv) {
1452                         if (!reacquired) {
1453                                 reacquired = true;
1454                                 call_void_vb_qop(vb, buf_cleanup, vb);
1455                         }
1456                         call_void_memop(vb, put_userptr, vb->planes[plane].mem_priv);
1457                 }
1458
1459                 vb->planes[plane].mem_priv = NULL;
1460                 memset(&vb->v4l2_planes[plane], 0, sizeof(struct v4l2_plane));
1461
1462                 /* Acquire each plane's memory */
1463                 mem_priv = call_ptr_memop(vb, get_userptr, q->alloc_ctx[plane],
1464                                       planes[plane].m.userptr,
1465                                       planes[plane].length, dma_dir);
1466                 if (IS_ERR_OR_NULL(mem_priv)) {
1467                         dprintk(1, "failed acquiring userspace "
1468                                                 "memory for plane %d\n", plane);
1469                         ret = mem_priv ? PTR_ERR(mem_priv) : -EINVAL;
1470                         goto err;
1471                 }
1472                 vb->planes[plane].mem_priv = mem_priv;
1473         }
1474
1475         /*
1476          * Now that everything is in order, copy relevant information
1477          * provided by userspace.
1478          */
1479         for (plane = 0; plane < vb->num_planes; ++plane)
1480                 vb->v4l2_planes[plane] = planes[plane];
1481
1482         if (reacquired) {
1483                 /*
1484                  * One or more planes changed, so we must call buf_init to do
1485                  * the driver-specific initialization on the newly acquired
1486                  * buffer, if provided.
1487                  */
1488                 ret = call_vb_qop(vb, buf_init, vb);
1489                 if (ret) {
1490                         dprintk(1, "buffer initialization failed\n");
1491                         goto err;
1492                 }
1493         }
1494
1495         ret = call_vb_qop(vb, buf_prepare, vb);
1496         if (ret) {
1497                 dprintk(1, "buffer preparation failed\n");
1498                 call_void_vb_qop(vb, buf_cleanup, vb);
1499                 goto err;
1500         }
1501
1502         return 0;
1503 err:
1504         /* In case of errors, release planes that were already acquired */
1505         for (plane = 0; plane < vb->num_planes; ++plane) {
1506                 if (vb->planes[plane].mem_priv)
1507                         call_void_memop(vb, put_userptr, vb->planes[plane].mem_priv);
1508                 vb->planes[plane].mem_priv = NULL;
1509                 vb->v4l2_planes[plane].m.userptr = 0;
1510                 vb->v4l2_planes[plane].length = 0;
1511         }
1512
1513         return ret;
1514 }
1515
1516 /**
1517  * __qbuf_dmabuf() - handle qbuf of a DMABUF buffer
1518  */
1519 static int __qbuf_dmabuf(struct vb2_buffer *vb, const struct v4l2_buffer *b)
1520 {
1521         struct v4l2_plane planes[VIDEO_MAX_PLANES];
1522         struct vb2_queue *q = vb->vb2_queue;
1523         void *mem_priv;
1524         unsigned int plane;
1525         int ret;
1526         enum dma_data_direction dma_dir =
1527                 V4L2_TYPE_IS_OUTPUT(q->type) ? DMA_TO_DEVICE : DMA_FROM_DEVICE;
1528         bool reacquired = vb->planes[0].mem_priv == NULL;
1529
1530         memset(planes, 0, sizeof(planes[0]) * vb->num_planes);
1531         /* Copy relevant information provided by the userspace */
1532         __fill_vb2_buffer(vb, b, planes);
1533
1534         for (plane = 0; plane < vb->num_planes; ++plane) {
1535                 struct dma_buf *dbuf = dma_buf_get(planes[plane].m.fd);
1536
1537                 if (IS_ERR_OR_NULL(dbuf)) {
1538                         dprintk(1, "invalid dmabuf fd for plane %d\n",
1539                                 plane);
1540                         ret = -EINVAL;
1541                         goto err;
1542                 }
1543
1544                 /* use DMABUF size if length is not provided */
1545                 if (planes[plane].length == 0)
1546                         planes[plane].length = dbuf->size;
1547
1548                 if (planes[plane].length < q->plane_sizes[plane]) {
1549                         dprintk(1, "invalid dmabuf length for plane %d\n",
1550                                 plane);
1551                         ret = -EINVAL;
1552                         goto err;
1553                 }
1554
1555                 /* Skip the plane if already verified */
1556                 if (dbuf == vb->planes[plane].dbuf &&
1557                     vb->v4l2_planes[plane].length == planes[plane].length) {
1558                         dma_buf_put(dbuf);
1559                         continue;
1560                 }
1561
1562                 dprintk(1, "buffer for plane %d changed\n", plane);
1563
1564                 if (!reacquired) {
1565                         reacquired = true;
1566                         call_void_vb_qop(vb, buf_cleanup, vb);
1567                 }
1568
1569                 /* Release previously acquired memory if present */
1570                 __vb2_plane_dmabuf_put(vb, &vb->planes[plane]);
1571                 memset(&vb->v4l2_planes[plane], 0, sizeof(struct v4l2_plane));
1572
1573                 /* Acquire each plane's memory */
1574                 mem_priv = call_ptr_memop(vb, attach_dmabuf, q->alloc_ctx[plane],
1575                         dbuf, planes[plane].length, dma_dir);
1576                 if (IS_ERR(mem_priv)) {
1577                         dprintk(1, "failed to attach dmabuf\n");
1578                         ret = PTR_ERR(mem_priv);
1579                         dma_buf_put(dbuf);
1580                         goto err;
1581                 }
1582
1583                 vb->planes[plane].dbuf = dbuf;
1584                 vb->planes[plane].mem_priv = mem_priv;
1585         }
1586
1587         /* TODO: This pins the buffer(s) with  dma_buf_map_attachment()).. but
1588          * really we want to do this just before the DMA, not while queueing
1589          * the buffer(s)..
1590          */
1591         for (plane = 0; plane < vb->num_planes; ++plane) {
1592                 ret = call_memop(vb, map_dmabuf, vb->planes[plane].mem_priv);
1593                 if (ret) {
1594                         dprintk(1, "failed to map dmabuf for plane %d\n",
1595                                 plane);
1596                         goto err;
1597                 }
1598                 vb->planes[plane].dbuf_mapped = 1;
1599         }
1600
1601         /*
1602          * Now that everything is in order, copy relevant information
1603          * provided by userspace.
1604          */
1605         for (plane = 0; plane < vb->num_planes; ++plane)
1606                 vb->v4l2_planes[plane] = planes[plane];
1607
1608         if (reacquired) {
1609                 /*
1610                  * Call driver-specific initialization on the newly acquired buffer,
1611                  * if provided.
1612                  */
1613                 ret = call_vb_qop(vb, buf_init, vb);
1614                 if (ret) {
1615                         dprintk(1, "buffer initialization failed\n");
1616                         goto err;
1617                 }
1618         }
1619
1620         ret = call_vb_qop(vb, buf_prepare, vb);
1621         if (ret) {
1622                 dprintk(1, "buffer preparation failed\n");
1623                 call_void_vb_qop(vb, buf_cleanup, vb);
1624                 goto err;
1625         }
1626
1627         return 0;
1628 err:
1629         /* In case of errors, release planes that were already acquired */
1630         __vb2_buf_dmabuf_put(vb);
1631
1632         return ret;
1633 }
1634
1635 /**
1636  * __enqueue_in_driver() - enqueue a vb2_buffer in driver for processing
1637  */
1638 static void __enqueue_in_driver(struct vb2_buffer *vb)
1639 {
1640         struct vb2_queue *q = vb->vb2_queue;
1641         unsigned int plane;
1642
1643         vb->state = VB2_BUF_STATE_ACTIVE;
1644         atomic_inc(&q->owned_by_drv_count);
1645
1646         trace_vb2_buf_queue(q, vb);
1647
1648         /* sync buffers */
1649         for (plane = 0; plane < vb->num_planes; ++plane)
1650                 call_void_memop(vb, prepare, vb->planes[plane].mem_priv);
1651
1652         call_void_vb_qop(vb, buf_queue, vb);
1653 }
1654
1655 static int __buf_prepare(struct vb2_buffer *vb, const struct v4l2_buffer *b)
1656 {
1657         struct vb2_queue *q = vb->vb2_queue;
1658         int ret;
1659
1660         ret = __verify_length(vb, b);
1661         if (ret < 0) {
1662                 dprintk(1, "plane parameters verification failed: %d\n", ret);
1663                 return ret;
1664         }
1665         if (b->field == V4L2_FIELD_ALTERNATE && V4L2_TYPE_IS_OUTPUT(q->type)) {
1666                 /*
1667                  * If the format's field is ALTERNATE, then the buffer's field
1668                  * should be either TOP or BOTTOM, not ALTERNATE since that
1669                  * makes no sense. The driver has to know whether the
1670                  * buffer represents a top or a bottom field in order to
1671                  * program any DMA correctly. Using ALTERNATE is wrong, since
1672                  * that just says that it is either a top or a bottom field,
1673                  * but not which of the two it is.
1674                  */
1675                 dprintk(1, "the field is incorrectly set to ALTERNATE for an output buffer\n");
1676                 return -EINVAL;
1677         }
1678
1679         if (q->error) {
1680                 dprintk(1, "fatal error occurred on queue\n");
1681                 return -EIO;
1682         }
1683
1684         vb->state = VB2_BUF_STATE_PREPARING;
1685         vb->v4l2_buf.timestamp.tv_sec = 0;
1686         vb->v4l2_buf.timestamp.tv_usec = 0;
1687         vb->v4l2_buf.sequence = 0;
1688
1689         switch (q->memory) {
1690         case V4L2_MEMORY_MMAP:
1691                 ret = __qbuf_mmap(vb, b);
1692                 break;
1693         case V4L2_MEMORY_USERPTR:
1694                 ret = __qbuf_userptr(vb, b);
1695                 break;
1696         case V4L2_MEMORY_DMABUF:
1697                 ret = __qbuf_dmabuf(vb, b);
1698                 break;
1699         default:
1700                 WARN(1, "Invalid queue type\n");
1701                 ret = -EINVAL;
1702         }
1703
1704         if (ret)
1705                 dprintk(1, "buffer preparation failed: %d\n", ret);
1706         vb->state = ret ? VB2_BUF_STATE_DEQUEUED : VB2_BUF_STATE_PREPARED;
1707
1708         return ret;
1709 }
1710
1711 static int vb2_queue_or_prepare_buf(struct vb2_queue *q, struct v4l2_buffer *b,
1712                                     const char *opname)
1713 {
1714         if (b->type != q->type) {
1715                 dprintk(1, "%s: invalid buffer type\n", opname);
1716                 return -EINVAL;
1717         }
1718
1719         if (b->index >= q->num_buffers) {
1720                 dprintk(1, "%s: buffer index out of range\n", opname);
1721                 return -EINVAL;
1722         }
1723
1724         if (q->bufs[b->index] == NULL) {
1725                 /* Should never happen */
1726                 dprintk(1, "%s: buffer is NULL\n", opname);
1727                 return -EINVAL;
1728         }
1729
1730         if (b->memory != q->memory) {
1731                 dprintk(1, "%s: invalid memory type\n", opname);
1732                 return -EINVAL;
1733         }
1734
1735         return __verify_planes_array(q->bufs[b->index], b);
1736 }
1737
1738 /**
1739  * vb2_prepare_buf() - Pass ownership of a buffer from userspace to the kernel
1740  * @q:          videobuf2 queue
1741  * @b:          buffer structure passed from userspace to vidioc_prepare_buf
1742  *              handler in driver
1743  *
1744  * Should be called from vidioc_prepare_buf ioctl handler of a driver.
1745  * This function:
1746  * 1) verifies the passed buffer,
1747  * 2) calls buf_prepare callback in the driver (if provided), in which
1748  *    driver-specific buffer initialization can be performed,
1749  *
1750  * The return values from this function are intended to be directly returned
1751  * from vidioc_prepare_buf handler in driver.
1752  */
1753 int vb2_prepare_buf(struct vb2_queue *q, struct v4l2_buffer *b)
1754 {
1755         struct vb2_buffer *vb;
1756         int ret;
1757
1758         if (vb2_fileio_is_active(q)) {
1759                 dprintk(1, "file io in progress\n");
1760                 return -EBUSY;
1761         }
1762
1763         ret = vb2_queue_or_prepare_buf(q, b, "prepare_buf");
1764         if (ret)
1765                 return ret;
1766
1767         vb = q->bufs[b->index];
1768         if (vb->state != VB2_BUF_STATE_DEQUEUED) {
1769                 dprintk(1, "invalid buffer state %d\n",
1770                         vb->state);
1771                 return -EINVAL;
1772         }
1773
1774         ret = __buf_prepare(vb, b);
1775         if (!ret) {
1776                 /* Fill buffer information for the userspace */
1777                 __fill_v4l2_buffer(vb, b);
1778
1779                 dprintk(1, "prepare of buffer %d succeeded\n", vb->v4l2_buf.index);
1780         }
1781         return ret;
1782 }
1783 EXPORT_SYMBOL_GPL(vb2_prepare_buf);
1784
1785 /**
1786  * vb2_start_streaming() - Attempt to start streaming.
1787  * @q:          videobuf2 queue
1788  *
1789  * Attempt to start streaming. When this function is called there must be
1790  * at least q->min_buffers_needed buffers queued up (i.e. the minimum
1791  * number of buffers required for the DMA engine to function). If the
1792  * @start_streaming op fails it is supposed to return all the driver-owned
1793  * buffers back to vb2 in state QUEUED. Check if that happened and if
1794  * not warn and reclaim them forcefully.
1795  */
1796 static int vb2_start_streaming(struct vb2_queue *q)
1797 {
1798         struct vb2_buffer *vb;
1799         int ret;
1800
1801         /*
1802          * If any buffers were queued before streamon,
1803          * we can now pass them to driver for processing.
1804          */
1805         list_for_each_entry(vb, &q->queued_list, queued_entry)
1806                 __enqueue_in_driver(vb);
1807
1808         /* Tell the driver to start streaming */
1809         q->start_streaming_called = 1;
1810         ret = call_qop(q, start_streaming, q,
1811                        atomic_read(&q->owned_by_drv_count));
1812         if (!ret)
1813                 return 0;
1814
1815         q->start_streaming_called = 0;
1816
1817         dprintk(1, "driver refused to start streaming\n");
1818         /*
1819          * If you see this warning, then the driver isn't cleaning up properly
1820          * after a failed start_streaming(). See the start_streaming()
1821          * documentation in videobuf2-v4l2.h for more information how buffers
1822          * should be returned to vb2 in start_streaming().
1823          */
1824         if (WARN_ON(atomic_read(&q->owned_by_drv_count))) {
1825                 unsigned i;
1826
1827                 /*
1828                  * Forcefully reclaim buffers if the driver did not
1829                  * correctly return them to vb2.
1830                  */
1831                 for (i = 0; i < q->num_buffers; ++i) {
1832                         vb = q->bufs[i];
1833                         if (vb->state == VB2_BUF_STATE_ACTIVE)
1834                                 vb2_buffer_done(vb, VB2_BUF_STATE_QUEUED);
1835                 }
1836                 /* Must be zero now */
1837                 WARN_ON(atomic_read(&q->owned_by_drv_count));
1838         }
1839         /*
1840          * If done_list is not empty, then start_streaming() didn't call
1841          * vb2_buffer_done(vb, VB2_BUF_STATE_QUEUED) but STATE_ERROR or
1842          * STATE_DONE.
1843          */
1844         WARN_ON(!list_empty(&q->done_list));
1845         return ret;
1846 }
1847
1848 static int vb2_internal_qbuf(struct vb2_queue *q, struct v4l2_buffer *b)
1849 {
1850         int ret = vb2_queue_or_prepare_buf(q, b, "qbuf");
1851         struct vb2_buffer *vb;
1852
1853         if (ret)
1854                 return ret;
1855
1856         vb = q->bufs[b->index];
1857
1858         switch (vb->state) {
1859         case VB2_BUF_STATE_DEQUEUED:
1860                 ret = __buf_prepare(vb, b);
1861                 if (ret)
1862                         return ret;
1863                 break;
1864         case VB2_BUF_STATE_PREPARED:
1865                 break;
1866         case VB2_BUF_STATE_PREPARING:
1867                 dprintk(1, "buffer still being prepared\n");
1868                 return -EINVAL;
1869         default:
1870                 dprintk(1, "invalid buffer state %d\n", vb->state);
1871                 return -EINVAL;
1872         }
1873
1874         /*
1875          * Add to the queued buffers list, a buffer will stay on it until
1876          * dequeued in dqbuf.
1877          */
1878         list_add_tail(&vb->queued_entry, &q->queued_list);
1879         q->queued_count++;
1880         q->waiting_for_buffers = false;
1881         vb->state = VB2_BUF_STATE_QUEUED;
1882         if (V4L2_TYPE_IS_OUTPUT(q->type)) {
1883                 /*
1884                  * For output buffers copy the timestamp if needed,
1885                  * and the timecode field and flag if needed.
1886                  */
1887                 if ((q->timestamp_flags & V4L2_BUF_FLAG_TIMESTAMP_MASK) ==
1888                     V4L2_BUF_FLAG_TIMESTAMP_COPY)
1889                         vb->v4l2_buf.timestamp = b->timestamp;
1890                 vb->v4l2_buf.flags |= b->flags & V4L2_BUF_FLAG_TIMECODE;
1891                 if (b->flags & V4L2_BUF_FLAG_TIMECODE)
1892                         vb->v4l2_buf.timecode = b->timecode;
1893         }
1894
1895         trace_vb2_qbuf(q, vb);
1896
1897         /*
1898          * If already streaming, give the buffer to driver for processing.
1899          * If not, the buffer will be given to driver on next streamon.
1900          */
1901         if (q->start_streaming_called)
1902                 __enqueue_in_driver(vb);
1903
1904         /* Fill buffer information for the userspace */
1905         __fill_v4l2_buffer(vb, b);
1906
1907         /*
1908          * If streamon has been called, and we haven't yet called
1909          * start_streaming() since not enough buffers were queued, and
1910          * we now have reached the minimum number of queued buffers,
1911          * then we can finally call start_streaming().
1912          */
1913         if (q->streaming && !q->start_streaming_called &&
1914             q->queued_count >= q->min_buffers_needed) {
1915                 ret = vb2_start_streaming(q);
1916                 if (ret)
1917                         return ret;
1918         }
1919
1920         dprintk(1, "qbuf of buffer %d succeeded\n", vb->v4l2_buf.index);
1921         return 0;
1922 }
1923
1924 /**
1925  * vb2_qbuf() - Queue a buffer from userspace
1926  * @q:          videobuf2 queue
1927  * @b:          buffer structure passed from userspace to vidioc_qbuf handler
1928  *              in driver
1929  *
1930  * Should be called from vidioc_qbuf ioctl handler of a driver.
1931  * This function:
1932  * 1) verifies the passed buffer,
1933  * 2) if necessary, calls buf_prepare callback in the driver (if provided), in
1934  *    which driver-specific buffer initialization can be performed,
1935  * 3) if streaming is on, queues the buffer in driver by the means of buf_queue
1936  *    callback for processing.
1937  *
1938  * The return values from this function are intended to be directly returned
1939  * from vidioc_qbuf handler in driver.
1940  */
1941 int vb2_qbuf(struct vb2_queue *q, struct v4l2_buffer *b)
1942 {
1943         if (vb2_fileio_is_active(q)) {
1944                 dprintk(1, "file io in progress\n");
1945                 return -EBUSY;
1946         }
1947
1948         return vb2_internal_qbuf(q, b);
1949 }
1950 EXPORT_SYMBOL_GPL(vb2_qbuf);
1951
1952 /**
1953  * __vb2_wait_for_done_vb() - wait for a buffer to become available
1954  * for dequeuing
1955  *
1956  * Will sleep if required for nonblocking == false.
1957  */
1958 static int __vb2_wait_for_done_vb(struct vb2_queue *q, int nonblocking)
1959 {
1960         /*
1961          * All operations on vb_done_list are performed under done_lock
1962          * spinlock protection. However, buffers may be removed from
1963          * it and returned to userspace only while holding both driver's
1964          * lock and the done_lock spinlock. Thus we can be sure that as
1965          * long as we hold the driver's lock, the list will remain not
1966          * empty if list_empty() check succeeds.
1967          */
1968
1969         for (;;) {
1970                 int ret;
1971
1972                 if (!q->streaming) {
1973                         dprintk(1, "streaming off, will not wait for buffers\n");
1974                         return -EINVAL;
1975                 }
1976
1977                 if (q->error) {
1978                         dprintk(1, "Queue in error state, will not wait for buffers\n");
1979                         return -EIO;
1980                 }
1981
1982                 if (q->last_buffer_dequeued) {
1983                         dprintk(3, "last buffer dequeued already, will not wait for buffers\n");
1984                         return -EPIPE;
1985                 }
1986
1987                 if (!list_empty(&q->done_list)) {
1988                         /*
1989                          * Found a buffer that we were waiting for.
1990                          */
1991                         break;
1992                 }
1993
1994                 if (nonblocking) {
1995                         dprintk(1, "nonblocking and no buffers to dequeue, "
1996                                                                 "will not wait\n");
1997                         return -EAGAIN;
1998                 }
1999
2000                 /*
2001                  * We are streaming and blocking, wait for another buffer to
2002                  * become ready or for streamoff. Driver's lock is released to
2003                  * allow streamoff or qbuf to be called while waiting.
2004                  */
2005                 call_void_qop(q, wait_prepare, q);
2006
2007                 /*
2008                  * All locks have been released, it is safe to sleep now.
2009                  */
2010                 dprintk(3, "will sleep waiting for buffers\n");
2011                 ret = wait_event_interruptible(q->done_wq,
2012                                 !list_empty(&q->done_list) || !q->streaming ||
2013                                 q->error);
2014
2015                 /*
2016                  * We need to reevaluate both conditions again after reacquiring
2017                  * the locks or return an error if one occurred.
2018                  */
2019                 call_void_qop(q, wait_finish, q);
2020                 if (ret) {
2021                         dprintk(1, "sleep was interrupted\n");
2022                         return ret;
2023                 }
2024         }
2025         return 0;
2026 }
2027
2028 /**
2029  * __vb2_get_done_vb() - get a buffer ready for dequeuing
2030  *
2031  * Will sleep if required for nonblocking == false.
2032  */
2033 static int __vb2_get_done_vb(struct vb2_queue *q, struct vb2_buffer **vb,
2034                                 struct v4l2_buffer *b, int nonblocking)
2035 {
2036         unsigned long flags;
2037         int ret;
2038
2039         /*
2040          * Wait for at least one buffer to become available on the done_list.
2041          */
2042         ret = __vb2_wait_for_done_vb(q, nonblocking);
2043         if (ret)
2044                 return ret;
2045
2046         /*
2047          * Driver's lock has been held since we last verified that done_list
2048          * is not empty, so no need for another list_empty(done_list) check.
2049          */
2050         spin_lock_irqsave(&q->done_lock, flags);
2051         *vb = list_first_entry(&q->done_list, struct vb2_buffer, done_entry);
2052         /*
2053          * Only remove the buffer from done_list if v4l2_buffer can handle all
2054          * the planes.
2055          */
2056         ret = __verify_planes_array(*vb, b);
2057         if (!ret)
2058                 list_del(&(*vb)->done_entry);
2059         spin_unlock_irqrestore(&q->done_lock, flags);
2060
2061         return ret;
2062 }
2063
2064 /**
2065  * vb2_wait_for_all_buffers() - wait until all buffers are given back to vb2
2066  * @q:          videobuf2 queue
2067  *
2068  * This function will wait until all buffers that have been given to the driver
2069  * by buf_queue() are given back to vb2 with vb2_buffer_done(). It doesn't call
2070  * wait_prepare, wait_finish pair. It is intended to be called with all locks
2071  * taken, for example from stop_streaming() callback.
2072  */
2073 int vb2_wait_for_all_buffers(struct vb2_queue *q)
2074 {
2075         if (!q->streaming) {
2076                 dprintk(1, "streaming off, will not wait for buffers\n");
2077                 return -EINVAL;
2078         }
2079
2080         if (q->start_streaming_called)
2081                 wait_event(q->done_wq, !atomic_read(&q->owned_by_drv_count));
2082         return 0;
2083 }
2084 EXPORT_SYMBOL_GPL(vb2_wait_for_all_buffers);
2085
2086 /**
2087  * __vb2_dqbuf() - bring back the buffer to the DEQUEUED state
2088  */
2089 static void __vb2_dqbuf(struct vb2_buffer *vb)
2090 {
2091         struct vb2_queue *q = vb->vb2_queue;
2092         unsigned int i;
2093
2094         /* nothing to do if the buffer is already dequeued */
2095         if (vb->state == VB2_BUF_STATE_DEQUEUED)
2096                 return;
2097
2098         vb->state = VB2_BUF_STATE_DEQUEUED;
2099
2100         /* unmap DMABUF buffer */
2101         if (q->memory == V4L2_MEMORY_DMABUF)
2102                 for (i = 0; i < vb->num_planes; ++i) {
2103                         if (!vb->planes[i].dbuf_mapped)
2104                                 continue;
2105                         call_void_memop(vb, unmap_dmabuf, vb->planes[i].mem_priv);
2106                         vb->planes[i].dbuf_mapped = 0;
2107                 }
2108 }
2109
2110 static int vb2_internal_dqbuf(struct vb2_queue *q, struct v4l2_buffer *b, bool nonblocking)
2111 {
2112         struct vb2_buffer *vb = NULL;
2113         int ret;
2114
2115         if (b->type != q->type) {
2116                 dprintk(1, "invalid buffer type\n");
2117                 return -EINVAL;
2118         }
2119         ret = __vb2_get_done_vb(q, &vb, b, nonblocking);
2120         if (ret < 0)
2121                 return ret;
2122
2123         switch (vb->state) {
2124         case VB2_BUF_STATE_DONE:
2125                 dprintk(3, "returning done buffer\n");
2126                 break;
2127         case VB2_BUF_STATE_ERROR:
2128                 dprintk(3, "returning done buffer with errors\n");
2129                 break;
2130         default:
2131                 dprintk(1, "invalid buffer state\n");
2132                 return -EINVAL;
2133         }
2134
2135         call_void_vb_qop(vb, buf_finish, vb);
2136
2137         /* Fill buffer information for the userspace */
2138         __fill_v4l2_buffer(vb, b);
2139         /* Remove from videobuf queue */
2140         list_del(&vb->queued_entry);
2141         q->queued_count--;
2142
2143         trace_vb2_dqbuf(q, vb);
2144
2145         if (!V4L2_TYPE_IS_OUTPUT(q->type) &&
2146             vb->v4l2_buf.flags & V4L2_BUF_FLAG_LAST)
2147                 q->last_buffer_dequeued = true;
2148         /* go back to dequeued state */
2149         __vb2_dqbuf(vb);
2150
2151         dprintk(1, "dqbuf of buffer %d, with state %d\n",
2152                         vb->v4l2_buf.index, vb->state);
2153
2154         return 0;
2155 }
2156
2157 /**
2158  * vb2_dqbuf() - Dequeue a buffer to the userspace
2159  * @q:          videobuf2 queue
2160  * @b:          buffer structure passed from userspace to vidioc_dqbuf handler
2161  *              in driver
2162  * @nonblocking: if true, this call will not sleep waiting for a buffer if no
2163  *               buffers ready for dequeuing are present. Normally the driver
2164  *               would be passing (file->f_flags & O_NONBLOCK) here
2165  *
2166  * Should be called from vidioc_dqbuf ioctl handler of a driver.
2167  * This function:
2168  * 1) verifies the passed buffer,
2169  * 2) calls buf_finish callback in the driver (if provided), in which
2170  *    driver can perform any additional operations that may be required before
2171  *    returning the buffer to userspace, such as cache sync,
2172  * 3) the buffer struct members are filled with relevant information for
2173  *    the userspace.
2174  *
2175  * The return values from this function are intended to be directly returned
2176  * from vidioc_dqbuf handler in driver.
2177  */
2178 int vb2_dqbuf(struct vb2_queue *q, struct v4l2_buffer *b, bool nonblocking)
2179 {
2180         if (vb2_fileio_is_active(q)) {
2181                 dprintk(1, "file io in progress\n");
2182                 return -EBUSY;
2183         }
2184         return vb2_internal_dqbuf(q, b, nonblocking);
2185 }
2186 EXPORT_SYMBOL_GPL(vb2_dqbuf);
2187
2188 /**
2189  * __vb2_queue_cancel() - cancel and stop (pause) streaming
2190  *
2191  * Removes all queued buffers from driver's queue and all buffers queued by
2192  * userspace from videobuf's queue. Returns to state after reqbufs.
2193  */
2194 static void __vb2_queue_cancel(struct vb2_queue *q)
2195 {
2196         unsigned int i;
2197
2198         /*
2199          * Tell driver to stop all transactions and release all queued
2200          * buffers.
2201          */
2202         if (q->start_streaming_called)
2203                 call_void_qop(q, stop_streaming, q);
2204
2205         /*
2206          * If you see this warning, then the driver isn't cleaning up properly
2207          * in stop_streaming(). See the stop_streaming() documentation in
2208          * videobuf2-v4l2.h for more information how buffers should be returned
2209          * to vb2 in stop_streaming().
2210          */
2211         if (WARN_ON(atomic_read(&q->owned_by_drv_count))) {
2212                 for (i = 0; i < q->num_buffers; ++i)
2213                         if (q->bufs[i]->state == VB2_BUF_STATE_ACTIVE)
2214                                 vb2_buffer_done(q->bufs[i], VB2_BUF_STATE_ERROR);
2215                 /* Must be zero now */
2216                 WARN_ON(atomic_read(&q->owned_by_drv_count));
2217         }
2218
2219         q->streaming = 0;
2220         q->start_streaming_called = 0;
2221         q->queued_count = 0;
2222         q->error = 0;
2223
2224         /*
2225          * Remove all buffers from videobuf's list...
2226          */
2227         INIT_LIST_HEAD(&q->queued_list);
2228         /*
2229          * ...and done list; userspace will not receive any buffers it
2230          * has not already dequeued before initiating cancel.
2231          */
2232         INIT_LIST_HEAD(&q->done_list);
2233         atomic_set(&q->owned_by_drv_count, 0);
2234         wake_up_all(&q->done_wq);
2235
2236         /*
2237          * Reinitialize all buffers for next use.
2238          * Make sure to call buf_finish for any queued buffers. Normally
2239          * that's done in dqbuf, but that's not going to happen when we
2240          * cancel the whole queue. Note: this code belongs here, not in
2241          * __vb2_dqbuf() since in vb2_internal_dqbuf() there is a critical
2242          * call to __fill_v4l2_buffer() after buf_finish(). That order can't
2243          * be changed, so we can't move the buf_finish() to __vb2_dqbuf().
2244          */
2245         for (i = 0; i < q->num_buffers; ++i) {
2246                 struct vb2_buffer *vb = q->bufs[i];
2247
2248                 if (vb->state != VB2_BUF_STATE_DEQUEUED) {
2249                         vb->state = VB2_BUF_STATE_PREPARED;
2250                         call_void_vb_qop(vb, buf_finish, vb);
2251                 }
2252                 __vb2_dqbuf(vb);
2253         }
2254 }
2255
2256 static int vb2_internal_streamon(struct vb2_queue *q, enum v4l2_buf_type type)
2257 {
2258         int ret;
2259
2260         if (type != q->type) {
2261                 dprintk(1, "invalid stream type\n");
2262                 return -EINVAL;
2263         }
2264
2265         if (q->streaming) {
2266                 dprintk(3, "already streaming\n");
2267                 return 0;
2268         }
2269
2270         if (!q->num_buffers) {
2271                 dprintk(1, "no buffers have been allocated\n");
2272                 return -EINVAL;
2273         }
2274
2275         if (q->num_buffers < q->min_buffers_needed) {
2276                 dprintk(1, "need at least %u allocated buffers\n",
2277                                 q->min_buffers_needed);
2278                 return -EINVAL;
2279         }
2280
2281         /*
2282          * Tell driver to start streaming provided sufficient buffers
2283          * are available.
2284          */
2285         if (q->queued_count >= q->min_buffers_needed) {
2286                 ret = vb2_start_streaming(q);
2287                 if (ret) {
2288                         __vb2_queue_cancel(q);
2289                         return ret;
2290                 }
2291         }
2292
2293         q->streaming = 1;
2294
2295         dprintk(3, "successful\n");
2296         return 0;
2297 }
2298
2299 /**
2300  * vb2_queue_error() - signal a fatal error on the queue
2301  * @q:          videobuf2 queue
2302  *
2303  * Flag that a fatal unrecoverable error has occurred and wake up all processes
2304  * waiting on the queue. Polling will now set POLLERR and queuing and dequeuing
2305  * buffers will return -EIO.
2306  *
2307  * The error flag will be cleared when cancelling the queue, either from
2308  * vb2_streamoff or vb2_queue_release. Drivers should thus not call this
2309  * function before starting the stream, otherwise the error flag will remain set
2310  * until the queue is released when closing the device node.
2311  */
2312 void vb2_queue_error(struct vb2_queue *q)
2313 {
2314         q->error = 1;
2315
2316         wake_up_all(&q->done_wq);
2317 }
2318 EXPORT_SYMBOL_GPL(vb2_queue_error);
2319
2320 /**
2321  * vb2_streamon - start streaming
2322  * @q:          videobuf2 queue
2323  * @type:       type argument passed from userspace to vidioc_streamon handler
2324  *
2325  * Should be called from vidioc_streamon handler of a driver.
2326  * This function:
2327  * 1) verifies current state
2328  * 2) passes any previously queued buffers to the driver and starts streaming
2329  *
2330  * The return values from this function are intended to be directly returned
2331  * from vidioc_streamon handler in the driver.
2332  */
2333 int vb2_streamon(struct vb2_queue *q, enum v4l2_buf_type type)
2334 {
2335         if (vb2_fileio_is_active(q)) {
2336                 dprintk(1, "file io in progress\n");
2337                 return -EBUSY;
2338         }
2339         return vb2_internal_streamon(q, type);
2340 }
2341 EXPORT_SYMBOL_GPL(vb2_streamon);
2342
2343 static int vb2_internal_streamoff(struct vb2_queue *q, enum v4l2_buf_type type)
2344 {
2345         if (type != q->type) {
2346                 dprintk(1, "invalid stream type\n");
2347                 return -EINVAL;
2348         }
2349
2350         /*
2351          * Cancel will pause streaming and remove all buffers from the driver
2352          * and videobuf, effectively returning control over them to userspace.
2353          *
2354          * Note that we do this even if q->streaming == 0: if you prepare or
2355          * queue buffers, and then call streamoff without ever having called
2356          * streamon, you would still expect those buffers to be returned to
2357          * their normal dequeued state.
2358          */
2359         __vb2_queue_cancel(q);
2360         q->waiting_for_buffers = !V4L2_TYPE_IS_OUTPUT(q->type);
2361         q->last_buffer_dequeued = false;
2362
2363         dprintk(3, "successful\n");
2364         return 0;
2365 }
2366
2367 /**
2368  * vb2_streamoff - stop streaming
2369  * @q:          videobuf2 queue
2370  * @type:       type argument passed from userspace to vidioc_streamoff handler
2371  *
2372  * Should be called from vidioc_streamoff handler of a driver.
2373  * This function:
2374  * 1) verifies current state,
2375  * 2) stop streaming and dequeues any queued buffers, including those previously
2376  *    passed to the driver (after waiting for the driver to finish).
2377  *
2378  * This call can be used for pausing playback.
2379  * The return values from this function are intended to be directly returned
2380  * from vidioc_streamoff handler in the driver
2381  */
2382 int vb2_streamoff(struct vb2_queue *q, enum v4l2_buf_type type)
2383 {
2384         if (vb2_fileio_is_active(q)) {
2385                 dprintk(1, "file io in progress\n");
2386                 return -EBUSY;
2387         }
2388         return vb2_internal_streamoff(q, type);
2389 }
2390 EXPORT_SYMBOL_GPL(vb2_streamoff);
2391
2392 /**
2393  * __find_plane_by_offset() - find plane associated with the given offset off
2394  */
2395 static int __find_plane_by_offset(struct vb2_queue *q, unsigned long off,
2396                         unsigned int *_buffer, unsigned int *_plane)
2397 {
2398         struct vb2_buffer *vb;
2399         unsigned int buffer, plane;
2400
2401         /*
2402          * Go over all buffers and their planes, comparing the given offset
2403          * with an offset assigned to each plane. If a match is found,
2404          * return its buffer and plane numbers.
2405          */
2406         for (buffer = 0; buffer < q->num_buffers; ++buffer) {
2407                 vb = q->bufs[buffer];
2408
2409                 for (plane = 0; plane < vb->num_planes; ++plane) {
2410                         if (vb->v4l2_planes[plane].m.mem_offset == off) {
2411                                 *_buffer = buffer;
2412                                 *_plane = plane;
2413                                 return 0;
2414                         }
2415                 }
2416         }
2417
2418         return -EINVAL;
2419 }
2420
2421 /**
2422  * vb2_expbuf() - Export a buffer as a file descriptor
2423  * @q:          videobuf2 queue
2424  * @eb:         export buffer structure passed from userspace to vidioc_expbuf
2425  *              handler in driver
2426  *
2427  * The return values from this function are intended to be directly returned
2428  * from vidioc_expbuf handler in driver.
2429  */
2430 int vb2_expbuf(struct vb2_queue *q, struct v4l2_exportbuffer *eb)
2431 {
2432         struct vb2_buffer *vb = NULL;
2433         struct vb2_plane *vb_plane;
2434         int ret;
2435         struct dma_buf *dbuf;
2436
2437         if (q->memory != V4L2_MEMORY_MMAP) {
2438                 dprintk(1, "queue is not currently set up for mmap\n");
2439                 return -EINVAL;
2440         }
2441
2442         if (!q->mem_ops->get_dmabuf) {
2443                 dprintk(1, "queue does not support DMA buffer exporting\n");
2444                 return -EINVAL;
2445         }
2446
2447         if (eb->flags & ~(O_CLOEXEC | O_ACCMODE)) {
2448                 dprintk(1, "queue does support only O_CLOEXEC and access mode flags\n");
2449                 return -EINVAL;
2450         }
2451
2452         if (eb->type != q->type) {
2453                 dprintk(1, "invalid buffer type\n");
2454                 return -EINVAL;
2455         }
2456
2457         if (eb->index >= q->num_buffers) {
2458                 dprintk(1, "buffer index out of range\n");
2459                 return -EINVAL;
2460         }
2461
2462         vb = q->bufs[eb->index];
2463
2464         if (eb->plane >= vb->num_planes) {
2465                 dprintk(1, "buffer plane out of range\n");
2466                 return -EINVAL;
2467         }
2468
2469         if (vb2_fileio_is_active(q)) {
2470                 dprintk(1, "expbuf: file io in progress\n");
2471                 return -EBUSY;
2472         }
2473
2474         vb_plane = &vb->planes[eb->plane];
2475
2476         dbuf = call_ptr_memop(vb, get_dmabuf, vb_plane->mem_priv, eb->flags & O_ACCMODE);
2477         if (IS_ERR_OR_NULL(dbuf)) {
2478                 dprintk(1, "failed to export buffer %d, plane %d\n",
2479                         eb->index, eb->plane);
2480                 return -EINVAL;
2481         }
2482
2483         ret = dma_buf_fd(dbuf, eb->flags & ~O_ACCMODE);
2484         if (ret < 0) {
2485                 dprintk(3, "buffer %d, plane %d failed to export (%d)\n",
2486                         eb->index, eb->plane, ret);
2487                 dma_buf_put(dbuf);
2488                 return ret;
2489         }
2490
2491         dprintk(3, "buffer %d, plane %d exported as %d descriptor\n",
2492                 eb->index, eb->plane, ret);
2493         eb->fd = ret;
2494
2495         return 0;
2496 }
2497 EXPORT_SYMBOL_GPL(vb2_expbuf);
2498
2499 /**
2500  * vb2_mmap() - map video buffers into application address space
2501  * @q:          videobuf2 queue
2502  * @vma:        vma passed to the mmap file operation handler in the driver
2503  *
2504  * Should be called from mmap file operation handler of a driver.
2505  * This function maps one plane of one of the available video buffers to
2506  * userspace. To map whole video memory allocated on reqbufs, this function
2507  * has to be called once per each plane per each buffer previously allocated.
2508  *
2509  * When the userspace application calls mmap, it passes to it an offset returned
2510  * to it earlier by the means of vidioc_querybuf handler. That offset acts as
2511  * a "cookie", which is then used to identify the plane to be mapped.
2512  * This function finds a plane with a matching offset and a mapping is performed
2513  * by the means of a provided memory operation.
2514  *
2515  * The return values from this function are intended to be directly returned
2516  * from the mmap handler in driver.
2517  */
2518 int vb2_mmap(struct vb2_queue *q, struct vm_area_struct *vma)
2519 {
2520         unsigned long off = vma->vm_pgoff << PAGE_SHIFT;
2521         struct vb2_buffer *vb;
2522         unsigned int buffer = 0, plane = 0;
2523         int ret;
2524         unsigned long length;
2525
2526         if (q->memory != V4L2_MEMORY_MMAP) {
2527                 dprintk(1, "queue is not currently set up for mmap\n");
2528                 return -EINVAL;
2529         }
2530
2531         /*
2532          * Check memory area access mode.
2533          */
2534         if (!(vma->vm_flags & VM_SHARED)) {
2535                 dprintk(1, "invalid vma flags, VM_SHARED needed\n");
2536                 return -EINVAL;
2537         }
2538         if (V4L2_TYPE_IS_OUTPUT(q->type)) {
2539                 if (!(vma->vm_flags & VM_WRITE)) {
2540                         dprintk(1, "invalid vma flags, VM_WRITE needed\n");
2541                         return -EINVAL;
2542                 }
2543         } else {
2544                 if (!(vma->vm_flags & VM_READ)) {
2545                         dprintk(1, "invalid vma flags, VM_READ needed\n");
2546                         return -EINVAL;
2547                 }
2548         }
2549         if (vb2_fileio_is_active(q)) {
2550                 dprintk(1, "mmap: file io in progress\n");
2551                 return -EBUSY;
2552         }
2553
2554         /*
2555          * Find the plane corresponding to the offset passed by userspace.
2556          */
2557         ret = __find_plane_by_offset(q, off, &buffer, &plane);
2558         if (ret)
2559                 return ret;
2560
2561         vb = q->bufs[buffer];
2562
2563         /*
2564          * MMAP requires page_aligned buffers.
2565          * The buffer length was page_aligned at __vb2_buf_mem_alloc(),
2566          * so, we need to do the same here.
2567          */
2568         length = PAGE_ALIGN(vb->v4l2_planes[plane].length);
2569         if (length < (vma->vm_end - vma->vm_start)) {
2570                 dprintk(1,
2571                         "MMAP invalid, as it would overflow buffer length\n");
2572                 return -EINVAL;
2573         }
2574
2575         mutex_lock(&q->mmap_lock);
2576         ret = call_memop(vb, mmap, vb->planes[plane].mem_priv, vma);
2577         mutex_unlock(&q->mmap_lock);
2578         if (ret)
2579                 return ret;
2580
2581         dprintk(3, "buffer %d, plane %d successfully mapped\n", buffer, plane);
2582         return 0;
2583 }
2584 EXPORT_SYMBOL_GPL(vb2_mmap);
2585
2586 #ifndef CONFIG_MMU
2587 unsigned long vb2_get_unmapped_area(struct vb2_queue *q,
2588                                     unsigned long addr,
2589                                     unsigned long len,
2590                                     unsigned long pgoff,
2591                                     unsigned long flags)
2592 {
2593         unsigned long off = pgoff << PAGE_SHIFT;
2594         struct vb2_buffer *vb;
2595         unsigned int buffer, plane;
2596         void *vaddr;
2597         int ret;
2598
2599         if (q->memory != V4L2_MEMORY_MMAP) {
2600                 dprintk(1, "queue is not currently set up for mmap\n");
2601                 return -EINVAL;
2602         }
2603
2604         /*
2605          * Find the plane corresponding to the offset passed by userspace.
2606          */
2607         ret = __find_plane_by_offset(q, off, &buffer, &plane);
2608         if (ret)
2609                 return ret;
2610
2611         vb = q->bufs[buffer];
2612
2613         vaddr = vb2_plane_vaddr(vb, plane);
2614         return vaddr ? (unsigned long)vaddr : -EINVAL;
2615 }
2616 EXPORT_SYMBOL_GPL(vb2_get_unmapped_area);
2617 #endif
2618
2619 static int __vb2_init_fileio(struct vb2_queue *q, int read);
2620 static int __vb2_cleanup_fileio(struct vb2_queue *q);
2621
2622 /**
2623  * vb2_poll() - implements poll userspace operation
2624  * @q:          videobuf2 queue
2625  * @file:       file argument passed to the poll file operation handler
2626  * @wait:       wait argument passed to the poll file operation handler
2627  *
2628  * This function implements poll file operation handler for a driver.
2629  * For CAPTURE queues, if a buffer is ready to be dequeued, the userspace will
2630  * be informed that the file descriptor of a video device is available for
2631  * reading.
2632  * For OUTPUT queues, if a buffer is ready to be dequeued, the file descriptor
2633  * will be reported as available for writing.
2634  *
2635  * If the driver uses struct v4l2_fh, then vb2_poll() will also check for any
2636  * pending events.
2637  *
2638  * The return values from this function are intended to be directly returned
2639  * from poll handler in driver.
2640  */
2641 unsigned int vb2_poll(struct vb2_queue *q, struct file *file, poll_table *wait)
2642 {
2643         struct video_device *vfd = video_devdata(file);
2644         unsigned long req_events = poll_requested_events(wait);
2645         struct vb2_buffer *vb = NULL;
2646         unsigned int res = 0;
2647         unsigned long flags;
2648
2649         if (test_bit(V4L2_FL_USES_V4L2_FH, &vfd->flags)) {
2650                 struct v4l2_fh *fh = file->private_data;
2651
2652                 if (v4l2_event_pending(fh))
2653                         res = POLLPRI;
2654                 else if (req_events & POLLPRI)
2655                         poll_wait(file, &fh->wait, wait);
2656         }
2657
2658         if (!V4L2_TYPE_IS_OUTPUT(q->type) && !(req_events & (POLLIN | POLLRDNORM)))
2659                 return res;
2660         if (V4L2_TYPE_IS_OUTPUT(q->type) && !(req_events & (POLLOUT | POLLWRNORM)))
2661                 return res;
2662
2663         /*
2664          * Start file I/O emulator only if streaming API has not been used yet.
2665          */
2666         if (q->num_buffers == 0 && !vb2_fileio_is_active(q)) {
2667                 if (!V4L2_TYPE_IS_OUTPUT(q->type) && (q->io_modes & VB2_READ) &&
2668                                 (req_events & (POLLIN | POLLRDNORM))) {
2669                         if (__vb2_init_fileio(q, 1))
2670                                 return res | POLLERR;
2671                 }
2672                 if (V4L2_TYPE_IS_OUTPUT(q->type) && (q->io_modes & VB2_WRITE) &&
2673                                 (req_events & (POLLOUT | POLLWRNORM))) {
2674                         if (__vb2_init_fileio(q, 0))
2675                                 return res | POLLERR;
2676                         /*
2677                          * Write to OUTPUT queue can be done immediately.
2678                          */
2679                         return res | POLLOUT | POLLWRNORM;
2680                 }
2681         }
2682
2683         /*
2684          * There is nothing to wait for if the queue isn't streaming, or if the
2685          * error flag is set.
2686          */
2687         if (!vb2_is_streaming(q) || q->error)
2688                 return res | POLLERR;
2689         /*
2690          * For compatibility with vb1: if QBUF hasn't been called yet, then
2691          * return POLLERR as well. This only affects capture queues, output
2692          * queues will always initialize waiting_for_buffers to false.
2693          */
2694         if (q->waiting_for_buffers)
2695                 return res | POLLERR;
2696
2697         /*
2698          * For output streams you can write as long as there are fewer buffers
2699          * queued than there are buffers available.
2700          */
2701         if (V4L2_TYPE_IS_OUTPUT(q->type) && q->queued_count < q->num_buffers)
2702                 return res | POLLOUT | POLLWRNORM;
2703
2704         if (list_empty(&q->done_list)) {
2705                 /*
2706                  * If the last buffer was dequeued from a capture queue,
2707                  * return immediately. DQBUF will return -EPIPE.
2708                  */
2709                 if (q->last_buffer_dequeued)
2710                         return res | POLLIN | POLLRDNORM;
2711
2712                 poll_wait(file, &q->done_wq, wait);
2713         }
2714
2715         /*
2716          * Take first buffer available for dequeuing.
2717          */
2718         spin_lock_irqsave(&q->done_lock, flags);
2719         if (!list_empty(&q->done_list))
2720                 vb = list_first_entry(&q->done_list, struct vb2_buffer,
2721                                         done_entry);
2722         spin_unlock_irqrestore(&q->done_lock, flags);
2723
2724         if (vb && (vb->state == VB2_BUF_STATE_DONE
2725                         || vb->state == VB2_BUF_STATE_ERROR)) {
2726                 return (V4L2_TYPE_IS_OUTPUT(q->type)) ?
2727                                 res | POLLOUT | POLLWRNORM :
2728                                 res | POLLIN | POLLRDNORM;
2729         }
2730         return res;
2731 }
2732 EXPORT_SYMBOL_GPL(vb2_poll);
2733
2734 /**
2735  * vb2_queue_init() - initialize a videobuf2 queue
2736  * @q:          videobuf2 queue; this structure should be allocated in driver
2737  *
2738  * The vb2_queue structure should be allocated by the driver. The driver is
2739  * responsible of clearing it's content and setting initial values for some
2740  * required entries before calling this function.
2741  * q->ops, q->mem_ops, q->type and q->io_modes are mandatory. Please refer
2742  * to the struct vb2_queue description in include/media/videobuf2-v4l2.h
2743  * for more information.
2744  */
2745 int vb2_queue_init(struct vb2_queue *q)
2746 {
2747         /*
2748          * Sanity check
2749          */
2750         if (WARN_ON(!q)                   ||
2751             WARN_ON(!q->ops)              ||
2752             WARN_ON(!q->mem_ops)          ||
2753             WARN_ON(!q->type)             ||
2754             WARN_ON(!q->io_modes)         ||
2755             WARN_ON(!q->ops->queue_setup) ||
2756             WARN_ON(!q->ops->buf_queue)   ||
2757             WARN_ON(q->timestamp_flags &
2758                     ~(V4L2_BUF_FLAG_TIMESTAMP_MASK |
2759                       V4L2_BUF_FLAG_TSTAMP_SRC_MASK)))
2760                 return -EINVAL;
2761
2762         /* Warn that the driver should choose an appropriate timestamp type */
2763         WARN_ON((q->timestamp_flags & V4L2_BUF_FLAG_TIMESTAMP_MASK) ==
2764                 V4L2_BUF_FLAG_TIMESTAMP_UNKNOWN);
2765
2766         INIT_LIST_HEAD(&q->queued_list);
2767         INIT_LIST_HEAD(&q->done_list);
2768         spin_lock_init(&q->done_lock);
2769         mutex_init(&q->mmap_lock);
2770         init_waitqueue_head(&q->done_wq);
2771
2772         if (q->buf_struct_size == 0)
2773                 q->buf_struct_size = sizeof(struct vb2_buffer);
2774
2775         return 0;
2776 }
2777 EXPORT_SYMBOL_GPL(vb2_queue_init);
2778
2779 /**
2780  * vb2_queue_release() - stop streaming, release the queue and free memory
2781  * @q:          videobuf2 queue
2782  *
2783  * This function stops streaming and performs necessary clean ups, including
2784  * freeing video buffer memory. The driver is responsible for freeing
2785  * the vb2_queue structure itself.
2786  */
2787 void vb2_queue_release(struct vb2_queue *q)
2788 {
2789         __vb2_cleanup_fileio(q);
2790         __vb2_queue_cancel(q);
2791         mutex_lock(&q->mmap_lock);
2792         __vb2_queue_free(q, q->num_buffers);
2793         mutex_unlock(&q->mmap_lock);
2794 }
2795 EXPORT_SYMBOL_GPL(vb2_queue_release);
2796
2797 /**
2798  * struct vb2_fileio_buf - buffer context used by file io emulator
2799  *
2800  * vb2 provides a compatibility layer and emulator of file io (read and
2801  * write) calls on top of streaming API. This structure is used for
2802  * tracking context related to the buffers.
2803  */
2804 struct vb2_fileio_buf {
2805         void *vaddr;
2806         unsigned int size;
2807         unsigned int pos;
2808         unsigned int queued:1;
2809 };
2810
2811 /**
2812  * struct vb2_fileio_data - queue context used by file io emulator
2813  *
2814  * @cur_index:  the index of the buffer currently being read from or
2815  *              written to. If equal to q->num_buffers then a new buffer
2816  *              must be dequeued.
2817  * @initial_index: in the read() case all buffers are queued up immediately
2818  *              in __vb2_init_fileio() and __vb2_perform_fileio() just cycles
2819  *              buffers. However, in the write() case no buffers are initially
2820  *              queued, instead whenever a buffer is full it is queued up by
2821  *              __vb2_perform_fileio(). Only once all available buffers have
2822  *              been queued up will __vb2_perform_fileio() start to dequeue
2823  *              buffers. This means that initially __vb2_perform_fileio()
2824  *              needs to know what buffer index to use when it is queuing up
2825  *              the buffers for the first time. That initial index is stored
2826  *              in this field. Once it is equal to q->num_buffers all
2827  *              available buffers have been queued and __vb2_perform_fileio()
2828  *              should start the normal dequeue/queue cycle.
2829  *
2830  * vb2 provides a compatibility layer and emulator of file io (read and
2831  * write) calls on top of streaming API. For proper operation it required
2832  * this structure to save the driver state between each call of the read
2833  * or write function.
2834  */
2835 struct vb2_fileio_data {
2836         struct v4l2_requestbuffers req;
2837         struct v4l2_plane p;
2838         struct v4l2_buffer b;
2839         struct vb2_fileio_buf bufs[VIDEO_MAX_FRAME];
2840         unsigned int cur_index;
2841         unsigned int initial_index;
2842         unsigned int q_count;
2843         unsigned int dq_count;
2844         unsigned read_once:1;
2845         unsigned write_immediately:1;
2846 };
2847
2848 /**
2849  * __vb2_init_fileio() - initialize file io emulator
2850  * @q:          videobuf2 queue
2851  * @read:       mode selector (1 means read, 0 means write)
2852  */
2853 static int __vb2_init_fileio(struct vb2_queue *q, int read)
2854 {
2855         struct vb2_fileio_data *fileio;
2856         int i, ret;
2857         unsigned int count = 0;
2858
2859         /*
2860          * Sanity check
2861          */
2862         if (WARN_ON((read && !(q->io_modes & VB2_READ)) ||
2863                     (!read && !(q->io_modes & VB2_WRITE))))
2864                 return -EINVAL;
2865
2866         /*
2867          * Check if device supports mapping buffers to kernel virtual space.
2868          */
2869         if (!q->mem_ops->vaddr)
2870                 return -EBUSY;
2871
2872         /*
2873          * Check if streaming api has not been already activated.
2874          */
2875         if (q->streaming || q->num_buffers > 0)
2876                 return -EBUSY;
2877
2878         /*
2879          * Start with count 1, driver can increase it in queue_setup()
2880          */
2881         count = 1;
2882
2883         dprintk(3, "setting up file io: mode %s, count %d, read_once %d, write_immediately %d\n",
2884                 (read) ? "read" : "write", count, q->fileio_read_once,
2885                 q->fileio_write_immediately);
2886
2887         fileio = kzalloc(sizeof(struct vb2_fileio_data), GFP_KERNEL);
2888         if (fileio == NULL)
2889                 return -ENOMEM;
2890
2891         fileio->read_once = q->fileio_read_once;
2892         fileio->write_immediately = q->fileio_write_immediately;
2893
2894         /*
2895          * Request buffers and use MMAP type to force driver
2896          * to allocate buffers by itself.
2897          */
2898         fileio->req.count = count;
2899         fileio->req.memory = V4L2_MEMORY_MMAP;
2900         fileio->req.type = q->type;
2901         q->fileio = fileio;
2902         ret = __reqbufs(q, &fileio->req);
2903         if (ret)
2904                 goto err_kfree;
2905
2906         /*
2907          * Check if plane_count is correct
2908          * (multiplane buffers are not supported).
2909          */
2910         if (q->bufs[0]->num_planes != 1) {
2911                 ret = -EBUSY;
2912                 goto err_reqbufs;
2913         }
2914
2915         /*
2916          * Get kernel address of each buffer.
2917          */
2918         for (i = 0; i < q->num_buffers; i++) {
2919                 fileio->bufs[i].vaddr = vb2_plane_vaddr(q->bufs[i], 0);
2920                 if (fileio->bufs[i].vaddr == NULL) {
2921                         ret = -EINVAL;
2922                         goto err_reqbufs;
2923                 }
2924                 fileio->bufs[i].size = vb2_plane_size(q->bufs[i], 0);
2925         }
2926
2927         /*
2928          * Read mode requires pre queuing of all buffers.
2929          */
2930         if (read) {
2931                 bool is_multiplanar = V4L2_TYPE_IS_MULTIPLANAR(q->type);
2932
2933                 /*
2934                  * Queue all buffers.
2935                  */
2936                 for (i = 0; i < q->num_buffers; i++) {
2937                         struct v4l2_buffer *b = &fileio->b;
2938
2939                         memset(b, 0, sizeof(*b));
2940                         b->type = q->type;
2941                         if (is_multiplanar) {
2942                                 memset(&fileio->p, 0, sizeof(fileio->p));
2943                                 b->m.planes = &fileio->p;
2944                                 b->length = 1;
2945                         }
2946                         b->memory = q->memory;
2947                         b->index = i;
2948                         ret = vb2_internal_qbuf(q, b);
2949                         if (ret)
2950                                 goto err_reqbufs;
2951                         fileio->bufs[i].queued = 1;
2952                 }
2953                 /*
2954                  * All buffers have been queued, so mark that by setting
2955                  * initial_index to q->num_buffers
2956                  */
2957                 fileio->initial_index = q->num_buffers;
2958                 fileio->cur_index = q->num_buffers;
2959         }
2960
2961         /*
2962          * Start streaming.
2963          */
2964         ret = vb2_internal_streamon(q, q->type);
2965         if (ret)
2966                 goto err_reqbufs;
2967
2968         return ret;
2969
2970 err_reqbufs:
2971         fileio->req.count = 0;
2972         __reqbufs(q, &fileio->req);
2973
2974 err_kfree:
2975         q->fileio = NULL;