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

   1 /*
   2  * Memory-to-memory device framework for Video for Linux 2 and videobuf.
   3  *
   4  * Helper functions for devices that use videobuf buffers for both their
   5  * source and destination.
   6  *
   7  * Copyright (c) 2009-2010 Samsung Electronics Co., Ltd.
   8  * Pawel Osciak, <pawel@osciak.com>
   9  * Marek Szyprowski, <m.szyprowski@samsung.com>
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by the
  13  * Free Software Foundation; either version 2 of the License, or (at your
  14  * option) any later version.
  15  */
  16 #include <linux/module.h>
  17 #include <linux/sched.h>
  18 #include <linux/slab.h>
  19
  20 #include <media/media-device.h>
  21 #include <media/videobuf2-v4l2.h>
  22 #include <media/v4l2-mem2mem.h>
  23 #include <media/v4l2-dev.h>
  24 #include <media/v4l2-device.h>
  25 #include <media/v4l2-fh.h>
  26 #include <media/v4l2-event.h>
  27
  28 MODULE_DESCRIPTION("Mem to mem device framework for videobuf");
  29 MODULE_AUTHOR("Pawel Osciak, <pawel@osciak.com>");
  30 MODULE_LICENSE("GPL");
  31
  32 static bool debug;
  33 module_param(debug, bool, 0644);
  34
  35 #define dprintk(fmt, arg...)                                            \
  36         do {                                                            \
  37                 if (debug)                                              \
  38                         printk(KERN_DEBUG "%s: " fmt, __func__, ## arg);\
  39         } while (0)
  40
  41
  42 /* Instance is already queued on the job_queue */
  43 #define TRANS_QUEUED            (1 << 0)
  44 /* Instance is currently running in hardware */
  45 #define TRANS_RUNNING           (1 << 1)
  46 /* Instance is currently aborting */
  47 #define TRANS_ABORT             (1 << 2)
  48
  49
  50 /* Offset base for buffers on the destination queue - used to distinguish
  51  * between source and destination buffers when mmapping - they receive the same
  52  * offsets but for different queues */
  53 #define DST_QUEUE_OFF_BASE      (1 << 30)
  54
  55 enum v4l2_m2m_entity_type {
  56         MEM2MEM_ENT_TYPE_SOURCE,
  57         MEM2MEM_ENT_TYPE_SINK,
  58         MEM2MEM_ENT_TYPE_PROC
  59 };
  60
  61 static const char * const m2m_entity_name[] = {
  62         "source",
  63         "sink",
  64         "proc"
  65 };
  66
  67 /**
  68  * struct v4l2_m2m_dev - per-device context
  69  * @source:             &struct media_entity pointer with the source entity
  70  *                      Used only when the M2M device is registered via
  71  *                      v4l2_m2m_unregister_media_controller().
  72  * @source_pad:         &struct media_pad with the source pad.
  73  *                      Used only when the M2M device is registered via
  74  *                      v4l2_m2m_unregister_media_controller().
  75  * @sink:               &struct media_entity pointer with the sink entity
  76  *                      Used only when the M2M device is registered via
  77  *                      v4l2_m2m_unregister_media_controller().
  78  * @sink_pad:           &struct media_pad with the sink pad.
  79  *                      Used only when the M2M device is registered via
  80  *                      v4l2_m2m_unregister_media_controller().
  81  * @proc:               &struct media_entity pointer with the M2M device itself.
  82  * @proc_pads:          &struct media_pad with the @proc pads.
  83  *                      Used only when the M2M device is registered via
  84  *                      v4l2_m2m_unregister_media_controller().
  85  * @intf_devnode:       &struct media_intf devnode pointer with the interface
  86  *                      with controls the M2M device.
  87  * @curr_ctx:           currently running instance
  88  * @job_queue:          instances queued to run
  89  * @job_spinlock:       protects job_queue
  90  * @job_work:           worker to run queued jobs.
  91  * @m2m_ops:            driver callbacks
  92  */
  93 struct v4l2_m2m_dev {
  94         struct v4l2_m2m_ctx     *curr_ctx;
  95 #ifdef CONFIG_MEDIA_CONTROLLER
  96         struct media_entity     *source;
  97         struct media_pad        source_pad;
  98         struct media_entity     sink;
  99         struct media_pad        sink_pad;
 100         struct media_entity     proc;
 101         struct media_pad        proc_pads[2];
 102         struct media_intf_devnode *intf_devnode;
 103 #endif
 104
 105         struct list_head        job_queue;
 106         spinlock_t              job_spinlock;
 107         struct work_struct      job_work;
 108
 109         const struct v4l2_m2m_ops *m2m_ops;
 110 };
 111
 112 static struct v4l2_m2m_queue_ctx *get_queue_ctx(struct v4l2_m2m_ctx *m2m_ctx,
 113                                                 enum v4l2_buf_type type)
 114 {
 115         if (V4L2_TYPE_IS_OUTPUT(type))
 116                 return &m2m_ctx->out_q_ctx;
 117         else
 118                 return &m2m_ctx->cap_q_ctx;
 119 }
 120
 121 struct vb2_queue *v4l2_m2m_get_vq(struct v4l2_m2m_ctx *m2m_ctx,
 122                                        enum v4l2_buf_type type)
 123 {
 124         struct v4l2_m2m_queue_ctx *q_ctx;
 125
 126         q_ctx = get_queue_ctx(m2m_ctx, type);
 127         if (!q_ctx)
 128                 return NULL;
 129
 130         return &q_ctx->q;
 131 }
 132 EXPORT_SYMBOL(v4l2_m2m_get_vq);
 133
 134 void *v4l2_m2m_next_buf(struct v4l2_m2m_queue_ctx *q_ctx)
 135 {
 136         struct v4l2_m2m_buffer *b;
 137         unsigned long flags;
 138
 139         spin_lock_irqsave(&q_ctx->rdy_spinlock, flags);
 140
 141         if (list_empty(&q_ctx->rdy_queue)) {
 142                 spin_unlock_irqrestore(&q_ctx->rdy_spinlock, flags);
 143                 return NULL;
 144         }
 145
 146         b = list_first_entry(&q_ctx->rdy_queue, struct v4l2_m2m_buffer, list);
 147         spin_unlock_irqrestore(&q_ctx->rdy_spinlock, flags);
 148         return &b->vb;
 149 }
 150 EXPORT_SYMBOL_GPL(v4l2_m2m_next_buf);
 151
 152 void *v4l2_m2m_last_buf(struct v4l2_m2m_queue_ctx *q_ctx)
 153 {
 154         struct v4l2_m2m_buffer *b;
 155         unsigned long flags;
 156
 157         spin_lock_irqsave(&q_ctx->rdy_spinlock, flags);
 158
 159         if (list_empty(&q_ctx->rdy_queue)) {
 160                 spin_unlock_irqrestore(&q_ctx->rdy_spinlock, flags);
 161                 return NULL;
 162         }
 163
 164         b = list_last_entry(&q_ctx->rdy_queue, struct v4l2_m2m_buffer, list);
 165         spin_unlock_irqrestore(&q_ctx->rdy_spinlock, flags);
 166         return &b->vb;
 167 }
 168 EXPORT_SYMBOL_GPL(v4l2_m2m_last_buf);
 169
 170 void *v4l2_m2m_buf_remove(struct v4l2_m2m_queue_ctx *q_ctx)
 171 {
 172         struct v4l2_m2m_buffer *b;
 173         unsigned long flags;
 174
 175         spin_lock_irqsave(&q_ctx->rdy_spinlock, flags);
 176         if (list_empty(&q_ctx->rdy_queue)) {
 177                 spin_unlock_irqrestore(&q_ctx->rdy_spinlock, flags);
 178                 return NULL;
 179         }
 180         b = list_first_entry(&q_ctx->rdy_queue, struct v4l2_m2m_buffer, list);
 181         list_del(&b->list);
 182         q_ctx->num_rdy--;
 183         spin_unlock_irqrestore(&q_ctx->rdy_spinlock, flags);
 184
 185         return &b->vb;
 186 }
 187 EXPORT_SYMBOL_GPL(v4l2_m2m_buf_remove);
 188
 189 void v4l2_m2m_buf_remove_by_buf(struct v4l2_m2m_queue_ctx *q_ctx,
 190                                 struct vb2_v4l2_buffer *vbuf)
 191 {
 192         struct v4l2_m2m_buffer *b;
 193         unsigned long flags;
 194
 195         spin_lock_irqsave(&q_ctx->rdy_spinlock, flags);
 196         b = container_of(vbuf, struct v4l2_m2m_buffer, vb);
 197         list_del(&b->list);
 198         q_ctx->num_rdy--;
 199         spin_unlock_irqrestore(&q_ctx->rdy_spinlock, flags);
 200 }
 201 EXPORT_SYMBOL_GPL(v4l2_m2m_buf_remove_by_buf);
 202
 203 struct vb2_v4l2_buffer *
 204 v4l2_m2m_buf_remove_by_idx(struct v4l2_m2m_queue_ctx *q_ctx, unsigned int idx)
 205
 206 {
 207         struct v4l2_m2m_buffer *b, *tmp;
 208         struct vb2_v4l2_buffer *ret = NULL;
 209         unsigned long flags;
 210
 211         spin_lock_irqsave(&q_ctx->rdy_spinlock, flags);
 212         list_for_each_entry_safe(b, tmp, &q_ctx->rdy_queue, list) {
 213                 if (b->vb.vb2_buf.index == idx) {
 214                         list_del(&b->list);
 215                         q_ctx->num_rdy--;
 216                         ret = &b->vb;
 217                         break;
 218                 }
 219         }
 220         spin_unlock_irqrestore(&q_ctx->rdy_spinlock, flags);
 221
 222         return ret;
 223 }
 224 EXPORT_SYMBOL_GPL(v4l2_m2m_buf_remove_by_idx);
 225
 226 /*
 227  * Scheduling handlers
 228  */
 229
 230 void *v4l2_m2m_get_curr_priv(struct v4l2_m2m_dev *m2m_dev)
 231 {
 232         unsigned long flags;
 233         void *ret = NULL;
 234
 235         spin_lock_irqsave(&m2m_dev->job_spinlock, flags);
 236         if (m2m_dev->curr_ctx)
 237                 ret = m2m_dev->curr_ctx->priv;
 238         spin_unlock_irqrestore(&m2m_dev->job_spinlock, flags);
 239
 240         return ret;
 241 }
 242 EXPORT_SYMBOL(v4l2_m2m_get_curr_priv);
 243
 244 /**
 245  * v4l2_m2m_try_run() - select next job to perform and run it if possible
 246  * @m2m_dev: per-device context
 247  *
 248  * Get next transaction (if present) from the waiting jobs list and run it.
 249  *
 250  * Note that this function can run on a given v4l2_m2m_ctx context,
 251  * but call .device_run for another context.
 252  */
 253 static void v4l2_m2m_try_run(struct v4l2_m2m_dev *m2m_dev)
 254 {
 255         unsigned long flags;
 256
 257         spin_lock_irqsave(&m2m_dev->job_spinlock, flags);
 258         if (NULL != m2m_dev->curr_ctx) {
 259                 spin_unlock_irqrestore(&m2m_dev->job_spinlock, flags);
 260                 dprintk("Another instance is running, won't run now\n");
 261                 return;
 262         }
 263
 264         if (list_empty(&m2m_dev->job_queue)) {
 265                 spin_unlock_irqrestore(&m2m_dev->job_spinlock, flags);
 266                 dprintk("No job pending\n");
 267                 return;
 268         }
 269
 270         m2m_dev->curr_ctx = list_first_entry(&m2m_dev->job_queue,
 271                                    struct v4l2_m2m_ctx, queue);
 272         m2m_dev->curr_ctx->job_flags |= TRANS_RUNNING;
 273         spin_unlock_irqrestore(&m2m_dev->job_spinlock, flags);
 274
 275         dprintk("Running job on m2m_ctx: %p\n", m2m_dev->curr_ctx);
 276         m2m_dev->m2m_ops->device_run(m2m_dev->curr_ctx->priv);
 277 }
 278
 279 /*
 280  * __v4l2_m2m_try_queue() - queue a job
 281  * @m2m_dev: m2m device
 282  * @m2m_ctx: m2m context
 283  *
 284  * Check if this context is ready to queue a job.
 285  *
 286  * This function can run in interrupt context.
 287  */
 288 static void __v4l2_m2m_try_queue(struct v4l2_m2m_dev *m2m_dev,
 289                                  struct v4l2_m2m_ctx *m2m_ctx)
 290 {
 291         unsigned long flags_job, flags_out, flags_cap;
 292
 293         dprintk("Trying to schedule a job for m2m_ctx: %p\n", m2m_ctx);
 294
 295         if (!m2m_ctx->out_q_ctx.q.streaming
 296             || !m2m_ctx->cap_q_ctx.q.streaming) {
 297                 dprintk("Streaming needs to be on for both queues\n");
 298                 return;
 299         }
 300
 301         spin_lock_irqsave(&m2m_dev->job_spinlock, flags_job);
 302
 303         /* If the context is aborted then don't schedule it */
 304         if (m2m_ctx->job_flags & TRANS_ABORT) {
 305                 dprintk("Aborted context\n");
 306                 goto job_unlock;
 307         }
 308
 309         if (m2m_ctx->job_flags & TRANS_QUEUED) {
 310                 dprintk("On job queue already\n");
 311                 goto job_unlock;
 312         }
 313
 314         spin_lock_irqsave(&m2m_ctx->out_q_ctx.rdy_spinlock, flags_out);
 315         if (list_empty(&m2m_ctx->out_q_ctx.rdy_queue)
 316             && !m2m_ctx->out_q_ctx.buffered) {
 317                 dprintk("No input buffers available\n");
 318                 goto out_unlock;
 319         }
 320         spin_lock_irqsave(&m2m_ctx->cap_q_ctx.rdy_spinlock, flags_cap);
 321         if (list_empty(&m2m_ctx->cap_q_ctx.rdy_queue)
 322             && !m2m_ctx->cap_q_ctx.buffered) {
 323                 dprintk("No output buffers available\n");
 324                 goto cap_unlock;
 325         }
 326         spin_unlock_irqrestore(&m2m_ctx->cap_q_ctx.rdy_spinlock, flags_cap);
 327         spin_unlock_irqrestore(&m2m_ctx->out_q_ctx.rdy_spinlock, flags_out);
 328
 329         if (m2m_dev->m2m_ops->job_ready
 330                 && (!m2m_dev->m2m_ops->job_ready(m2m_ctx->priv))) {
 331                 dprintk("Driver not ready\n");
 332                 goto job_unlock;
 333         }
 334
 335         list_add_tail(&m2m_ctx->queue, &m2m_dev->job_queue);
 336         m2m_ctx->job_flags |= TRANS_QUEUED;
 337
 338         spin_unlock_irqrestore(&m2m_dev->job_spinlock, flags_job);
 339         return;
 340
 341 cap_unlock:
 342         spin_unlock_irqrestore(&m2m_ctx->cap_q_ctx.rdy_spinlock, flags_cap);
 343 out_unlock:
 344         spin_unlock_irqrestore(&m2m_ctx->out_q_ctx.rdy_spinlock, flags_out);
 345 job_unlock:
 346         spin_unlock_irqrestore(&m2m_dev->job_spinlock, flags_job);
 347 }
 348
 349 /**
 350  * v4l2_m2m_try_schedule() - schedule and possibly run a job for any context
 351  * @m2m_ctx: m2m context
 352  *
 353  * Check if this context is ready to queue a job. If suitable,
 354  * run the next queued job on the mem2mem device.
 355  *
 356  * This function shouldn't run in interrupt context.
 357  *
 358  * Note that v4l2_m2m_try_schedule() can schedule one job for this context,
 359  * and then run another job for another context.
 360  */
 361 void v4l2_m2m_try_schedule(struct v4l2_m2m_ctx *m2m_ctx)
 362 {
 363         struct v4l2_m2m_dev *m2m_dev = m2m_ctx->m2m_dev;
 364
 365         __v4l2_m2m_try_queue(m2m_dev, m2m_ctx);
 366         v4l2_m2m_try_run(m2m_dev);
 367 }
 368 EXPORT_SYMBOL_GPL(v4l2_m2m_try_schedule);
 369
 370 /**
 371  * v4l2_m2m_device_run_work() - run pending jobs for the context
 372  * @work: Work structure used for scheduling the execution of this function.
 373  */
 374 static void v4l2_m2m_device_run_work(struct work_struct *work)
 375 {
 376         struct v4l2_m2m_dev *m2m_dev =
 377                 container_of(work, struct v4l2_m2m_dev, job_work);
 378
 379         v4l2_m2m_try_run(m2m_dev);
 380 }
 381
 382 /**
 383  * v4l2_m2m_cancel_job() - cancel pending jobs for the context
 384  * @m2m_ctx: m2m context with jobs to be canceled
 385  *
 386  * In case of streamoff or release called on any context,
 387  * 1] If the context is currently running, then abort job will be called
 388  * 2] If the context is queued, then the context will be removed from
 389  *    the job_queue
 390  */
 391 static void v4l2_m2m_cancel_job(struct v4l2_m2m_ctx *m2m_ctx)
 392 {
 393         struct v4l2_m2m_dev *m2m_dev;
 394         unsigned long flags;
 395
 396         m2m_dev = m2m_ctx->m2m_dev;
 397         spin_lock_irqsave(&m2m_dev->job_spinlock, flags);
 398
 399         m2m_ctx->job_flags |= TRANS_ABORT;
 400         if (m2m_ctx->job_flags & TRANS_RUNNING) {
 401                 spin_unlock_irqrestore(&m2m_dev->job_spinlock, flags);
 402                 if (m2m_dev->m2m_ops->job_abort)
 403                         m2m_dev->m2m_ops->job_abort(m2m_ctx->priv);
 404                 dprintk("m2m_ctx %p running, will wait to complete\n", m2m_ctx);
 405                 wait_event(m2m_ctx->finished,
 406                                 !(m2m_ctx->job_flags & TRANS_RUNNING));
 407         } else if (m2m_ctx->job_flags & TRANS_QUEUED) {
 408                 list_del(&m2m_ctx->queue);
 409                 m2m_ctx->job_flags &= ~(TRANS_QUEUED | TRANS_RUNNING);
 410                 spin_unlock_irqrestore(&m2m_dev->job_spinlock, flags);
 411                 dprintk("m2m_ctx: %p had been on queue and was removed\n",
 412                         m2m_ctx);
 413         } else {
 414                 /* Do nothing, was not on queue/running */
 415                 spin_unlock_irqrestore(&m2m_dev->job_spinlock, flags);
 416         }
 417 }
 418
 419 void v4l2_m2m_job_finish(struct v4l2_m2m_dev *m2m_dev,
 420                          struct v4l2_m2m_ctx *m2m_ctx)
 421 {
 422         unsigned long flags;
 423
 424         spin_lock_irqsave(&m2m_dev->job_spinlock, flags);
 425         if (!m2m_dev->curr_ctx || m2m_dev->curr_ctx != m2m_ctx) {
 426                 spin_unlock_irqrestore(&m2m_dev->job_spinlock, flags);
 427                 dprintk("Called by an instance not currently running\n");
 428                 return;
 429         }
 430
 431         list_del(&m2m_dev->curr_ctx->queue);
 432         m2m_dev->curr_ctx->job_flags &= ~(TRANS_QUEUED | TRANS_RUNNING);
 433         wake_up(&m2m_dev->curr_ctx->finished);
 434         m2m_dev->curr_ctx = NULL;
 435
 436         spin_unlock_irqrestore(&m2m_dev->job_spinlock, flags);
 437
 438         /* This instance might have more buffers ready, but since we do not
 439          * allow more than one job on the job_queue per instance, each has
 440          * to be scheduled separately after the previous one finishes. */
 441         __v4l2_m2m_try_queue(m2m_dev, m2m_ctx);
 442
 443         /* We might be running in atomic context,
 444          * but the job must be run in non-atomic context.
 445          */
 446         schedule_work(&m2m_dev->job_work);
 447 }
 448 EXPORT_SYMBOL(v4l2_m2m_job_finish);
 449
 450 int v4l2_m2m_reqbufs(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
 451                      struct v4l2_requestbuffers *reqbufs)
 452 {
 453         struct vb2_queue *vq;
 454         int ret;
 455
 456         vq = v4l2_m2m_get_vq(m2m_ctx, reqbufs->type);
 457         ret = vb2_reqbufs(vq, reqbufs);
 458         /* If count == 0, then the owner has released all buffers and he
 459            is no longer owner of the queue. Otherwise we have an owner. */
 460         if (ret == 0)
 461                 vq->owner = reqbufs->count ? file->private_data : NULL;
 462
 463         return ret;
 464 }
 465 EXPORT_SYMBOL_GPL(v4l2_m2m_reqbufs);
 466
 467 int v4l2_m2m_querybuf(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
 468                       struct v4l2_buffer *buf)
 469 {
 470         struct vb2_queue *vq;
 471         int ret = 0;
 472         unsigned int i;
 473
 474         vq = v4l2_m2m_get_vq(m2m_ctx, buf->type);
 475         ret = vb2_querybuf(vq, buf);
 476
 477         /* Adjust MMAP memory offsets for the CAPTURE queue */
 478         if (buf->memory == V4L2_MEMORY_MMAP && !V4L2_TYPE_IS_OUTPUT(vq->type)) {
 479                 if (V4L2_TYPE_IS_MULTIPLANAR(vq->type)) {
 480                         for (i = 0; i < buf->length; ++i)
 481                                 buf->m.planes[i].m.mem_offset
 482                                         += DST_QUEUE_OFF_BASE;
 483                 } else {
 484                         buf->m.offset += DST_QUEUE_OFF_BASE;
 485                 }
 486         }
 487
 488         return ret;
 489 }
 490 EXPORT_SYMBOL_GPL(v4l2_m2m_querybuf);
 491
 492 int v4l2_m2m_qbuf(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
 493                   struct v4l2_buffer *buf)
 494 {
 495         struct video_device *vdev = video_devdata(file);
 496         struct vb2_queue *vq;
 497         int ret;
 498
 499         vq = v4l2_m2m_get_vq(m2m_ctx, buf->type);
 500         if (!V4L2_TYPE_IS_OUTPUT(vq->type) &&
 501             (buf->flags & V4L2_BUF_FLAG_REQUEST_FD)) {
 502                 dprintk("%s: requests cannot be used with capture buffers\n",
 503                         __func__);
 504                 return -EPERM;
 505         }
 506         ret = vb2_qbuf(vq, vdev->v4l2_dev->mdev, buf);
 507         if (!ret && !(buf->flags & V4L2_BUF_FLAG_IN_REQUEST))
 508                 v4l2_m2m_try_schedule(m2m_ctx);
 509
 510         return ret;
 511 }
 512 EXPORT_SYMBOL_GPL(v4l2_m2m_qbuf);
 513
 514 int v4l2_m2m_dqbuf(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
 515                    struct v4l2_buffer *buf)
 516 {
 517         struct vb2_queue *vq;
 518
 519         vq = v4l2_m2m_get_vq(m2m_ctx, buf->type);
 520         return vb2_dqbuf(vq, buf, file->f_flags & O_NONBLOCK);
 521 }
 522 EXPORT_SYMBOL_GPL(v4l2_m2m_dqbuf);
 523
 524 int v4l2_m2m_prepare_buf(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
 525                          struct v4l2_buffer *buf)
 526 {
 527         struct video_device *vdev = video_devdata(file);
 528         struct vb2_queue *vq;
 529
 530         vq = v4l2_m2m_get_vq(m2m_ctx, buf->type);
 531         return vb2_prepare_buf(vq, vdev->v4l2_dev->mdev, buf);
 532 }
 533 EXPORT_SYMBOL_GPL(v4l2_m2m_prepare_buf);
 534
 535 int v4l2_m2m_create_bufs(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
 536                          struct v4l2_create_buffers *create)
 537 {
 538         struct vb2_queue *vq;
 539
 540         vq = v4l2_m2m_get_vq(m2m_ctx, create->format.type);
 541         return vb2_create_bufs(vq, create);
 542 }
 543 EXPORT_SYMBOL_GPL(v4l2_m2m_create_bufs);
 544
 545 int v4l2_m2m_expbuf(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
 546                   struct v4l2_exportbuffer *eb)
 547 {
 548         struct vb2_queue *vq;
 549
 550         vq = v4l2_m2m_get_vq(m2m_ctx, eb->type);
 551         return vb2_expbuf(vq, eb);
 552 }
 553 EXPORT_SYMBOL_GPL(v4l2_m2m_expbuf);
 554
 555 int v4l2_m2m_streamon(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
 556                       enum v4l2_buf_type type)
 557 {
 558         struct vb2_queue *vq;
 559         int ret;
 560
 561         vq = v4l2_m2m_get_vq(m2m_ctx, type);
 562         ret = vb2_streamon(vq, type);
 563         if (!ret)
 564                 v4l2_m2m_try_schedule(m2m_ctx);
 565
 566         return ret;
 567 }
 568 EXPORT_SYMBOL_GPL(v4l2_m2m_streamon);
 569
 570 int v4l2_m2m_streamoff(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
 571                        enum v4l2_buf_type type)
 572 {
 573         struct v4l2_m2m_dev *m2m_dev;
 574         struct v4l2_m2m_queue_ctx *q_ctx;
 575         unsigned long flags_job, flags;
 576         int ret;
 577
 578         /* wait until the current context is dequeued from job_queue */
 579         v4l2_m2m_cancel_job(m2m_ctx);
 580
 581         q_ctx = get_queue_ctx(m2m_ctx, type);
 582         ret = vb2_streamoff(&q_ctx->q, type);
 583         if (ret)
 584                 return ret;
 585
 586         m2m_dev = m2m_ctx->m2m_dev;
 587         spin_lock_irqsave(&m2m_dev->job_spinlock, flags_job);
 588         /* We should not be scheduled anymore, since we're dropping a queue. */
 589         if (m2m_ctx->job_flags & TRANS_QUEUED)
 590                 list_del(&m2m_ctx->queue);
 591         m2m_ctx->job_flags = 0;
 592
 593         spin_lock_irqsave(&q_ctx->rdy_spinlock, flags);
 594         /* Drop queue, since streamoff returns device to the same state as after
 595          * calling reqbufs. */
 596         INIT_LIST_HEAD(&q_ctx->rdy_queue);
 597         q_ctx->num_rdy = 0;
 598         spin_unlock_irqrestore(&q_ctx->rdy_spinlock, flags);
 599
 600         if (m2m_dev->curr_ctx == m2m_ctx) {
 601                 m2m_dev->curr_ctx = NULL;
 602                 wake_up(&m2m_ctx->finished);
 603         }
 604         spin_unlock_irqrestore(&m2m_dev->job_spinlock, flags_job);
 605
 606         return 0;
 607 }
 608 EXPORT_SYMBOL_GPL(v4l2_m2m_streamoff);
 609
 610 __poll_t v4l2_m2m_poll(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
 611                            struct poll_table_struct *wait)
 612 {
 613         struct video_device *vfd = video_devdata(file);
 614         __poll_t req_events = poll_requested_events(wait);
 615         struct vb2_queue *src_q, *dst_q;
 616         struct vb2_buffer *src_vb = NULL, *dst_vb = NULL;
 617         __poll_t rc = 0;
 618         unsigned long flags;
 619
 620         if (test_bit(V4L2_FL_USES_V4L2_FH, &vfd->flags)) {
 621                 struct v4l2_fh *fh = file->private_data;
 622
 623                 if (v4l2_event_pending(fh))
 624                         rc = EPOLLPRI;
 625                 else if (req_events & EPOLLPRI)
 626                         poll_wait(file, &fh->wait, wait);
 627                 if (!(req_events & (EPOLLOUT | EPOLLWRNORM | EPOLLIN | EPOLLRDNORM)))
 628                         return rc;
 629         }
 630
 631         src_q = v4l2_m2m_get_src_vq(m2m_ctx);
 632         dst_q = v4l2_m2m_get_dst_vq(m2m_ctx);
 633
 634         /*
 635          * There has to be at least one buffer queued on each queued_list, which
 636          * means either in driver already or waiting for driver to claim it
 637          * and start processing.
 638          */
 639         if ((!src_q->streaming || list_empty(&src_q->queued_list))
 640                 && (!dst_q->streaming || list_empty(&dst_q->queued_list))) {
 641                 rc |= EPOLLERR;
 642                 goto end;
 643         }
 644
 645         spin_lock_irqsave(&src_q->done_lock, flags);
 646         if (list_empty(&src_q->done_list))
 647                 poll_wait(file, &src_q->done_wq, wait);
 648         spin_unlock_irqrestore(&src_q->done_lock, flags);
 649
 650         spin_lock_irqsave(&dst_q->done_lock, flags);
 651         if (list_empty(&dst_q->done_list)) {
 652                 /*
 653                  * If the last buffer was dequeued from the capture queue,
 654                  * return immediately. DQBUF will return -EPIPE.
 655                  */
 656                 if (dst_q->last_buffer_dequeued) {
 657                         spin_unlock_irqrestore(&dst_q->done_lock, flags);
 658                         return rc | EPOLLIN | EPOLLRDNORM;
 659                 }
 660
 661                 poll_wait(file, &dst_q->done_wq, wait);
 662         }
 663         spin_unlock_irqrestore(&dst_q->done_lock, flags);
 664
 665         spin_lock_irqsave(&src_q->done_lock, flags);
 666         if (!list_empty(&src_q->done_list))
 667                 src_vb = list_first_entry(&src_q->done_list, struct vb2_buffer,
 668                                                 done_entry);
 669         if (src_vb && (src_vb->state == VB2_BUF_STATE_DONE
 670                         || src_vb->state == VB2_BUF_STATE_ERROR))
 671                 rc |= EPOLLOUT | EPOLLWRNORM;
 672         spin_unlock_irqrestore(&src_q->done_lock, flags);
 673
 674         spin_lock_irqsave(&dst_q->done_lock, flags);
 675         if (!list_empty(&dst_q->done_list))
 676                 dst_vb = list_first_entry(&dst_q->done_list, struct vb2_buffer,
 677                                                 done_entry);
 678         if (dst_vb && (dst_vb->state == VB2_BUF_STATE_DONE
 679                         || dst_vb->state == VB2_BUF_STATE_ERROR))
 680                 rc |= EPOLLIN | EPOLLRDNORM;
 681         spin_unlock_irqrestore(&dst_q->done_lock, flags);
 682
 683 end:
 684         return rc;
 685 }
 686 EXPORT_SYMBOL_GPL(v4l2_m2m_poll);
 687
 688 int v4l2_m2m_mmap(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
 689                          struct vm_area_struct *vma)
 690 {
 691         unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
 692         struct vb2_queue *vq;
 693
 694         if (offset < DST_QUEUE_OFF_BASE) {
 695                 vq = v4l2_m2m_get_src_vq(m2m_ctx);
 696         } else {
 697                 vq = v4l2_m2m_get_dst_vq(m2m_ctx);
 698                 vma->vm_pgoff -= (DST_QUEUE_OFF_BASE >> PAGE_SHIFT);
 699         }
 700
 701         return vb2_mmap(vq, vma);
 702 }
 703 EXPORT_SYMBOL(v4l2_m2m_mmap);
 704
 705 #if defined(CONFIG_MEDIA_CONTROLLER)
 706 void v4l2_m2m_unregister_media_controller(struct v4l2_m2m_dev *m2m_dev)
 707 {
 708         media_remove_intf_links(&m2m_dev->intf_devnode->intf);
 709         media_devnode_remove(m2m_dev->intf_devnode);
 710
 711         media_entity_remove_links(m2m_dev->source);
 712         media_entity_remove_links(&m2m_dev->sink);
 713         media_entity_remove_links(&m2m_dev->proc);
 714         media_device_unregister_entity(m2m_dev->source);
 715         media_device_unregister_entity(&m2m_dev->sink);
 716         media_device_unregister_entity(&m2m_dev->proc);
 717         kfree(m2m_dev->source->name);
 718         kfree(m2m_dev->sink.name);
 719         kfree(m2m_dev->proc.name);
 720 }
 721 EXPORT_SYMBOL_GPL(v4l2_m2m_unregister_media_controller);
 722
 723 static int v4l2_m2m_register_entity(struct media_device *mdev,
 724         struct v4l2_m2m_dev *m2m_dev, enum v4l2_m2m_entity_type type,
 725         struct video_device *vdev, int function)
 726 {
 727         struct media_entity *entity;
 728         struct media_pad *pads;
 729         char *name;
 730         unsigned int len;
 731         int num_pads;
 732         int ret;
 733
 734         switch (type) {
 735         case MEM2MEM_ENT_TYPE_SOURCE:
 736                 entity = m2m_dev->source;
 737                 pads = &m2m_dev->source_pad;
 738                 pads[0].flags = MEDIA_PAD_FL_SOURCE;
 739                 num_pads = 1;
 740                 break;
 741         case MEM2MEM_ENT_TYPE_SINK:
 742                 entity = &m2m_dev->sink;
 743                 pads = &m2m_dev->sink_pad;
 744                 pads[0].flags = MEDIA_PAD_FL_SINK;
 745                 num_pads = 1;
 746                 break;
 747         case MEM2MEM_ENT_TYPE_PROC:
 748                 entity = &m2m_dev->proc;
 749                 pads = m2m_dev->proc_pads;
 750                 pads[0].flags = MEDIA_PAD_FL_SINK;
 751                 pads[1].flags = MEDIA_PAD_FL_SOURCE;
 752                 num_pads = 2;
 753                 break;
 754         default:
 755                 return -EINVAL;
 756         }
 757
 758         entity->obj_type = MEDIA_ENTITY_TYPE_BASE;
 759         if (type != MEM2MEM_ENT_TYPE_PROC) {
 760                 entity->info.dev.major = VIDEO_MAJOR;
 761                 entity->info.dev.minor = vdev->minor;
 762         }
 763         len = strlen(vdev->name) + 2 + strlen(m2m_entity_name[type]);
 764         name = kmalloc(len, GFP_KERNEL);
 765         if (!name)
 766                 return -ENOMEM;
 767         snprintf(name, len, "%s-%s", vdev->name, m2m_entity_name[type]);
 768         entity->name = name;
 769         entity->function = function;
 770
 771         ret = media_entity_pads_init(entity, num_pads, pads);
 772         if (ret)
 773                 return ret;
 774         ret = media_device_register_entity(mdev, entity);
 775         if (ret)
 776                 return ret;
 777
 778         return 0;
 779 }
 780
 781 int v4l2_m2m_register_media_controller(struct v4l2_m2m_dev *m2m_dev,
 782                 struct video_device *vdev, int function)
 783 {
 784         struct media_device *mdev = vdev->v4l2_dev->mdev;
 785         struct media_link *link;
 786         int ret;
 787
 788         if (!mdev)
 789                 return 0;
 790
 791         /* A memory-to-memory device consists in two
 792          * DMA engine and one video processing entities.
 793          * The DMA engine entities are linked to a V4L interface
 794          */
 795
 796         /* Create the three entities with their pads */
 797         m2m_dev->source = &vdev->entity;
 798         ret = v4l2_m2m_register_entity(mdev, m2m_dev,
 799                         MEM2MEM_ENT_TYPE_SOURCE, vdev, MEDIA_ENT_F_IO_V4L);
 800         if (ret)
 801                 return ret;
 802         ret = v4l2_m2m_register_entity(mdev, m2m_dev,
 803                         MEM2MEM_ENT_TYPE_PROC, vdev, function);
 804         if (ret)
 805                 goto err_rel_entity0;
 806         ret = v4l2_m2m_register_entity(mdev, m2m_dev,
 807                         MEM2MEM_ENT_TYPE_SINK, vdev, MEDIA_ENT_F_IO_V4L);
 808         if (ret)
 809                 goto err_rel_entity1;
 810
 811         /* Connect the three entities */
 812         ret = media_create_pad_link(m2m_dev->source, 0, &m2m_dev->proc, 1,
 813                         MEDIA_LNK_FL_IMMUTABLE | MEDIA_LNK_FL_ENABLED);
 814         if (ret)
 815                 goto err_rel_entity2;
 816
 817         ret = media_create_pad_link(&m2m_dev->proc, 0, &m2m_dev->sink, 0,
 818                         MEDIA_LNK_FL_IMMUTABLE | MEDIA_LNK_FL_ENABLED);
 819         if (ret)
 820                 goto err_rm_links0;
 821
 822         /* Create video interface */
 823         m2m_dev->intf_devnode = media_devnode_create(mdev,
 824                         MEDIA_INTF_T_V4L_VIDEO, 0,
 825                         VIDEO_MAJOR, vdev->minor);
 826         if (!m2m_dev->intf_devnode) {
 827                 ret = -ENOMEM;
 828                 goto err_rm_links1;
 829         }
 830
 831         /* Connect the two DMA engines to the interface */
 832         link = media_create_intf_link(m2m_dev->source,
 833                         &m2m_dev->intf_devnode->intf,
 834                         MEDIA_LNK_FL_IMMUTABLE | MEDIA_LNK_FL_ENABLED);
 835         if (!link) {
 836                 ret = -ENOMEM;
 837                 goto err_rm_devnode;
 838         }
 839
 840         link = media_create_intf_link(&m2m_dev->sink,
 841                         &m2m_dev->intf_devnode->intf,
 842                         MEDIA_LNK_FL_IMMUTABLE | MEDIA_LNK_FL_ENABLED);
 843         if (!link) {
 844                 ret = -ENOMEM;
 845                 goto err_rm_intf_link;
 846         }
 847         return 0;
 848
 849 err_rm_intf_link:
 850         media_remove_intf_links(&m2m_dev->intf_devnode->intf);
 851 err_rm_devnode:
 852         media_devnode_remove(m2m_dev->intf_devnode);
 853 err_rm_links1:
 854         media_entity_remove_links(&m2m_dev->sink);
 855 err_rm_links0:
 856         media_entity_remove_links(&m2m_dev->proc);
 857         media_entity_remove_links(m2m_dev->source);
 858 err_rel_entity2:
 859         media_device_unregister_entity(&m2m_dev->proc);
 860         kfree(m2m_dev->proc.name);
 861 err_rel_entity1:
 862         media_device_unregister_entity(&m2m_dev->sink);
 863         kfree(m2m_dev->sink.name);
 864 err_rel_entity0:
 865         media_device_unregister_entity(m2m_dev->source);
 866         kfree(m2m_dev->source->name);
 867         return ret;
 868         return 0;
 869 }
 870 EXPORT_SYMBOL_GPL(v4l2_m2m_register_media_controller);
 871 #endif
 872
 873 struct v4l2_m2m_dev *v4l2_m2m_init(const struct v4l2_m2m_ops *m2m_ops)
 874 {
 875         struct v4l2_m2m_dev *m2m_dev;
 876
 877         if (!m2m_ops || WARN_ON(!m2m_ops->device_run))
 878                 return ERR_PTR(-EINVAL);
 879
 880         m2m_dev = kzalloc(sizeof *m2m_dev, GFP_KERNEL);
 881         if (!m2m_dev)
 882                 return ERR_PTR(-ENOMEM);
 883
 884         m2m_dev->curr_ctx = NULL;
 885         m2m_dev->m2m_ops = m2m_ops;
 886         INIT_LIST_HEAD(&m2m_dev->job_queue);
 887         spin_lock_init(&m2m_dev->job_spinlock);
 888         INIT_WORK(&m2m_dev->job_work, v4l2_m2m_device_run_work);
 889
 890         return m2m_dev;
 891 }
 892 EXPORT_SYMBOL_GPL(v4l2_m2m_init);
 893
 894 void v4l2_m2m_release(struct v4l2_m2m_dev *m2m_dev)
 895 {
 896         kfree(m2m_dev);
 897 }
 898 EXPORT_SYMBOL_GPL(v4l2_m2m_release);
 899
 900 struct v4l2_m2m_ctx *v4l2_m2m_ctx_init(struct v4l2_m2m_dev *m2m_dev,
 901                 void *drv_priv,
 902                 int (*queue_init)(void *priv, struct vb2_queue *src_vq, struct vb2_queue *dst_vq))
 903 {
 904         struct v4l2_m2m_ctx *m2m_ctx;
 905         struct v4l2_m2m_queue_ctx *out_q_ctx, *cap_q_ctx;
 906         int ret;
 907
 908         m2m_ctx = kzalloc(sizeof *m2m_ctx, GFP_KERNEL);
 909         if (!m2m_ctx)
 910                 return ERR_PTR(-ENOMEM);
 911
 912         m2m_ctx->priv = drv_priv;
 913         m2m_ctx->m2m_dev = m2m_dev;
 914         init_waitqueue_head(&m2m_ctx->finished);
 915
 916         out_q_ctx = &m2m_ctx->out_q_ctx;
 917         cap_q_ctx = &m2m_ctx->cap_q_ctx;
 918
 919         INIT_LIST_HEAD(&out_q_ctx->rdy_queue);
 920         INIT_LIST_HEAD(&cap_q_ctx->rdy_queue);
 921         spin_lock_init(&out_q_ctx->rdy_spinlock);
 922         spin_lock_init(&cap_q_ctx->rdy_spinlock);
 923
 924         INIT_LIST_HEAD(&m2m_ctx->queue);
 925
 926         ret = queue_init(drv_priv, &out_q_ctx->q, &cap_q_ctx->q);
 927
 928         if (ret)
 929                 goto err;
 930         /*
 931          * Both queues should use same the mutex to lock the m2m context.
 932          * This lock is used in some v4l2_m2m_* helpers.
 933          */
 934         if (WARN_ON(out_q_ctx->q.lock != cap_q_ctx->q.lock)) {
 935                 ret = -EINVAL;
 936                 goto err;
 937         }
 938         m2m_ctx->q_lock = out_q_ctx->q.lock;
 939
 940         return m2m_ctx;
 941 err:
 942         kfree(m2m_ctx);
 943         return ERR_PTR(ret);
 944 }
 945 EXPORT_SYMBOL_GPL(v4l2_m2m_ctx_init);
 946
 947 void v4l2_m2m_ctx_release(struct v4l2_m2m_ctx *m2m_ctx)
 948 {
 949         /* wait until the current context is dequeued from job_queue */
 950         v4l2_m2m_cancel_job(m2m_ctx);
 951
 952         vb2_queue_release(&m2m_ctx->cap_q_ctx.q);
 953         vb2_queue_release(&m2m_ctx->out_q_ctx.q);
 954
 955         kfree(m2m_ctx);
 956 }
 957 EXPORT_SYMBOL_GPL(v4l2_m2m_ctx_release);
 958
 959 void v4l2_m2m_buf_queue(struct v4l2_m2m_ctx *m2m_ctx,
 960                 struct vb2_v4l2_buffer *vbuf)
 961 {
 962         struct v4l2_m2m_buffer *b = container_of(vbuf,
 963                                 struct v4l2_m2m_buffer, vb);
 964         struct v4l2_m2m_queue_ctx *q_ctx;
 965         unsigned long flags;
 966
 967         q_ctx = get_queue_ctx(m2m_ctx, vbuf->vb2_buf.vb2_queue->type);
 968         if (!q_ctx)
 969                 return;
 970
 971         spin_lock_irqsave(&q_ctx->rdy_spinlock, flags);
 972         list_add_tail(&b->list, &q_ctx->rdy_queue);
 973         q_ctx->num_rdy++;
 974         spin_unlock_irqrestore(&q_ctx->rdy_spinlock, flags);
 975 }
 976 EXPORT_SYMBOL_GPL(v4l2_m2m_buf_queue);
 977
 978 void v4l2_m2m_request_queue(struct media_request *req)
 979 {
 980         struct media_request_object *obj, *obj_safe;
 981         struct v4l2_m2m_ctx *m2m_ctx = NULL;
 982
 983         /*
 984          * Queue all objects. Note that buffer objects are at the end of the
 985          * objects list, after all other object types. Once buffer objects
 986          * are queued, the driver might delete them immediately (if the driver
 987          * processes the buffer at once), so we have to use
 988          * list_for_each_entry_safe() to handle the case where the object we
 989          * queue is deleted.
 990          */
 991         list_for_each_entry_safe(obj, obj_safe, &req->objects, list) {
 992                 struct v4l2_m2m_ctx *m2m_ctx_obj;
 993                 struct vb2_buffer *vb;
 994
 995                 if (!obj->ops->queue)
 996                         continue;
 997
 998                 if (vb2_request_object_is_buffer(obj)) {
 999                         /* Sanity checks */
1000                         vb = container_of(obj, struct vb2_buffer, req_obj);
1001                         WARN_ON(!V4L2_TYPE_IS_OUTPUT(vb->vb2_queue->type));
1002                         m2m_ctx_obj = container_of(vb->vb2_queue,
1003                                                    struct v4l2_m2m_ctx,
1004                                                    out_q_ctx.q);
1005                         WARN_ON(m2m_ctx && m2m_ctx_obj != m2m_ctx);
1006                         m2m_ctx = m2m_ctx_obj;
1007                 }
1008
1009                 /*
1010                  * The buffer we queue here can in theory be immediately
1011                  * unbound, hence the use of list_for_each_entry_safe()
1012                  * above and why we call the queue op last.
1013                  */
1014                 obj->ops->queue(obj);
1015         }
1016
1017         WARN_ON(!m2m_ctx);
1018
1019         if (m2m_ctx)
1020                 v4l2_m2m_try_schedule(m2m_ctx);
1021 }
1022 EXPORT_SYMBOL_GPL(v4l2_m2m_request_queue);
1023
1024 /* Videobuf2 ioctl helpers */
1025
1026 int v4l2_m2m_ioctl_reqbufs(struct file *file, void *priv,
1027                                 struct v4l2_requestbuffers *rb)
1028 {
1029         struct v4l2_fh *fh = file->private_data;
1030
1031         return v4l2_m2m_reqbufs(file, fh->m2m_ctx, rb);
1032 }
1033 EXPORT_SYMBOL_GPL(v4l2_m2m_ioctl_reqbufs);
1034
1035 int v4l2_m2m_ioctl_create_bufs(struct file *file, void *priv,
1036                                 struct v4l2_create_buffers *create)
1037 {
1038         struct v4l2_fh *fh = file->private_data;
1039
1040         return v4l2_m2m_create_bufs(file, fh->m2m_ctx, create);
1041 }
1042 EXPORT_SYMBOL_GPL(v4l2_m2m_ioctl_create_bufs);
1043
1044 int v4l2_m2m_ioctl_querybuf(struct file *file, void *priv,
1045                                 struct v4l2_buffer *buf)
1046 {
1047         struct v4l2_fh *fh = file->private_data;
1048
1049         return v4l2_m2m_querybuf(file, fh->m2m_ctx, buf);
1050 }
1051 EXPORT_SYMBOL_GPL(v4l2_m2m_ioctl_querybuf);
1052
1053 int v4l2_m2m_ioctl_qbuf(struct file *file, void *priv,
1054                                 struct v4l2_buffer *buf)
1055 {
1056         struct v4l2_fh *fh = file->private_data;
1057
1058         return v4l2_m2m_qbuf(file, fh->m2m_ctx, buf);
1059 }
1060 EXPORT_SYMBOL_GPL(v4l2_m2m_ioctl_qbuf);
1061
1062 int v4l2_m2m_ioctl_dqbuf(struct file *file, void *priv,
1063                                 struct v4l2_buffer *buf)
1064 {
1065         struct v4l2_fh *fh = file->private_data;
1066
1067         return v4l2_m2m_dqbuf(file, fh->m2m_ctx, buf);
1068 }
1069 EXPORT_SYMBOL_GPL(v4l2_m2m_ioctl_dqbuf);
1070
1071 int v4l2_m2m_ioctl_prepare_buf(struct file *file, void *priv,
1072                                struct v4l2_buffer *buf)
1073 {
1074         struct v4l2_fh *fh = file->private_data;
1075
1076         return v4l2_m2m_prepare_buf(file, fh->m2m_ctx, buf);
1077 }
1078 EXPORT_SYMBOL_GPL(v4l2_m2m_ioctl_prepare_buf);
1079
1080 int v4l2_m2m_ioctl_expbuf(struct file *file, void *priv,
1081                                 struct v4l2_exportbuffer *eb)
1082 {
1083         struct v4l2_fh *fh = file->private_data;
1084
1085         return v4l2_m2m_expbuf(file, fh->m2m_ctx, eb);
1086 }
1087 EXPORT_SYMBOL_GPL(v4l2_m2m_ioctl_expbuf);
1088
1089 int v4l2_m2m_ioctl_streamon(struct file *file, void *priv,
1090                                 enum v4l2_buf_type type)
1091 {
1092         struct v4l2_fh *fh = file->private_data;
1093
1094         return v4l2_m2m_streamon(file, fh->m2m_ctx, type);
1095 }
1096 EXPORT_SYMBOL_GPL(v4l2_m2m_ioctl_streamon);
1097
1098 int v4l2_m2m_ioctl_streamoff(struct file *file, void *priv,
1099                                 enum v4l2_buf_type type)
1100 {
1101         struct v4l2_fh *fh = file->private_data;
1102
1103         return v4l2_m2m_streamoff(file, fh->m2m_ctx, type);
1104 }
1105 EXPORT_SYMBOL_GPL(v4l2_m2m_ioctl_streamoff);
1106
1107 /*
1108  * v4l2_file_operations helpers. It is assumed here same lock is used
1109  * for the output and the capture buffer queue.
1110  */
1111
1112 int v4l2_m2m_fop_mmap(struct file *file, struct vm_area_struct *vma)
1113 {
1114         struct v4l2_fh *fh = file->private_data;
1115
1116         return v4l2_m2m_mmap(file, fh->m2m_ctx, vma);
1117 }
1118 EXPORT_SYMBOL_GPL(v4l2_m2m_fop_mmap);
1119
1120 __poll_t v4l2_m2m_fop_poll(struct file *file, poll_table *wait)
1121 {
1122         struct v4l2_fh *fh = file->private_data;
1123         struct v4l2_m2m_ctx *m2m_ctx = fh->m2m_ctx;
1124         __poll_t ret;
1125
1126         if (m2m_ctx->q_lock)
1127                 mutex_lock(m2m_ctx->q_lock);
1128
1129         ret = v4l2_m2m_poll(file, m2m_ctx, wait);
1130
1131         if (m2m_ctx->q_lock)
1132                 mutex_unlock(m2m_ctx->q_lock);
1133
1134         return ret;
1135 }
1136 EXPORT_SYMBOL_GPL(v4l2_m2m_fop_poll);
1137