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(vb: &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 the video buffer, which will receive normal per-queue offsets |
490 | * and proper vb2 queue pointers. The differentiation is made outside |
491 | * vb2 by adding a predefined offset to buffers from one of the queues |
492 | * and subtracting it before passing it back to vb2. 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 | #ifndef CONFIG_MMU |
499 | unsigned long v4l2_m2m_get_unmapped_area(struct file *file, unsigned long addr, |
500 | unsigned long len, unsigned long pgoff, |
501 | unsigned long flags); |
502 | #endif |
503 | /** |
504 | * v4l2_m2m_init() - initialize per-driver m2m data |
505 | * |
506 | * @m2m_ops: pointer to struct v4l2_m2m_ops |
507 | * |
508 | * Usually called from driver's ``probe()`` function. |
509 | * |
510 | * Return: returns an opaque pointer to the internal data to handle M2M context |
511 | */ |
512 | struct v4l2_m2m_dev *v4l2_m2m_init(const struct v4l2_m2m_ops *m2m_ops); |
513 | |
514 | #if defined(CONFIG_MEDIA_CONTROLLER) |
515 | void v4l2_m2m_unregister_media_controller(struct v4l2_m2m_dev *m2m_dev); |
516 | int v4l2_m2m_register_media_controller(struct v4l2_m2m_dev *m2m_dev, |
517 | struct video_device *vdev, int function); |
518 | #else |
519 | static inline void |
520 | v4l2_m2m_unregister_media_controller(struct v4l2_m2m_dev *m2m_dev) |
521 | { |
522 | } |
523 | |
524 | static inline int |
525 | v4l2_m2m_register_media_controller(struct v4l2_m2m_dev *m2m_dev, |
526 | struct video_device *vdev, int function) |
527 | { |
528 | return 0; |
529 | } |
530 | #endif |
531 | |
532 | /** |
533 | * v4l2_m2m_release() - cleans up and frees a m2m_dev structure |
534 | * |
535 | * @m2m_dev: opaque pointer to the internal data to handle M2M context |
536 | * |
537 | * Usually called from driver's ``remove()`` function. |
538 | */ |
539 | void v4l2_m2m_release(struct v4l2_m2m_dev *m2m_dev); |
540 | |
541 | /** |
542 | * v4l2_m2m_ctx_init() - allocate and initialize a m2m context |
543 | * |
544 | * @m2m_dev: opaque pointer to the internal data to handle M2M context |
545 | * @drv_priv: driver's instance private data |
546 | * @queue_init: a callback for queue type-specific initialization function |
547 | * to be used for initializing vb2_queues |
548 | * |
549 | * Usually called from driver's ``open()`` function. |
550 | */ |
551 | struct v4l2_m2m_ctx *v4l2_m2m_ctx_init(struct v4l2_m2m_dev *m2m_dev, |
552 | void *drv_priv, |
553 | int (*queue_init)(void *priv, struct vb2_queue *src_vq, struct vb2_queue *dst_vq)); |
554 | |
555 | static inline void v4l2_m2m_set_src_buffered(struct v4l2_m2m_ctx *m2m_ctx, |
556 | bool buffered) |
557 | { |
558 | m2m_ctx->out_q_ctx.buffered = buffered; |
559 | } |
560 | |
561 | static inline void v4l2_m2m_set_dst_buffered(struct v4l2_m2m_ctx *m2m_ctx, |
562 | bool buffered) |
563 | { |
564 | m2m_ctx->cap_q_ctx.buffered = buffered; |
565 | } |
566 | |
567 | /** |
568 | * v4l2_m2m_ctx_release() - release m2m context |
569 | * |
570 | * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx |
571 | * |
572 | * Usually called from driver's release() function. |
573 | */ |
574 | void v4l2_m2m_ctx_release(struct v4l2_m2m_ctx *m2m_ctx); |
575 | |
576 | /** |
577 | * v4l2_m2m_buf_queue() - add a buffer to the proper ready buffers list. |
578 | * |
579 | * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx |
580 | * @vbuf: pointer to struct &vb2_v4l2_buffer |
581 | * |
582 | * Call from vb2_queue_ops->ops->buf_queue, vb2_queue_ops callback. |
583 | */ |
584 | void v4l2_m2m_buf_queue(struct v4l2_m2m_ctx *m2m_ctx, |
585 | struct vb2_v4l2_buffer *vbuf); |
586 | |
587 | /** |
588 | * v4l2_m2m_num_src_bufs_ready() - return the number of source buffers ready for |
589 | * use |
590 | * |
591 | * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx |
592 | */ |
593 | static inline |
594 | unsigned int v4l2_m2m_num_src_bufs_ready(struct v4l2_m2m_ctx *m2m_ctx) |
595 | { |
596 | unsigned int num_buf_rdy; |
597 | unsigned long flags; |
598 | |
599 | spin_lock_irqsave(&m2m_ctx->out_q_ctx.rdy_spinlock, flags); |
600 | num_buf_rdy = m2m_ctx->out_q_ctx.num_rdy; |
601 | spin_unlock_irqrestore(lock: &m2m_ctx->out_q_ctx.rdy_spinlock, flags); |
602 | |
603 | return num_buf_rdy; |
604 | } |
605 | |
606 | /** |
607 | * v4l2_m2m_num_dst_bufs_ready() - return the number of destination buffers |
608 | * ready for use |
609 | * |
610 | * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx |
611 | */ |
612 | static inline |
613 | unsigned int v4l2_m2m_num_dst_bufs_ready(struct v4l2_m2m_ctx *m2m_ctx) |
614 | { |
615 | unsigned int num_buf_rdy; |
616 | unsigned long flags; |
617 | |
618 | spin_lock_irqsave(&m2m_ctx->cap_q_ctx.rdy_spinlock, flags); |
619 | num_buf_rdy = m2m_ctx->cap_q_ctx.num_rdy; |
620 | spin_unlock_irqrestore(lock: &m2m_ctx->cap_q_ctx.rdy_spinlock, flags); |
621 | |
622 | return num_buf_rdy; |
623 | } |
624 | |
625 | /** |
626 | * v4l2_m2m_next_buf() - return next buffer from the list of ready buffers |
627 | * |
628 | * @q_ctx: pointer to struct @v4l2_m2m_queue_ctx |
629 | */ |
630 | struct vb2_v4l2_buffer *v4l2_m2m_next_buf(struct v4l2_m2m_queue_ctx *q_ctx); |
631 | |
632 | /** |
633 | * v4l2_m2m_next_src_buf() - return next source buffer from the list of ready |
634 | * buffers |
635 | * |
636 | * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx |
637 | */ |
638 | static inline struct vb2_v4l2_buffer * |
639 | v4l2_m2m_next_src_buf(struct v4l2_m2m_ctx *m2m_ctx) |
640 | { |
641 | return v4l2_m2m_next_buf(q_ctx: &m2m_ctx->out_q_ctx); |
642 | } |
643 | |
644 | /** |
645 | * v4l2_m2m_next_dst_buf() - return next 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_next_dst_buf(struct v4l2_m2m_ctx *m2m_ctx) |
652 | { |
653 | return v4l2_m2m_next_buf(q_ctx: &m2m_ctx->cap_q_ctx); |
654 | } |
655 | |
656 | /** |
657 | * v4l2_m2m_last_buf() - return last buffer from the list of ready buffers |
658 | * |
659 | * @q_ctx: pointer to struct @v4l2_m2m_queue_ctx |
660 | */ |
661 | struct vb2_v4l2_buffer *v4l2_m2m_last_buf(struct v4l2_m2m_queue_ctx *q_ctx); |
662 | |
663 | /** |
664 | * v4l2_m2m_last_src_buf() - return last destination buffer from the list of |
665 | * ready buffers |
666 | * |
667 | * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx |
668 | */ |
669 | static inline struct vb2_v4l2_buffer * |
670 | v4l2_m2m_last_src_buf(struct v4l2_m2m_ctx *m2m_ctx) |
671 | { |
672 | return v4l2_m2m_last_buf(q_ctx: &m2m_ctx->out_q_ctx); |
673 | } |
674 | |
675 | /** |
676 | * v4l2_m2m_last_dst_buf() - return last destination buffer from the list of |
677 | * ready buffers |
678 | * |
679 | * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx |
680 | */ |
681 | static inline struct vb2_v4l2_buffer * |
682 | v4l2_m2m_last_dst_buf(struct v4l2_m2m_ctx *m2m_ctx) |
683 | { |
684 | return v4l2_m2m_last_buf(q_ctx: &m2m_ctx->cap_q_ctx); |
685 | } |
686 | |
687 | /** |
688 | * v4l2_m2m_for_each_dst_buf() - iterate over a list of destination ready |
689 | * buffers |
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 | */ |
694 | #define v4l2_m2m_for_each_dst_buf(m2m_ctx, b) \ |
695 | list_for_each_entry(b, &m2m_ctx->cap_q_ctx.rdy_queue, list) |
696 | |
697 | /** |
698 | * v4l2_m2m_for_each_src_buf() - iterate over a list of source ready buffers |
699 | * |
700 | * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx |
701 | * @b: current buffer of type struct v4l2_m2m_buffer |
702 | */ |
703 | #define v4l2_m2m_for_each_src_buf(m2m_ctx, b) \ |
704 | list_for_each_entry(b, &m2m_ctx->out_q_ctx.rdy_queue, list) |
705 | |
706 | /** |
707 | * v4l2_m2m_for_each_dst_buf_safe() - iterate over a list of destination ready |
708 | * buffers safely |
709 | * |
710 | * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx |
711 | * @b: current buffer of type struct v4l2_m2m_buffer |
712 | * @n: used as temporary storage |
713 | */ |
714 | #define v4l2_m2m_for_each_dst_buf_safe(m2m_ctx, b, n) \ |
715 | list_for_each_entry_safe(b, n, &m2m_ctx->cap_q_ctx.rdy_queue, list) |
716 | |
717 | /** |
718 | * v4l2_m2m_for_each_src_buf_safe() - iterate over a list of source ready |
719 | * buffers safely |
720 | * |
721 | * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx |
722 | * @b: current buffer of type struct v4l2_m2m_buffer |
723 | * @n: used as temporary storage |
724 | */ |
725 | #define v4l2_m2m_for_each_src_buf_safe(m2m_ctx, b, n) \ |
726 | list_for_each_entry_safe(b, n, &m2m_ctx->out_q_ctx.rdy_queue, list) |
727 | |
728 | /** |
729 | * v4l2_m2m_get_src_vq() - return vb2_queue for source buffers |
730 | * |
731 | * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx |
732 | */ |
733 | static inline |
734 | struct vb2_queue *v4l2_m2m_get_src_vq(struct v4l2_m2m_ctx *m2m_ctx) |
735 | { |
736 | return &m2m_ctx->out_q_ctx.q; |
737 | } |
738 | |
739 | /** |
740 | * v4l2_m2m_get_dst_vq() - return vb2_queue for destination buffers |
741 | * |
742 | * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx |
743 | */ |
744 | static inline |
745 | struct vb2_queue *v4l2_m2m_get_dst_vq(struct v4l2_m2m_ctx *m2m_ctx) |
746 | { |
747 | return &m2m_ctx->cap_q_ctx.q; |
748 | } |
749 | |
750 | /** |
751 | * v4l2_m2m_buf_remove() - take off a buffer from the list of ready buffers and |
752 | * return it |
753 | * |
754 | * @q_ctx: pointer to struct @v4l2_m2m_queue_ctx |
755 | */ |
756 | struct vb2_v4l2_buffer *v4l2_m2m_buf_remove(struct v4l2_m2m_queue_ctx *q_ctx); |
757 | |
758 | /** |
759 | * v4l2_m2m_src_buf_remove() - take off a source buffer from the list of ready |
760 | * buffers and return it |
761 | * |
762 | * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx |
763 | */ |
764 | static inline struct vb2_v4l2_buffer * |
765 | v4l2_m2m_src_buf_remove(struct v4l2_m2m_ctx *m2m_ctx) |
766 | { |
767 | return v4l2_m2m_buf_remove(q_ctx: &m2m_ctx->out_q_ctx); |
768 | } |
769 | |
770 | /** |
771 | * v4l2_m2m_dst_buf_remove() - take off a destination buffer from the list of |
772 | * ready buffers and return it |
773 | * |
774 | * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx |
775 | */ |
776 | static inline struct vb2_v4l2_buffer * |
777 | v4l2_m2m_dst_buf_remove(struct v4l2_m2m_ctx *m2m_ctx) |
778 | { |
779 | return v4l2_m2m_buf_remove(q_ctx: &m2m_ctx->cap_q_ctx); |
780 | } |
781 | |
782 | /** |
783 | * v4l2_m2m_buf_remove_by_buf() - take off exact buffer from the list of ready |
784 | * buffers |
785 | * |
786 | * @q_ctx: pointer to struct @v4l2_m2m_queue_ctx |
787 | * @vbuf: the buffer to be removed |
788 | */ |
789 | void v4l2_m2m_buf_remove_by_buf(struct v4l2_m2m_queue_ctx *q_ctx, |
790 | struct vb2_v4l2_buffer *vbuf); |
791 | |
792 | /** |
793 | * v4l2_m2m_src_buf_remove_by_buf() - take off exact source buffer from the list |
794 | * of ready buffers |
795 | * |
796 | * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx |
797 | * @vbuf: the buffer to be removed |
798 | */ |
799 | static inline void v4l2_m2m_src_buf_remove_by_buf(struct v4l2_m2m_ctx *m2m_ctx, |
800 | struct vb2_v4l2_buffer *vbuf) |
801 | { |
802 | v4l2_m2m_buf_remove_by_buf(q_ctx: &m2m_ctx->out_q_ctx, vbuf); |
803 | } |
804 | |
805 | /** |
806 | * v4l2_m2m_dst_buf_remove_by_buf() - take off exact destination buffer from the |
807 | * list of ready buffers |
808 | * |
809 | * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx |
810 | * @vbuf: the buffer to be removed |
811 | */ |
812 | static inline void v4l2_m2m_dst_buf_remove_by_buf(struct v4l2_m2m_ctx *m2m_ctx, |
813 | struct vb2_v4l2_buffer *vbuf) |
814 | { |
815 | v4l2_m2m_buf_remove_by_buf(q_ctx: &m2m_ctx->cap_q_ctx, vbuf); |
816 | } |
817 | |
818 | struct vb2_v4l2_buffer * |
819 | v4l2_m2m_buf_remove_by_idx(struct v4l2_m2m_queue_ctx *q_ctx, unsigned int idx); |
820 | |
821 | static inline struct vb2_v4l2_buffer * |
822 | v4l2_m2m_src_buf_remove_by_idx(struct v4l2_m2m_ctx *m2m_ctx, unsigned int idx) |
823 | { |
824 | return v4l2_m2m_buf_remove_by_idx(q_ctx: &m2m_ctx->out_q_ctx, idx); |
825 | } |
826 | |
827 | static inline struct vb2_v4l2_buffer * |
828 | v4l2_m2m_dst_buf_remove_by_idx(struct v4l2_m2m_ctx *m2m_ctx, unsigned int idx) |
829 | { |
830 | return v4l2_m2m_buf_remove_by_idx(q_ctx: &m2m_ctx->cap_q_ctx, idx); |
831 | } |
832 | |
833 | /** |
834 | * v4l2_m2m_buf_copy_metadata() - copy buffer metadata from |
835 | * the output buffer to the capture buffer |
836 | * |
837 | * @out_vb: the output buffer that is the source of the metadata. |
838 | * @cap_vb: the capture buffer that will receive the metadata. |
839 | * @copy_frame_flags: copy the KEY/B/PFRAME flags as well. |
840 | * |
841 | * This helper function copies the timestamp, timecode (if the TIMECODE |
842 | * buffer flag was set), field and the TIMECODE, KEYFRAME, BFRAME, PFRAME |
843 | * and TSTAMP_SRC_MASK flags from @out_vb to @cap_vb. |
844 | * |
845 | * If @copy_frame_flags is false, then the KEYFRAME, BFRAME and PFRAME |
846 | * flags are not copied. This is typically needed for encoders that |
847 | * set this bits explicitly. |
848 | */ |
849 | void v4l2_m2m_buf_copy_metadata(const struct vb2_v4l2_buffer *out_vb, |
850 | struct vb2_v4l2_buffer *cap_vb, |
851 | bool copy_frame_flags); |
852 | |
853 | /* v4l2 request helper */ |
854 | |
855 | void v4l2_m2m_request_queue(struct media_request *req); |
856 | |
857 | /* v4l2 ioctl helpers */ |
858 | |
859 | int v4l2_m2m_ioctl_reqbufs(struct file *file, void *priv, |
860 | struct v4l2_requestbuffers *rb); |
861 | int v4l2_m2m_ioctl_create_bufs(struct file *file, void *fh, |
862 | struct v4l2_create_buffers *create); |
863 | int v4l2_m2m_ioctl_querybuf(struct file *file, void *fh, |
864 | struct v4l2_buffer *buf); |
865 | int v4l2_m2m_ioctl_expbuf(struct file *file, void *fh, |
866 | struct v4l2_exportbuffer *eb); |
867 | int v4l2_m2m_ioctl_qbuf(struct file *file, void *fh, |
868 | struct v4l2_buffer *buf); |
869 | int v4l2_m2m_ioctl_dqbuf(struct file *file, void *fh, |
870 | struct v4l2_buffer *buf); |
871 | int v4l2_m2m_ioctl_prepare_buf(struct file *file, void *fh, |
872 | struct v4l2_buffer *buf); |
873 | int v4l2_m2m_ioctl_streamon(struct file *file, void *fh, |
874 | enum v4l2_buf_type type); |
875 | int v4l2_m2m_ioctl_streamoff(struct file *file, void *fh, |
876 | enum v4l2_buf_type type); |
877 | int v4l2_m2m_ioctl_encoder_cmd(struct file *file, void *fh, |
878 | struct v4l2_encoder_cmd *ec); |
879 | int v4l2_m2m_ioctl_decoder_cmd(struct file *file, void *fh, |
880 | struct v4l2_decoder_cmd *dc); |
881 | int v4l2_m2m_ioctl_try_encoder_cmd(struct file *file, void *fh, |
882 | struct v4l2_encoder_cmd *ec); |
883 | int v4l2_m2m_ioctl_try_decoder_cmd(struct file *file, void *fh, |
884 | struct v4l2_decoder_cmd *dc); |
885 | int v4l2_m2m_ioctl_stateless_try_decoder_cmd(struct file *file, void *fh, |
886 | struct v4l2_decoder_cmd *dc); |
887 | int v4l2_m2m_ioctl_stateless_decoder_cmd(struct file *file, void *priv, |
888 | struct v4l2_decoder_cmd *dc); |
889 | int v4l2_m2m_fop_mmap(struct file *file, struct vm_area_struct *vma); |
890 | __poll_t v4l2_m2m_fop_poll(struct file *file, poll_table *wait); |
891 | |
892 | #endif /* _MEDIA_V4L2_MEM2MEM_H */ |
893 | |
894 | |