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_reqbufs() - multi-queue-aware REQBUFS multiplexer
 309  *
 310  * @file: pointer to struct &file
 311  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 312  * @reqbufs: pointer to struct &v4l2_requestbuffers
 313  */
 314 int v4l2_m2m_reqbufs(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
 315                      struct v4l2_requestbuffers *reqbufs);
 316
 317 /**
 318  * v4l2_m2m_querybuf() - multi-queue-aware QUERYBUF multiplexer
 319  *
 320  * @file: pointer to struct &file
 321  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 322  * @buf: pointer to struct &v4l2_buffer
 323  *
 324  * See v4l2_m2m_mmap() documentation for details.
 325  */
 326 int v4l2_m2m_querybuf(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
 327                       struct v4l2_buffer *buf);
 328
 329 /**
 330  * v4l2_m2m_qbuf() - enqueue a source or destination buffer, depending on
 331  * the type
 332  *
 333  * @file: pointer to struct &file
 334  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 335  * @buf: pointer to struct &v4l2_buffer
 336  */
 337 int v4l2_m2m_qbuf(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
 338                   struct v4l2_buffer *buf);
 339
 340 /**
 341  * v4l2_m2m_dqbuf() - dequeue a source or destination buffer, depending on
 342  * the type
 343  *
 344  * @file: pointer to struct &file
 345  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 346  * @buf: pointer to struct &v4l2_buffer
 347  */
 348 int v4l2_m2m_dqbuf(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
 349                    struct v4l2_buffer *buf);
 350
 351 /**
 352  * v4l2_m2m_prepare_buf() - prepare 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_prepare_buf(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
 360                          struct v4l2_buffer *buf);
 361
 362 /**
 363  * v4l2_m2m_create_bufs() - create a source or destination buffer, depending
 364  * on 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  * @create: pointer to struct &v4l2_create_buffers
 369  */
 370 int v4l2_m2m_create_bufs(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
 371                          struct v4l2_create_buffers *create);
 372
 373 /**
 374  * v4l2_m2m_expbuf() - export 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  * @eb: pointer to struct &v4l2_exportbuffer
 380  */
 381 int v4l2_m2m_expbuf(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
 382                    struct v4l2_exportbuffer *eb);
 383
 384 /**
 385  * v4l2_m2m_streamon() - turn on streaming for a video queue
 386  *
 387  * @file: pointer to struct &file
 388  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 389  * @type: type of the V4L2 buffer, as defined by enum &v4l2_buf_type
 390  */
 391 int v4l2_m2m_streamon(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
 392                       enum v4l2_buf_type type);
 393
 394 /**
 395  * v4l2_m2m_streamoff() - turn off streaming for a video queue
 396  *
 397  * @file: pointer to struct &file
 398  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 399  * @type: type of the V4L2 buffer, as defined by enum &v4l2_buf_type
 400  */
 401 int v4l2_m2m_streamoff(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
 402                        enum v4l2_buf_type type);
 403
 404 /**
 405  * v4l2_m2m_update_start_streaming_state() - update the encoding/decoding
 406  * session state when a start of streaming of a video queue is requested
 407  *
 408  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 409  * @q: queue
 410  */
 411 void v4l2_m2m_update_start_streaming_state(struct v4l2_m2m_ctx *m2m_ctx,
 412                                            struct vb2_queue *q);
 413
 414 /**
 415  * v4l2_m2m_update_stop_streaming_state() -  update the encoding/decoding
 416  * session state when a stop of streaming of a video queue is requested
 417  *
 418  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 419  * @q: queue
 420  */
 421 void v4l2_m2m_update_stop_streaming_state(struct v4l2_m2m_ctx *m2m_ctx,
 422                                           struct vb2_queue *q);
 423
 424 /**
 425  * v4l2_m2m_encoder_cmd() - execute an encoder command
 426  *
 427  * @file: pointer to struct &file
 428  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 429  * @ec: pointer to the encoder command
 430  */
 431 int v4l2_m2m_encoder_cmd(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
 432                          struct v4l2_encoder_cmd *ec);
 433
 434 /**
 435  * v4l2_m2m_decoder_cmd() - execute a decoder command
 436  *
 437  * @file: pointer to struct &file
 438  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 439  * @dc: pointer to the decoder command
 440  */
 441 int v4l2_m2m_decoder_cmd(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
 442                          struct v4l2_decoder_cmd *dc);
 443
 444 /**
 445  * v4l2_m2m_poll() - poll replacement, for destination buffers only
 446  *
 447  * @file: pointer to struct &file
 448  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 449  * @wait: pointer to struct &poll_table_struct
 450  *
 451  * Call from the driver's poll() function. Will poll both queues. If a buffer
 452  * is available to dequeue (with dqbuf) from the source queue, this will
 453  * indicate that a non-blocking write can be performed, while read will be
 454  * returned in case of the destination queue.
 455  */
 456 __poll_t v4l2_m2m_poll(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
 457                            struct poll_table_struct *wait);
 458
 459 /**
 460  * v4l2_m2m_mmap() - source and destination queues-aware mmap multiplexer
 461  *
 462  * @file: pointer to struct &file
 463  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 464  * @vma: pointer to struct &vm_area_struct
 465  *
 466  * Call from driver's mmap() function. Will handle mmap() for both queues
 467  * seamlessly for videobuffer, which will receive normal per-queue offsets and
 468  * proper videobuf queue pointers. The differentiation is made outside videobuf
 469  * by adding a predefined offset to buffers from one of the queues and
 470  * subtracting it before passing it back to videobuf. Only drivers (and
 471  * thus applications) receive modified offsets.
 472  */
 473 int v4l2_m2m_mmap(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
 474                   struct vm_area_struct *vma);
 475
 476 /**
 477  * v4l2_m2m_init() - initialize per-driver m2m data
 478  *
 479  * @m2m_ops: pointer to struct v4l2_m2m_ops
 480  *
 481  * Usually called from driver's ``probe()`` function.
 482  *
 483  * Return: returns an opaque pointer to the internal data to handle M2M context
 484  */
 485 struct v4l2_m2m_dev *v4l2_m2m_init(const struct v4l2_m2m_ops *m2m_ops);
 486
 487 #if defined(CONFIG_MEDIA_CONTROLLER)
 488 void v4l2_m2m_unregister_media_controller(struct v4l2_m2m_dev *m2m_dev);
 489 int v4l2_m2m_register_media_controller(struct v4l2_m2m_dev *m2m_dev,
 490                         struct video_device *vdev, int function);
 491 #else
 492 static inline void
 493 v4l2_m2m_unregister_media_controller(struct v4l2_m2m_dev *m2m_dev)
 494 {
 495 }
 496
 497 static inline int
 498 v4l2_m2m_register_media_controller(struct v4l2_m2m_dev *m2m_dev,
 499                 struct video_device *vdev, int function)
 500 {
 501         return 0;
 502 }
 503 #endif
 504
 505 /**
 506  * v4l2_m2m_release() - cleans up and frees a m2m_dev structure
 507  *
 508  * @m2m_dev: opaque pointer to the internal data to handle M2M context
 509  *
 510  * Usually called from driver's ``remove()`` function.
 511  */
 512 void v4l2_m2m_release(struct v4l2_m2m_dev *m2m_dev);
 513
 514 /**
 515  * v4l2_m2m_ctx_init() - allocate and initialize a m2m context
 516  *
 517  * @m2m_dev: opaque pointer to the internal data to handle M2M context
 518  * @drv_priv: driver's instance private data
 519  * @queue_init: a callback for queue type-specific initialization function
 520  *      to be used for initializing videobuf_queues
 521  *
 522  * Usually called from driver's ``open()`` function.
 523  */
 524 struct v4l2_m2m_ctx *v4l2_m2m_ctx_init(struct v4l2_m2m_dev *m2m_dev,
 525                 void *drv_priv,
 526                 int (*queue_init)(void *priv, struct vb2_queue *src_vq, struct vb2_queue *dst_vq));
 527
 528 static inline void v4l2_m2m_set_src_buffered(struct v4l2_m2m_ctx *m2m_ctx,
 529                                              bool buffered)
 530 {
 531         m2m_ctx->out_q_ctx.buffered = buffered;
 532 }
 533
 534 static inline void v4l2_m2m_set_dst_buffered(struct v4l2_m2m_ctx *m2m_ctx,
 535                                              bool buffered)
 536 {
 537         m2m_ctx->cap_q_ctx.buffered = buffered;
 538 }
 539
 540 /**
 541  * v4l2_m2m_ctx_release() - release m2m context
 542  *
 543  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 544  *
 545  * Usually called from driver's release() function.
 546  */
 547 void v4l2_m2m_ctx_release(struct v4l2_m2m_ctx *m2m_ctx);
 548
 549 /**
 550  * v4l2_m2m_buf_queue() - add a buffer to the proper ready buffers list.
 551  *
 552  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 553  * @vbuf: pointer to struct &vb2_v4l2_buffer
 554  *
 555  * Call from videobuf_queue_ops->ops->buf_queue, videobuf_queue_ops callback.
 556  */
 557 void v4l2_m2m_buf_queue(struct v4l2_m2m_ctx *m2m_ctx,
 558                         struct vb2_v4l2_buffer *vbuf);
 559
 560 /**
 561  * v4l2_m2m_num_src_bufs_ready() - return the number of source buffers ready for
 562  * use
 563  *
 564  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 565  */
 566 static inline
 567 unsigned int v4l2_m2m_num_src_bufs_ready(struct v4l2_m2m_ctx *m2m_ctx)
 568 {
 569         return m2m_ctx->out_q_ctx.num_rdy;
 570 }
 571
 572 /**
 573  * v4l2_m2m_num_dst_bufs_ready() - return the number of destination buffers
 574  * ready for use
 575  *
 576  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 577  */
 578 static inline
 579 unsigned int v4l2_m2m_num_dst_bufs_ready(struct v4l2_m2m_ctx *m2m_ctx)
 580 {
 581         return m2m_ctx->cap_q_ctx.num_rdy;
 582 }
 583
 584 /**
 585  * v4l2_m2m_next_buf() - return next buffer from the list of ready buffers
 586  *
 587  * @q_ctx: pointer to struct @v4l2_m2m_queue_ctx
 588  */
 589 struct vb2_v4l2_buffer *v4l2_m2m_next_buf(struct v4l2_m2m_queue_ctx *q_ctx);
 590
 591 /**
 592  * v4l2_m2m_next_src_buf() - return next source buffer from the list of ready
 593  * buffers
 594  *
 595  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 596  */
 597 static inline struct vb2_v4l2_buffer *
 598 v4l2_m2m_next_src_buf(struct v4l2_m2m_ctx *m2m_ctx)
 599 {
 600         return v4l2_m2m_next_buf(&m2m_ctx->out_q_ctx);
 601 }
 602
 603 /**
 604  * v4l2_m2m_next_dst_buf() - return next destination buffer from the list of
 605  * ready buffers
 606  *
 607  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 608  */
 609 static inline struct vb2_v4l2_buffer *
 610 v4l2_m2m_next_dst_buf(struct v4l2_m2m_ctx *m2m_ctx)
 611 {
 612         return v4l2_m2m_next_buf(&m2m_ctx->cap_q_ctx);
 613 }
 614
 615 /**
 616  * v4l2_m2m_last_buf() - return last buffer from the list of ready buffers
 617  *
 618  * @q_ctx: pointer to struct @v4l2_m2m_queue_ctx
 619  */
 620 struct vb2_v4l2_buffer *v4l2_m2m_last_buf(struct v4l2_m2m_queue_ctx *q_ctx);
 621
 622 /**
 623  * v4l2_m2m_last_src_buf() - return last destination buffer from the list of
 624  * ready buffers
 625  *
 626  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 627  */
 628 static inline struct vb2_v4l2_buffer *
 629 v4l2_m2m_last_src_buf(struct v4l2_m2m_ctx *m2m_ctx)
 630 {
 631         return v4l2_m2m_last_buf(&m2m_ctx->out_q_ctx);
 632 }
 633
 634 /**
 635  * v4l2_m2m_last_dst_buf() - return last destination buffer from the list of
 636  * ready buffers
 637  *
 638  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 639  */
 640 static inline struct vb2_v4l2_buffer *
 641 v4l2_m2m_last_dst_buf(struct v4l2_m2m_ctx *m2m_ctx)
 642 {
 643         return v4l2_m2m_last_buf(&m2m_ctx->cap_q_ctx);
 644 }
 645
 646 /**
 647  * v4l2_m2m_for_each_dst_buf() - iterate over a list of destination ready
 648  * buffers
 649  *
 650  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 651  * @b: current buffer of type struct v4l2_m2m_buffer
 652  */
 653 #define v4l2_m2m_for_each_dst_buf(m2m_ctx, b)   \
 654         list_for_each_entry(b, &m2m_ctx->cap_q_ctx.rdy_queue, list)
 655
 656 /**
 657  * v4l2_m2m_for_each_src_buf() - iterate over a list of source ready buffers
 658  *
 659  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 660  * @b: current buffer of type struct v4l2_m2m_buffer
 661  */
 662 #define v4l2_m2m_for_each_src_buf(m2m_ctx, b)   \
 663         list_for_each_entry(b, &m2m_ctx->out_q_ctx.rdy_queue, list)
 664
 665 /**
 666  * v4l2_m2m_for_each_dst_buf_safe() - iterate over a list of destination ready
 667  * buffers safely
 668  *
 669  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 670  * @b: current buffer of type struct v4l2_m2m_buffer
 671  * @n: used as temporary storage
 672  */
 673 #define v4l2_m2m_for_each_dst_buf_safe(m2m_ctx, b, n)   \
 674         list_for_each_entry_safe(b, n, &m2m_ctx->cap_q_ctx.rdy_queue, list)
 675
 676 /**
 677  * v4l2_m2m_for_each_src_buf_safe() - iterate over a list of source ready
 678  * buffers safely
 679  *
 680  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 681  * @b: current buffer of type struct v4l2_m2m_buffer
 682  * @n: used as temporary storage
 683  */
 684 #define v4l2_m2m_for_each_src_buf_safe(m2m_ctx, b, n)   \
 685         list_for_each_entry_safe(b, n, &m2m_ctx->out_q_ctx.rdy_queue, list)
 686
 687 /**
 688  * v4l2_m2m_get_src_vq() - return vb2_queue for source buffers
 689  *
 690  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 691  */
 692 static inline
 693 struct vb2_queue *v4l2_m2m_get_src_vq(struct v4l2_m2m_ctx *m2m_ctx)
 694 {
 695         return &m2m_ctx->out_q_ctx.q;
 696 }
 697
 698 /**
 699  * v4l2_m2m_get_dst_vq() - return vb2_queue for destination buffers
 700  *
 701  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 702  */
 703 static inline
 704 struct vb2_queue *v4l2_m2m_get_dst_vq(struct v4l2_m2m_ctx *m2m_ctx)
 705 {
 706         return &m2m_ctx->cap_q_ctx.q;
 707 }
 708
 709 /**
 710  * v4l2_m2m_buf_remove() - take off a buffer from the list of ready buffers and
 711  * return it
 712  *
 713  * @q_ctx: pointer to struct @v4l2_m2m_queue_ctx
 714  */
 715 struct vb2_v4l2_buffer *v4l2_m2m_buf_remove(struct v4l2_m2m_queue_ctx *q_ctx);
 716
 717 /**
 718  * v4l2_m2m_src_buf_remove() - take off a source buffer from the list of ready
 719  * buffers and return it
 720  *
 721  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 722  */
 723 static inline struct vb2_v4l2_buffer *
 724 v4l2_m2m_src_buf_remove(struct v4l2_m2m_ctx *m2m_ctx)
 725 {
 726         return v4l2_m2m_buf_remove(&m2m_ctx->out_q_ctx);
 727 }
 728
 729 /**
 730  * v4l2_m2m_dst_buf_remove() - take off a destination buffer from the list of
 731  * ready buffers and return it
 732  *
 733  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 734  */
 735 static inline struct vb2_v4l2_buffer *
 736 v4l2_m2m_dst_buf_remove(struct v4l2_m2m_ctx *m2m_ctx)
 737 {
 738         return v4l2_m2m_buf_remove(&m2m_ctx->cap_q_ctx);
 739 }
 740
 741 /**
 742  * v4l2_m2m_buf_remove_by_buf() - take off exact buffer from the list of ready
 743  * buffers
 744  *
 745  * @q_ctx: pointer to struct @v4l2_m2m_queue_ctx
 746  * @vbuf: the buffer to be removed
 747  */
 748 void v4l2_m2m_buf_remove_by_buf(struct v4l2_m2m_queue_ctx *q_ctx,
 749                                 struct vb2_v4l2_buffer *vbuf);
 750
 751 /**
 752  * v4l2_m2m_src_buf_remove_by_buf() - take off exact source buffer from the list
 753  * of ready buffers
 754  *
 755  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 756  * @vbuf: the buffer to be removed
 757  */
 758 static inline void v4l2_m2m_src_buf_remove_by_buf(struct v4l2_m2m_ctx *m2m_ctx,
 759                                                   struct vb2_v4l2_buffer *vbuf)
 760 {
 761         v4l2_m2m_buf_remove_by_buf(&m2m_ctx->out_q_ctx, vbuf);
 762 }
 763
 764 /**
 765  * v4l2_m2m_dst_buf_remove_by_buf() - take off exact destination buffer from the
 766  * list of ready buffers
 767  *
 768  * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
 769  * @vbuf: the buffer to be removed
 770  */
 771 static inline void v4l2_m2m_dst_buf_remove_by_buf(struct v4l2_m2m_ctx *m2m_ctx,
 772                                                   struct vb2_v4l2_buffer *vbuf)
 773 {
 774         v4l2_m2m_buf_remove_by_buf(&m2m_ctx->cap_q_ctx, vbuf);
 775 }
 776
 777 struct vb2_v4l2_buffer *
 778 v4l2_m2m_buf_remove_by_idx(struct v4l2_m2m_queue_ctx *q_ctx, unsigned int idx);
 779
 780 static inline struct vb2_v4l2_buffer *
 781 v4l2_m2m_src_buf_remove_by_idx(struct v4l2_m2m_ctx *m2m_ctx, unsigned int idx)
 782 {
 783         return v4l2_m2m_buf_remove_by_idx(&m2m_ctx->out_q_ctx, idx);
 784 }
 785
 786 static inline struct vb2_v4l2_buffer *
 787 v4l2_m2m_dst_buf_remove_by_idx(struct v4l2_m2m_ctx *m2m_ctx, unsigned int idx)
 788 {
 789         return v4l2_m2m_buf_remove_by_idx(&m2m_ctx->cap_q_ctx, idx);
 790 }
 791
 792 /**
 793  * v4l2_m2m_buf_copy_metadata() - copy buffer metadata from
 794  * the output buffer to the capture buffer
 795  *
 796  * @out_vb: the output buffer that is the source of the metadata.
 797  * @cap_vb: the capture buffer that will receive the metadata.
 798  * @copy_frame_flags: copy the KEY/B/PFRAME flags as well.
 799  *
 800  * This helper function copies the timestamp, timecode (if the TIMECODE
 801  * buffer flag was set), field and the TIMECODE, KEYFRAME, BFRAME, PFRAME
 802  * and TSTAMP_SRC_MASK flags from @out_vb to @cap_vb.
 803  *
 804  * If @copy_frame_flags is false, then the KEYFRAME, BFRAME and PFRAME
 805  * flags are not copied. This is typically needed for encoders that
 806  * set this bits explicitly.
 807  */
 808 void v4l2_m2m_buf_copy_metadata(const struct vb2_v4l2_buffer *out_vb,
 809                                 struct vb2_v4l2_buffer *cap_vb,
 810                                 bool copy_frame_flags);
 811
 812 /* v4l2 request helper */
 813
 814 void v4l2_m2m_request_queue(struct media_request *req);
 815
 816 /* v4l2 ioctl helpers */
 817
 818 int v4l2_m2m_ioctl_reqbufs(struct file *file, void *priv,
 819                                 struct v4l2_requestbuffers *rb);
 820 int v4l2_m2m_ioctl_create_bufs(struct file *file, void *fh,
 821                                 struct v4l2_create_buffers *create);
 822 int v4l2_m2m_ioctl_querybuf(struct file *file, void *fh,
 823                                 struct v4l2_buffer *buf);
 824 int v4l2_m2m_ioctl_expbuf(struct file *file, void *fh,
 825                                 struct v4l2_exportbuffer *eb);
 826 int v4l2_m2m_ioctl_qbuf(struct file *file, void *fh,
 827                                 struct v4l2_buffer *buf);
 828 int v4l2_m2m_ioctl_dqbuf(struct file *file, void *fh,
 829                                 struct v4l2_buffer *buf);
 830 int v4l2_m2m_ioctl_prepare_buf(struct file *file, void *fh,
 831                                struct v4l2_buffer *buf);
 832 int v4l2_m2m_ioctl_streamon(struct file *file, void *fh,
 833                                 enum v4l2_buf_type type);
 834 int v4l2_m2m_ioctl_streamoff(struct file *file, void *fh,
 835                                 enum v4l2_buf_type type);
 836 int v4l2_m2m_ioctl_encoder_cmd(struct file *file, void *fh,
 837                                struct v4l2_encoder_cmd *ec);
 838 int v4l2_m2m_ioctl_decoder_cmd(struct file *file, void *fh,
 839                                struct v4l2_decoder_cmd *dc);
 840 int v4l2_m2m_ioctl_try_encoder_cmd(struct file *file, void *fh,
 841                                    struct v4l2_encoder_cmd *ec);
 842 int v4l2_m2m_ioctl_try_decoder_cmd(struct file *file, void *fh,
 843                                    struct v4l2_decoder_cmd *dc);
 844 int v4l2_m2m_ioctl_stateless_try_decoder_cmd(struct file *file, void *fh,
 845                                              struct v4l2_decoder_cmd *dc);
 846 int v4l2_m2m_ioctl_stateless_decoder_cmd(struct file *file, void *priv,
 847                                          struct v4l2_decoder_cmd *dc);
 848 int v4l2_m2m_fop_mmap(struct file *file, struct vm_area_struct *vma);
 849 __poll_t v4l2_m2m_fop_poll(struct file *file, poll_table *wait);
 850
 851 #endif /* _MEDIA_V4L2_MEM2MEM_H */
 852