Pawel Osciak | 7f98639 | 2010-04-23 05:38:37 -0300 | [diff] [blame] | 1 | /* |
| 2 | * Memory-to-memory device framework for Video for Linux 2. |
| 3 | * |
| 4 | * Helper functions for devices that use memory buffers for both source |
| 5 | * and destination. |
| 6 | * |
| 7 | * Copyright (c) 2009 Samsung Electronics Co., Ltd. |
Pawel Osciak | 9507208 | 2011-03-13 15:23:32 -0300 | [diff] [blame] | 8 | * Pawel Osciak, <pawel@osciak.com> |
Pawel Osciak | 7f98639 | 2010-04-23 05:38:37 -0300 | [diff] [blame] | 9 | * Marek Szyprowski, <m.szyprowski@samsung.com> |
| 10 | * |
| 11 | * This program is free software; you can redistribute it and/or modify |
| 12 | * it under the terms of the GNU General Public License as published by the |
| 13 | * Free Software Foundation; either version 2 of the |
| 14 | * License, or (at your option) any later version |
| 15 | */ |
| 16 | |
| 17 | #ifndef _MEDIA_V4L2_MEM2MEM_H |
| 18 | #define _MEDIA_V4L2_MEM2MEM_H |
| 19 | |
Junghak Sung | c139990 | 2015-09-22 10:30:29 -0300 | [diff] [blame] | 20 | #include <media/videobuf2-v4l2.h> |
Pawel Osciak | 7f98639 | 2010-04-23 05:38:37 -0300 | [diff] [blame] | 21 | |
| 22 | /** |
| 23 | * struct v4l2_m2m_ops - mem-to-mem device driver callbacks |
| 24 | * @device_run: required. Begin the actual job (transaction) inside this |
| 25 | * callback. |
| 26 | * The job does NOT have to end before this callback returns |
| 27 | * (and it will be the usual case). When the job finishes, |
| 28 | * v4l2_m2m_job_finish() has to be called. |
| 29 | * @job_ready: optional. Should return 0 if the driver does not have a job |
| 30 | * fully prepared to run yet (i.e. it will not be able to finish a |
| 31 | * transaction without sleeping). If not provided, it will be |
| 32 | * assumed that one source and one destination buffer are all |
| 33 | * that is required for the driver to perform one full transaction. |
| 34 | * This method may not sleep. |
| 35 | * @job_abort: required. Informs the driver that it has to abort the currently |
| 36 | * running transaction as soon as possible (i.e. as soon as it can |
| 37 | * stop the device safely; e.g. in the next interrupt handler), |
| 38 | * even if the transaction would not have been finished by then. |
| 39 | * After the driver performs the necessary steps, it has to call |
| 40 | * v4l2_m2m_job_finish() (as if the transaction ended normally). |
| 41 | * This function does not have to (and will usually not) wait |
| 42 | * until the device enters a state when it can be stopped. |
Mauro Carvalho Chehab | 62c0d01 | 2015-08-22 05:34:40 -0300 | [diff] [blame] | 43 | * @lock: optional. Define a driver's own lock callback, instead of using |
| 44 | * m2m_ctx->q_lock. |
| 45 | * @unlock: optional. Define a driver's own unlock callback, instead of |
| 46 | * using m2m_ctx->q_lock. |
Pawel Osciak | 7f98639 | 2010-04-23 05:38:37 -0300 | [diff] [blame] | 47 | */ |
| 48 | struct v4l2_m2m_ops { |
| 49 | void (*device_run)(void *priv); |
| 50 | int (*job_ready)(void *priv); |
| 51 | void (*job_abort)(void *priv); |
Marek Szyprowski | 908a0d7 | 2011-01-12 06:50:24 -0300 | [diff] [blame] | 52 | void (*lock)(void *priv); |
| 53 | void (*unlock)(void *priv); |
Pawel Osciak | 7f98639 | 2010-04-23 05:38:37 -0300 | [diff] [blame] | 54 | }; |
| 55 | |
| 56 | struct v4l2_m2m_dev; |
| 57 | |
| 58 | struct v4l2_m2m_queue_ctx { |
| 59 | /* private: internal use only */ |
Marek Szyprowski | 908a0d7 | 2011-01-12 06:50:24 -0300 | [diff] [blame] | 60 | struct vb2_queue q; |
Pawel Osciak | 7f98639 | 2010-04-23 05:38:37 -0300 | [diff] [blame] | 61 | |
| 62 | /* Queue for buffers ready to be processed as soon as this |
| 63 | * instance receives access to the device */ |
| 64 | struct list_head rdy_queue; |
Marek Szyprowski | 908a0d7 | 2011-01-12 06:50:24 -0300 | [diff] [blame] | 65 | spinlock_t rdy_spinlock; |
Pawel Osciak | 7f98639 | 2010-04-23 05:38:37 -0300 | [diff] [blame] | 66 | u8 num_rdy; |
Philipp Zabel | 33bdd5a | 2013-06-03 04:23:48 -0300 | [diff] [blame] | 67 | bool buffered; |
Pawel Osciak | 7f98639 | 2010-04-23 05:38:37 -0300 | [diff] [blame] | 68 | }; |
| 69 | |
| 70 | struct v4l2_m2m_ctx { |
Sylwester Nawrocki | 8e6e8f9 | 2013-09-14 18:39:04 -0300 | [diff] [blame] | 71 | /* optional cap/out vb2 queues lock */ |
| 72 | struct mutex *q_lock; |
| 73 | |
Pawel Osciak | 7f98639 | 2010-04-23 05:38:37 -0300 | [diff] [blame] | 74 | /* private: internal use only */ |
| 75 | struct v4l2_m2m_dev *m2m_dev; |
| 76 | |
| 77 | /* Capture (output to memory) queue context */ |
| 78 | struct v4l2_m2m_queue_ctx cap_q_ctx; |
| 79 | |
| 80 | /* Output (input from memory) queue context */ |
| 81 | struct v4l2_m2m_queue_ctx out_q_ctx; |
| 82 | |
| 83 | /* For device job queue */ |
| 84 | struct list_head queue; |
| 85 | unsigned long job_flags; |
Marek Szyprowski | 908a0d7 | 2011-01-12 06:50:24 -0300 | [diff] [blame] | 86 | wait_queue_head_t finished; |
Pawel Osciak | 7f98639 | 2010-04-23 05:38:37 -0300 | [diff] [blame] | 87 | |
| 88 | /* Instance private data */ |
| 89 | void *priv; |
| 90 | }; |
| 91 | |
Marek Szyprowski | 908a0d7 | 2011-01-12 06:50:24 -0300 | [diff] [blame] | 92 | struct v4l2_m2m_buffer { |
Junghak Sung | 2d70071 | 2015-09-22 10:30:30 -0300 | [diff] [blame] | 93 | struct vb2_v4l2_buffer vb; |
Marek Szyprowski | 908a0d7 | 2011-01-12 06:50:24 -0300 | [diff] [blame] | 94 | struct list_head list; |
| 95 | }; |
| 96 | |
Mauro Carvalho Chehab | 4781646 | 2016-09-08 10:16:27 -0300 | [diff] [blame^] | 97 | /** |
| 98 | * v4l2_m2m_get_curr_priv() - return driver private data for the currently |
| 99 | * running instance or NULL if no instance is running |
| 100 | */ |
Pawel Osciak | 7f98639 | 2010-04-23 05:38:37 -0300 | [diff] [blame] | 101 | void *v4l2_m2m_get_curr_priv(struct v4l2_m2m_dev *m2m_dev); |
| 102 | |
Mauro Carvalho Chehab | 4781646 | 2016-09-08 10:16:27 -0300 | [diff] [blame^] | 103 | /** |
| 104 | * v4l2_m2m_get_vq() - return vb2_queue for the given type |
| 105 | */ |
Marek Szyprowski | 908a0d7 | 2011-01-12 06:50:24 -0300 | [diff] [blame] | 106 | struct vb2_queue *v4l2_m2m_get_vq(struct v4l2_m2m_ctx *m2m_ctx, |
Pawel Osciak | 7f98639 | 2010-04-23 05:38:37 -0300 | [diff] [blame] | 107 | enum v4l2_buf_type type); |
| 108 | |
Mauro Carvalho Chehab | 4781646 | 2016-09-08 10:16:27 -0300 | [diff] [blame^] | 109 | /** |
| 110 | * v4l2_m2m_try_schedule() - check whether an instance is ready to be added to |
| 111 | * the pending job queue and add it if so. |
| 112 | * @m2m_ctx: m2m context assigned to the instance to be checked |
| 113 | * |
| 114 | * There are three basic requirements an instance has to meet to be able to run: |
| 115 | * 1) at least one source buffer has to be queued, |
| 116 | * 2) at least one destination buffer has to be queued, |
| 117 | * 3) streaming has to be on. |
| 118 | * |
| 119 | * If a queue is buffered (for example a decoder hardware ringbuffer that has |
| 120 | * to be drained before doing streamoff), allow scheduling without v4l2 buffers |
| 121 | * on that queue. |
| 122 | * |
| 123 | * There may also be additional, custom requirements. In such case the driver |
| 124 | * should supply a custom callback (job_ready in v4l2_m2m_ops) that should |
| 125 | * return 1 if the instance is ready. |
| 126 | * An example of the above could be an instance that requires more than one |
| 127 | * src/dst buffer per transaction. |
| 128 | */ |
Michael Olbrich | 1190a41 | 2014-07-22 09:36:04 -0300 | [diff] [blame] | 129 | void v4l2_m2m_try_schedule(struct v4l2_m2m_ctx *m2m_ctx); |
| 130 | |
Mauro Carvalho Chehab | 4781646 | 2016-09-08 10:16:27 -0300 | [diff] [blame^] | 131 | /** |
| 132 | * v4l2_m2m_job_finish() - inform the framework that a job has been finished |
| 133 | * and have it clean up |
| 134 | * |
| 135 | * Called by a driver to yield back the device after it has finished with it. |
| 136 | * Should be called as soon as possible after reaching a state which allows |
| 137 | * other instances to take control of the device. |
| 138 | * |
| 139 | * This function has to be called only after device_run() callback has been |
| 140 | * called on the driver. To prevent recursion, it should not be called directly |
| 141 | * from the device_run() callback though. |
| 142 | */ |
Pawel Osciak | 7f98639 | 2010-04-23 05:38:37 -0300 | [diff] [blame] | 143 | void v4l2_m2m_job_finish(struct v4l2_m2m_dev *m2m_dev, |
| 144 | struct v4l2_m2m_ctx *m2m_ctx); |
| 145 | |
Marek Szyprowski | 908a0d7 | 2011-01-12 06:50:24 -0300 | [diff] [blame] | 146 | static inline void |
Junghak Sung | 2d70071 | 2015-09-22 10:30:30 -0300 | [diff] [blame] | 147 | v4l2_m2m_buf_done(struct vb2_v4l2_buffer *buf, enum vb2_buffer_state state) |
Marek Szyprowski | 908a0d7 | 2011-01-12 06:50:24 -0300 | [diff] [blame] | 148 | { |
Junghak Sung | 2d70071 | 2015-09-22 10:30:30 -0300 | [diff] [blame] | 149 | vb2_buffer_done(&buf->vb2_buf, state); |
Marek Szyprowski | 908a0d7 | 2011-01-12 06:50:24 -0300 | [diff] [blame] | 150 | } |
| 151 | |
Mauro Carvalho Chehab | 4781646 | 2016-09-08 10:16:27 -0300 | [diff] [blame^] | 152 | /** |
| 153 | * v4l2_m2m_reqbufs() - multi-queue-aware REQBUFS multiplexer |
| 154 | */ |
Pawel Osciak | 7f98639 | 2010-04-23 05:38:37 -0300 | [diff] [blame] | 155 | int v4l2_m2m_reqbufs(struct file *file, struct v4l2_m2m_ctx *m2m_ctx, |
| 156 | struct v4l2_requestbuffers *reqbufs); |
| 157 | |
Mauro Carvalho Chehab | 4781646 | 2016-09-08 10:16:27 -0300 | [diff] [blame^] | 158 | /** |
| 159 | * v4l2_m2m_querybuf() - multi-queue-aware QUERYBUF multiplexer |
| 160 | * |
| 161 | * See v4l2_m2m_mmap() documentation for details. |
| 162 | */ |
Pawel Osciak | 7f98639 | 2010-04-23 05:38:37 -0300 | [diff] [blame] | 163 | int v4l2_m2m_querybuf(struct file *file, struct v4l2_m2m_ctx *m2m_ctx, |
| 164 | struct v4l2_buffer *buf); |
| 165 | |
Mauro Carvalho Chehab | 4781646 | 2016-09-08 10:16:27 -0300 | [diff] [blame^] | 166 | /** |
| 167 | * v4l2_m2m_qbuf() - enqueue a source or destination buffer, depending on |
| 168 | * the type |
| 169 | */ |
Pawel Osciak | 7f98639 | 2010-04-23 05:38:37 -0300 | [diff] [blame] | 170 | int v4l2_m2m_qbuf(struct file *file, struct v4l2_m2m_ctx *m2m_ctx, |
| 171 | struct v4l2_buffer *buf); |
Mauro Carvalho Chehab | 4781646 | 2016-09-08 10:16:27 -0300 | [diff] [blame^] | 172 | |
| 173 | /** |
| 174 | * v4l2_m2m_dqbuf() - dequeue a source or destination buffer, depending on |
| 175 | * the type |
| 176 | */ |
Pawel Osciak | 7f98639 | 2010-04-23 05:38:37 -0300 | [diff] [blame] | 177 | int v4l2_m2m_dqbuf(struct file *file, struct v4l2_m2m_ctx *m2m_ctx, |
| 178 | struct v4l2_buffer *buf); |
Mauro Carvalho Chehab | 4781646 | 2016-09-08 10:16:27 -0300 | [diff] [blame^] | 179 | |
| 180 | /** |
| 181 | * v4l2_m2m_prepare_buf() - prepare a source or destination buffer, depending on |
| 182 | * the type |
| 183 | */ |
Hans Verkuil | e68cf47 | 2015-06-05 11:28:50 -0300 | [diff] [blame] | 184 | int v4l2_m2m_prepare_buf(struct file *file, struct v4l2_m2m_ctx *m2m_ctx, |
| 185 | struct v4l2_buffer *buf); |
Mauro Carvalho Chehab | 4781646 | 2016-09-08 10:16:27 -0300 | [diff] [blame^] | 186 | |
| 187 | /** |
| 188 | * v4l2_m2m_create_bufs() - create a source or destination buffer, depending |
| 189 | * on the type |
| 190 | */ |
Philipp Zabel | 8b94ca6 | 2013-05-21 04:16:28 -0300 | [diff] [blame] | 191 | int v4l2_m2m_create_bufs(struct file *file, struct v4l2_m2m_ctx *m2m_ctx, |
| 192 | struct v4l2_create_buffers *create); |
Pawel Osciak | 7f98639 | 2010-04-23 05:38:37 -0300 | [diff] [blame] | 193 | |
Mauro Carvalho Chehab | 4781646 | 2016-09-08 10:16:27 -0300 | [diff] [blame^] | 194 | /** |
| 195 | * v4l2_m2m_expbuf() - export a source or destination buffer, depending on |
| 196 | * the type |
| 197 | */ |
Tomasz Stanislawski | 83ae7c5 | 2012-06-14 11:32:24 -0300 | [diff] [blame] | 198 | int v4l2_m2m_expbuf(struct file *file, struct v4l2_m2m_ctx *m2m_ctx, |
| 199 | struct v4l2_exportbuffer *eb); |
| 200 | |
Mauro Carvalho Chehab | 4781646 | 2016-09-08 10:16:27 -0300 | [diff] [blame^] | 201 | /** |
| 202 | * v4l2_m2m_streamon() - turn on streaming for a video queue |
| 203 | */ |
Pawel Osciak | 7f98639 | 2010-04-23 05:38:37 -0300 | [diff] [blame] | 204 | int v4l2_m2m_streamon(struct file *file, struct v4l2_m2m_ctx *m2m_ctx, |
| 205 | enum v4l2_buf_type type); |
Mauro Carvalho Chehab | 4781646 | 2016-09-08 10:16:27 -0300 | [diff] [blame^] | 206 | |
| 207 | /** |
| 208 | * v4l2_m2m_streamoff() - turn off streaming for a video queue |
| 209 | */ |
Pawel Osciak | 7f98639 | 2010-04-23 05:38:37 -0300 | [diff] [blame] | 210 | int v4l2_m2m_streamoff(struct file *file, struct v4l2_m2m_ctx *m2m_ctx, |
| 211 | enum v4l2_buf_type type); |
| 212 | |
Mauro Carvalho Chehab | 4781646 | 2016-09-08 10:16:27 -0300 | [diff] [blame^] | 213 | /** |
| 214 | * v4l2_m2m_poll() - poll replacement, for destination buffers only |
| 215 | * |
| 216 | * Call from the driver's poll() function. Will poll both queues. If a buffer |
| 217 | * is available to dequeue (with dqbuf) from the source queue, this will |
| 218 | * indicate that a non-blocking write can be performed, while read will be |
| 219 | * returned in case of the destination queue. |
| 220 | */ |
Pawel Osciak | 7f98639 | 2010-04-23 05:38:37 -0300 | [diff] [blame] | 221 | unsigned int v4l2_m2m_poll(struct file *file, struct v4l2_m2m_ctx *m2m_ctx, |
| 222 | struct poll_table_struct *wait); |
| 223 | |
Mauro Carvalho Chehab | 4781646 | 2016-09-08 10:16:27 -0300 | [diff] [blame^] | 224 | /** |
| 225 | * v4l2_m2m_mmap() - source and destination queues-aware mmap multiplexer |
| 226 | * |
| 227 | * Call from driver's mmap() function. Will handle mmap() for both queues |
| 228 | * seamlessly for videobuffer, which will receive normal per-queue offsets and |
| 229 | * proper videobuf queue pointers. The differentiation is made outside videobuf |
| 230 | * by adding a predefined offset to buffers from one of the queues and |
| 231 | * subtracting it before passing it back to videobuf. Only drivers (and |
| 232 | * thus applications) receive modified offsets. |
| 233 | */ |
Pawel Osciak | 7f98639 | 2010-04-23 05:38:37 -0300 | [diff] [blame] | 234 | int v4l2_m2m_mmap(struct file *file, struct v4l2_m2m_ctx *m2m_ctx, |
| 235 | struct vm_area_struct *vma); |
| 236 | |
Mauro Carvalho Chehab | 4781646 | 2016-09-08 10:16:27 -0300 | [diff] [blame^] | 237 | /** |
| 238 | * v4l2_m2m_init() - initialize per-driver m2m data |
| 239 | * |
| 240 | * Usually called from driver's probe() function. |
| 241 | */ |
Guennadi Liakhovetski | b1252eb | 2012-09-11 06:32:17 -0300 | [diff] [blame] | 242 | struct v4l2_m2m_dev *v4l2_m2m_init(const struct v4l2_m2m_ops *m2m_ops); |
Mauro Carvalho Chehab | 4781646 | 2016-09-08 10:16:27 -0300 | [diff] [blame^] | 243 | |
| 244 | /** |
| 245 | * v4l2_m2m_release() - cleans up and frees a m2m_dev structure |
| 246 | * |
| 247 | * Usually called from driver's remove() function. |
| 248 | */ |
Pawel Osciak | 7f98639 | 2010-04-23 05:38:37 -0300 | [diff] [blame] | 249 | void v4l2_m2m_release(struct v4l2_m2m_dev *m2m_dev); |
| 250 | |
Mauro Carvalho Chehab | 4781646 | 2016-09-08 10:16:27 -0300 | [diff] [blame^] | 251 | /** |
| 252 | * v4l2_m2m_ctx_init() - allocate and initialize a m2m context |
| 253 | * @priv - driver's instance private data |
| 254 | * @m2m_dev - a previously initialized m2m_dev struct |
| 255 | * @vq_init - a callback for queue type-specific initialization function to be |
| 256 | * used for initializing videobuf_queues |
| 257 | * |
| 258 | * Usually called from driver's open() function. |
| 259 | */ |
Marek Szyprowski | 908a0d7 | 2011-01-12 06:50:24 -0300 | [diff] [blame] | 260 | struct v4l2_m2m_ctx *v4l2_m2m_ctx_init(struct v4l2_m2m_dev *m2m_dev, |
| 261 | void *drv_priv, |
| 262 | int (*queue_init)(void *priv, struct vb2_queue *src_vq, struct vb2_queue *dst_vq)); |
| 263 | |
Philipp Zabel | 33bdd5a | 2013-06-03 04:23:48 -0300 | [diff] [blame] | 264 | static inline void v4l2_m2m_set_src_buffered(struct v4l2_m2m_ctx *m2m_ctx, |
| 265 | bool buffered) |
| 266 | { |
| 267 | m2m_ctx->out_q_ctx.buffered = buffered; |
| 268 | } |
| 269 | |
| 270 | static inline void v4l2_m2m_set_dst_buffered(struct v4l2_m2m_ctx *m2m_ctx, |
| 271 | bool buffered) |
| 272 | { |
| 273 | m2m_ctx->cap_q_ctx.buffered = buffered; |
| 274 | } |
| 275 | |
Mauro Carvalho Chehab | 4781646 | 2016-09-08 10:16:27 -0300 | [diff] [blame^] | 276 | /** |
| 277 | * v4l2_m2m_ctx_release() - release m2m context |
| 278 | * |
| 279 | * Usually called from driver's release() function. |
| 280 | */ |
Pawel Osciak | 7f98639 | 2010-04-23 05:38:37 -0300 | [diff] [blame] | 281 | void v4l2_m2m_ctx_release(struct v4l2_m2m_ctx *m2m_ctx); |
| 282 | |
Mauro Carvalho Chehab | 4781646 | 2016-09-08 10:16:27 -0300 | [diff] [blame^] | 283 | /** |
| 284 | * v4l2_m2m_buf_queue() - add a buffer to the proper ready buffers list. |
| 285 | * |
| 286 | * Call from buf_queue(), videobuf_queue_ops callback. |
| 287 | */ |
Junghak Sung | 2d70071 | 2015-09-22 10:30:30 -0300 | [diff] [blame] | 288 | void v4l2_m2m_buf_queue(struct v4l2_m2m_ctx *m2m_ctx, |
| 289 | struct vb2_v4l2_buffer *vbuf); |
Pawel Osciak | 7f98639 | 2010-04-23 05:38:37 -0300 | [diff] [blame] | 290 | |
| 291 | /** |
| 292 | * v4l2_m2m_num_src_bufs_ready() - return the number of source buffers ready for |
| 293 | * use |
Mauro Carvalho Chehab | 62c0d01 | 2015-08-22 05:34:40 -0300 | [diff] [blame] | 294 | * |
| 295 | * @m2m_ctx: pointer to struct v4l2_m2m_ctx |
Pawel Osciak | 7f98639 | 2010-04-23 05:38:37 -0300 | [diff] [blame] | 296 | */ |
| 297 | static inline |
| 298 | unsigned int v4l2_m2m_num_src_bufs_ready(struct v4l2_m2m_ctx *m2m_ctx) |
| 299 | { |
Sascha Hauer | 961ae44 | 2012-08-31 09:18:04 -0300 | [diff] [blame] | 300 | return m2m_ctx->out_q_ctx.num_rdy; |
Pawel Osciak | 7f98639 | 2010-04-23 05:38:37 -0300 | [diff] [blame] | 301 | } |
| 302 | |
| 303 | /** |
| 304 | * v4l2_m2m_num_src_bufs_ready() - return the number of destination buffers |
| 305 | * ready for use |
Mauro Carvalho Chehab | 62c0d01 | 2015-08-22 05:34:40 -0300 | [diff] [blame] | 306 | * |
| 307 | * @m2m_ctx: pointer to struct v4l2_m2m_ctx |
Pawel Osciak | 7f98639 | 2010-04-23 05:38:37 -0300 | [diff] [blame] | 308 | */ |
| 309 | static inline |
| 310 | unsigned int v4l2_m2m_num_dst_bufs_ready(struct v4l2_m2m_ctx *m2m_ctx) |
| 311 | { |
Sascha Hauer | 961ae44 | 2012-08-31 09:18:04 -0300 | [diff] [blame] | 312 | return m2m_ctx->cap_q_ctx.num_rdy; |
Pawel Osciak | 7f98639 | 2010-04-23 05:38:37 -0300 | [diff] [blame] | 313 | } |
| 314 | |
Mauro Carvalho Chehab | 4781646 | 2016-09-08 10:16:27 -0300 | [diff] [blame^] | 315 | /** |
| 316 | * v4l2_m2m_next_buf() - return next buffer from the list of ready buffers |
| 317 | */ |
Marek Szyprowski | 908a0d7 | 2011-01-12 06:50:24 -0300 | [diff] [blame] | 318 | void *v4l2_m2m_next_buf(struct v4l2_m2m_queue_ctx *q_ctx); |
Pawel Osciak | 7f98639 | 2010-04-23 05:38:37 -0300 | [diff] [blame] | 319 | |
| 320 | /** |
| 321 | * v4l2_m2m_next_src_buf() - return next source buffer from the list of ready |
| 322 | * buffers |
Mauro Carvalho Chehab | 62c0d01 | 2015-08-22 05:34:40 -0300 | [diff] [blame] | 323 | * |
| 324 | * @m2m_ctx: pointer to struct v4l2_m2m_ctx |
Pawel Osciak | 7f98639 | 2010-04-23 05:38:37 -0300 | [diff] [blame] | 325 | */ |
| 326 | static inline void *v4l2_m2m_next_src_buf(struct v4l2_m2m_ctx *m2m_ctx) |
| 327 | { |
Marek Szyprowski | 908a0d7 | 2011-01-12 06:50:24 -0300 | [diff] [blame] | 328 | return v4l2_m2m_next_buf(&m2m_ctx->out_q_ctx); |
Pawel Osciak | 7f98639 | 2010-04-23 05:38:37 -0300 | [diff] [blame] | 329 | } |
| 330 | |
| 331 | /** |
| 332 | * v4l2_m2m_next_dst_buf() - return next destination buffer from the list of |
| 333 | * ready buffers |
Mauro Carvalho Chehab | 62c0d01 | 2015-08-22 05:34:40 -0300 | [diff] [blame] | 334 | * |
| 335 | * @m2m_ctx: pointer to struct v4l2_m2m_ctx |
Pawel Osciak | 7f98639 | 2010-04-23 05:38:37 -0300 | [diff] [blame] | 336 | */ |
| 337 | static inline void *v4l2_m2m_next_dst_buf(struct v4l2_m2m_ctx *m2m_ctx) |
| 338 | { |
Marek Szyprowski | 908a0d7 | 2011-01-12 06:50:24 -0300 | [diff] [blame] | 339 | return v4l2_m2m_next_buf(&m2m_ctx->cap_q_ctx); |
Pawel Osciak | 7f98639 | 2010-04-23 05:38:37 -0300 | [diff] [blame] | 340 | } |
| 341 | |
| 342 | /** |
Marek Szyprowski | 908a0d7 | 2011-01-12 06:50:24 -0300 | [diff] [blame] | 343 | * v4l2_m2m_get_src_vq() - return vb2_queue for source buffers |
Mauro Carvalho Chehab | 62c0d01 | 2015-08-22 05:34:40 -0300 | [diff] [blame] | 344 | * |
| 345 | * @m2m_ctx: pointer to struct v4l2_m2m_ctx |
Pawel Osciak | 7f98639 | 2010-04-23 05:38:37 -0300 | [diff] [blame] | 346 | */ |
| 347 | static inline |
Marek Szyprowski | 908a0d7 | 2011-01-12 06:50:24 -0300 | [diff] [blame] | 348 | struct vb2_queue *v4l2_m2m_get_src_vq(struct v4l2_m2m_ctx *m2m_ctx) |
Pawel Osciak | 7f98639 | 2010-04-23 05:38:37 -0300 | [diff] [blame] | 349 | { |
Marek Szyprowski | 908a0d7 | 2011-01-12 06:50:24 -0300 | [diff] [blame] | 350 | return &m2m_ctx->out_q_ctx.q; |
Pawel Osciak | 7f98639 | 2010-04-23 05:38:37 -0300 | [diff] [blame] | 351 | } |
| 352 | |
| 353 | /** |
Marek Szyprowski | 908a0d7 | 2011-01-12 06:50:24 -0300 | [diff] [blame] | 354 | * v4l2_m2m_get_dst_vq() - return vb2_queue for destination buffers |
Mauro Carvalho Chehab | 62c0d01 | 2015-08-22 05:34:40 -0300 | [diff] [blame] | 355 | * |
| 356 | * @m2m_ctx: pointer to struct v4l2_m2m_ctx |
Pawel Osciak | 7f98639 | 2010-04-23 05:38:37 -0300 | [diff] [blame] | 357 | */ |
| 358 | static inline |
Marek Szyprowski | 908a0d7 | 2011-01-12 06:50:24 -0300 | [diff] [blame] | 359 | struct vb2_queue *v4l2_m2m_get_dst_vq(struct v4l2_m2m_ctx *m2m_ctx) |
Pawel Osciak | 7f98639 | 2010-04-23 05:38:37 -0300 | [diff] [blame] | 360 | { |
Marek Szyprowski | 908a0d7 | 2011-01-12 06:50:24 -0300 | [diff] [blame] | 361 | return &m2m_ctx->cap_q_ctx.q; |
Pawel Osciak | 7f98639 | 2010-04-23 05:38:37 -0300 | [diff] [blame] | 362 | } |
| 363 | |
Mauro Carvalho Chehab | 4781646 | 2016-09-08 10:16:27 -0300 | [diff] [blame^] | 364 | /** |
| 365 | * v4l2_m2m_buf_remove() - take off a buffer from the list of ready buffers and |
| 366 | * return it |
| 367 | */ |
Marek Szyprowski | 908a0d7 | 2011-01-12 06:50:24 -0300 | [diff] [blame] | 368 | void *v4l2_m2m_buf_remove(struct v4l2_m2m_queue_ctx *q_ctx); |
Pawel Osciak | 7f98639 | 2010-04-23 05:38:37 -0300 | [diff] [blame] | 369 | |
| 370 | /** |
| 371 | * v4l2_m2m_src_buf_remove() - take off a source buffer from the list of ready |
| 372 | * buffers and return it |
Mauro Carvalho Chehab | 62c0d01 | 2015-08-22 05:34:40 -0300 | [diff] [blame] | 373 | * |
| 374 | * @m2m_ctx: pointer to struct v4l2_m2m_ctx |
Pawel Osciak | 7f98639 | 2010-04-23 05:38:37 -0300 | [diff] [blame] | 375 | */ |
| 376 | static inline void *v4l2_m2m_src_buf_remove(struct v4l2_m2m_ctx *m2m_ctx) |
| 377 | { |
Marek Szyprowski | 908a0d7 | 2011-01-12 06:50:24 -0300 | [diff] [blame] | 378 | return v4l2_m2m_buf_remove(&m2m_ctx->out_q_ctx); |
Pawel Osciak | 7f98639 | 2010-04-23 05:38:37 -0300 | [diff] [blame] | 379 | } |
| 380 | |
| 381 | /** |
| 382 | * v4l2_m2m_dst_buf_remove() - take off a destination buffer from the list of |
| 383 | * ready buffers and return it |
Mauro Carvalho Chehab | 62c0d01 | 2015-08-22 05:34:40 -0300 | [diff] [blame] | 384 | * |
| 385 | * @m2m_ctx: pointer to struct v4l2_m2m_ctx |
Pawel Osciak | 7f98639 | 2010-04-23 05:38:37 -0300 | [diff] [blame] | 386 | */ |
| 387 | static inline void *v4l2_m2m_dst_buf_remove(struct v4l2_m2m_ctx *m2m_ctx) |
| 388 | { |
Marek Szyprowski | 908a0d7 | 2011-01-12 06:50:24 -0300 | [diff] [blame] | 389 | return v4l2_m2m_buf_remove(&m2m_ctx->cap_q_ctx); |
Pawel Osciak | 7f98639 | 2010-04-23 05:38:37 -0300 | [diff] [blame] | 390 | } |
| 391 | |
Sylwester Nawrocki | 8e6e8f9 | 2013-09-14 18:39:04 -0300 | [diff] [blame] | 392 | /* v4l2 ioctl helpers */ |
| 393 | |
| 394 | int v4l2_m2m_ioctl_reqbufs(struct file *file, void *priv, |
| 395 | struct v4l2_requestbuffers *rb); |
| 396 | int v4l2_m2m_ioctl_create_bufs(struct file *file, void *fh, |
| 397 | struct v4l2_create_buffers *create); |
| 398 | int v4l2_m2m_ioctl_querybuf(struct file *file, void *fh, |
| 399 | struct v4l2_buffer *buf); |
| 400 | int v4l2_m2m_ioctl_expbuf(struct file *file, void *fh, |
| 401 | struct v4l2_exportbuffer *eb); |
| 402 | int v4l2_m2m_ioctl_qbuf(struct file *file, void *fh, |
| 403 | struct v4l2_buffer *buf); |
| 404 | int v4l2_m2m_ioctl_dqbuf(struct file *file, void *fh, |
| 405 | struct v4l2_buffer *buf); |
Hans Verkuil | e68cf47 | 2015-06-05 11:28:50 -0300 | [diff] [blame] | 406 | int v4l2_m2m_ioctl_prepare_buf(struct file *file, void *fh, |
| 407 | struct v4l2_buffer *buf); |
Sylwester Nawrocki | 8e6e8f9 | 2013-09-14 18:39:04 -0300 | [diff] [blame] | 408 | int v4l2_m2m_ioctl_streamon(struct file *file, void *fh, |
| 409 | enum v4l2_buf_type type); |
| 410 | int v4l2_m2m_ioctl_streamoff(struct file *file, void *fh, |
| 411 | enum v4l2_buf_type type); |
| 412 | int v4l2_m2m_fop_mmap(struct file *file, struct vm_area_struct *vma); |
| 413 | unsigned int v4l2_m2m_fop_poll(struct file *file, poll_table *wait); |
| 414 | |
Pawel Osciak | 7f98639 | 2010-04-23 05:38:37 -0300 | [diff] [blame] | 415 | #endif /* _MEDIA_V4L2_MEM2MEM_H */ |
| 416 | |