]>
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 | ||
911ea8ec PHS |
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 | ||
4781646c MCC |
329 | /** |
330 | * v4l2_m2m_reqbufs() - multi-queue-aware REQBUFS multiplexer | |
dcbd8735 MCC |
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 | |
4781646c | 335 | */ |
7f98639d PO |
336 | int v4l2_m2m_reqbufs(struct file *file, struct v4l2_m2m_ctx *m2m_ctx, |
337 | struct v4l2_requestbuffers *reqbufs); | |
338 | ||
4781646c MCC |
339 | /** |
340 | * v4l2_m2m_querybuf() - multi-queue-aware QUERYBUF multiplexer | |
341 | * | |
dcbd8735 MCC |
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 | * | |
4781646c MCC |
346 | * See v4l2_m2m_mmap() documentation for details. |
347 | */ | |
7f98639d PO |
348 | int v4l2_m2m_querybuf(struct file *file, struct v4l2_m2m_ctx *m2m_ctx, |
349 | struct v4l2_buffer *buf); | |
350 | ||
4781646c MCC |
351 | /** |
352 | * v4l2_m2m_qbuf() - enqueue 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 | */ |
7f98639d PO |
359 | int v4l2_m2m_qbuf(struct file *file, struct v4l2_m2m_ctx *m2m_ctx, |
360 | struct v4l2_buffer *buf); | |
4781646c MCC |
361 | |
362 | /** | |
363 | * v4l2_m2m_dqbuf() - dequeue a source or destination buffer, depending on | |
364 | * 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 | * @buf: pointer to struct &v4l2_buffer | |
4781646c | 369 | */ |
7f98639d PO |
370 | int v4l2_m2m_dqbuf(struct file *file, struct v4l2_m2m_ctx *m2m_ctx, |
371 | struct v4l2_buffer *buf); | |
4781646c MCC |
372 | |
373 | /** | |
374 | * v4l2_m2m_prepare_buf() - prepare 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 | * @buf: pointer to struct &v4l2_buffer | |
4781646c | 380 | */ |
e68cf471 HV |
381 | int v4l2_m2m_prepare_buf(struct file *file, struct v4l2_m2m_ctx *m2m_ctx, |
382 | struct v4l2_buffer *buf); | |
4781646c MCC |
383 | |
384 | /** | |
385 | * v4l2_m2m_create_bufs() - create a source or destination buffer, depending | |
386 | * on the type | |
dcbd8735 MCC |
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 | |
4781646c | 391 | */ |
8b94ca61 PZ |
392 | int v4l2_m2m_create_bufs(struct file *file, struct v4l2_m2m_ctx *m2m_ctx, |
393 | struct v4l2_create_buffers *create); | |
7f98639d | 394 | |
4781646c MCC |
395 | /** |
396 | * v4l2_m2m_expbuf() - export a source or destination buffer, depending on | |
397 | * the type | |
dcbd8735 MCC |
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 | |
4781646c | 402 | */ |
83ae7c5a TS |
403 | int v4l2_m2m_expbuf(struct file *file, struct v4l2_m2m_ctx *m2m_ctx, |
404 | struct v4l2_exportbuffer *eb); | |
405 | ||
4781646c MCC |
406 | /** |
407 | * v4l2_m2m_streamon() - turn on streaming for a video queue | |
dcbd8735 MCC |
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 | |
4781646c | 412 | */ |
7f98639d PO |
413 | int v4l2_m2m_streamon(struct file *file, struct v4l2_m2m_ctx *m2m_ctx, |
414 | enum v4l2_buf_type type); | |
4781646c MCC |
415 | |
416 | /** | |
417 | * v4l2_m2m_streamoff() - turn off streaming for a video queue | |
dcbd8735 MCC |
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 | |
4781646c | 422 | */ |
7f98639d PO |
423 | int v4l2_m2m_streamoff(struct file *file, struct v4l2_m2m_ctx *m2m_ctx, |
424 | enum v4l2_buf_type type); | |
425 | ||
2b48e113 NA |
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 | ||
4781646c MCC |
466 | /** |
467 | * v4l2_m2m_poll() - poll replacement, for destination buffers only | |
468 | * | |
dcbd8735 MCC |
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 | * | |
4781646c MCC |
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 | */ | |
c23e0cb8 | 478 | __poll_t v4l2_m2m_poll(struct file *file, struct v4l2_m2m_ctx *m2m_ctx, |
7f98639d PO |
479 | struct poll_table_struct *wait); |
480 | ||
4781646c MCC |
481 | /** |
482 | * v4l2_m2m_mmap() - source and destination queues-aware mmap multiplexer | |
483 | * | |
dcbd8735 MCC |
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 | * | |
4781646c MCC |
488 | * Call from driver's mmap() function. Will handle mmap() for both queues |
489 | * seamlessly for videobuffer, which will receive normal per-queue offsets and | |
490 | * proper videobuf queue pointers. The differentiation is made outside videobuf | |
491 | * by adding a predefined offset to buffers from one of the queues and | |
492 | * subtracting it before passing it back to videobuf. Only drivers (and | |
493 | * thus applications) receive modified offsets. | |
494 | */ | |
7f98639d PO |
495 | int v4l2_m2m_mmap(struct file *file, struct v4l2_m2m_ctx *m2m_ctx, |
496 | struct vm_area_struct *vma); | |
497 | ||
4781646c MCC |
498 | /** |
499 | * v4l2_m2m_init() - initialize per-driver m2m data | |
500 | * | |
dcbd8735 MCC |
501 | * @m2m_ops: pointer to struct v4l2_m2m_ops |
502 | * | |
5fa5edbe MCC |
503 | * Usually called from driver's ``probe()`` function. |
504 | * | |
505 | * Return: returns an opaque pointer to the internal data to handle M2M context | |
4781646c | 506 | */ |
b1252eb8 | 507 | struct v4l2_m2m_dev *v4l2_m2m_init(const struct v4l2_m2m_ops *m2m_ops); |
4781646c | 508 | |
be2fff65 EG |
509 | #if defined(CONFIG_MEDIA_CONTROLLER) |
510 | void v4l2_m2m_unregister_media_controller(struct v4l2_m2m_dev *m2m_dev); | |
511 | int v4l2_m2m_register_media_controller(struct v4l2_m2m_dev *m2m_dev, | |
512 | struct video_device *vdev, int function); | |
513 | #else | |
514 | static inline void | |
515 | v4l2_m2m_unregister_media_controller(struct v4l2_m2m_dev *m2m_dev) | |
516 | { | |
517 | } | |
518 | ||
519 | static inline int | |
520 | v4l2_m2m_register_media_controller(struct v4l2_m2m_dev *m2m_dev, | |
521 | struct video_device *vdev, int function) | |
522 | { | |
523 | return 0; | |
524 | } | |
525 | #endif | |
526 | ||
4781646c MCC |
527 | /** |
528 | * v4l2_m2m_release() - cleans up and frees a m2m_dev structure | |
529 | * | |
9f8d3a2e | 530 | * @m2m_dev: opaque pointer to the internal data to handle M2M context |
dcbd8735 | 531 | * |
5fa5edbe | 532 | * Usually called from driver's ``remove()`` function. |
4781646c | 533 | */ |
7f98639d PO |
534 | void v4l2_m2m_release(struct v4l2_m2m_dev *m2m_dev); |
535 | ||
4781646c MCC |
536 | /** |
537 | * v4l2_m2m_ctx_init() - allocate and initialize a m2m context | |
dcbd8735 | 538 | * |
9f8d3a2e | 539 | * @m2m_dev: opaque pointer to the internal data to handle M2M context |
dcbd8735 MCC |
540 | * @drv_priv: driver's instance private data |
541 | * @queue_init: a callback for queue type-specific initialization function | |
542 | * to be used for initializing videobuf_queues | |
4781646c | 543 | * |
5fa5edbe | 544 | * Usually called from driver's ``open()`` function. |
4781646c | 545 | */ |
908a0d7c MS |
546 | struct v4l2_m2m_ctx *v4l2_m2m_ctx_init(struct v4l2_m2m_dev *m2m_dev, |
547 | void *drv_priv, | |
548 | int (*queue_init)(void *priv, struct vb2_queue *src_vq, struct vb2_queue *dst_vq)); | |
549 | ||
33bdd5a8 PZ |
550 | static inline void v4l2_m2m_set_src_buffered(struct v4l2_m2m_ctx *m2m_ctx, |
551 | bool buffered) | |
552 | { | |
553 | m2m_ctx->out_q_ctx.buffered = buffered; | |
554 | } | |
555 | ||
556 | static inline void v4l2_m2m_set_dst_buffered(struct v4l2_m2m_ctx *m2m_ctx, | |
557 | bool buffered) | |
558 | { | |
559 | m2m_ctx->cap_q_ctx.buffered = buffered; | |
560 | } | |
561 | ||
4781646c MCC |
562 | /** |
563 | * v4l2_m2m_ctx_release() - release m2m context | |
564 | * | |
dcbd8735 MCC |
565 | * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx |
566 | * | |
4781646c MCC |
567 | * Usually called from driver's release() function. |
568 | */ | |
7f98639d PO |
569 | void v4l2_m2m_ctx_release(struct v4l2_m2m_ctx *m2m_ctx); |
570 | ||
4781646c MCC |
571 | /** |
572 | * v4l2_m2m_buf_queue() - add a buffer to the proper ready buffers list. | |
573 | * | |
dcbd8735 MCC |
574 | * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx |
575 | * @vbuf: pointer to struct &vb2_v4l2_buffer | |
576 | * | |
5fa5edbe | 577 | * Call from videobuf_queue_ops->ops->buf_queue, videobuf_queue_ops callback. |
4781646c | 578 | */ |
2d700715 JS |
579 | void v4l2_m2m_buf_queue(struct v4l2_m2m_ctx *m2m_ctx, |
580 | struct vb2_v4l2_buffer *vbuf); | |
7f98639d PO |
581 | |
582 | /** | |
583 | * v4l2_m2m_num_src_bufs_ready() - return the number of source buffers ready for | |
584 | * use | |
62c0d016 | 585 | * |
dcbd8735 | 586 | * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx |
7f98639d PO |
587 | */ |
588 | static inline | |
589 | unsigned int v4l2_m2m_num_src_bufs_ready(struct v4l2_m2m_ctx *m2m_ctx) | |
590 | { | |
961ae449 | 591 | return m2m_ctx->out_q_ctx.num_rdy; |
7f98639d PO |
592 | } |
593 | ||
594 | /** | |
e383ce07 | 595 | * v4l2_m2m_num_dst_bufs_ready() - return the number of destination buffers |
7f98639d | 596 | * ready for use |
62c0d016 | 597 | * |
dcbd8735 | 598 | * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx |
7f98639d PO |
599 | */ |
600 | static inline | |
601 | unsigned int v4l2_m2m_num_dst_bufs_ready(struct v4l2_m2m_ctx *m2m_ctx) | |
602 | { | |
961ae449 | 603 | return m2m_ctx->cap_q_ctx.num_rdy; |
7f98639d PO |
604 | } |
605 | ||
4781646c MCC |
606 | /** |
607 | * v4l2_m2m_next_buf() - return next buffer from the list of ready buffers | |
dcbd8735 MCC |
608 | * |
609 | * @q_ctx: pointer to struct @v4l2_m2m_queue_ctx | |
4781646c | 610 | */ |
8dd22b28 | 611 | struct vb2_v4l2_buffer *v4l2_m2m_next_buf(struct v4l2_m2m_queue_ctx *q_ctx); |
7f98639d PO |
612 | |
613 | /** | |
614 | * v4l2_m2m_next_src_buf() - return next source buffer from the list of ready | |
615 | * buffers | |
62c0d016 | 616 | * |
dcbd8735 | 617 | * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx |
7f98639d | 618 | */ |
8dd22b28 EG |
619 | static inline struct vb2_v4l2_buffer * |
620 | v4l2_m2m_next_src_buf(struct v4l2_m2m_ctx *m2m_ctx) | |
7f98639d | 621 | { |
908a0d7c | 622 | return v4l2_m2m_next_buf(&m2m_ctx->out_q_ctx); |
7f98639d PO |
623 | } |
624 | ||
625 | /** | |
626 | * v4l2_m2m_next_dst_buf() - return next destination buffer from the list of | |
627 | * ready buffers | |
62c0d016 | 628 | * |
dcbd8735 | 629 | * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx |
7f98639d | 630 | */ |
8dd22b28 EG |
631 | static inline struct vb2_v4l2_buffer * |
632 | v4l2_m2m_next_dst_buf(struct v4l2_m2m_ctx *m2m_ctx) | |
7f98639d | 633 | { |
908a0d7c | 634 | return v4l2_m2m_next_buf(&m2m_ctx->cap_q_ctx); |
7f98639d PO |
635 | } |
636 | ||
ee1228cc HV |
637 | /** |
638 | * v4l2_m2m_last_buf() - return last buffer from the list of ready buffers | |
639 | * | |
640 | * @q_ctx: pointer to struct @v4l2_m2m_queue_ctx | |
641 | */ | |
8dd22b28 | 642 | struct vb2_v4l2_buffer *v4l2_m2m_last_buf(struct v4l2_m2m_queue_ctx *q_ctx); |
ee1228cc HV |
643 | |
644 | /** | |
645 | * v4l2_m2m_last_src_buf() - return last 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 | */ | |
8dd22b28 EG |
650 | static inline struct vb2_v4l2_buffer * |
651 | v4l2_m2m_last_src_buf(struct v4l2_m2m_ctx *m2m_ctx) | |
ee1228cc HV |
652 | { |
653 | return v4l2_m2m_last_buf(&m2m_ctx->out_q_ctx); | |
654 | } | |
655 | ||
656 | /** | |
657 | * v4l2_m2m_last_dst_buf() - return last destination buffer from the list of | |
658 | * ready buffers | |
659 | * | |
660 | * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx | |
661 | */ | |
8dd22b28 EG |
662 | static inline struct vb2_v4l2_buffer * |
663 | v4l2_m2m_last_dst_buf(struct v4l2_m2m_ctx *m2m_ctx) | |
ee1228cc HV |
664 | { |
665 | return v4l2_m2m_last_buf(&m2m_ctx->cap_q_ctx); | |
666 | } | |
667 | ||
d4987564 SV |
668 | /** |
669 | * v4l2_m2m_for_each_dst_buf() - iterate over a list of destination ready | |
670 | * buffers | |
671 | * | |
672 | * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx | |
673 | * @b: current buffer of type struct v4l2_m2m_buffer | |
674 | */ | |
675 | #define v4l2_m2m_for_each_dst_buf(m2m_ctx, b) \ | |
676 | list_for_each_entry(b, &m2m_ctx->cap_q_ctx.rdy_queue, list) | |
677 | ||
678 | /** | |
679 | * v4l2_m2m_for_each_src_buf() - iterate over a list of source ready buffers | |
680 | * | |
681 | * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx | |
682 | * @b: current buffer of type struct v4l2_m2m_buffer | |
683 | */ | |
684 | #define v4l2_m2m_for_each_src_buf(m2m_ctx, b) \ | |
685 | list_for_each_entry(b, &m2m_ctx->out_q_ctx.rdy_queue, list) | |
686 | ||
687 | /** | |
688 | * v4l2_m2m_for_each_dst_buf_safe() - iterate over a list of destination ready | |
689 | * buffers safely | |
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 | * @n: used as temporary storage | |
694 | */ | |
695 | #define v4l2_m2m_for_each_dst_buf_safe(m2m_ctx, b, n) \ | |
696 | list_for_each_entry_safe(b, n, &m2m_ctx->cap_q_ctx.rdy_queue, list) | |
697 | ||
698 | /** | |
699 | * v4l2_m2m_for_each_src_buf_safe() - iterate over a list of source ready | |
700 | * buffers safely | |
701 | * | |
702 | * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx | |
703 | * @b: current buffer of type struct v4l2_m2m_buffer | |
704 | * @n: used as temporary storage | |
705 | */ | |
706 | #define v4l2_m2m_for_each_src_buf_safe(m2m_ctx, b, n) \ | |
707 | list_for_each_entry_safe(b, n, &m2m_ctx->out_q_ctx.rdy_queue, list) | |
708 | ||
7f98639d | 709 | /** |
908a0d7c | 710 | * v4l2_m2m_get_src_vq() - return vb2_queue for source buffers |
62c0d016 | 711 | * |
dcbd8735 | 712 | * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx |
7f98639d PO |
713 | */ |
714 | static inline | |
908a0d7c | 715 | struct vb2_queue *v4l2_m2m_get_src_vq(struct v4l2_m2m_ctx *m2m_ctx) |
7f98639d | 716 | { |
908a0d7c | 717 | return &m2m_ctx->out_q_ctx.q; |
7f98639d PO |
718 | } |
719 | ||
720 | /** | |
908a0d7c | 721 | * v4l2_m2m_get_dst_vq() - return vb2_queue for destination buffers |
62c0d016 | 722 | * |
dcbd8735 | 723 | * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx |
7f98639d PO |
724 | */ |
725 | static inline | |
908a0d7c | 726 | struct vb2_queue *v4l2_m2m_get_dst_vq(struct v4l2_m2m_ctx *m2m_ctx) |
7f98639d | 727 | { |
908a0d7c | 728 | return &m2m_ctx->cap_q_ctx.q; |
7f98639d PO |
729 | } |
730 | ||
4781646c MCC |
731 | /** |
732 | * v4l2_m2m_buf_remove() - take off a buffer from the list of ready buffers and | |
733 | * return it | |
dcbd8735 MCC |
734 | * |
735 | * @q_ctx: pointer to struct @v4l2_m2m_queue_ctx | |
4781646c | 736 | */ |
8dd22b28 | 737 | struct vb2_v4l2_buffer *v4l2_m2m_buf_remove(struct v4l2_m2m_queue_ctx *q_ctx); |
7f98639d PO |
738 | |
739 | /** | |
740 | * v4l2_m2m_src_buf_remove() - take off a source buffer from the list of ready | |
741 | * buffers and return it | |
62c0d016 | 742 | * |
dcbd8735 | 743 | * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx |
7f98639d | 744 | */ |
8dd22b28 EG |
745 | static inline struct vb2_v4l2_buffer * |
746 | v4l2_m2m_src_buf_remove(struct v4l2_m2m_ctx *m2m_ctx) | |
7f98639d | 747 | { |
908a0d7c | 748 | return v4l2_m2m_buf_remove(&m2m_ctx->out_q_ctx); |
7f98639d PO |
749 | } |
750 | ||
751 | /** | |
752 | * v4l2_m2m_dst_buf_remove() - take off a destination buffer from the list of | |
753 | * ready buffers and return it | |
62c0d016 | 754 | * |
dcbd8735 | 755 | * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx |
7f98639d | 756 | */ |
8dd22b28 EG |
757 | static inline struct vb2_v4l2_buffer * |
758 | v4l2_m2m_dst_buf_remove(struct v4l2_m2m_ctx *m2m_ctx) | |
7f98639d | 759 | { |
908a0d7c | 760 | return v4l2_m2m_buf_remove(&m2m_ctx->cap_q_ctx); |
7f98639d PO |
761 | } |
762 | ||
d4987564 SV |
763 | /** |
764 | * v4l2_m2m_buf_remove_by_buf() - take off exact buffer from the list of ready | |
765 | * buffers | |
766 | * | |
767 | * @q_ctx: pointer to struct @v4l2_m2m_queue_ctx | |
768 | * @vbuf: the buffer to be removed | |
769 | */ | |
770 | void v4l2_m2m_buf_remove_by_buf(struct v4l2_m2m_queue_ctx *q_ctx, | |
771 | struct vb2_v4l2_buffer *vbuf); | |
772 | ||
773 | /** | |
774 | * v4l2_m2m_src_buf_remove_by_buf() - take off exact source buffer from the list | |
775 | * of ready buffers | |
776 | * | |
777 | * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx | |
778 | * @vbuf: the buffer to be removed | |
779 | */ | |
780 | static inline void v4l2_m2m_src_buf_remove_by_buf(struct v4l2_m2m_ctx *m2m_ctx, | |
781 | struct vb2_v4l2_buffer *vbuf) | |
782 | { | |
783 | v4l2_m2m_buf_remove_by_buf(&m2m_ctx->out_q_ctx, vbuf); | |
784 | } | |
785 | ||
786 | /** | |
787 | * v4l2_m2m_dst_buf_remove_by_buf() - take off exact destination buffer from the | |
788 | * list of ready buffers | |
789 | * | |
790 | * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx | |
791 | * @vbuf: the buffer to be removed | |
792 | */ | |
793 | static inline void v4l2_m2m_dst_buf_remove_by_buf(struct v4l2_m2m_ctx *m2m_ctx, | |
794 | struct vb2_v4l2_buffer *vbuf) | |
795 | { | |
796 | v4l2_m2m_buf_remove_by_buf(&m2m_ctx->cap_q_ctx, vbuf); | |
797 | } | |
798 | ||
799 | struct vb2_v4l2_buffer * | |
800 | v4l2_m2m_buf_remove_by_idx(struct v4l2_m2m_queue_ctx *q_ctx, unsigned int idx); | |
801 | ||
802 | static inline struct vb2_v4l2_buffer * | |
803 | v4l2_m2m_src_buf_remove_by_idx(struct v4l2_m2m_ctx *m2m_ctx, unsigned int idx) | |
804 | { | |
805 | return v4l2_m2m_buf_remove_by_idx(&m2m_ctx->out_q_ctx, idx); | |
806 | } | |
807 | ||
808 | static inline struct vb2_v4l2_buffer * | |
809 | v4l2_m2m_dst_buf_remove_by_idx(struct v4l2_m2m_ctx *m2m_ctx, unsigned int idx) | |
810 | { | |
811 | return v4l2_m2m_buf_remove_by_idx(&m2m_ctx->cap_q_ctx, idx); | |
812 | } | |
813 | ||
e2d8ffe2 | 814 | /** |
a4d3d612 EG |
815 | * v4l2_m2m_buf_copy_metadata() - copy buffer metadata from |
816 | * the output buffer to the capture buffer | |
e2d8ffe2 | 817 | * |
a4d3d612 EG |
818 | * @out_vb: the output buffer that is the source of the metadata. |
819 | * @cap_vb: the capture buffer that will receive the metadata. | |
e2d8ffe2 HV |
820 | * @copy_frame_flags: copy the KEY/B/PFRAME flags as well. |
821 | * | |
822 | * This helper function copies the timestamp, timecode (if the TIMECODE | |
823 | * buffer flag was set), field and the TIMECODE, KEYFRAME, BFRAME, PFRAME | |
824 | * and TSTAMP_SRC_MASK flags from @out_vb to @cap_vb. | |
825 | * | |
826 | * If @copy_frame_flags is false, then the KEYFRAME, BFRAME and PFRAME | |
827 | * flags are not copied. This is typically needed for encoders that | |
828 | * set this bits explicitly. | |
829 | */ | |
a4d3d612 EG |
830 | void v4l2_m2m_buf_copy_metadata(const struct vb2_v4l2_buffer *out_vb, |
831 | struct vb2_v4l2_buffer *cap_vb, | |
832 | bool copy_frame_flags); | |
e2d8ffe2 | 833 | |
803a7ab7 HV |
834 | /* v4l2 request helper */ |
835 | ||
ef86eaf9 | 836 | void v4l2_m2m_request_queue(struct media_request *req); |
803a7ab7 | 837 | |
8e6e8f93 SN |
838 | /* v4l2 ioctl helpers */ |
839 | ||
840 | int v4l2_m2m_ioctl_reqbufs(struct file *file, void *priv, | |
841 | struct v4l2_requestbuffers *rb); | |
842 | int v4l2_m2m_ioctl_create_bufs(struct file *file, void *fh, | |
843 | struct v4l2_create_buffers *create); | |
844 | int v4l2_m2m_ioctl_querybuf(struct file *file, void *fh, | |
845 | struct v4l2_buffer *buf); | |
846 | int v4l2_m2m_ioctl_expbuf(struct file *file, void *fh, | |
847 | struct v4l2_exportbuffer *eb); | |
848 | int v4l2_m2m_ioctl_qbuf(struct file *file, void *fh, | |
849 | struct v4l2_buffer *buf); | |
850 | int v4l2_m2m_ioctl_dqbuf(struct file *file, void *fh, | |
851 | struct v4l2_buffer *buf); | |
e68cf471 HV |
852 | int v4l2_m2m_ioctl_prepare_buf(struct file *file, void *fh, |
853 | struct v4l2_buffer *buf); | |
8e6e8f93 SN |
854 | int v4l2_m2m_ioctl_streamon(struct file *file, void *fh, |
855 | enum v4l2_buf_type type); | |
856 | int v4l2_m2m_ioctl_streamoff(struct file *file, void *fh, | |
857 | enum v4l2_buf_type type); | |
2b48e113 NA |
858 | int v4l2_m2m_ioctl_encoder_cmd(struct file *file, void *fh, |
859 | struct v4l2_encoder_cmd *ec); | |
860 | int v4l2_m2m_ioctl_decoder_cmd(struct file *file, void *fh, | |
861 | struct v4l2_decoder_cmd *dc); | |
ef732d5e HV |
862 | int v4l2_m2m_ioctl_try_encoder_cmd(struct file *file, void *fh, |
863 | struct v4l2_encoder_cmd *ec); | |
864 | int v4l2_m2m_ioctl_try_decoder_cmd(struct file *file, void *fh, | |
865 | struct v4l2_decoder_cmd *dc); | |
bef41d93 JS |
866 | int v4l2_m2m_ioctl_stateless_try_decoder_cmd(struct file *file, void *fh, |
867 | struct v4l2_decoder_cmd *dc); | |
868 | int v4l2_m2m_ioctl_stateless_decoder_cmd(struct file *file, void *priv, | |
869 | struct v4l2_decoder_cmd *dc); | |
8e6e8f93 | 870 | int v4l2_m2m_fop_mmap(struct file *file, struct vm_area_struct *vma); |
c23e0cb8 | 871 | __poll_t v4l2_m2m_fop_poll(struct file *file, poll_table *wait); |
8e6e8f93 | 872 | |
7f98639d PO |
873 | #endif /* _MEDIA_V4L2_MEM2MEM_H */ |
874 |