LCOV - code coverage report
Current view: top level - drivers/media/common/videobuf2 - videobuf2-core.c (source / functions) Hit Total Coverage
Test: Real Lines: 55 952 5.8 %
Date: 2020-10-17 15:46:16 Functions: 0 57 0.0 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

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

Generated by: LCOV version 1.14