]>
Commit | Line | Data |
---|---|---|
2874c5fd | 1 | /* SPDX-License-Identifier: GPL-2.0-or-later */ |
7f98639d PO |
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. | |
95072084 | 9 | * Pawel Osciak, <pawel@osciak.com> |
7f98639d | 10 | * Marek Szyprowski, <m.szyprowski@samsung.com> |
7f98639d PO |
11 | */ |
12 | ||
13 | #ifndef _MEDIA_V4L2_MEM2MEM_H | |
14 | #define _MEDIA_V4L2_MEM2MEM_H | |
15 | ||
c139990e | 16 | #include <media/videobuf2-v4l2.h> |
7f98639d PO |
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, | |
f8cca8c9 HV |
24 | * v4l2_m2m_job_finish() or v4l2_m2m_buf_done_and_job_finish() |
25 | * has to be called. | |
7f98639d PO |
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. | |
5525b831 | 32 | * @job_abort: optional. Informs the driver that it has to abort the currently |
7f98639d PO |
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 | |
f8cca8c9 HV |
37 | * v4l2_m2m_job_finish() or v4l2_m2m_buf_done_and_job_finish() as |
38 | * if the transaction ended normally. | |
7f98639d PO |
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 | ||
be2fff65 | 48 | struct video_device; |
7f98639d PO |
49 | struct v4l2_m2m_dev; |
50 | ||
5fa5edbe MCC |
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 | ||
7f98639d | 65 | struct v4l2_m2m_queue_ctx { |
908a0d7c | 66 | struct vb2_queue q; |
7f98639d | 67 | |
7f98639d | 68 | struct list_head rdy_queue; |
908a0d7c | 69 | spinlock_t rdy_spinlock; |
7f98639d | 70 | u8 num_rdy; |
33bdd5a8 | 71 | bool buffered; |
7f98639d PO |
72 | }; |
73 | ||
5fa5edbe MCC |
74 | /** |
75 | * struct v4l2_m2m_ctx - Memory to memory context structure | |
76 | * | |
77 | * @q_lock: struct &mutex lock | |
f07602ac HV |
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. | |
2b48e113 NA |
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 | |
9f8d3a2e | 87 | * @m2m_dev: opaque pointer to the internal data to handle M2M context |
5fa5edbe MCC |
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 | |
708f48e7 SA |
95 | * |
96 | * The memory to memory context is specific to a file handle, NOT to e.g. | |
97 | * a device. | |
5fa5edbe | 98 | */ |
7f98639d | 99 | struct v4l2_m2m_ctx { |
8e6e8f93 SN |
100 | /* optional cap/out vb2 queues lock */ |
101 | struct mutex *q_lock; | |
102 | ||
f07602ac HV |
103 | bool new_frame; |
104 | ||
2b48e113 NA |
105 | bool is_draining; |
106 | struct vb2_v4l2_buffer *last_src_buf; | |
107 | bool next_buf_last; | |
108 | bool has_stopped; | |
109 | ||
5fa5edbe | 110 | /* internal use only */ |
7f98639d PO |
111 | struct v4l2_m2m_dev *m2m_dev; |
112 | ||
7f98639d PO |
113 | struct v4l2_m2m_queue_ctx cap_q_ctx; |
114 | ||
7f98639d PO |
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; | |
908a0d7c | 120 | wait_queue_head_t finished; |
7f98639d | 121 | |
7f98639d PO |
122 | void *priv; |
123 | }; | |
124 | ||
5fa5edbe MCC |
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 | */ | |
908a0d7c | 131 | struct v4l2_m2m_buffer { |
2d700715 | 132 | struct vb2_v4l2_buffer vb; |
908a0d7c MS |
133 | struct list_head list; |
134 | }; | |
135 | ||
4781646c MCC |
136 | /** |
137 | * v4l2_m2m_get_curr_priv() - return driver private data for the currently | |
138 | * running instance or NULL if no instance is running | |
dcbd8735 | 139 | * |
9f8d3a2e | 140 | * @m2m_dev: opaque pointer to the internal data to handle M2M context |
4781646c | 141 | */ |
7f98639d PO |
142 | void *v4l2_m2m_get_curr_priv(struct v4l2_m2m_dev *m2m_dev); |
143 | ||
4781646c MCC |
144 | /** |
145 | * v4l2_m2m_get_vq() - return vb2_queue for the given type | |
dcbd8735 MCC |
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 | |
4781646c | 149 | */ |
908a0d7c | 150 | struct vb2_queue *v4l2_m2m_get_vq(struct v4l2_m2m_ctx *m2m_ctx, |
7f98639d PO |
151 | enum v4l2_buf_type type); |
152 | ||
4781646c MCC |
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. | |
dcbd8735 MCC |
156 | * |
157 | * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx | |
4781646c MCC |
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 | */ | |
1190a419 MO |
174 | void v4l2_m2m_try_schedule(struct v4l2_m2m_ctx *m2m_ctx); |
175 | ||
4781646c MCC |
176 | /** |
177 | * v4l2_m2m_job_finish() - inform the framework that a job has been finished | |
178 | * and have it clean up | |
179 | * | |
9f8d3a2e | 180 | * @m2m_dev: opaque pointer to the internal data to handle M2M context |
dcbd8735 MCC |
181 | * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx |
182 | * | |
4781646c MCC |
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 | * | |
5fa5edbe MCC |
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. | |
4781646c | 190 | */ |
7f98639d PO |
191 | void v4l2_m2m_job_finish(struct v4l2_m2m_dev *m2m_dev, |
192 | struct v4l2_m2m_ctx *m2m_ctx); | |
193 | ||
f8cca8c9 HV |
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 | ||
908a0d7c | 221 | static inline void |
2d700715 | 222 | v4l2_m2m_buf_done(struct vb2_v4l2_buffer *buf, enum vb2_buffer_state state) |
908a0d7c | 223 | { |
2d700715 | 224 | vb2_buffer_done(&buf->vb2_buf, state); |
908a0d7c MS |
225 | } |
226 | ||
2b48e113 NA |
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 | ||
4781646c MCC |
307 | /** |
308 | * v4l2_m2m_reqbufs() - multi-queue-aware REQBUFS multiplexer | |
dcbd8735 MCC |
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 | |
4781646c | 313 | */ |
7f98639d PO |
314 | int v4l2_m2m_reqbufs(struct file *file, struct v4l2_m2m_ctx *m2m_ctx, |
315 | struct v4l2_requestbuffers *reqbufs); | |
316 | ||
4781646c MCC |
317 | /** |
318 | * v4l2_m2m_querybuf() - multi-queue-aware QUERYBUF multiplexer | |
319 | * | |
dcbd8735 MCC |
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 | * | |
4781646c MCC |
324 | * See v4l2_m2m_mmap() documentation for details. |
325 | */ | |
7f98639d PO |
326 | int v4l2_m2m_querybuf(struct file *file, struct v4l2_m2m_ctx *m2m_ctx, |
327 | struct v4l2_buffer *buf); | |
328 | ||
4781646c MCC |
329 | /** |
330 | * v4l2_m2m_qbuf() - enqueue a source or destination buffer, depending on | |
331 | * the type | |
dcbd8735 MCC |
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 | |
4781646c | 336 | */ |
7f98639d PO |
337 | int v4l2_m2m_qbuf(struct file *file, struct v4l2_m2m_ctx *m2m_ctx, |
338 | struct v4l2_buffer *buf); | |
4781646c MCC |
339 | |
340 | /** | |
341 | * v4l2_m2m_dqbuf() - dequeue a source or destination buffer, depending on | |
342 | * the type | |
dcbd8735 MCC |
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 | |
4781646c | 347 | */ |
7f98639d PO |
348 | int v4l2_m2m_dqbuf(struct file *file, struct v4l2_m2m_ctx *m2m_ctx, |
349 | struct v4l2_buffer *buf); | |
4781646c MCC |
350 | |
351 | /** | |
352 | * v4l2_m2m_prepare_buf() - prepare a source or destination buffer, depending on | |
353 | * the type | |
dcbd8735 MCC |
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 | |
4781646c | 358 | */ |
e68cf471 HV |
359 | int v4l2_m2m_prepare_buf(struct file *file, struct v4l2_m2m_ctx *m2m_ctx, |
360 | struct v4l2_buffer *buf); | |
4781646c MCC |
361 | |
362 | /** | |
363 | * v4l2_m2m_create_bufs() - create a source or destination buffer, depending | |
364 | * on the type | |
dcbd8735 MCC |
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 | |
4781646c | 369 | */ |
8b94ca61 PZ |
370 | int v4l2_m2m_create_bufs(struct file *file, struct v4l2_m2m_ctx *m2m_ctx, |
371 | struct v4l2_create_buffers *create); | |
7f98639d | 372 | |
4781646c MCC |
373 | /** |
374 | * v4l2_m2m_expbuf() - export a source or destination buffer, depending on | |
375 | * the type | |
dcbd8735 MCC |
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 | |
4781646c | 380 | */ |
83ae7c5a TS |
381 | int v4l2_m2m_expbuf(struct file *file, struct v4l2_m2m_ctx *m2m_ctx, |
382 | struct v4l2_exportbuffer *eb); | |
383 | ||
4781646c MCC |
384 | /** |
385 | * v4l2_m2m_streamon() - turn on streaming for a video queue | |
dcbd8735 MCC |
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 | |
4781646c | 390 | */ |
7f98639d PO |
391 | int v4l2_m2m_streamon(struct file *file, struct v4l2_m2m_ctx *m2m_ctx, |
392 | enum v4l2_buf_type type); | |
4781646c MCC |
393 | |
394 | /** | |
395 | * v4l2_m2m_streamoff() - turn off streaming for a video queue | |
dcbd8735 MCC |
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 | |
4781646c | 400 | */ |
7f98639d PO |
401 | int v4l2_m2m_streamoff(struct file *file, struct v4l2_m2m_ctx *m2m_ctx, |
402 | enum v4l2_buf_type type); | |
403 | ||
2b48e113 NA |
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 | ||
4781646c MCC |
444 | /** |
445 | * v4l2_m2m_poll() - poll replacement, for destination buffers only | |
446 | * | |
dcbd8735 MCC |
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 | * | |
4781646c MCC |
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 | */ | |
c23e0cb8 | 456 | __poll_t v4l2_m2m_poll(struct file *file, struct v4l2_m2m_ctx *m2m_ctx, |
7f98639d PO |
457 | struct poll_table_struct *wait); |
458 | ||
4781646c MCC |
459 | /** |
460 | * v4l2_m2m_mmap() - source and destination queues-aware mmap multiplexer | |
461 | * | |
dcbd8735 MCC |
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 | * | |
4781646c MCC |
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 | */ | |
7f98639d PO |
473 | int v4l2_m2m_mmap(struct file *file, struct v4l2_m2m_ctx *m2m_ctx, |
474 | struct vm_area_struct *vma); | |
475 | ||
4781646c MCC |
476 | /** |
477 | * v4l2_m2m_init() - initialize per-driver m2m data | |
478 | * | |
dcbd8735 MCC |
479 | * @m2m_ops: pointer to struct v4l2_m2m_ops |
480 | * | |
5fa5edbe MCC |
481 | * Usually called from driver's ``probe()`` function. |
482 | * | |
483 | * Return: returns an opaque pointer to the internal data to handle M2M context | |
4781646c | 484 | */ |
b1252eb8 | 485 | struct v4l2_m2m_dev *v4l2_m2m_init(const struct v4l2_m2m_ops *m2m_ops); |
4781646c | 486 | |
be2fff65 EG |
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 | ||
4781646c MCC |
505 | /** |
506 | * v4l2_m2m_release() - cleans up and frees a m2m_dev structure | |
507 | * | |
9f8d3a2e | 508 | * @m2m_dev: opaque pointer to the internal data to handle M2M context |
dcbd8735 | 509 | * |
5fa5edbe | 510 | * Usually called from driver's ``remove()`` function. |
4781646c | 511 | */ |
7f98639d PO |
512 | void v4l2_m2m_release(struct v4l2_m2m_dev *m2m_dev); |
513 | ||
4781646c MCC |
514 | /** |
515 | * v4l2_m2m_ctx_init() - allocate and initialize a m2m context | |
dcbd8735 | 516 | * |
9f8d3a2e | 517 | * @m2m_dev: opaque pointer to the internal data to handle M2M context |
dcbd8735 MCC |
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 | |
4781646c | 521 | * |
5fa5edbe | 522 | * Usually called from driver's ``open()`` function. |
4781646c | 523 | */ |
908a0d7c MS |
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 | ||
33bdd5a8 PZ |
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 | ||
4781646c MCC |
540 | /** |
541 | * v4l2_m2m_ctx_release() - release m2m context | |
542 | * | |
dcbd8735 MCC |
543 | * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx |
544 | * | |
4781646c MCC |
545 | * Usually called from driver's release() function. |
546 | */ | |
7f98639d PO |
547 | void v4l2_m2m_ctx_release(struct v4l2_m2m_ctx *m2m_ctx); |
548 | ||
4781646c MCC |
549 | /** |
550 | * v4l2_m2m_buf_queue() - add a buffer to the proper ready buffers list. | |
551 | * | |
dcbd8735 MCC |
552 | * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx |
553 | * @vbuf: pointer to struct &vb2_v4l2_buffer | |
554 | * | |
5fa5edbe | 555 | * Call from videobuf_queue_ops->ops->buf_queue, videobuf_queue_ops callback. |
4781646c | 556 | */ |
2d700715 JS |
557 | void v4l2_m2m_buf_queue(struct v4l2_m2m_ctx *m2m_ctx, |
558 | struct vb2_v4l2_buffer *vbuf); | |
7f98639d PO |
559 | |
560 | /** | |
561 | * v4l2_m2m_num_src_bufs_ready() - return the number of source buffers ready for | |
562 | * use | |
62c0d016 | 563 | * |
dcbd8735 | 564 | * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx |
7f98639d PO |
565 | */ |
566 | static inline | |
567 | unsigned int v4l2_m2m_num_src_bufs_ready(struct v4l2_m2m_ctx *m2m_ctx) | |
568 | { | |
961ae449 | 569 | return m2m_ctx->out_q_ctx.num_rdy; |
7f98639d PO |
570 | } |
571 | ||
572 | /** | |
e383ce07 | 573 | * v4l2_m2m_num_dst_bufs_ready() - return the number of destination buffers |
7f98639d | 574 | * ready for use |
62c0d016 | 575 | * |
dcbd8735 | 576 | * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx |
7f98639d PO |
577 | */ |
578 | static inline | |
579 | unsigned int v4l2_m2m_num_dst_bufs_ready(struct v4l2_m2m_ctx *m2m_ctx) | |
580 | { | |
961ae449 | 581 | return m2m_ctx->cap_q_ctx.num_rdy; |
7f98639d PO |
582 | } |
583 | ||
4781646c MCC |
584 | /** |
585 | * v4l2_m2m_next_buf() - return next buffer from the list of ready buffers | |
dcbd8735 MCC |
586 | * |
587 | * @q_ctx: pointer to struct @v4l2_m2m_queue_ctx | |
4781646c | 588 | */ |
8dd22b28 | 589 | struct vb2_v4l2_buffer *v4l2_m2m_next_buf(struct v4l2_m2m_queue_ctx *q_ctx); |
7f98639d PO |
590 | |
591 | /** | |
592 | * v4l2_m2m_next_src_buf() - return next source buffer from the list of ready | |
593 | * buffers | |
62c0d016 | 594 | * |
dcbd8735 | 595 | * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx |
7f98639d | 596 | */ |
8dd22b28 EG |
597 | static inline struct vb2_v4l2_buffer * |
598 | v4l2_m2m_next_src_buf(struct v4l2_m2m_ctx *m2m_ctx) | |
7f98639d | 599 | { |
908a0d7c | 600 | return v4l2_m2m_next_buf(&m2m_ctx->out_q_ctx); |
7f98639d PO |
601 | } |
602 | ||
603 | /** | |
604 | * v4l2_m2m_next_dst_buf() - return next destination buffer from the list of | |
605 | * ready buffers | |
62c0d016 | 606 | * |
dcbd8735 | 607 | * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx |
7f98639d | 608 | */ |
8dd22b28 EG |
609 | static inline struct vb2_v4l2_buffer * |
610 | v4l2_m2m_next_dst_buf(struct v4l2_m2m_ctx *m2m_ctx) | |
7f98639d | 611 | { |
908a0d7c | 612 | return v4l2_m2m_next_buf(&m2m_ctx->cap_q_ctx); |
7f98639d PO |
613 | } |
614 | ||
ee1228cc HV |
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 | */ | |
8dd22b28 | 620 | struct vb2_v4l2_buffer *v4l2_m2m_last_buf(struct v4l2_m2m_queue_ctx *q_ctx); |
ee1228cc HV |
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 | */ | |
8dd22b28 EG |
628 | static inline struct vb2_v4l2_buffer * |
629 | v4l2_m2m_last_src_buf(struct v4l2_m2m_ctx *m2m_ctx) | |
ee1228cc HV |
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 | */ | |
8dd22b28 EG |
640 | static inline struct vb2_v4l2_buffer * |
641 | v4l2_m2m_last_dst_buf(struct v4l2_m2m_ctx *m2m_ctx) | |
ee1228cc HV |
642 | { |
643 | return v4l2_m2m_last_buf(&m2m_ctx->cap_q_ctx); | |
644 | } | |
645 | ||
d4987564 SV |
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 | ||
7f98639d | 687 | /** |
908a0d7c | 688 | * v4l2_m2m_get_src_vq() - return vb2_queue for source buffers |
62c0d016 | 689 | * |
dcbd8735 | 690 | * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx |
7f98639d PO |
691 | */ |
692 | static inline | |
908a0d7c | 693 | struct vb2_queue *v4l2_m2m_get_src_vq(struct v4l2_m2m_ctx *m2m_ctx) |
7f98639d | 694 | { |
908a0d7c | 695 | return &m2m_ctx->out_q_ctx.q; |
7f98639d PO |
696 | } |
697 | ||
698 | /** | |
908a0d7c | 699 | * v4l2_m2m_get_dst_vq() - return vb2_queue for destination buffers |
62c0d016 | 700 | * |
dcbd8735 | 701 | * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx |
7f98639d PO |
702 | */ |
703 | static inline | |
908a0d7c | 704 | struct vb2_queue *v4l2_m2m_get_dst_vq(struct v4l2_m2m_ctx *m2m_ctx) |
7f98639d | 705 | { |
908a0d7c | 706 | return &m2m_ctx->cap_q_ctx.q; |
7f98639d PO |
707 | } |
708 | ||
4781646c MCC |
709 | /** |
710 | * v4l2_m2m_buf_remove() - take off a buffer from the list of ready buffers and | |
711 | * return it | |
dcbd8735 MCC |
712 | * |
713 | * @q_ctx: pointer to struct @v4l2_m2m_queue_ctx | |
4781646c | 714 | */ |
8dd22b28 | 715 | struct vb2_v4l2_buffer *v4l2_m2m_buf_remove(struct v4l2_m2m_queue_ctx *q_ctx); |
7f98639d PO |
716 | |
717 | /** | |
718 | * v4l2_m2m_src_buf_remove() - take off a source buffer from the list of ready | |
719 | * buffers and return it | |
62c0d016 | 720 | * |
dcbd8735 | 721 | * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx |
7f98639d | 722 | */ |
8dd22b28 EG |
723 | static inline struct vb2_v4l2_buffer * |
724 | v4l2_m2m_src_buf_remove(struct v4l2_m2m_ctx *m2m_ctx) | |
7f98639d | 725 | { |
908a0d7c | 726 | return v4l2_m2m_buf_remove(&m2m_ctx->out_q_ctx); |
7f98639d PO |
727 | } |
728 | ||
729 | /** | |
730 | * v4l2_m2m_dst_buf_remove() - take off a destination buffer from the list of | |
731 | * ready buffers and return it | |
62c0d016 | 732 | * |
dcbd8735 | 733 | * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx |
7f98639d | 734 | */ |
8dd22b28 EG |
735 | static inline struct vb2_v4l2_buffer * |
736 | v4l2_m2m_dst_buf_remove(struct v4l2_m2m_ctx *m2m_ctx) | |
7f98639d | 737 | { |
908a0d7c | 738 | return v4l2_m2m_buf_remove(&m2m_ctx->cap_q_ctx); |
7f98639d PO |
739 | } |
740 | ||
d4987564 SV |
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 | ||
e2d8ffe2 | 792 | /** |
a4d3d612 EG |
793 | * v4l2_m2m_buf_copy_metadata() - copy buffer metadata from |
794 | * the output buffer to the capture buffer | |
e2d8ffe2 | 795 | * |
a4d3d612 EG |
796 | * @out_vb: the output buffer that is the source of the metadata. |
797 | * @cap_vb: the capture buffer that will receive the metadata. | |
e2d8ffe2 HV |
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 | */ | |
a4d3d612 EG |
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); | |
e2d8ffe2 | 811 | |
803a7ab7 HV |
812 | /* v4l2 request helper */ |
813 | ||
ef86eaf9 | 814 | void v4l2_m2m_request_queue(struct media_request *req); |
803a7ab7 | 815 | |
8e6e8f93 SN |
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); | |
e68cf471 HV |
830 | int v4l2_m2m_ioctl_prepare_buf(struct file *file, void *fh, |
831 | struct v4l2_buffer *buf); | |
8e6e8f93 SN |
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); | |
2b48e113 NA |
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); | |
ef732d5e HV |
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); | |
bef41d93 JS |
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); | |
8e6e8f93 | 848 | int v4l2_m2m_fop_mmap(struct file *file, struct vm_area_struct *vma); |
c23e0cb8 | 849 | __poll_t v4l2_m2m_fop_poll(struct file *file, poll_table *wait); |
8e6e8f93 | 850 | |
7f98639d PO |
851 | #endif /* _MEDIA_V4L2_MEM2MEM_H */ |
852 |