drivers/media/v4l2-core/videobuf2-core.c

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