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
v4l2_m2m_buf_done(struct vb2_v4l2_buffer * buf,enum vb2_buffer_state state)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
v4l2_m2m_unregister_media_controller(struct v4l2_m2m_dev * m2m_dev)332 v4l2_m2m_unregister_media_controller(struct v4l2_m2m_dev *m2m_dev)
333 {
334 }
335
336 static inline int
v4l2_m2m_register_media_controller(struct v4l2_m2m_dev * m2m_dev,struct video_device * vdev,int function)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
v4l2_m2m_set_src_buffered(struct v4l2_m2m_ctx * m2m_ctx,bool buffered)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
v4l2_m2m_set_dst_buffered(struct v4l2_m2m_ctx * m2m_ctx,bool buffered)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
v4l2_m2m_num_src_bufs_ready(struct v4l2_m2m_ctx * m2m_ctx)406 unsigned int v4l2_m2m_num_src_bufs_ready(struct v4l2_m2m_ctx *m2m_ctx)
407 {
408 unsigned int num_buf_rdy;
409 unsigned long flags;
410
411 spin_lock_irqsave(&m2m_ctx->out_q_ctx.rdy_spinlock, flags);
412 num_buf_rdy = m2m_ctx->out_q_ctx.num_rdy;
413 spin_unlock_irqrestore(&m2m_ctx->out_q_ctx.rdy_spinlock, flags);
414
415 return num_buf_rdy;
416 }
417
418 /**
419 * v4l2_m2m_num_dst_bufs_ready() - return the number of destination buffers
420 * ready for use
421 *
422 * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
423 */
424 static inline
v4l2_m2m_num_dst_bufs_ready(struct v4l2_m2m_ctx * m2m_ctx)425 unsigned int v4l2_m2m_num_dst_bufs_ready(struct v4l2_m2m_ctx *m2m_ctx)
426 {
427 unsigned int num_buf_rdy;
428 unsigned long flags;
429
430 spin_lock_irqsave(&m2m_ctx->cap_q_ctx.rdy_spinlock, flags);
431 num_buf_rdy = m2m_ctx->cap_q_ctx.num_rdy;
432 spin_unlock_irqrestore(&m2m_ctx->cap_q_ctx.rdy_spinlock, flags);
433
434 return num_buf_rdy;
435 }
436
437 /**
438 * v4l2_m2m_next_buf() - return next buffer from the list of ready buffers
439 *
440 * @q_ctx: pointer to struct @v4l2_m2m_queue_ctx
441 */
442 void *v4l2_m2m_next_buf(struct v4l2_m2m_queue_ctx *q_ctx);
443
444 /**
445 * v4l2_m2m_next_src_buf() - return next source buffer from the list of ready
446 * buffers
447 *
448 * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
449 */
v4l2_m2m_next_src_buf(struct v4l2_m2m_ctx * m2m_ctx)450 static inline void *v4l2_m2m_next_src_buf(struct v4l2_m2m_ctx *m2m_ctx)
451 {
452 return v4l2_m2m_next_buf(&m2m_ctx->out_q_ctx);
453 }
454
455 /**
456 * v4l2_m2m_next_dst_buf() - return next destination buffer from the list of
457 * ready buffers
458 *
459 * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
460 */
v4l2_m2m_next_dst_buf(struct v4l2_m2m_ctx * m2m_ctx)461 static inline void *v4l2_m2m_next_dst_buf(struct v4l2_m2m_ctx *m2m_ctx)
462 {
463 return v4l2_m2m_next_buf(&m2m_ctx->cap_q_ctx);
464 }
465
466 /**
467 * v4l2_m2m_last_buf() - return last buffer from the list of ready buffers
468 *
469 * @q_ctx: pointer to struct @v4l2_m2m_queue_ctx
470 */
471 void *v4l2_m2m_last_buf(struct v4l2_m2m_queue_ctx *q_ctx);
472
473 /**
474 * v4l2_m2m_last_src_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 */
v4l2_m2m_last_src_buf(struct v4l2_m2m_ctx * m2m_ctx)479 static inline void *v4l2_m2m_last_src_buf(struct v4l2_m2m_ctx *m2m_ctx)
480 {
481 return v4l2_m2m_last_buf(&m2m_ctx->out_q_ctx);
482 }
483
484 /**
485 * v4l2_m2m_last_dst_buf() - return last destination buffer from the list of
486 * ready buffers
487 *
488 * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
489 */
v4l2_m2m_last_dst_buf(struct v4l2_m2m_ctx * m2m_ctx)490 static inline void *v4l2_m2m_last_dst_buf(struct v4l2_m2m_ctx *m2m_ctx)
491 {
492 return v4l2_m2m_last_buf(&m2m_ctx->cap_q_ctx);
493 }
494
495 /**
496 * v4l2_m2m_for_each_dst_buf() - iterate over a list of destination ready
497 * buffers
498 *
499 * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
500 * @b: current buffer of type struct v4l2_m2m_buffer
501 */
502 #define v4l2_m2m_for_each_dst_buf(m2m_ctx, b) \
503 list_for_each_entry(b, &m2m_ctx->cap_q_ctx.rdy_queue, list)
504
505 /**
506 * v4l2_m2m_for_each_src_buf() - iterate over a list of source ready buffers
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 */
511 #define v4l2_m2m_for_each_src_buf(m2m_ctx, b) \
512 list_for_each_entry(b, &m2m_ctx->out_q_ctx.rdy_queue, list)
513
514 /**
515 * v4l2_m2m_for_each_dst_buf_safe() - iterate over a list of destination ready
516 * buffers safely
517 *
518 * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
519 * @b: current buffer of type struct v4l2_m2m_buffer
520 * @n: used as temporary storage
521 */
522 #define v4l2_m2m_for_each_dst_buf_safe(m2m_ctx, b, n) \
523 list_for_each_entry_safe(b, n, &m2m_ctx->cap_q_ctx.rdy_queue, list)
524
525 /**
526 * v4l2_m2m_for_each_src_buf_safe() - iterate over a list of source ready
527 * buffers safely
528 *
529 * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
530 * @b: current buffer of type struct v4l2_m2m_buffer
531 * @n: used as temporary storage
532 */
533 #define v4l2_m2m_for_each_src_buf_safe(m2m_ctx, b, n) \
534 list_for_each_entry_safe(b, n, &m2m_ctx->out_q_ctx.rdy_queue, list)
535
536 /**
537 * v4l2_m2m_get_src_vq() - return vb2_queue for source buffers
538 *
539 * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
540 */
541 static inline
v4l2_m2m_get_src_vq(struct v4l2_m2m_ctx * m2m_ctx)542 struct vb2_queue *v4l2_m2m_get_src_vq(struct v4l2_m2m_ctx *m2m_ctx)
543 {
544 return &m2m_ctx->out_q_ctx.q;
545 }
546
547 /**
548 * v4l2_m2m_get_dst_vq() - return vb2_queue for destination buffers
549 *
550 * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
551 */
552 static inline
v4l2_m2m_get_dst_vq(struct v4l2_m2m_ctx * m2m_ctx)553 struct vb2_queue *v4l2_m2m_get_dst_vq(struct v4l2_m2m_ctx *m2m_ctx)
554 {
555 return &m2m_ctx->cap_q_ctx.q;
556 }
557
558 /**
559 * v4l2_m2m_buf_remove() - take off a buffer from the list of ready buffers and
560 * return it
561 *
562 * @q_ctx: pointer to struct @v4l2_m2m_queue_ctx
563 */
564 void *v4l2_m2m_buf_remove(struct v4l2_m2m_queue_ctx *q_ctx);
565
566 /**
567 * v4l2_m2m_src_buf_remove() - take off a source buffer from the list of ready
568 * buffers and return it
569 *
570 * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
571 */
v4l2_m2m_src_buf_remove(struct v4l2_m2m_ctx * m2m_ctx)572 static inline void *v4l2_m2m_src_buf_remove(struct v4l2_m2m_ctx *m2m_ctx)
573 {
574 return v4l2_m2m_buf_remove(&m2m_ctx->out_q_ctx);
575 }
576
577 /**
578 * v4l2_m2m_dst_buf_remove() - take off a destination buffer from the list of
579 * ready buffers and return it
580 *
581 * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
582 */
v4l2_m2m_dst_buf_remove(struct v4l2_m2m_ctx * m2m_ctx)583 static inline void *v4l2_m2m_dst_buf_remove(struct v4l2_m2m_ctx *m2m_ctx)
584 {
585 return v4l2_m2m_buf_remove(&m2m_ctx->cap_q_ctx);
586 }
587
588 /**
589 * v4l2_m2m_buf_remove_by_buf() - take off exact buffer from the list of ready
590 * buffers
591 *
592 * @q_ctx: pointer to struct @v4l2_m2m_queue_ctx
593 * @vbuf: the buffer to be removed
594 */
595 void v4l2_m2m_buf_remove_by_buf(struct v4l2_m2m_queue_ctx *q_ctx,
596 struct vb2_v4l2_buffer *vbuf);
597
598 /**
599 * v4l2_m2m_src_buf_remove_by_buf() - take off exact source buffer from the list
600 * of ready buffers
601 *
602 * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
603 * @vbuf: the buffer to be removed
604 */
v4l2_m2m_src_buf_remove_by_buf(struct v4l2_m2m_ctx * m2m_ctx,struct vb2_v4l2_buffer * vbuf)605 static inline void v4l2_m2m_src_buf_remove_by_buf(struct v4l2_m2m_ctx *m2m_ctx,
606 struct vb2_v4l2_buffer *vbuf)
607 {
608 v4l2_m2m_buf_remove_by_buf(&m2m_ctx->out_q_ctx, vbuf);
609 }
610
611 /**
612 * v4l2_m2m_dst_buf_remove_by_buf() - take off exact destination buffer from the
613 * list of ready buffers
614 *
615 * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx
616 * @vbuf: the buffer to be removed
617 */
v4l2_m2m_dst_buf_remove_by_buf(struct v4l2_m2m_ctx * m2m_ctx,struct vb2_v4l2_buffer * vbuf)618 static inline void v4l2_m2m_dst_buf_remove_by_buf(struct v4l2_m2m_ctx *m2m_ctx,
619 struct vb2_v4l2_buffer *vbuf)
620 {
621 v4l2_m2m_buf_remove_by_buf(&m2m_ctx->cap_q_ctx, vbuf);
622 }
623
624 struct vb2_v4l2_buffer *
625 v4l2_m2m_buf_remove_by_idx(struct v4l2_m2m_queue_ctx *q_ctx, unsigned int idx);
626
627 static inline struct vb2_v4l2_buffer *
v4l2_m2m_src_buf_remove_by_idx(struct v4l2_m2m_ctx * m2m_ctx,unsigned int idx)628 v4l2_m2m_src_buf_remove_by_idx(struct v4l2_m2m_ctx *m2m_ctx, unsigned int idx)
629 {
630 return v4l2_m2m_buf_remove_by_idx(&m2m_ctx->out_q_ctx, idx);
631 }
632
633 static inline struct vb2_v4l2_buffer *
v4l2_m2m_dst_buf_remove_by_idx(struct v4l2_m2m_ctx * m2m_ctx,unsigned int idx)634 v4l2_m2m_dst_buf_remove_by_idx(struct v4l2_m2m_ctx *m2m_ctx, unsigned int idx)
635 {
636 return v4l2_m2m_buf_remove_by_idx(&m2m_ctx->cap_q_ctx, idx);
637 }
638
639 /* v4l2 ioctl helpers */
640
641 int v4l2_m2m_ioctl_reqbufs(struct file *file, void *priv,
642 struct v4l2_requestbuffers *rb);
643 int v4l2_m2m_ioctl_create_bufs(struct file *file, void *fh,
644 struct v4l2_create_buffers *create);
645 int v4l2_m2m_ioctl_querybuf(struct file *file, void *fh,
646 struct v4l2_buffer *buf);
647 int v4l2_m2m_ioctl_expbuf(struct file *file, void *fh,
648 struct v4l2_exportbuffer *eb);
649 int v4l2_m2m_ioctl_qbuf(struct file *file, void *fh,
650 struct v4l2_buffer *buf);
651 int v4l2_m2m_ioctl_dqbuf(struct file *file, void *fh,
652 struct v4l2_buffer *buf);
653 int v4l2_m2m_ioctl_prepare_buf(struct file *file, void *fh,
654 struct v4l2_buffer *buf);
655 int v4l2_m2m_ioctl_streamon(struct file *file, void *fh,
656 enum v4l2_buf_type type);
657 int v4l2_m2m_ioctl_streamoff(struct file *file, void *fh,
658 enum v4l2_buf_type type);
659 int v4l2_m2m_fop_mmap(struct file *file, struct vm_area_struct *vma);
660 __poll_t v4l2_m2m_fop_poll(struct file *file, poll_table *wait);
661
662 #endif /* _MEDIA_V4L2_MEM2MEM_H */
663
664