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

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

Generated by: LCOV version 1.14