include/media/v4l2-mem2mem.h

   1 /* SPDX-License-Identifier: GPL-2.0-or-later */
   2 /*
   3  * Memory-to-memory device framework for Video for Linux 2.
   4  *
   5  * Helper functions for devices that use memory buffers for both source
   6  * and destination.
   7  *
   8  * Copyright (c) 2009 Samsung Electronics Co., Ltd.
   9  * Pawel Osciak, <pawel@osciak.com>
  10  * Marek Szyprowski, <m.szyprowski@samsung.com>
  11  */
  12
  13 #ifndef _MEDIA_V4L2_MEM2MEM_H
  14 #define _MEDIA_V4L2_MEM2MEM_H
  15
  16 #include <media/videobuf2-v4l2.h>
  17
  18 /**
  19  * struct v4l2_m2m_ops - mem-to-mem device driver callbacks
  20  * @device_run: required. Begin the actual job (transaction) inside this
  21  *              callback.
  22  *              The job does NOT have to end before this callback returns
  23  *              (and it will be the usual case). When the job finishes,
  24  *              v4l2_m2m_job_finish() or v4l2_m2m_buf_done_and_job_finish()
  25  *              has to be called.
  26  * @job_ready:  optional. Should return 0 if the driver does not have a job
  27  *              fully prepared to run yet (i.e. it will not be able to finish a
  28  *              transaction without sleeping). If not provided, it will be
  29  *              assumed that one source and one destination buffer are all
  30  *              that is required for the driver to perform one full transaction.
  31  *              This method may not sleep.
  32  * @job_abort:  optional. Informs the driver that it has to abort the currently
  33  *              running transaction as soon as possible (i.e. as soon as it can
  34  *              stop the device safely; e.g. in the next interrupt handler),
  35  *              even if the transaction would not have been finished by then.
  36  *              After the driver performs the necessary steps, it has to call
  37  *              v4l2_m2m_job_finish() or v4l2_m2m_buf_done_and_job_finish() as
  38  *              if the transaction ended normally.
  39  *              This function does not have to (and will usually not) wait
  40  *              until the device enters a state when it can be stopped.
  41  */
  42 struct v4l2_m2m_ops {
  43         void (*device_run)(void *priv);
  44         int (*job_ready)(void *priv);
  45         void (*job_abort)(void *priv);
  46 };
  47
  48 struct video_device;
  49 struct v4l2_m2m_dev;
  50
  51 /**
  52  * struct v4l2_m2m_queue_ctx - represents a queue for buffers ready to be
  53  *      processed
  54  *
  55  * @q:          pointer to struct &vb2_queue
  56  * @rdy_queue:  List of V4L2 mem-to-mem queues
  57  * @rdy_spinlock: spin lock to protect the struct usage
  58  * @num_rdy:    number of buffers ready to be processed
  59  * @buffered:   is the queue buffered?
  60  *
  61  * Queue for buffers ready to be processed as soon as this
  62  * instance receives access to the device.
  63  */
  64
  65 struct v4l2_m2m_queue_ctx {
  66         struct vb2_queue        q;
  67
  68         struct list_head        rdy_queue;
  69         spinlock_t              rdy_spinlock;
  70         u8                      num_rdy;
  71         bool                    buffered;
  72 };
  73
  74 /**
  75  * struct v4l2_m2m_ctx - Memory to memory context structure
  76  *
  77  * @q_lock: struct &mutex lock
  78  * @new_frame: valid in the device_run callback: if true, then this
  79  *              starts a new frame; if false, then this is a new slice
  80  *              for an existing frame. This is always true unless
  81  *              V4L2_BUF_CAP_SUPPORTS_M2M_HOLD_CAPTURE_BUF is set, which
  82  *              indicates slicing support.
  83  * @is_draining: indicates device is in draining phase
  84  * @last_src_buf: indicate the last source buffer for draining
  85  * @next_buf_last: next capture queud buffer will be tagged as last
  86  * @has_stopped: indicate the device has been stopped
  87  * @m2m_dev: opaque pointer to the internal data to handle M2M context
  88  * @cap_q_ctx: Capture (output to memory) queue context
  89  * @out_q_ctx: Output (input from memory) queue context
  90  * @queue: List of memory to memory contexts
  91  * @job_flags: Job queue flags, used internally by v4l2-mem2mem.c:
  92  *              %TRANS_QUEUED, %TRANS_RUNNING and %TRANS_ABORT.
  93  * @finished: Wait queue used to signalize when a job queue finished.
  94  * @priv: Instance private data
  95  *
  96  * The memory to memory context is specific to a file handle, NOT to e.g.
  97  * a device.
  98  */
  99 struct v4l2_m2m_ctx {
 100         /* optional cap/out vb2 queues lock */
 101         struct mutex                    *q_lock;
 102
 103         bool                            new_frame;
 104
 105         bool                            is_draining;
 106         struct vb2_v4l2_buffer          *last_src_buf;
 107         bool                            next_buf_last;
 108         bool                            has_stopped;
 109
 110         /* internal use only */
 111         struct v4l2_m2m_dev             *m2m_dev;
 112
 113         struct v4l2_m2m_queue_ctx       cap_q_ctx;
 114
 115         struct v4l2_m2m_queue_ctx       out_q_ctx;
 116
 117         /* For device job queue */
 118         struct list_head                queue;
 119         unsigned long                   job_flags;
 120         wait_queue_head_t               finished;
 121
 122         void                            *priv;
 123 };
 124
 125 /**
 126  * struct v4l2_m2m_buffer - Memory to memory buffer
 127  *
 128  * @vb: pointer to struct &vb2_v4l2_buffer
 129  * @list: list of m2m buffers
 130  */
 131 struct v4l2_m2m_buffer {
 132         struct vb2_v4l2_buffer  vb;
 133         struct list_head        list;
 134 };
 135
 136 /**
 137  * v4l2_m2m_get_curr_priv() - return driver private data for the currently
 138  * running instance or NULL if no instance is running
 139  *
 140  * @m2m_dev: opaque pointer to the internal data to handle M2M context
 141  */
 142 void *v4l2_m2m_get_curr_priv(struct v4l2_m2m_dev *m2m_dev);
 143
 144 /**
 145  * v4l2_m2m_get_vq() - return vb2_queue for the given type
 146  *
 147  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 148  * @type: type of the V4L2 buffer, as defined by enum &v4l2_buf_type
 149  */
 150 struct vb2_queue *v4l2_m2m_get_vq(struct v4l2_m2m_ctx *m2m_ctx,
 151                                        enum v4l2_buf_type type);
 152
 153 /**
 154  * v4l2_m2m_try_schedule() - check whether an instance is ready to be added to
 155  * the pending job queue and add it if so.
 156  *
 157  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 158  *
 159  * There are three basic requirements an instance has to meet to be able to run:
 160  * 1) at least one source buffer has to be queued,
 161  * 2) at least one destination buffer has to be queued,
 162  * 3) streaming has to be on.
 163  *
 164  * If a queue is buffered (for example a decoder hardware ringbuffer that has
 165  * to be drained before doing streamoff), allow scheduling without v4l2 buffers
 166  * on that queue.
 167  *
 168  * There may also be additional, custom requirements. In such case the driver
 169  * should supply a custom callback (job_ready in v4l2_m2m_ops) that should
 170  * return 1 if the instance is ready.
 171  * An example of the above could be an instance that requires more than one
 172  * src/dst buffer per transaction.
 173  */
 174 void v4l2_m2m_try_schedule(struct v4l2_m2m_ctx *m2m_ctx);
 175
 176 /**
 177  * v4l2_m2m_job_finish() - inform the framework that a job has been finished
 178  * and have it clean up
 179  *
 180  * @m2m_dev: opaque pointer to the internal data to handle M2M context
 181  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 182  *
 183  * Called by a driver to yield back the device after it has finished with it.
 184  * Should be called as soon as possible after reaching a state which allows
 185  * other instances to take control of the device.
 186  *
 187  * This function has to be called only after &v4l2_m2m_ops->device_run
 188  * callback has been called on the driver. To prevent recursion, it should
 189  * not be called directly from the &v4l2_m2m_ops->device_run callback though.
 190  */
 191 void v4l2_m2m_job_finish(struct v4l2_m2m_dev *m2m_dev,
 192                          struct v4l2_m2m_ctx *m2m_ctx);
 193
 194 /**
 195  * v4l2_m2m_buf_done_and_job_finish() - return source/destination buffers with
 196  * state and inform the framework that a job has been finished and have it
 197  * clean up
 198  *
 199  * @m2m_dev: opaque pointer to the internal data to handle M2M context
 200  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 201  * @state: vb2 buffer state passed to v4l2_m2m_buf_done().
 202  *
 203  * Drivers that set V4L2_BUF_CAP_SUPPORTS_M2M_HOLD_CAPTURE_BUF must use this
 204  * function instead of job_finish() to take held buffers into account. It is
 205  * optional for other drivers.
 206  *
 207  * This function removes the source buffer from the ready list and returns
 208  * it with the given state. The same is done for the destination buffer, unless
 209  * it is marked 'held'. In that case the buffer is kept on the ready list.
 210  *
 211  * After that the job is finished (see job_finish()).
 212  *
 213  * This allows for multiple output buffers to be used to fill in a single
 214  * capture buffer. This is typically used by stateless decoders where
 215  * multiple e.g. H.264 slices contribute to a single decoded frame.
 216  */
 217 void v4l2_m2m_buf_done_and_job_finish(struct v4l2_m2m_dev *m2m_dev,
 218                                       struct v4l2_m2m_ctx *m2m_ctx,
 219                                       enum vb2_buffer_state state);
 220
 221 static inline void
 222 v4l2_m2m_buf_done(struct vb2_v4l2_buffer *buf, enum vb2_buffer_state state)
 223 {
 224         vb2_buffer_done(&buf->vb2_buf, state);
 225 }
 226
 227 /**
 228  * v4l2_m2m_clear_state() - clear encoding/decoding state
 229  *
 230  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 231  */
 232 static inline void
 233 v4l2_m2m_clear_state(struct v4l2_m2m_ctx *m2m_ctx)
 234 {
 235         m2m_ctx->next_buf_last = false;
 236         m2m_ctx->is_draining = false;
 237         m2m_ctx->has_stopped = false;
 238 }
 239
 240 /**
 241  * v4l2_m2m_mark_stopped() - set current encoding/decoding state as stopped
 242  *
 243  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 244  */
 245 static inline void
 246 v4l2_m2m_mark_stopped(struct v4l2_m2m_ctx *m2m_ctx)
 247 {
 248         m2m_ctx->next_buf_last = false;
 249         m2m_ctx->is_draining = false;
 250         m2m_ctx->has_stopped = true;
 251 }
 252
 253 /**
 254  * v4l2_m2m_dst_buf_is_last() - return the current encoding/decoding session
 255  * draining management state of next queued capture buffer
 256  *
 257  * This last capture buffer should be tagged with V4L2_BUF_FLAG_LAST to notify
 258  * the end of the capture session.
 259  *
 260  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 261  */
 262 static inline bool
 263 v4l2_m2m_dst_buf_is_last(struct v4l2_m2m_ctx *m2m_ctx)
 264 {
 265         return m2m_ctx->is_draining && m2m_ctx->next_buf_last;
 266 }
 267
 268 /**
 269  * v4l2_m2m_has_stopped() - return the current encoding/decoding session
 270  * stopped state
 271  *
 272  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 273  */
 274 static inline bool
 275 v4l2_m2m_has_stopped(struct v4l2_m2m_ctx *m2m_ctx)
 276 {
 277         return m2m_ctx->has_stopped;
 278 }
 279
 280 /**
 281  * v4l2_m2m_is_last_draining_src_buf() - return the output buffer draining
 282  * state in the current encoding/decoding session
 283  *
 284  * This will identify the last output buffer queued before a session stop
 285  * was required, leading to an actual encoding/decoding session stop state
 286  * in the encoding/decoding process after being processed.
 287  *
 288  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 289  * @vbuf: pointer to struct &v4l2_buffer
 290  */
 291 static inline bool
 292 v4l2_m2m_is_last_draining_src_buf(struct v4l2_m2m_ctx *m2m_ctx,
 293                                   struct vb2_v4l2_buffer *vbuf)
 294 {
 295         return m2m_ctx->is_draining && vbuf == m2m_ctx->last_src_buf;
 296 }
 297
 298 /**
 299  * v4l2_m2m_last_buffer_done() - marks the buffer with LAST flag and DONE
 300  *
 301  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 302  * @vbuf: pointer to struct &v4l2_buffer
 303  */
 304 void v4l2_m2m_last_buffer_done(struct v4l2_m2m_ctx *m2m_ctx,
 305                                struct vb2_v4l2_buffer *vbuf);
 306
 307 /**
 308  * v4l2_m2m_suspend() - stop new jobs from being run and wait for current job
 309  * to finish
 310  *
 311  * @m2m_dev: opaque pointer to the internal data to handle M2M context
 312  *
 313  * Called by a driver in the suspend hook. Stop new jobs from being run, and
 314  * wait for current running job to finish.
 315  */
 316 void v4l2_m2m_suspend(struct v4l2_m2m_dev *m2m_dev);
 317
 318 /**
 319  * v4l2_m2m_resume() - resume job running and try to run a queued job
 320  *
 321  * @m2m_dev: opaque pointer to the internal data to handle M2M context
 322  *
 323  * Called by a driver in the resume hook. This reverts the operation of
 324  * v4l2_m2m_suspend() and allows job to be run. Also try to run a queued job if
 325  * there is any.
 326  */
 327 void v4l2_m2m_resume(struct v4l2_m2m_dev *m2m_dev);
 328
 329 /**
 330  * v4l2_m2m_reqbufs() - multi-queue-aware REQBUFS multiplexer
 331  *
 332  * @file: pointer to struct &file
 333  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 334  * @reqbufs: pointer to struct &v4l2_requestbuffers
 335  */
 336 int v4l2_m2m_reqbufs(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
 337                      struct v4l2_requestbuffers *reqbufs);
 338
 339 /**
 340  * v4l2_m2m_querybuf() - multi-queue-aware QUERYBUF multiplexer
 341  *
 342  * @file: pointer to struct &file
 343  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 344  * @buf: pointer to struct &v4l2_buffer
 345  *
 346  * See v4l2_m2m_mmap() documentation for details.
 347  */
 348 int v4l2_m2m_querybuf(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
 349                       struct v4l2_buffer *buf);
 350
 351 /**
 352  * v4l2_m2m_qbuf() - enqueue a source or destination buffer, depending on
 353  * the type
 354  *
 355  * @file: pointer to struct &file
 356  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 357  * @buf: pointer to struct &v4l2_buffer
 358  */
 359 int v4l2_m2m_qbuf(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
 360                   struct v4l2_buffer *buf);
 361
 362 /**
 363  * v4l2_m2m_dqbuf() - dequeue a source or destination buffer, depending on
 364  * the type
 365  *
 366  * @file: pointer to struct &file
 367  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 368  * @buf: pointer to struct &v4l2_buffer
 369  */
 370 int v4l2_m2m_dqbuf(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
 371                    struct v4l2_buffer *buf);
 372
 373 /**
 374  * v4l2_m2m_prepare_buf() - prepare a source or destination buffer, depending on
 375  * the type
 376  *
 377  * @file: pointer to struct &file
 378  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 379  * @buf: pointer to struct &v4l2_buffer
 380  */
 381 int v4l2_m2m_prepare_buf(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
 382                          struct v4l2_buffer *buf);
 383
 384 /**
 385  * v4l2_m2m_create_bufs() - create a source or destination buffer, depending
 386  * on the type
 387  *
 388  * @file: pointer to struct &file
 389  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 390  * @create: pointer to struct &v4l2_create_buffers
 391  */
 392 int v4l2_m2m_create_bufs(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
 393                          struct v4l2_create_buffers *create);
 394
 395 /**
 396  * v4l2_m2m_expbuf() - export a source or destination buffer, depending on
 397  * the type
 398  *
 399  * @file: pointer to struct &file
 400  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 401  * @eb: pointer to struct &v4l2_exportbuffer
 402  */
 403 int v4l2_m2m_expbuf(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
 404                    struct v4l2_exportbuffer *eb);
 405
 406 /**
 407  * v4l2_m2m_streamon() - turn on streaming for a video queue
 408  *
 409  * @file: pointer to struct &file
 410  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 411  * @type: type of the V4L2 buffer, as defined by enum &v4l2_buf_type
 412  */
 413 int v4l2_m2m_streamon(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
 414                       enum v4l2_buf_type type);
 415
 416 /**
 417  * v4l2_m2m_streamoff() - turn off streaming for a video queue
 418  *
 419  * @file: pointer to struct &file
 420  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 421  * @type: type of the V4L2 buffer, as defined by enum &v4l2_buf_type
 422  */
 423 int v4l2_m2m_streamoff(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
 424                        enum v4l2_buf_type type);
 425
 426 /**
 427  * v4l2_m2m_update_start_streaming_state() - update the encoding/decoding
 428  * session state when a start of streaming of a video queue is requested
 429  *
 430  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 431  * @q: queue
 432  */
 433 void v4l2_m2m_update_start_streaming_state(struct v4l2_m2m_ctx *m2m_ctx,
 434                                            struct vb2_queue *q);
 435
 436 /**
 437  * v4l2_m2m_update_stop_streaming_state() -  update the encoding/decoding
 438  * session state when a stop of streaming of a video queue is requested
 439  *
 440  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 441  * @q: queue
 442  */
 443 void v4l2_m2m_update_stop_streaming_state(struct v4l2_m2m_ctx *m2m_ctx,
 444                                           struct vb2_queue *q);
 445
 446 /**
 447  * v4l2_m2m_encoder_cmd() - execute an encoder command
 448  *
 449  * @file: pointer to struct &file
 450  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 451  * @ec: pointer to the encoder command
 452  */
 453 int v4l2_m2m_encoder_cmd(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
 454                          struct v4l2_encoder_cmd *ec);
 455
 456 /**
 457  * v4l2_m2m_decoder_cmd() - execute a decoder command
 458  *
 459  * @file: pointer to struct &file
 460  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 461  * @dc: pointer to the decoder command
 462  */
 463 int v4l2_m2m_decoder_cmd(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
 464                          struct v4l2_decoder_cmd *dc);
 465
 466 /**
 467  * v4l2_m2m_poll() - poll replacement, for destination buffers only
 468  *
 469  * @file: pointer to struct &file
 470  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 471  * @wait: pointer to struct &poll_table_struct
 472  *
 473  * Call from the driver's poll() function. Will poll both queues. If a buffer
 474  * is available to dequeue (with dqbuf) from the source queue, this will
 475  * indicate that a non-blocking write can be performed, while read will be
 476  * returned in case of the destination queue.
 477  */
 478 __poll_t v4l2_m2m_poll(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
 479                            struct poll_table_struct *wait);
 480
 481 /**
 482  * v4l2_m2m_mmap() - source and destination queues-aware mmap multiplexer
 483  *
 484  * @file: pointer to struct &file
 485  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 486  * @vma: pointer to struct &vm_area_struct
 487  *
 488  * Call from driver's mmap() function. Will handle mmap() for both queues
 489  * seamlessly for videobuffer, which will receive normal per-queue offsets and
 490  * proper videobuf queue pointers. The differentiation is made outside videobuf
 491  * by adding a predefined offset to buffers from one of the queues and
 492  * subtracting it before passing it back to videobuf. Only drivers (and
 493  * thus applications) receive modified offsets.
 494  */
 495 int v4l2_m2m_mmap(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
 496                   struct vm_area_struct *vma);
 497
 498 /**
 499  * v4l2_m2m_init() - initialize per-driver m2m data
 500  *
 501  * @m2m_ops: pointer to struct v4l2_m2m_ops
 502  *
 503  * Usually called from driver's ``probe()`` function.
 504  *
 505  * Return: returns an opaque pointer to the internal data to handle M2M context
 506  */
 507 struct v4l2_m2m_dev *v4l2_m2m_init(const struct v4l2_m2m_ops *m2m_ops);
 508
 509 #if defined(CONFIG_MEDIA_CONTROLLER)
 510 void v4l2_m2m_unregister_media_controller(struct v4l2_m2m_dev *m2m_dev);
 511 int v4l2_m2m_register_media_controller(struct v4l2_m2m_dev *m2m_dev,
 512                         struct video_device *vdev, int function);
 513 #else
 514 static inline void
 515 v4l2_m2m_unregister_media_controller(struct v4l2_m2m_dev *m2m_dev)
 516 {
 517 }
 518
 519 static inline int
 520 v4l2_m2m_register_media_controller(struct v4l2_m2m_dev *m2m_dev,
 521                 struct video_device *vdev, int function)
 522 {
 523         return 0;
 524 }
 525 #endif
 526
 527 /**
 528  * v4l2_m2m_release() - cleans up and frees a m2m_dev structure
 529  *
 530  * @m2m_dev: opaque pointer to the internal data to handle M2M context
 531  *
 532  * Usually called from driver's ``remove()`` function.
 533  */
 534 void v4l2_m2m_release(struct v4l2_m2m_dev *m2m_dev);
 535
 536 /**
 537  * v4l2_m2m_ctx_init() - allocate and initialize a m2m context
 538  *
 539  * @m2m_dev: opaque pointer to the internal data to handle M2M context
 540  * @drv_priv: driver's instance private data
 541  * @queue_init: a callback for queue type-specific initialization function
 542  *      to be used for initializing videobuf_queues
 543  *
 544  * Usually called from driver's ``open()`` function.
 545  */
 546 struct v4l2_m2m_ctx *v4l2_m2m_ctx_init(struct v4l2_m2m_dev *m2m_dev,
 547                 void *drv_priv,
 548                 int (*queue_init)(void *priv, struct vb2_queue *src_vq, struct vb2_queue *dst_vq));
 549
 550 static inline void v4l2_m2m_set_src_buffered(struct v4l2_m2m_ctx *m2m_ctx,
 551                                              bool buffered)
 552 {
 553         m2m_ctx->out_q_ctx.buffered = buffered;
 554 }
 555
 556 static inline void v4l2_m2m_set_dst_buffered(struct v4l2_m2m_ctx *m2m_ctx,
 557                                              bool buffered)
 558 {
 559         m2m_ctx->cap_q_ctx.buffered = buffered;
 560 }
 561
 562 /**
 563  * v4l2_m2m_ctx_release() - release m2m context
 564  *
 565  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 566  *
 567  * Usually called from driver's release() function.
 568  */
 569 void v4l2_m2m_ctx_release(struct v4l2_m2m_ctx *m2m_ctx);
 570
 571 /**
 572  * v4l2_m2m_buf_queue() - add a buffer to the proper ready buffers list.
 573  *
 574  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 575  * @vbuf: pointer to struct &vb2_v4l2_buffer
 576  *
 577  * Call from videobuf_queue_ops->ops->buf_queue, videobuf_queue_ops callback.
 578  */
 579 void v4l2_m2m_buf_queue(struct v4l2_m2m_ctx *m2m_ctx,
 580                         struct vb2_v4l2_buffer *vbuf);
 581
 582 /**
 583  * v4l2_m2m_num_src_bufs_ready() - return the number of source buffers ready for
 584  * use
 585  *
 586  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 587  */
 588 static inline
 589 unsigned int v4l2_m2m_num_src_bufs_ready(struct v4l2_m2m_ctx *m2m_ctx)
 590 {
 591         return m2m_ctx->out_q_ctx.num_rdy;
 592 }
 593
 594 /**
 595  * v4l2_m2m_num_dst_bufs_ready() - return the number of destination buffers
 596  * ready for use
 597  *
 598  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 599  */
 600 static inline
 601 unsigned int v4l2_m2m_num_dst_bufs_ready(struct v4l2_m2m_ctx *m2m_ctx)
 602 {
 603         return m2m_ctx->cap_q_ctx.num_rdy;
 604 }
 605
 606 /**
 607  * v4l2_m2m_next_buf() - return next buffer from the list of ready buffers
 608  *
 609  * @q_ctx: pointer to struct @v4l2_m2m_queue_ctx
 610  */
 611 struct vb2_v4l2_buffer *v4l2_m2m_next_buf(struct v4l2_m2m_queue_ctx *q_ctx);
 612
 613 /**
 614  * v4l2_m2m_next_src_buf() - return next source buffer from the list of ready
 615  * buffers
 616  *
 617  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 618  */
 619 static inline struct vb2_v4l2_buffer *
 620 v4l2_m2m_next_src_buf(struct v4l2_m2m_ctx *m2m_ctx)
 621 {
 622         return v4l2_m2m_next_buf(&m2m_ctx->out_q_ctx);
 623 }
 624
 625 /**
 626  * v4l2_m2m_next_dst_buf() - return next destination buffer from the list of
 627  * ready buffers
 628  *
 629  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 630  */
 631 static inline struct vb2_v4l2_buffer *
 632 v4l2_m2m_next_dst_buf(struct v4l2_m2m_ctx *m2m_ctx)
 633 {
 634         return v4l2_m2m_next_buf(&m2m_ctx->cap_q_ctx);
 635 }
 636
 637 /**
 638  * v4l2_m2m_last_buf() - return last buffer from the list of ready buffers
 639  *
 640  * @q_ctx: pointer to struct @v4l2_m2m_queue_ctx
 641  */
 642 struct vb2_v4l2_buffer *v4l2_m2m_last_buf(struct v4l2_m2m_queue_ctx *q_ctx);
 643
 644 /**
 645  * v4l2_m2m_last_src_buf() - return last destination buffer from the list of
 646  * ready buffers
 647  *
 648  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 649  */
 650 static inline struct vb2_v4l2_buffer *
 651 v4l2_m2m_last_src_buf(struct v4l2_m2m_ctx *m2m_ctx)
 652 {
 653         return v4l2_m2m_last_buf(&m2m_ctx->out_q_ctx);
 654 }
 655
 656 /**
 657  * v4l2_m2m_last_dst_buf() - return last destination buffer from the list of
 658  * ready buffers
 659  *
 660  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 661  */
 662 static inline struct vb2_v4l2_buffer *
 663 v4l2_m2m_last_dst_buf(struct v4l2_m2m_ctx *m2m_ctx)
 664 {
 665         return v4l2_m2m_last_buf(&m2m_ctx->cap_q_ctx);
 666 }
 667
 668 /**
 669  * v4l2_m2m_for_each_dst_buf() - iterate over a list of destination ready
 670  * buffers
 671  *
 672  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 673  * @b: current buffer of type struct v4l2_m2m_buffer
 674  */
 675 #define v4l2_m2m_for_each_dst_buf(m2m_ctx, b)   \
 676         list_for_each_entry(b, &m2m_ctx->cap_q_ctx.rdy_queue, list)
 677
 678 /**
 679  * v4l2_m2m_for_each_src_buf() - iterate over a list of source ready buffers
 680  *
 681  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 682  * @b: current buffer of type struct v4l2_m2m_buffer
 683  */
 684 #define v4l2_m2m_for_each_src_buf(m2m_ctx, b)   \
 685         list_for_each_entry(b, &m2m_ctx->out_q_ctx.rdy_queue, list)
 686
 687 /**
 688  * v4l2_m2m_for_each_dst_buf_safe() - iterate over a list of destination ready
 689  * buffers safely
 690  *
 691  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 692  * @b: current buffer of type struct v4l2_m2m_buffer
 693  * @n: used as temporary storage
 694  */
 695 #define v4l2_m2m_for_each_dst_buf_safe(m2m_ctx, b, n)   \
 696         list_for_each_entry_safe(b, n, &m2m_ctx->cap_q_ctx.rdy_queue, list)
 697
 698 /**
 699  * v4l2_m2m_for_each_src_buf_safe() - iterate over a list of source ready
 700  * buffers safely
 701  *
 702  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 703  * @b: current buffer of type struct v4l2_m2m_buffer
 704  * @n: used as temporary storage
 705  */
 706 #define v4l2_m2m_for_each_src_buf_safe(m2m_ctx, b, n)   \
 707         list_for_each_entry_safe(b, n, &m2m_ctx->out_q_ctx.rdy_queue, list)
 708
 709 /**
 710  * v4l2_m2m_get_src_vq() - return vb2_queue for source buffers
 711  *
 712  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 713  */
 714 static inline
 715 struct vb2_queue *v4l2_m2m_get_src_vq(struct v4l2_m2m_ctx *m2m_ctx)
 716 {
 717         return &m2m_ctx->out_q_ctx.q;
 718 }
 719
 720 /**
 721  * v4l2_m2m_get_dst_vq() - return vb2_queue for destination buffers
 722  *
 723  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 724  */
 725 static inline
 726 struct vb2_queue *v4l2_m2m_get_dst_vq(struct v4l2_m2m_ctx *m2m_ctx)
 727 {
 728         return &m2m_ctx->cap_q_ctx.q;
 729 }
 730
 731 /**
 732  * v4l2_m2m_buf_remove() - take off a buffer from the list of ready buffers and
 733  * return it
 734  *
 735  * @q_ctx: pointer to struct @v4l2_m2m_queue_ctx
 736  */
 737 struct vb2_v4l2_buffer *v4l2_m2m_buf_remove(struct v4l2_m2m_queue_ctx *q_ctx);
 738
 739 /**
 740  * v4l2_m2m_src_buf_remove() - take off a source buffer from the list of ready
 741  * buffers and return it
 742  *
 743  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 744  */
 745 static inline struct vb2_v4l2_buffer *
 746 v4l2_m2m_src_buf_remove(struct v4l2_m2m_ctx *m2m_ctx)
 747 {
 748         return v4l2_m2m_buf_remove(&m2m_ctx->out_q_ctx);
 749 }
 750
 751 /**
 752  * v4l2_m2m_dst_buf_remove() - take off a destination buffer from the list of
 753  * ready buffers and return it
 754  *
 755  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 756  */
 757 static inline struct vb2_v4l2_buffer *
 758 v4l2_m2m_dst_buf_remove(struct v4l2_m2m_ctx *m2m_ctx)
 759 {
 760         return v4l2_m2m_buf_remove(&m2m_ctx->cap_q_ctx);
 761 }
 762
 763 /**
 764  * v4l2_m2m_buf_remove_by_buf() - take off exact buffer from the list of ready
 765  * buffers
 766  *
 767  * @q_ctx: pointer to struct @v4l2_m2m_queue_ctx
 768  * @vbuf: the buffer to be removed
 769  */
 770 void v4l2_m2m_buf_remove_by_buf(struct v4l2_m2m_queue_ctx *q_ctx,
 771                                 struct vb2_v4l2_buffer *vbuf);
 772
 773 /**
 774  * v4l2_m2m_src_buf_remove_by_buf() - take off exact source buffer from the list
 775  * of ready buffers
 776  *
 777  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 778  * @vbuf: the buffer to be removed
 779  */
 780 static inline void v4l2_m2m_src_buf_remove_by_buf(struct v4l2_m2m_ctx *m2m_ctx,
 781                                                   struct vb2_v4l2_buffer *vbuf)
 782 {
 783         v4l2_m2m_buf_remove_by_buf(&m2m_ctx->out_q_ctx, vbuf);
 784 }
 785
 786 /**
 787  * v4l2_m2m_dst_buf_remove_by_buf() - take off exact destination buffer from the
 788  * list of ready buffers
 789  *
 790  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 791  * @vbuf: the buffer to be removed
 792  */
 793 static inline void v4l2_m2m_dst_buf_remove_by_buf(struct v4l2_m2m_ctx *m2m_ctx,
 794                                                   struct vb2_v4l2_buffer *vbuf)
 795 {
 796         v4l2_m2m_buf_remove_by_buf(&m2m_ctx->cap_q_ctx, vbuf);
 797 }
 798
 799 struct vb2_v4l2_buffer *
 800 v4l2_m2m_buf_remove_by_idx(struct v4l2_m2m_queue_ctx *q_ctx, unsigned int idx);
 801
 802 static inline struct vb2_v4l2_buffer *
 803 v4l2_m2m_src_buf_remove_by_idx(struct v4l2_m2m_ctx *m2m_ctx, unsigned int idx)
 804 {
 805         return v4l2_m2m_buf_remove_by_idx(&m2m_ctx->out_q_ctx, idx);
 806 }
 807
 808 static inline struct vb2_v4l2_buffer *
 809 v4l2_m2m_dst_buf_remove_by_idx(struct v4l2_m2m_ctx *m2m_ctx, unsigned int idx)
 810 {
 811         return v4l2_m2m_buf_remove_by_idx(&m2m_ctx->cap_q_ctx, idx);
 812 }
 813
 814 /**
 815  * v4l2_m2m_buf_copy_metadata() - copy buffer metadata from
 816  * the output buffer to the capture buffer
 817  *
 818  * @out_vb: the output buffer that is the source of the metadata.
 819  * @cap_vb: the capture buffer that will receive the metadata.
 820  * @copy_frame_flags: copy the KEY/B/PFRAME flags as well.
 821  *
 822  * This helper function copies the timestamp, timecode (if the TIMECODE
 823  * buffer flag was set), field and the TIMECODE, KEYFRAME, BFRAME, PFRAME
 824  * and TSTAMP_SRC_MASK flags from @out_vb to @cap_vb.
 825  *
 826  * If @copy_frame_flags is false, then the KEYFRAME, BFRAME and PFRAME
 827  * flags are not copied. This is typically needed for encoders that
 828  * set this bits explicitly.
 829  */
 830 void v4l2_m2m_buf_copy_metadata(const struct vb2_v4l2_buffer *out_vb,
 831                                 struct vb2_v4l2_buffer *cap_vb,
 832                                 bool copy_frame_flags);
 833
 834 /* v4l2 request helper */
 835
 836 void v4l2_m2m_request_queue(struct media_request *req);
 837
 838 /* v4l2 ioctl helpers */
 839
 840 int v4l2_m2m_ioctl_reqbufs(struct file *file, void *priv,
 841                                 struct v4l2_requestbuffers *rb);
 842 int v4l2_m2m_ioctl_create_bufs(struct file *file, void *fh,
 843                                 struct v4l2_create_buffers *create);
 844 int v4l2_m2m_ioctl_querybuf(struct file *file, void *fh,
 845                                 struct v4l2_buffer *buf);
 846 int v4l2_m2m_ioctl_expbuf(struct file *file, void *fh,
 847                                 struct v4l2_exportbuffer *eb);
 848 int v4l2_m2m_ioctl_qbuf(struct file *file, void *fh,
 849                                 struct v4l2_buffer *buf);
 850 int v4l2_m2m_ioctl_dqbuf(struct file *file, void *fh,
 851                                 struct v4l2_buffer *buf);
 852 int v4l2_m2m_ioctl_prepare_buf(struct file *file, void *fh,
 853                                struct v4l2_buffer *buf);
 854 int v4l2_m2m_ioctl_streamon(struct file *file, void *fh,
 855                                 enum v4l2_buf_type type);
 856 int v4l2_m2m_ioctl_streamoff(struct file *file, void *fh,
 857                                 enum v4l2_buf_type type);
 858 int v4l2_m2m_ioctl_encoder_cmd(struct file *file, void *fh,
 859                                struct v4l2_encoder_cmd *ec);
 860 int v4l2_m2m_ioctl_decoder_cmd(struct file *file, void *fh,
 861                                struct v4l2_decoder_cmd *dc);
 862 int v4l2_m2m_ioctl_try_encoder_cmd(struct file *file, void *fh,
 863                                    struct v4l2_encoder_cmd *ec);
 864 int v4l2_m2m_ioctl_try_decoder_cmd(struct file *file, void *fh,
 865                                    struct v4l2_decoder_cmd *dc);
 866 int v4l2_m2m_ioctl_stateless_try_decoder_cmd(struct file *file, void *fh,
 867                                              struct v4l2_decoder_cmd *dc);
 868 int v4l2_m2m_ioctl_stateless_decoder_cmd(struct file *file, void *priv,
 869                                          struct v4l2_decoder_cmd *dc);
 870 int v4l2_m2m_fop_mmap(struct file *file, struct vm_area_struct *vma);
 871 __poll_t v4l2_m2m_fop_poll(struct file *file, poll_table *wait);
 872
 873 #endif /* _MEDIA_V4L2_MEM2MEM_H */
 874