xref: /linux/include/media/v4l2-mem2mem.h (revision 680e6ffa15103ab610c0fc1241d2f98c801b13e2)
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 
680