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/videobuf2-v4l2.h>
  21 #include <media/v4l2-mem2mem.h>
  22 #include <media/v4l2-dev.h>
  23 #include <media/v4l2-fh.h>
  24 #include <media/v4l2-event.h>
  25
  26 MODULE_DESCRIPTION("Mem to mem device framework for videobuf");
  27 MODULE_AUTHOR("Pawel Osciak, <pawel@osciak.com>");
  28 MODULE_LICENSE("GPL");
  29
  30 static bool debug;
  31 module_param(debug, bool, 0644);
  32
  33 #define dprintk(fmt, arg...)                                            \
  34         do {                                                            \
  35                 if (debug)                                              \
  36                         printk(KERN_DEBUG "%s: " fmt, __func__, ## arg);\
  37         } while (0)
  38
  39
  40 /* Instance is already queued on the job_queue */
  41 #define TRANS_QUEUED            (1 << 0)
  42 /* Instance is currently running in hardware */
  43 #define TRANS_RUNNING           (1 << 1)
  44 /* Instance is currently aborting */
  45 #define TRANS_ABORT             (1 << 2)
  46
  47
  48 /* Offset base for buffers on the destination queue - used to distinguish
  49  * between source and destination buffers when mmapping - they receive the same
  50  * offsets but for different queues */
  51 #define DST_QUEUE_OFF_BASE      (1 << 30)
  52
  53
  54 /**
  55  * struct v4l2_m2m_dev - per-device context
  56  * @curr_ctx:           currently running instance
  57  * @job_queue:          instances queued to run
  58  * @job_spinlock:       protects job_queue
  59  * @m2m_ops:            driver callbacks
  60  */
  61 struct v4l2_m2m_dev {
  62         struct v4l2_m2m_ctx     *curr_ctx;
  63
  64         struct list_head        job_queue;
  65         spinlock_t              job_spinlock;
  66
  67         const struct v4l2_m2m_ops *m2m_ops;
  68 };
  69
  70 static struct v4l2_m2m_queue_ctx *get_queue_ctx(struct v4l2_m2m_ctx *m2m_ctx,
  71                                                 enum v4l2_buf_type type)
  72 {
  73         if (V4L2_TYPE_IS_OUTPUT(type))
  74                 return &m2m_ctx->out_q_ctx;
  75         else
  76                 return &m2m_ctx->cap_q_ctx;
  77 }
  78
  79 struct vb2_queue *v4l2_m2m_get_vq(struct v4l2_m2m_ctx *m2m_ctx,
  80                                        enum v4l2_buf_type type)
  81 {
  82         struct v4l2_m2m_queue_ctx *q_ctx;
  83
  84         q_ctx = get_queue_ctx(m2m_ctx, type);
  85         if (!q_ctx)
  86                 return NULL;
  87
  88         return &q_ctx->q;
  89 }
  90 EXPORT_SYMBOL(v4l2_m2m_get_vq);
  91
  92 void *v4l2_m2m_next_buf(struct v4l2_m2m_queue_ctx *q_ctx)
  93 {
  94         struct v4l2_m2m_buffer *b;
  95         unsigned long flags;
  96
  97         spin_lock_irqsave(&q_ctx->rdy_spinlock, flags);
  98
  99         if (list_empty(&q_ctx->rdy_queue)) {
 100                 spin_unlock_irqrestore(&q_ctx->rdy_spinlock, flags);
 101                 return NULL;
 102         }
 103
 104         b = list_first_entry(&q_ctx->rdy_queue, struct v4l2_m2m_buffer, list);
 105         spin_unlock_irqrestore(&q_ctx->rdy_spinlock, flags);
 106         return &b->vb;
 107 }
 108 EXPORT_SYMBOL_GPL(v4l2_m2m_next_buf);
 109
 110 void *v4l2_m2m_buf_remove(struct v4l2_m2m_queue_ctx *q_ctx)
 111 {
 112         struct v4l2_m2m_buffer *b;
 113         unsigned long flags;
 114
 115         spin_lock_irqsave(&q_ctx->rdy_spinlock, flags);
 116         if (list_empty(&q_ctx->rdy_queue)) {
 117                 spin_unlock_irqrestore(&q_ctx->rdy_spinlock, flags);
 118                 return NULL;
 119         }
 120         b = list_first_entry(&q_ctx->rdy_queue, struct v4l2_m2m_buffer, list);
 121         list_del(&b->list);
 122         q_ctx->num_rdy--;
 123         spin_unlock_irqrestore(&q_ctx->rdy_spinlock, flags);
 124
 125         return &b->vb;
 126 }
 127 EXPORT_SYMBOL_GPL(v4l2_m2m_buf_remove);
 128
 129 /*
 130  * Scheduling handlers
 131  */
 132
 133 void *v4l2_m2m_get_curr_priv(struct v4l2_m2m_dev *m2m_dev)
 134 {
 135         unsigned long flags;
 136         void *ret = NULL;
 137
 138         spin_lock_irqsave(&m2m_dev->job_spinlock, flags);
 139         if (m2m_dev->curr_ctx)
 140                 ret = m2m_dev->curr_ctx->priv;
 141         spin_unlock_irqrestore(&m2m_dev->job_spinlock, flags);
 142
 143         return ret;
 144 }
 145 EXPORT_SYMBOL(v4l2_m2m_get_curr_priv);
 146
 147 /**
 148  * v4l2_m2m_try_run() - select next job to perform and run it if possible
 149  *
 150  * Get next transaction (if present) from the waiting jobs list and run it.
 151  */
 152 static void v4l2_m2m_try_run(struct v4l2_m2m_dev *m2m_dev)
 153 {
 154         unsigned long flags;
 155
 156         spin_lock_irqsave(&m2m_dev->job_spinlock, flags);
 157         if (NULL != m2m_dev->curr_ctx) {
 158                 spin_unlock_irqrestore(&m2m_dev->job_spinlock, flags);
 159                 dprintk("Another instance is running, won't run now\n");
 160                 return;
 161         }
 162
 163         if (list_empty(&m2m_dev->job_queue)) {
 164                 spin_unlock_irqrestore(&m2m_dev->job_spinlock, flags);
 165                 dprintk("No job pending\n");
 166                 return;
 167         }
 168
 169         m2m_dev->curr_ctx = list_first_entry(&m2m_dev->job_queue,
 170                                    struct v4l2_m2m_ctx, queue);
 171         m2m_dev->curr_ctx->job_flags |= TRANS_RUNNING;
 172         spin_unlock_irqrestore(&m2m_dev->job_spinlock, flags);
 173
 174         m2m_dev->m2m_ops->device_run(m2m_dev->curr_ctx->priv);
 175 }
 176
 177 void v4l2_m2m_try_schedule(struct v4l2_m2m_ctx *m2m_ctx)
 178 {
 179         struct v4l2_m2m_dev *m2m_dev;
 180         unsigned long flags_job, flags_out, flags_cap;
 181
 182         m2m_dev = m2m_ctx->m2m_dev;
 183         dprintk("Trying to schedule a job for m2m_ctx: %p\n", m2m_ctx);
 184
 185         if (!m2m_ctx->out_q_ctx.q.streaming
 186             || !m2m_ctx->cap_q_ctx.q.streaming) {
 187                 dprintk("Streaming needs to be on for both queues\n");
 188                 return;
 189         }
 190
 191         spin_lock_irqsave(&m2m_dev->job_spinlock, flags_job);
 192
 193         /* If the context is aborted then don't schedule it */
 194         if (m2m_ctx->job_flags & TRANS_ABORT) {
 195                 spin_unlock_irqrestore(&m2m_dev->job_spinlock, flags_job);
 196                 dprintk("Aborted context\n");
 197                 return;
 198         }
 199
 200         if (m2m_ctx->job_flags & TRANS_QUEUED) {
 201                 spin_unlock_irqrestore(&m2m_dev->job_spinlock, flags_job);
 202                 dprintk("On job queue already\n");
 203                 return;
 204         }
 205
 206         spin_lock_irqsave(&m2m_ctx->out_q_ctx.rdy_spinlock, flags_out);
 207         if (list_empty(&m2m_ctx->out_q_ctx.rdy_queue)
 208             && !m2m_ctx->out_q_ctx.buffered) {
 209                 spin_unlock_irqrestore(&m2m_ctx->out_q_ctx.rdy_spinlock,
 210                                         flags_out);
 211                 spin_unlock_irqrestore(&m2m_dev->job_spinlock, flags_job);
 212                 dprintk("No input buffers available\n");
 213                 return;
 214         }
 215         spin_lock_irqsave(&m2m_ctx->cap_q_ctx.rdy_spinlock, flags_cap);
 216         if (list_empty(&m2m_ctx->cap_q_ctx.rdy_queue)
 217             && !m2m_ctx->cap_q_ctx.buffered) {
 218                 spin_unlock_irqrestore(&m2m_ctx->cap_q_ctx.rdy_spinlock,
 219                                         flags_cap);
 220                 spin_unlock_irqrestore(&m2m_ctx->out_q_ctx.rdy_spinlock,
 221                                         flags_out);
 222                 spin_unlock_irqrestore(&m2m_dev->job_spinlock, flags_job);
 223                 dprintk("No output buffers available\n");
 224                 return;
 225         }
 226         spin_unlock_irqrestore(&m2m_ctx->cap_q_ctx.rdy_spinlock, flags_cap);
 227         spin_unlock_irqrestore(&m2m_ctx->out_q_ctx.rdy_spinlock, flags_out);
 228
 229         if (m2m_dev->m2m_ops->job_ready
 230                 && (!m2m_dev->m2m_ops->job_ready(m2m_ctx->priv))) {
 231                 spin_unlock_irqrestore(&m2m_dev->job_spinlock, flags_job);
 232                 dprintk("Driver not ready\n");
 233                 return;
 234         }
 235
 236         list_add_tail(&m2m_ctx->queue, &m2m_dev->job_queue);
 237         m2m_ctx->job_flags |= TRANS_QUEUED;
 238
 239         spin_unlock_irqrestore(&m2m_dev->job_spinlock, flags_job);
 240
 241         v4l2_m2m_try_run(m2m_dev);
 242 }
 243 EXPORT_SYMBOL_GPL(v4l2_m2m_try_schedule);
 244
 245 /**
 246  * v4l2_m2m_cancel_job() - cancel pending jobs for the context
 247  *
 248  * In case of streamoff or release called on any context,
 249  * 1] If the context is currently running, then abort job will be called
 250  * 2] If the context is queued, then the context will be removed from
 251  *    the job_queue
 252  */
 253 static void v4l2_m2m_cancel_job(struct v4l2_m2m_ctx *m2m_ctx)
 254 {
 255         struct v4l2_m2m_dev *m2m_dev;
 256         unsigned long flags;
 257
 258         m2m_dev = m2m_ctx->m2m_dev;
 259         spin_lock_irqsave(&m2m_dev->job_spinlock, flags);
 260
 261         m2m_ctx->job_flags |= TRANS_ABORT;
 262         if (m2m_ctx->job_flags & TRANS_RUNNING) {
 263                 spin_unlock_irqrestore(&m2m_dev->job_spinlock, flags);
 264                 m2m_dev->m2m_ops->job_abort(m2m_ctx->priv);
 265                 dprintk("m2m_ctx %p running, will wait to complete", m2m_ctx);
 266                 wait_event(m2m_ctx->finished,
 267                                 !(m2m_ctx->job_flags & TRANS_RUNNING));
 268         } else if (m2m_ctx->job_flags & TRANS_QUEUED) {
 269                 list_del(&m2m_ctx->queue);
 270                 m2m_ctx->job_flags &= ~(TRANS_QUEUED | TRANS_RUNNING);
 271                 spin_unlock_irqrestore(&m2m_dev->job_spinlock, flags);
 272                 dprintk("m2m_ctx: %p had been on queue and was removed\n",
 273                         m2m_ctx);
 274         } else {
 275                 /* Do nothing, was not on queue/running */
 276                 spin_unlock_irqrestore(&m2m_dev->job_spinlock, flags);
 277         }
 278 }
 279
 280 void v4l2_m2m_job_finish(struct v4l2_m2m_dev *m2m_dev,
 281                          struct v4l2_m2m_ctx *m2m_ctx)
 282 {
 283         unsigned long flags;
 284
 285         spin_lock_irqsave(&m2m_dev->job_spinlock, flags);
 286         if (!m2m_dev->curr_ctx || m2m_dev->curr_ctx != m2m_ctx) {
 287                 spin_unlock_irqrestore(&m2m_dev->job_spinlock, flags);
 288                 dprintk("Called by an instance not currently running\n");
 289                 return;
 290         }
 291
 292         list_del(&m2m_dev->curr_ctx->queue);
 293         m2m_dev->curr_ctx->job_flags &= ~(TRANS_QUEUED | TRANS_RUNNING);
 294         wake_up(&m2m_dev->curr_ctx->finished);
 295         m2m_dev->curr_ctx = NULL;
 296
 297         spin_unlock_irqrestore(&m2m_dev->job_spinlock, flags);
 298
 299         /* This instance might have more buffers ready, but since we do not
 300          * allow more than one job on the job_queue per instance, each has
 301          * to be scheduled separately after the previous one finishes. */
 302         v4l2_m2m_try_schedule(m2m_ctx);
 303         v4l2_m2m_try_run(m2m_dev);
 304 }
 305 EXPORT_SYMBOL(v4l2_m2m_job_finish);
 306
 307 int v4l2_m2m_reqbufs(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
 308                      struct v4l2_requestbuffers *reqbufs)
 309 {
 310         struct vb2_queue *vq;
 311         int ret;
 312
 313         vq = v4l2_m2m_get_vq(m2m_ctx, reqbufs->type);
 314         ret = vb2_reqbufs(vq, reqbufs);
 315         /* If count == 0, then the owner has released all buffers and he
 316            is no longer owner of the queue. Otherwise we have an owner. */
 317         if (ret == 0)
 318                 vq->owner = reqbufs->count ? file->private_data : NULL;
 319
 320         return ret;
 321 }
 322 EXPORT_SYMBOL_GPL(v4l2_m2m_reqbufs);
 323
 324 int v4l2_m2m_querybuf(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
 325                       struct v4l2_buffer *buf)
 326 {
 327         struct vb2_queue *vq;
 328         int ret = 0;
 329         unsigned int i;
 330
 331         vq = v4l2_m2m_get_vq(m2m_ctx, buf->type);
 332         ret = vb2_querybuf(vq, buf);
 333
 334         /* Adjust MMAP memory offsets for the CAPTURE queue */
 335         if (buf->memory == V4L2_MEMORY_MMAP && !V4L2_TYPE_IS_OUTPUT(vq->type)) {
 336                 if (V4L2_TYPE_IS_MULTIPLANAR(vq->type)) {
 337                         for (i = 0; i < buf->length; ++i)
 338                                 buf->m.planes[i].m.mem_offset
 339                                         += DST_QUEUE_OFF_BASE;
 340                 } else {
 341                         buf->m.offset += DST_QUEUE_OFF_BASE;
 342                 }
 343         }
 344
 345         return ret;
 346 }
 347 EXPORT_SYMBOL_GPL(v4l2_m2m_querybuf);
 348
 349 int v4l2_m2m_qbuf(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
 350                   struct v4l2_buffer *buf)
 351 {
 352         struct vb2_queue *vq;
 353         int ret;
 354
 355         vq = v4l2_m2m_get_vq(m2m_ctx, buf->type);
 356         ret = vb2_qbuf(vq, buf);
 357         if (!ret)
 358                 v4l2_m2m_try_schedule(m2m_ctx);
 359
 360         return ret;
 361 }
 362 EXPORT_SYMBOL_GPL(v4l2_m2m_qbuf);
 363
 364 int v4l2_m2m_dqbuf(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
 365                    struct v4l2_buffer *buf)
 366 {
 367         struct vb2_queue *vq;
 368
 369         vq = v4l2_m2m_get_vq(m2m_ctx, buf->type);
 370         return vb2_dqbuf(vq, buf, file->f_flags & O_NONBLOCK);
 371 }
 372 EXPORT_SYMBOL_GPL(v4l2_m2m_dqbuf);
 373
 374 int v4l2_m2m_prepare_buf(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
 375                          struct v4l2_buffer *buf)
 376 {
 377         struct vb2_queue *vq;
 378         int ret;
 379
 380         vq = v4l2_m2m_get_vq(m2m_ctx, buf->type);
 381         ret = vb2_prepare_buf(vq, buf);
 382         if (!ret)
 383                 v4l2_m2m_try_schedule(m2m_ctx);
 384
 385         return ret;
 386 }
 387 EXPORT_SYMBOL_GPL(v4l2_m2m_prepare_buf);
 388
 389 int v4l2_m2m_create_bufs(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
 390                          struct v4l2_create_buffers *create)
 391 {
 392         struct vb2_queue *vq;
 393
 394         vq = v4l2_m2m_get_vq(m2m_ctx, create->format.type);
 395         return vb2_create_bufs(vq, create);
 396 }
 397 EXPORT_SYMBOL_GPL(v4l2_m2m_create_bufs);
 398
 399 int v4l2_m2m_expbuf(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
 400                   struct v4l2_exportbuffer *eb)
 401 {
 402         struct vb2_queue *vq;
 403
 404         vq = v4l2_m2m_get_vq(m2m_ctx, eb->type);
 405         return vb2_expbuf(vq, eb);
 406 }
 407 EXPORT_SYMBOL_GPL(v4l2_m2m_expbuf);
 408
 409 int v4l2_m2m_streamon(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
 410                       enum v4l2_buf_type type)
 411 {
 412         struct vb2_queue *vq;
 413         int ret;
 414
 415         vq = v4l2_m2m_get_vq(m2m_ctx, type);
 416         ret = vb2_streamon(vq, type);
 417         if (!ret)
 418                 v4l2_m2m_try_schedule(m2m_ctx);
 419
 420         return ret;
 421 }
 422 EXPORT_SYMBOL_GPL(v4l2_m2m_streamon);
 423
 424 int v4l2_m2m_streamoff(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
 425                        enum v4l2_buf_type type)
 426 {
 427         struct v4l2_m2m_dev *m2m_dev;
 428         struct v4l2_m2m_queue_ctx *q_ctx;
 429         unsigned long flags_job, flags;
 430         int ret;
 431
 432         /* wait until the current context is dequeued from job_queue */
 433         v4l2_m2m_cancel_job(m2m_ctx);
 434
 435         q_ctx = get_queue_ctx(m2m_ctx, type);
 436         ret = vb2_streamoff(&q_ctx->q, type);
 437         if (ret)
 438                 return ret;
 439
 440         m2m_dev = m2m_ctx->m2m_dev;
 441         spin_lock_irqsave(&m2m_dev->job_spinlock, flags_job);
 442         /* We should not be scheduled anymore, since we're dropping a queue. */
 443         if (m2m_ctx->job_flags & TRANS_QUEUED)
 444                 list_del(&m2m_ctx->queue);
 445         m2m_ctx->job_flags = 0;
 446
 447         spin_lock_irqsave(&q_ctx->rdy_spinlock, flags);
 448         /* Drop queue, since streamoff returns device to the same state as after
 449          * calling reqbufs. */
 450         INIT_LIST_HEAD(&q_ctx->rdy_queue);
 451         q_ctx->num_rdy = 0;
 452         spin_unlock_irqrestore(&q_ctx->rdy_spinlock, flags);
 453
 454         if (m2m_dev->curr_ctx == m2m_ctx) {
 455                 m2m_dev->curr_ctx = NULL;
 456                 wake_up(&m2m_ctx->finished);
 457         }
 458         spin_unlock_irqrestore(&m2m_dev->job_spinlock, flags_job);
 459
 460         return 0;
 461 }
 462 EXPORT_SYMBOL_GPL(v4l2_m2m_streamoff);
 463
 464 unsigned int v4l2_m2m_poll(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
 465                            struct poll_table_struct *wait)
 466 {
 467         struct video_device *vfd = video_devdata(file);
 468         unsigned long req_events = poll_requested_events(wait);
 469         struct vb2_queue *src_q, *dst_q;
 470         struct vb2_buffer *src_vb = NULL, *dst_vb = NULL;
 471         unsigned int rc = 0;
 472         unsigned long flags;
 473
 474         if (test_bit(V4L2_FL_USES_V4L2_FH, &vfd->flags)) {
 475                 struct v4l2_fh *fh = file->private_data;
 476
 477                 if (v4l2_event_pending(fh))
 478                         rc = POLLPRI;
 479                 else if (req_events & POLLPRI)
 480                         poll_wait(file, &fh->wait, wait);
 481                 if (!(req_events & (POLLOUT | POLLWRNORM | POLLIN | POLLRDNORM)))
 482                         return rc;
 483         }
 484
 485         src_q = v4l2_m2m_get_src_vq(m2m_ctx);
 486         dst_q = v4l2_m2m_get_dst_vq(m2m_ctx);
 487
 488         /*
 489          * There has to be at least one buffer queued on each queued_list, which
 490          * means either in driver already or waiting for driver to claim it
 491          * and start processing.
 492          */
 493         if ((!src_q->streaming || list_empty(&src_q->queued_list))
 494                 && (!dst_q->streaming || list_empty(&dst_q->queued_list))) {
 495                 rc |= POLLERR;
 496                 goto end;
 497         }
 498
 499         spin_lock_irqsave(&src_q->done_lock, flags);
 500         if (list_empty(&src_q->done_list))
 501                 poll_wait(file, &src_q->done_wq, wait);
 502         spin_unlock_irqrestore(&src_q->done_lock, flags);
 503
 504         spin_lock_irqsave(&dst_q->done_lock, flags);
 505         if (list_empty(&dst_q->done_list)) {
 506                 /*
 507                  * If the last buffer was dequeued from the capture queue,
 508                  * return immediately. DQBUF will return -EPIPE.
 509                  */
 510                 if (dst_q->last_buffer_dequeued) {
 511                         spin_unlock_irqrestore(&dst_q->done_lock, flags);
 512                         return rc | POLLIN | POLLRDNORM;
 513                 }
 514
 515                 poll_wait(file, &dst_q->done_wq, wait);
 516         }
 517         spin_unlock_irqrestore(&dst_q->done_lock, flags);
 518
 519         spin_lock_irqsave(&src_q->done_lock, flags);
 520         if (!list_empty(&src_q->done_list))
 521                 src_vb = list_first_entry(&src_q->done_list, struct vb2_buffer,
 522                                                 done_entry);
 523         if (src_vb && (src_vb->state == VB2_BUF_STATE_DONE
 524                         || src_vb->state == VB2_BUF_STATE_ERROR))
 525                 rc |= POLLOUT | POLLWRNORM;
 526         spin_unlock_irqrestore(&src_q->done_lock, flags);
 527
 528         spin_lock_irqsave(&dst_q->done_lock, flags);
 529         if (!list_empty(&dst_q->done_list))
 530                 dst_vb = list_first_entry(&dst_q->done_list, struct vb2_buffer,
 531                                                 done_entry);
 532         if (dst_vb && (dst_vb->state == VB2_BUF_STATE_DONE
 533                         || dst_vb->state == VB2_BUF_STATE_ERROR))
 534                 rc |= POLLIN | POLLRDNORM;
 535         spin_unlock_irqrestore(&dst_q->done_lock, flags);
 536
 537 end:
 538         return rc;
 539 }
 540 EXPORT_SYMBOL_GPL(v4l2_m2m_poll);
 541
 542 int v4l2_m2m_mmap(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
 543                          struct vm_area_struct *vma)
 544 {
 545         unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
 546         struct vb2_queue *vq;
 547
 548         if (offset < DST_QUEUE_OFF_BASE) {
 549                 vq = v4l2_m2m_get_src_vq(m2m_ctx);
 550         } else {
 551                 vq = v4l2_m2m_get_dst_vq(m2m_ctx);
 552                 vma->vm_pgoff -= (DST_QUEUE_OFF_BASE >> PAGE_SHIFT);
 553         }
 554
 555         return vb2_mmap(vq, vma);
 556 }
 557 EXPORT_SYMBOL(v4l2_m2m_mmap);
 558
 559 struct v4l2_m2m_dev *v4l2_m2m_init(const struct v4l2_m2m_ops *m2m_ops)
 560 {
 561         struct v4l2_m2m_dev *m2m_dev;
 562
 563         if (!m2m_ops || WARN_ON(!m2m_ops->device_run) ||
 564                         WARN_ON(!m2m_ops->job_abort))
 565                 return ERR_PTR(-EINVAL);
 566
 567         m2m_dev = kzalloc(sizeof *m2m_dev, GFP_KERNEL);
 568         if (!m2m_dev)
 569                 return ERR_PTR(-ENOMEM);
 570
 571         m2m_dev->curr_ctx = NULL;
 572         m2m_dev->m2m_ops = m2m_ops;
 573         INIT_LIST_HEAD(&m2m_dev->job_queue);
 574         spin_lock_init(&m2m_dev->job_spinlock);
 575
 576         return m2m_dev;
 577 }
 578 EXPORT_SYMBOL_GPL(v4l2_m2m_init);
 579
 580 void v4l2_m2m_release(struct v4l2_m2m_dev *m2m_dev)
 581 {
 582         kfree(m2m_dev);
 583 }
 584 EXPORT_SYMBOL_GPL(v4l2_m2m_release);
 585
 586 struct v4l2_m2m_ctx *v4l2_m2m_ctx_init(struct v4l2_m2m_dev *m2m_dev,
 587                 void *drv_priv,
 588                 int (*queue_init)(void *priv, struct vb2_queue *src_vq, struct vb2_queue *dst_vq))
 589 {
 590         struct v4l2_m2m_ctx *m2m_ctx;
 591         struct v4l2_m2m_queue_ctx *out_q_ctx, *cap_q_ctx;
 592         int ret;
 593
 594         m2m_ctx = kzalloc(sizeof *m2m_ctx, GFP_KERNEL);
 595         if (!m2m_ctx)
 596                 return ERR_PTR(-ENOMEM);
 597
 598         m2m_ctx->priv = drv_priv;
 599         m2m_ctx->m2m_dev = m2m_dev;
 600         init_waitqueue_head(&m2m_ctx->finished);
 601
 602         out_q_ctx = &m2m_ctx->out_q_ctx;
 603         cap_q_ctx = &m2m_ctx->cap_q_ctx;
 604
 605         INIT_LIST_HEAD(&out_q_ctx->rdy_queue);
 606         INIT_LIST_HEAD(&cap_q_ctx->rdy_queue);
 607         spin_lock_init(&out_q_ctx->rdy_spinlock);
 608         spin_lock_init(&cap_q_ctx->rdy_spinlock);
 609
 610         INIT_LIST_HEAD(&m2m_ctx->queue);
 611
 612         ret = queue_init(drv_priv, &out_q_ctx->q, &cap_q_ctx->q);
 613
 614         if (ret)
 615                 goto err;
 616         /*
 617          * If both queues use same mutex assign it as the common buffer
 618          * queues lock to the m2m context. This lock is used in the
 619          * v4l2_m2m_ioctl_* helpers.
 620          */
 621         if (out_q_ctx->q.lock == cap_q_ctx->q.lock)
 622                 m2m_ctx->q_lock = out_q_ctx->q.lock;
 623
 624         return m2m_ctx;
 625 err:
 626         kfree(m2m_ctx);
 627         return ERR_PTR(ret);
 628 }
 629 EXPORT_SYMBOL_GPL(v4l2_m2m_ctx_init);
 630
 631 void v4l2_m2m_ctx_release(struct v4l2_m2m_ctx *m2m_ctx)
 632 {
 633         /* wait until the current context is dequeued from job_queue */
 634         v4l2_m2m_cancel_job(m2m_ctx);
 635
 636         vb2_queue_release(&m2m_ctx->cap_q_ctx.q);
 637         vb2_queue_release(&m2m_ctx->out_q_ctx.q);
 638
 639         kfree(m2m_ctx);
 640 }
 641 EXPORT_SYMBOL_GPL(v4l2_m2m_ctx_release);
 642
 643 void v4l2_m2m_buf_queue(struct v4l2_m2m_ctx *m2m_ctx,
 644                 struct vb2_v4l2_buffer *vbuf)
 645 {
 646         struct v4l2_m2m_buffer *b = container_of(vbuf,
 647                                 struct v4l2_m2m_buffer, vb);
 648         struct v4l2_m2m_queue_ctx *q_ctx;
 649         unsigned long flags;
 650
 651         q_ctx = get_queue_ctx(m2m_ctx, vbuf->vb2_buf.vb2_queue->type);
 652         if (!q_ctx)
 653                 return;
 654
 655         spin_lock_irqsave(&q_ctx->rdy_spinlock, flags);
 656         list_add_tail(&b->list, &q_ctx->rdy_queue);
 657         q_ctx->num_rdy++;
 658         spin_unlock_irqrestore(&q_ctx->rdy_spinlock, flags);
 659 }
 660 EXPORT_SYMBOL_GPL(v4l2_m2m_buf_queue);
 661
 662 /* Videobuf2 ioctl helpers */
 663
 664 int v4l2_m2m_ioctl_reqbufs(struct file *file, void *priv,
 665                                 struct v4l2_requestbuffers *rb)
 666 {
 667         struct v4l2_fh *fh = file->private_data;
 668
 669         return v4l2_m2m_reqbufs(file, fh->m2m_ctx, rb);
 670 }
 671 EXPORT_SYMBOL_GPL(v4l2_m2m_ioctl_reqbufs);
 672
 673 int v4l2_m2m_ioctl_create_bufs(struct file *file, void *priv,
 674                                 struct v4l2_create_buffers *create)
 675 {
 676         struct v4l2_fh *fh = file->private_data;
 677
 678         return v4l2_m2m_create_bufs(file, fh->m2m_ctx, create);
 679 }
 680 EXPORT_SYMBOL_GPL(v4l2_m2m_ioctl_create_bufs);
 681
 682 int v4l2_m2m_ioctl_querybuf(struct file *file, void *priv,
 683                                 struct v4l2_buffer *buf)
 684 {
 685         struct v4l2_fh *fh = file->private_data;
 686
 687         return v4l2_m2m_querybuf(file, fh->m2m_ctx, buf);
 688 }
 689 EXPORT_SYMBOL_GPL(v4l2_m2m_ioctl_querybuf);
 690
 691 int v4l2_m2m_ioctl_qbuf(struct file *file, void *priv,
 692                                 struct v4l2_buffer *buf)
 693 {
 694         struct v4l2_fh *fh = file->private_data;
 695
 696         return v4l2_m2m_qbuf(file, fh->m2m_ctx, buf);
 697 }
 698 EXPORT_SYMBOL_GPL(v4l2_m2m_ioctl_qbuf);
 699
 700 int v4l2_m2m_ioctl_dqbuf(struct file *file, void *priv,
 701                                 struct v4l2_buffer *buf)
 702 {
 703         struct v4l2_fh *fh = file->private_data;
 704
 705         return v4l2_m2m_dqbuf(file, fh->m2m_ctx, buf);
 706 }
 707 EXPORT_SYMBOL_GPL(v4l2_m2m_ioctl_dqbuf);
 708
 709 int v4l2_m2m_ioctl_prepare_buf(struct file *file, void *priv,
 710                                struct v4l2_buffer *buf)
 711 {
 712         struct v4l2_fh *fh = file->private_data;
 713
 714         return v4l2_m2m_prepare_buf(file, fh->m2m_ctx, buf);
 715 }
 716 EXPORT_SYMBOL_GPL(v4l2_m2m_ioctl_prepare_buf);
 717
 718 int v4l2_m2m_ioctl_expbuf(struct file *file, void *priv,
 719                                 struct v4l2_exportbuffer *eb)
 720 {
 721         struct v4l2_fh *fh = file->private_data;
 722
 723         return v4l2_m2m_expbuf(file, fh->m2m_ctx, eb);
 724 }
 725 EXPORT_SYMBOL_GPL(v4l2_m2m_ioctl_expbuf);
 726
 727 int v4l2_m2m_ioctl_streamon(struct file *file, void *priv,
 728                                 enum v4l2_buf_type type)
 729 {
 730         struct v4l2_fh *fh = file->private_data;
 731
 732         return v4l2_m2m_streamon(file, fh->m2m_ctx, type);
 733 }
 734 EXPORT_SYMBOL_GPL(v4l2_m2m_ioctl_streamon);
 735
 736 int v4l2_m2m_ioctl_streamoff(struct file *file, void *priv,
 737                                 enum v4l2_buf_type type)
 738 {
 739         struct v4l2_fh *fh = file->private_data;
 740
 741         return v4l2_m2m_streamoff(file, fh->m2m_ctx, type);
 742 }
 743 EXPORT_SYMBOL_GPL(v4l2_m2m_ioctl_streamoff);
 744
 745 /*
 746  * v4l2_file_operations helpers. It is assumed here same lock is used
 747  * for the output and the capture buffer queue.
 748  */
 749
 750 int v4l2_m2m_fop_mmap(struct file *file, struct vm_area_struct *vma)
 751 {
 752         struct v4l2_fh *fh = file->private_data;
 753
 754         return v4l2_m2m_mmap(file, fh->m2m_ctx, vma);
 755 }
 756 EXPORT_SYMBOL_GPL(v4l2_m2m_fop_mmap);
 757
 758 unsigned int v4l2_m2m_fop_poll(struct file *file, poll_table *wait)
 759 {
 760         struct v4l2_fh *fh = file->private_data;
 761         struct v4l2_m2m_ctx *m2m_ctx = fh->m2m_ctx;
 762         unsigned int ret;
 763
 764         if (m2m_ctx->q_lock)
 765                 mutex_lock(m2m_ctx->q_lock);
 766
 767         ret = v4l2_m2m_poll(file, m2m_ctx, wait);
 768
 769         if (m2m_ctx->q_lock)
 770                 mutex_unlock(m2m_ctx->q_lock);
 771
 772         return ret;
 773 }
 774 EXPORT_SYMBOL_GPL(v4l2_m2m_fop_poll);
 775