include/media/v4l2-mem2mem.h

   1 /*
   2  * Memory-to-memory device framework for Video for Linux 2.
   3  *
   4  * Helper functions for devices that use memory buffers for both source
   5  * and destination.
   6  *
   7  * Copyright (c) 2009 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
  14  * License, or (at your option) any later version
  15  */
  16
  17 #ifndef _MEDIA_V4L2_MEM2MEM_H
  18 #define _MEDIA_V4L2_MEM2MEM_H
  19
  20 #include <media/videobuf2-v4l2.h>
  21
  22 /**
  23  * struct v4l2_m2m_ops - mem-to-mem device driver callbacks
  24  * @device_run: required. Begin the actual job (transaction) inside this
  25  *              callback.
  26  *              The job does NOT have to end before this callback returns
  27  *              (and it will be the usual case). When the job finishes,
  28  *              v4l2_m2m_job_finish() has to be called.
  29  * @job_ready:  optional. Should return 0 if the driver does not have a job
  30  *              fully prepared to run yet (i.e. it will not be able to finish a
  31  *              transaction without sleeping). If not provided, it will be
  32  *              assumed that one source and one destination buffer are all
  33  *              that is required for the driver to perform one full transaction.
  34  *              This method may not sleep.
  35  * @job_abort:  optional. Informs the driver that it has to abort the currently
  36  *              running transaction as soon as possible (i.e. as soon as it can
  37  *              stop the device safely; e.g. in the next interrupt handler),
  38  *              even if the transaction would not have been finished by then.
  39  *              After the driver performs the necessary steps, it has to call
  40  *              v4l2_m2m_job_finish() (as if the transaction ended normally).
  41  *              This function does not have to (and will usually not) wait
  42  *              until the device enters a state when it can be stopped.
  43  */
  44 struct v4l2_m2m_ops {
  45         void (*device_run)(void *priv);
  46         int (*job_ready)(void *priv);
  47         void (*job_abort)(void *priv);
  48 };
  49
  50 struct video_device;
  51 struct v4l2_m2m_dev;
  52
  53 /**
  54  * struct v4l2_m2m_queue_ctx - represents a queue for buffers ready to be
  55  *      processed
  56  *
  57  * @q:          pointer to struct &vb2_queue
  58  * @rdy_queue:  List of V4L2 mem-to-mem queues
  59  * @rdy_spinlock: spin lock to protect the struct usage
  60  * @num_rdy:    number of buffers ready to be processed
  61  * @buffered:   is the queue buffered?
  62  *
  63  * Queue for buffers ready to be processed as soon as this
  64  * instance receives access to the device.
  65  */
  66
  67 struct v4l2_m2m_queue_ctx {
  68         struct vb2_queue        q;
  69
  70         struct list_head        rdy_queue;
  71         spinlock_t              rdy_spinlock;
  72         u8                      num_rdy;
  73         bool                    buffered;
  74 };
  75
  76 /**
  77  * struct v4l2_m2m_ctx - Memory to memory context structure
  78  *
  79  * @q_lock: struct &mutex lock
  80  * @m2m_dev: opaque pointer to the internal data to handle M2M context
  81  * @cap_q_ctx: Capture (output to memory) queue context
  82  * @out_q_ctx: Output (input from memory) queue context
  83  * @queue: List of memory to memory contexts
  84  * @job_flags: Job queue flags, used internally by v4l2-mem2mem.c:
  85  *              %TRANS_QUEUED, %TRANS_RUNNING and %TRANS_ABORT.
  86  * @finished: Wait queue used to signalize when a job queue finished.
  87  * @priv: Instance private data
  88  *
  89  * The memory to memory context is specific to a file handle, NOT to e.g.
  90  * a device.
  91  */
  92 struct v4l2_m2m_ctx {
  93         /* optional cap/out vb2 queues lock */
  94         struct mutex                    *q_lock;
  95
  96         /* internal use only */
  97         struct v4l2_m2m_dev             *m2m_dev;
  98
  99         struct v4l2_m2m_queue_ctx       cap_q_ctx;
 100
 101         struct v4l2_m2m_queue_ctx       out_q_ctx;
 102
 103         /* For device job queue */
 104         struct list_head                queue;
 105         unsigned long                   job_flags;
 106         wait_queue_head_t               finished;
 107
 108         void                            *priv;
 109 };
 110
 111 /**
 112  * struct v4l2_m2m_buffer - Memory to memory buffer
 113  *
 114  * @vb: pointer to struct &vb2_v4l2_buffer
 115  * @list: list of m2m buffers
 116  */
 117 struct v4l2_m2m_buffer {
 118         struct vb2_v4l2_buffer  vb;
 119         struct list_head        list;
 120 };
 121
 122 /**
 123  * v4l2_m2m_get_curr_priv() - return driver private data for the currently
 124  * running instance or NULL if no instance is running
 125  *
 126  * @m2m_dev: opaque pointer to the internal data to handle M2M context
 127  */
 128 void *v4l2_m2m_get_curr_priv(struct v4l2_m2m_dev *m2m_dev);
 129
 130 /**
 131  * v4l2_m2m_get_vq() - return vb2_queue for the given type
 132  *
 133  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 134  * @type: type of the V4L2 buffer, as defined by enum &v4l2_buf_type
 135  */
 136 struct vb2_queue *v4l2_m2m_get_vq(struct v4l2_m2m_ctx *m2m_ctx,
 137                                        enum v4l2_buf_type type);
 138
 139 /**
 140  * v4l2_m2m_try_schedule() - check whether an instance is ready to be added to
 141  * the pending job queue and add it if so.
 142  *
 143  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 144  *
 145  * There are three basic requirements an instance has to meet to be able to run:
 146  * 1) at least one source buffer has to be queued,
 147  * 2) at least one destination buffer has to be queued,
 148  * 3) streaming has to be on.
 149  *
 150  * If a queue is buffered (for example a decoder hardware ringbuffer that has
 151  * to be drained before doing streamoff), allow scheduling without v4l2 buffers
 152  * on that queue.
 153  *
 154  * There may also be additional, custom requirements. In such case the driver
 155  * should supply a custom callback (job_ready in v4l2_m2m_ops) that should
 156  * return 1 if the instance is ready.
 157  * An example of the above could be an instance that requires more than one
 158  * src/dst buffer per transaction.
 159  */
 160 void v4l2_m2m_try_schedule(struct v4l2_m2m_ctx *m2m_ctx);
 161
 162 /**
 163  * v4l2_m2m_job_finish() - inform the framework that a job has been finished
 164  * and have it clean up
 165  *
 166  * @m2m_dev: opaque pointer to the internal data to handle M2M context
 167  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 168  *
 169  * Called by a driver to yield back the device after it has finished with it.
 170  * Should be called as soon as possible after reaching a state which allows
 171  * other instances to take control of the device.
 172  *
 173  * This function has to be called only after &v4l2_m2m_ops->device_run
 174  * callback has been called on the driver. To prevent recursion, it should
 175  * not be called directly from the &v4l2_m2m_ops->device_run callback though.
 176  */
 177 void v4l2_m2m_job_finish(struct v4l2_m2m_dev *m2m_dev,
 178                          struct v4l2_m2m_ctx *m2m_ctx);
 179
 180 static inline void
 181 v4l2_m2m_buf_done(struct vb2_v4l2_buffer *buf, enum vb2_buffer_state state)
 182 {
 183         vb2_buffer_done(&buf->vb2_buf, state);
 184 }
 185
 186 /**
 187  * v4l2_m2m_reqbufs() - multi-queue-aware REQBUFS multiplexer
 188  *
 189  * @file: pointer to struct &file
 190  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 191  * @reqbufs: pointer to struct &v4l2_requestbuffers
 192  */
 193 int v4l2_m2m_reqbufs(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
 194                      struct v4l2_requestbuffers *reqbufs);
 195
 196 /**
 197  * v4l2_m2m_querybuf() - multi-queue-aware QUERYBUF multiplexer
 198  *
 199  * @file: pointer to struct &file
 200  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 201  * @buf: pointer to struct &v4l2_buffer
 202  *
 203  * See v4l2_m2m_mmap() documentation for details.
 204  */
 205 int v4l2_m2m_querybuf(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
 206                       struct v4l2_buffer *buf);
 207
 208 /**
 209  * v4l2_m2m_qbuf() - enqueue a source or destination buffer, depending on
 210  * the type
 211  *
 212  * @file: pointer to struct &file
 213  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 214  * @buf: pointer to struct &v4l2_buffer
 215  */
 216 int v4l2_m2m_qbuf(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
 217                   struct v4l2_buffer *buf);
 218
 219 /**
 220  * v4l2_m2m_dqbuf() - dequeue a source or destination buffer, depending on
 221  * the type
 222  *
 223  * @file: pointer to struct &file
 224  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 225  * @buf: pointer to struct &v4l2_buffer
 226  */
 227 int v4l2_m2m_dqbuf(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
 228                    struct v4l2_buffer *buf);
 229
 230 /**
 231  * v4l2_m2m_prepare_buf() - prepare a source or destination buffer, depending on
 232  * the type
 233  *
 234  * @file: pointer to struct &file
 235  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 236  * @buf: pointer to struct &v4l2_buffer
 237  */
 238 int v4l2_m2m_prepare_buf(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
 239                          struct v4l2_buffer *buf);
 240
 241 /**
 242  * v4l2_m2m_create_bufs() - create a source or destination buffer, depending
 243  * on the type
 244  *
 245  * @file: pointer to struct &file
 246  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 247  * @create: pointer to struct &v4l2_create_buffers
 248  */
 249 int v4l2_m2m_create_bufs(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
 250                          struct v4l2_create_buffers *create);
 251
 252 /**
 253  * v4l2_m2m_expbuf() - export a source or destination buffer, depending on
 254  * the type
 255  *
 256  * @file: pointer to struct &file
 257  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 258  * @eb: pointer to struct &v4l2_exportbuffer
 259  */
 260 int v4l2_m2m_expbuf(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
 261                    struct v4l2_exportbuffer *eb);
 262
 263 /**
 264  * v4l2_m2m_streamon() - turn on streaming for a video queue
 265  *
 266  * @file: pointer to struct &file
 267  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 268  * @type: type of the V4L2 buffer, as defined by enum &v4l2_buf_type
 269  */
 270 int v4l2_m2m_streamon(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
 271                       enum v4l2_buf_type type);
 272
 273 /**
 274  * v4l2_m2m_streamoff() - turn off streaming for a video queue
 275  *
 276  * @file: pointer to struct &file
 277  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 278  * @type: type of the V4L2 buffer, as defined by enum &v4l2_buf_type
 279  */
 280 int v4l2_m2m_streamoff(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
 281                        enum v4l2_buf_type type);
 282
 283 /**
 284  * v4l2_m2m_poll() - poll replacement, for destination buffers only
 285  *
 286  * @file: pointer to struct &file
 287  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 288  * @wait: pointer to struct &poll_table_struct
 289  *
 290  * Call from the driver's poll() function. Will poll both queues. If a buffer
 291  * is available to dequeue (with dqbuf) from the source queue, this will
 292  * indicate that a non-blocking write can be performed, while read will be
 293  * returned in case of the destination queue.
 294  */
 295 __poll_t v4l2_m2m_poll(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
 296                            struct poll_table_struct *wait);
 297
 298 /**
 299  * v4l2_m2m_mmap() - source and destination queues-aware mmap multiplexer
 300  *
 301  * @file: pointer to struct &file
 302  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 303  * @vma: pointer to struct &vm_area_struct
 304  *
 305  * Call from driver's mmap() function. Will handle mmap() for both queues
 306  * seamlessly for videobuffer, which will receive normal per-queue offsets and
 307  * proper videobuf queue pointers. The differentiation is made outside videobuf
 308  * by adding a predefined offset to buffers from one of the queues and
 309  * subtracting it before passing it back to videobuf. Only drivers (and
 310  * thus applications) receive modified offsets.
 311  */
 312 int v4l2_m2m_mmap(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
 313                   struct vm_area_struct *vma);
 314
 315 /**
 316  * v4l2_m2m_init() - initialize per-driver m2m data
 317  *
 318  * @m2m_ops: pointer to struct v4l2_m2m_ops
 319  *
 320  * Usually called from driver's ``probe()`` function.
 321  *
 322  * Return: returns an opaque pointer to the internal data to handle M2M context
 323  */
 324 struct v4l2_m2m_dev *v4l2_m2m_init(const struct v4l2_m2m_ops *m2m_ops);
 325
 326 #if defined(CONFIG_MEDIA_CONTROLLER)
 327 void v4l2_m2m_unregister_media_controller(struct v4l2_m2m_dev *m2m_dev);
 328 int v4l2_m2m_register_media_controller(struct v4l2_m2m_dev *m2m_dev,
 329                         struct video_device *vdev, int function);
 330 #else
 331 static inline void
 332 v4l2_m2m_unregister_media_controller(struct v4l2_m2m_dev *m2m_dev)
 333 {
 334 }
 335
 336 static inline int
 337 v4l2_m2m_register_media_controller(struct v4l2_m2m_dev *m2m_dev,
 338                 struct video_device *vdev, int function)
 339 {
 340         return 0;
 341 }
 342 #endif
 343
 344 /**
 345  * v4l2_m2m_release() - cleans up and frees a m2m_dev structure
 346  *
 347  * @m2m_dev: opaque pointer to the internal data to handle M2M context
 348  *
 349  * Usually called from driver's ``remove()`` function.
 350  */
 351 void v4l2_m2m_release(struct v4l2_m2m_dev *m2m_dev);
 352
 353 /**
 354  * v4l2_m2m_ctx_init() - allocate and initialize a m2m context
 355  *
 356  * @m2m_dev: opaque pointer to the internal data to handle M2M context
 357  * @drv_priv: driver's instance private data
 358  * @queue_init: a callback for queue type-specific initialization function
 359  *      to be used for initializing videobuf_queues
 360  *
 361  * Usually called from driver's ``open()`` function.
 362  */
 363 struct v4l2_m2m_ctx *v4l2_m2m_ctx_init(struct v4l2_m2m_dev *m2m_dev,
 364                 void *drv_priv,
 365                 int (*queue_init)(void *priv, struct vb2_queue *src_vq, struct vb2_queue *dst_vq));
 366
 367 static inline void v4l2_m2m_set_src_buffered(struct v4l2_m2m_ctx *m2m_ctx,
 368                                              bool buffered)
 369 {
 370         m2m_ctx->out_q_ctx.buffered = buffered;
 371 }
 372
 373 static inline void v4l2_m2m_set_dst_buffered(struct v4l2_m2m_ctx *m2m_ctx,
 374                                              bool buffered)
 375 {
 376         m2m_ctx->cap_q_ctx.buffered = buffered;
 377 }
 378
 379 /**
 380  * v4l2_m2m_ctx_release() - release m2m context
 381  *
 382  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 383  *
 384  * Usually called from driver's release() function.
 385  */
 386 void v4l2_m2m_ctx_release(struct v4l2_m2m_ctx *m2m_ctx);
 387
 388 /**
 389  * v4l2_m2m_buf_queue() - add a buffer to the proper ready buffers list.
 390  *
 391  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 392  * @vbuf: pointer to struct &vb2_v4l2_buffer
 393  *
 394  * Call from videobuf_queue_ops->ops->buf_queue, videobuf_queue_ops callback.
 395  */
 396 void v4l2_m2m_buf_queue(struct v4l2_m2m_ctx *m2m_ctx,
 397                         struct vb2_v4l2_buffer *vbuf);
 398
 399 /**
 400  * v4l2_m2m_num_src_bufs_ready() - return the number of source buffers ready for
 401  * use
 402  *
 403  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 404  */
 405 static inline
 406 unsigned int v4l2_m2m_num_src_bufs_ready(struct v4l2_m2m_ctx *m2m_ctx)
 407 {
 408         return m2m_ctx->out_q_ctx.num_rdy;
 409 }
 410
 411 /**
 412  * v4l2_m2m_num_dst_bufs_ready() - return the number of destination buffers
 413  * ready for use
 414  *
 415  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 416  */
 417 static inline
 418 unsigned int v4l2_m2m_num_dst_bufs_ready(struct v4l2_m2m_ctx *m2m_ctx)
 419 {
 420         return m2m_ctx->cap_q_ctx.num_rdy;
 421 }
 422
 423 /**
 424  * v4l2_m2m_next_buf() - return next buffer from the list of ready buffers
 425  *
 426  * @q_ctx: pointer to struct @v4l2_m2m_queue_ctx
 427  */
 428 struct vb2_v4l2_buffer *v4l2_m2m_next_buf(struct v4l2_m2m_queue_ctx *q_ctx);
 429
 430 /**
 431  * v4l2_m2m_next_src_buf() - return next source buffer from the list of ready
 432  * buffers
 433  *
 434  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 435  */
 436 static inline struct vb2_v4l2_buffer *
 437 v4l2_m2m_next_src_buf(struct v4l2_m2m_ctx *m2m_ctx)
 438 {
 439         return v4l2_m2m_next_buf(&m2m_ctx->out_q_ctx);
 440 }
 441
 442 /**
 443  * v4l2_m2m_next_dst_buf() - return next destination buffer from the list of
 444  * ready buffers
 445  *
 446  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 447  */
 448 static inline struct vb2_v4l2_buffer *
 449 v4l2_m2m_next_dst_buf(struct v4l2_m2m_ctx *m2m_ctx)
 450 {
 451         return v4l2_m2m_next_buf(&m2m_ctx->cap_q_ctx);
 452 }
 453
 454 /**
 455  * v4l2_m2m_last_buf() - return last buffer from the list of ready buffers
 456  *
 457  * @q_ctx: pointer to struct @v4l2_m2m_queue_ctx
 458  */
 459 struct vb2_v4l2_buffer *v4l2_m2m_last_buf(struct v4l2_m2m_queue_ctx *q_ctx);
 460
 461 /**
 462  * v4l2_m2m_last_src_buf() - return last destination buffer from the list of
 463  * ready buffers
 464  *
 465  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 466  */
 467 static inline struct vb2_v4l2_buffer *
 468 v4l2_m2m_last_src_buf(struct v4l2_m2m_ctx *m2m_ctx)
 469 {
 470         return v4l2_m2m_last_buf(&m2m_ctx->out_q_ctx);
 471 }
 472
 473 /**
 474  * v4l2_m2m_last_dst_buf() - return last destination buffer from the list of
 475  * ready buffers
 476  *
 477  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 478  */
 479 static inline struct vb2_v4l2_buffer *
 480 v4l2_m2m_last_dst_buf(struct v4l2_m2m_ctx *m2m_ctx)
 481 {
 482         return v4l2_m2m_last_buf(&m2m_ctx->cap_q_ctx);
 483 }
 484
 485 /**
 486  * v4l2_m2m_for_each_dst_buf() - iterate over a list of destination ready
 487  * buffers
 488  *
 489  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 490  * @b: current buffer of type struct v4l2_m2m_buffer
 491  */
 492 #define v4l2_m2m_for_each_dst_buf(m2m_ctx, b)   \
 493         list_for_each_entry(b, &m2m_ctx->cap_q_ctx.rdy_queue, list)
 494
 495 /**
 496  * v4l2_m2m_for_each_src_buf() - iterate over a list of source ready buffers
 497  *
 498  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 499  * @b: current buffer of type struct v4l2_m2m_buffer
 500  */
 501 #define v4l2_m2m_for_each_src_buf(m2m_ctx, b)   \
 502         list_for_each_entry(b, &m2m_ctx->out_q_ctx.rdy_queue, list)
 503
 504 /**
 505  * v4l2_m2m_for_each_dst_buf_safe() - iterate over a list of destination ready
 506  * buffers safely
 507  *
 508  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 509  * @b: current buffer of type struct v4l2_m2m_buffer
 510  * @n: used as temporary storage
 511  */
 512 #define v4l2_m2m_for_each_dst_buf_safe(m2m_ctx, b, n)   \
 513         list_for_each_entry_safe(b, n, &m2m_ctx->cap_q_ctx.rdy_queue, list)
 514
 515 /**
 516  * v4l2_m2m_for_each_src_buf_safe() - iterate over a list of source ready
 517  * buffers safely
 518  *
 519  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 520  * @b: current buffer of type struct v4l2_m2m_buffer
 521  * @n: used as temporary storage
 522  */
 523 #define v4l2_m2m_for_each_src_buf_safe(m2m_ctx, b, n)   \
 524         list_for_each_entry_safe(b, n, &m2m_ctx->out_q_ctx.rdy_queue, list)
 525
 526 /**
 527  * v4l2_m2m_get_src_vq() - return vb2_queue for source buffers
 528  *
 529  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 530  */
 531 static inline
 532 struct vb2_queue *v4l2_m2m_get_src_vq(struct v4l2_m2m_ctx *m2m_ctx)
 533 {
 534         return &m2m_ctx->out_q_ctx.q;
 535 }
 536
 537 /**
 538  * v4l2_m2m_get_dst_vq() - return vb2_queue for destination buffers
 539  *
 540  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 541  */
 542 static inline
 543 struct vb2_queue *v4l2_m2m_get_dst_vq(struct v4l2_m2m_ctx *m2m_ctx)
 544 {
 545         return &m2m_ctx->cap_q_ctx.q;
 546 }
 547
 548 /**
 549  * v4l2_m2m_buf_remove() - take off a buffer from the list of ready buffers and
 550  * return it
 551  *
 552  * @q_ctx: pointer to struct @v4l2_m2m_queue_ctx
 553  */
 554 struct vb2_v4l2_buffer *v4l2_m2m_buf_remove(struct v4l2_m2m_queue_ctx *q_ctx);
 555
 556 /**
 557  * v4l2_m2m_src_buf_remove() - take off a source buffer from the list of ready
 558  * buffers and return it
 559  *
 560  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 561  */
 562 static inline struct vb2_v4l2_buffer *
 563 v4l2_m2m_src_buf_remove(struct v4l2_m2m_ctx *m2m_ctx)
 564 {
 565         return v4l2_m2m_buf_remove(&m2m_ctx->out_q_ctx);
 566 }
 567
 568 /**
 569  * v4l2_m2m_dst_buf_remove() - take off a destination buffer from the list of
 570  * ready buffers and return it
 571  *
 572  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 573  */
 574 static inline struct vb2_v4l2_buffer *
 575 v4l2_m2m_dst_buf_remove(struct v4l2_m2m_ctx *m2m_ctx)
 576 {
 577         return v4l2_m2m_buf_remove(&m2m_ctx->cap_q_ctx);
 578 }
 579
 580 /**
 581  * v4l2_m2m_buf_remove_by_buf() - take off exact buffer from the list of ready
 582  * buffers
 583  *
 584  * @q_ctx: pointer to struct @v4l2_m2m_queue_ctx
 585  * @vbuf: the buffer to be removed
 586  */
 587 void v4l2_m2m_buf_remove_by_buf(struct v4l2_m2m_queue_ctx *q_ctx,
 588                                 struct vb2_v4l2_buffer *vbuf);
 589
 590 /**
 591  * v4l2_m2m_src_buf_remove_by_buf() - take off exact source buffer from the list
 592  * of ready buffers
 593  *
 594  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 595  * @vbuf: the buffer to be removed
 596  */
 597 static inline void v4l2_m2m_src_buf_remove_by_buf(struct v4l2_m2m_ctx *m2m_ctx,
 598                                                   struct vb2_v4l2_buffer *vbuf)
 599 {
 600         v4l2_m2m_buf_remove_by_buf(&m2m_ctx->out_q_ctx, vbuf);
 601 }
 602
 603 /**
 604  * v4l2_m2m_dst_buf_remove_by_buf() - take off exact destination buffer from the
 605  * list of ready buffers
 606  *
 607  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 608  * @vbuf: the buffer to be removed
 609  */
 610 static inline void v4l2_m2m_dst_buf_remove_by_buf(struct v4l2_m2m_ctx *m2m_ctx,
 611                                                   struct vb2_v4l2_buffer *vbuf)
 612 {
 613         v4l2_m2m_buf_remove_by_buf(&m2m_ctx->cap_q_ctx, vbuf);
 614 }
 615
 616 struct vb2_v4l2_buffer *
 617 v4l2_m2m_buf_remove_by_idx(struct v4l2_m2m_queue_ctx *q_ctx, unsigned int idx);
 618
 619 static inline struct vb2_v4l2_buffer *
 620 v4l2_m2m_src_buf_remove_by_idx(struct v4l2_m2m_ctx *m2m_ctx, unsigned int idx)
 621 {
 622         return v4l2_m2m_buf_remove_by_idx(&m2m_ctx->out_q_ctx, idx);
 623 }
 624
 625 static inline struct vb2_v4l2_buffer *
 626 v4l2_m2m_dst_buf_remove_by_idx(struct v4l2_m2m_ctx *m2m_ctx, unsigned int idx)
 627 {
 628         return v4l2_m2m_buf_remove_by_idx(&m2m_ctx->cap_q_ctx, idx);
 629 }
 630
 631 /**
 632  * v4l2_m2m_buf_copy_metadata() - copy buffer metadata from
 633  * the output buffer to the capture buffer
 634  *
 635  * @out_vb: the output buffer that is the source of the metadata.
 636  * @cap_vb: the capture buffer that will receive the metadata.
 637  * @copy_frame_flags: copy the KEY/B/PFRAME flags as well.
 638  *
 639  * This helper function copies the timestamp, timecode (if the TIMECODE
 640  * buffer flag was set), field and the TIMECODE, KEYFRAME, BFRAME, PFRAME
 641  * and TSTAMP_SRC_MASK flags from @out_vb to @cap_vb.
 642  *
 643  * If @copy_frame_flags is false, then the KEYFRAME, BFRAME and PFRAME
 644  * flags are not copied. This is typically needed for encoders that
 645  * set this bits explicitly.
 646  */
 647 void v4l2_m2m_buf_copy_metadata(const struct vb2_v4l2_buffer *out_vb,
 648                                 struct vb2_v4l2_buffer *cap_vb,
 649                                 bool copy_frame_flags);
 650
 651 /* v4l2 request helper */
 652
 653 void v4l2_m2m_request_queue(struct media_request *req);
 654
 655 /* v4l2 ioctl helpers */
 656
 657 int v4l2_m2m_ioctl_reqbufs(struct file *file, void *priv,
 658                                 struct v4l2_requestbuffers *rb);
 659 int v4l2_m2m_ioctl_create_bufs(struct file *file, void *fh,
 660                                 struct v4l2_create_buffers *create);
 661 int v4l2_m2m_ioctl_querybuf(struct file *file, void *fh,
 662                                 struct v4l2_buffer *buf);
 663 int v4l2_m2m_ioctl_expbuf(struct file *file, void *fh,
 664                                 struct v4l2_exportbuffer *eb);
 665 int v4l2_m2m_ioctl_qbuf(struct file *file, void *fh,
 666                                 struct v4l2_buffer *buf);
 667 int v4l2_m2m_ioctl_dqbuf(struct file *file, void *fh,
 668                                 struct v4l2_buffer *buf);
 669 int v4l2_m2m_ioctl_prepare_buf(struct file *file, void *fh,
 670                                struct v4l2_buffer *buf);
 671 int v4l2_m2m_ioctl_streamon(struct file *file, void *fh,
 672                                 enum v4l2_buf_type type);
 673 int v4l2_m2m_ioctl_streamoff(struct file *file, void *fh,
 674                                 enum v4l2_buf_type type);
 675 int v4l2_m2m_fop_mmap(struct file *file, struct vm_area_struct *vma);
 676 __poll_t v4l2_m2m_fop_poll(struct file *file, poll_table *wait);
 677
 678 #endif /* _MEDIA_V4L2_MEM2MEM_H */
 679