1 /* 2 * Memory-to-memory device framework for Video for Linux 2. 3 * 4 * Helper functions for devices that use memory buffers for both source 5 * and destination. 6 * 7 * Copyright (c) 2009 Samsung Electronics Co., Ltd. 8 * Pawel Osciak, <pawel@osciak.com> 9 * Marek Szyprowski, <m.szyprowski@samsung.com> 10 * 11 * This program is free software; you can redistribute it and/or modify 12 * it under the terms of the GNU General Public License as published by the 13 * Free Software Foundation; either version 2 of the 14 * License, or (at your option) any later version 15 */ 16 17 #ifndef _MEDIA_V4L2_MEM2MEM_H 18 #define _MEDIA_V4L2_MEM2MEM_H 19 20 #include <media/videobuf2-v4l2.h> 21 22 /** 23 * struct v4l2_m2m_ops - mem-to-mem device driver callbacks 24 * @device_run: required. Begin the actual job (transaction) inside this 25 * callback. 26 * The job does NOT have to end before this callback returns 27 * (and it will be the usual case). When the job finishes, 28 * v4l2_m2m_job_finish() has to be called. 29 * @job_ready: optional. Should return 0 if the driver does not have a job 30 * fully prepared to run yet (i.e. it will not be able to finish a 31 * transaction without sleeping). If not provided, it will be 32 * assumed that one source and one destination buffer are all 33 * that is required for the driver to perform one full transaction. 34 * This method may not sleep. 35 * @job_abort: 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. 43 * @lock: optional. Define a driver's own lock callback, instead of using 44 * &v4l2_m2m_ctx->q_lock. 45 * @unlock: optional. Define a driver's own unlock callback, instead of 46 * using &v4l2_m2m_ctx->q_lock. 47 */ 48 struct v4l2_m2m_ops { 49 void (*device_run)(void *priv); 50 int (*job_ready)(void *priv); 51 void (*job_abort)(void *priv); 52 void (*lock)(void *priv); 53 void (*unlock)(void *priv); 54 }; 55 56 struct v4l2_m2m_dev; 57 58 /** 59 * struct v4l2_m2m_queue_ctx - represents a queue for buffers ready to be 60 * processed 61 * 62 * @q: pointer to struct &vb2_queue 63 * @rdy_queue: List of V4L2 mem-to-mem queues 64 * @rdy_spinlock: spin lock to protect the struct usage 65 * @num_rdy: number of buffers ready to be processed 66 * @buffered: is the queue buffered? 67 * 68 * Queue for buffers ready to be processed as soon as this 69 * instance receives access to the device. 70 */ 71 72 struct v4l2_m2m_queue_ctx { 73 struct vb2_queue q; 74 75 struct list_head rdy_queue; 76 spinlock_t rdy_spinlock; 77 u8 num_rdy; 78 bool buffered; 79 }; 80 81 /** 82 * struct v4l2_m2m_ctx - Memory to memory context structure 83 * 84 * @q_lock: struct &mutex lock 85 * @m2m_dev: opaque pointer to the internal data to handle M2M context 86 * @cap_q_ctx: Capture (output to memory) queue context 87 * @out_q_ctx: Output (input from memory) queue context 88 * @queue: List of memory to memory contexts 89 * @job_flags: Job queue flags, used internally by v4l2-mem2mem.c: 90 * %TRANS_QUEUED, %TRANS_RUNNING and %TRANS_ABORT. 91 * @finished: Wait queue used to signalize when a job queue finished. 92 * @priv: Instance private data 93 * 94 * The memory to memory context is specific to a file handle, NOT to e.g. 95 * a device. 96 */ 97 struct v4l2_m2m_ctx { 98 /* optional cap/out vb2 queues lock */ 99 struct mutex *q_lock; 100 101 /* internal use only */ 102 struct v4l2_m2m_dev *m2m_dev; 103 104 struct v4l2_m2m_queue_ctx cap_q_ctx; 105 106 struct v4l2_m2m_queue_ctx out_q_ctx; 107 108 /* For device job queue */ 109 struct list_head queue; 110 unsigned long job_flags; 111 wait_queue_head_t finished; 112 113 void *priv; 114 }; 115 116 /** 117 * struct v4l2_m2m_buffer - Memory to memory buffer 118 * 119 * @vb: pointer to struct &vb2_v4l2_buffer 120 * @list: list of m2m buffers 121 */ 122 struct v4l2_m2m_buffer { 123 struct vb2_v4l2_buffer vb; 124 struct list_head list; 125 }; 126 127 /** 128 * v4l2_m2m_get_curr_priv() - return driver private data for the currently 129 * running instance or NULL if no instance is running 130 * 131 * @m2m_dev: opaque pointer to the internal data to handle M2M context 132 */ 133 void *v4l2_m2m_get_curr_priv(struct v4l2_m2m_dev *m2m_dev); 134 135 /** 136 * v4l2_m2m_get_vq() - return vb2_queue for the given type 137 * 138 * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx 139 * @type: type of the V4L2 buffer, as defined by enum &v4l2_buf_type 140 */ 141 struct vb2_queue *v4l2_m2m_get_vq(struct v4l2_m2m_ctx *m2m_ctx, 142 enum v4l2_buf_type type); 143 144 /** 145 * v4l2_m2m_try_schedule() - check whether an instance is ready to be added to 146 * the pending job queue and add it if so. 147 * 148 * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx 149 * 150 * There are three basic requirements an instance has to meet to be able to run: 151 * 1) at least one source buffer has to be queued, 152 * 2) at least one destination buffer has to be queued, 153 * 3) streaming has to be on. 154 * 155 * If a queue is buffered (for example a decoder hardware ringbuffer that has 156 * to be drained before doing streamoff), allow scheduling without v4l2 buffers 157 * on that queue. 158 * 159 * There may also be additional, custom requirements. In such case the driver 160 * should supply a custom callback (job_ready in v4l2_m2m_ops) that should 161 * return 1 if the instance is ready. 162 * An example of the above could be an instance that requires more than one 163 * src/dst buffer per transaction. 164 */ 165 void v4l2_m2m_try_schedule(struct v4l2_m2m_ctx *m2m_ctx); 166 167 /** 168 * v4l2_m2m_job_finish() - inform the framework that a job has been finished 169 * and have it clean up 170 * 171 * @m2m_dev: opaque pointer to the internal data to handle M2M context 172 * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx 173 * 174 * Called by a driver to yield back the device after it has finished with it. 175 * Should be called as soon as possible after reaching a state which allows 176 * other instances to take control of the device. 177 * 178 * This function has to be called only after &v4l2_m2m_ops->device_run 179 * callback has been called on the driver. To prevent recursion, it should 180 * not be called directly from the &v4l2_m2m_ops->device_run callback though. 181 */ 182 void v4l2_m2m_job_finish(struct v4l2_m2m_dev *m2m_dev, 183 struct v4l2_m2m_ctx *m2m_ctx); 184 185 static inline void 186 v4l2_m2m_buf_done(struct vb2_v4l2_buffer *buf, enum vb2_buffer_state state) 187 { 188 vb2_buffer_done(&buf->vb2_buf, state); 189 } 190 191 /** 192 * v4l2_m2m_reqbufs() - multi-queue-aware REQBUFS multiplexer 193 * 194 * @file: pointer to struct &file 195 * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx 196 * @reqbufs: pointer to struct &v4l2_requestbuffers 197 */ 198 int v4l2_m2m_reqbufs(struct file *file, struct v4l2_m2m_ctx *m2m_ctx, 199 struct v4l2_requestbuffers *reqbufs); 200 201 /** 202 * v4l2_m2m_querybuf() - multi-queue-aware QUERYBUF multiplexer 203 * 204 * @file: pointer to struct &file 205 * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx 206 * @buf: pointer to struct &v4l2_buffer 207 * 208 * See v4l2_m2m_mmap() documentation for details. 209 */ 210 int v4l2_m2m_querybuf(struct file *file, struct v4l2_m2m_ctx *m2m_ctx, 211 struct v4l2_buffer *buf); 212 213 /** 214 * v4l2_m2m_qbuf() - enqueue a source or destination buffer, depending on 215 * the type 216 * 217 * @file: pointer to struct &file 218 * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx 219 * @buf: pointer to struct &v4l2_buffer 220 */ 221 int v4l2_m2m_qbuf(struct file *file, struct v4l2_m2m_ctx *m2m_ctx, 222 struct v4l2_buffer *buf); 223 224 /** 225 * v4l2_m2m_dqbuf() - dequeue a source or destination buffer, depending on 226 * the type 227 * 228 * @file: pointer to struct &file 229 * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx 230 * @buf: pointer to struct &v4l2_buffer 231 */ 232 int v4l2_m2m_dqbuf(struct file *file, struct v4l2_m2m_ctx *m2m_ctx, 233 struct v4l2_buffer *buf); 234 235 /** 236 * v4l2_m2m_prepare_buf() - prepare a source or destination buffer, depending on 237 * the type 238 * 239 * @file: pointer to struct &file 240 * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx 241 * @buf: pointer to struct &v4l2_buffer 242 */ 243 int v4l2_m2m_prepare_buf(struct file *file, struct v4l2_m2m_ctx *m2m_ctx, 244 struct v4l2_buffer *buf); 245 246 /** 247 * v4l2_m2m_create_bufs() - create a source or destination buffer, depending 248 * on the type 249 * 250 * @file: pointer to struct &file 251 * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx 252 * @create: pointer to struct &v4l2_create_buffers 253 */ 254 int v4l2_m2m_create_bufs(struct file *file, struct v4l2_m2m_ctx *m2m_ctx, 255 struct v4l2_create_buffers *create); 256 257 /** 258 * v4l2_m2m_expbuf() - export a source or destination buffer, depending on 259 * the type 260 * 261 * @file: pointer to struct &file 262 * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx 263 * @eb: pointer to struct &v4l2_exportbuffer 264 */ 265 int v4l2_m2m_expbuf(struct file *file, struct v4l2_m2m_ctx *m2m_ctx, 266 struct v4l2_exportbuffer *eb); 267 268 /** 269 * v4l2_m2m_streamon() - turn on streaming for a video queue 270 * 271 * @file: pointer to struct &file 272 * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx 273 * @type: type of the V4L2 buffer, as defined by enum &v4l2_buf_type 274 */ 275 int v4l2_m2m_streamon(struct file *file, struct v4l2_m2m_ctx *m2m_ctx, 276 enum v4l2_buf_type type); 277 278 /** 279 * v4l2_m2m_streamoff() - turn off streaming for a video queue 280 * 281 * @file: pointer to struct &file 282 * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx 283 * @type: type of the V4L2 buffer, as defined by enum &v4l2_buf_type 284 */ 285 int v4l2_m2m_streamoff(struct file *file, struct v4l2_m2m_ctx *m2m_ctx, 286 enum v4l2_buf_type type); 287 288 /** 289 * v4l2_m2m_poll() - poll replacement, for destination buffers only 290 * 291 * @file: pointer to struct &file 292 * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx 293 * @wait: pointer to struct &poll_table_struct 294 * 295 * Call from the driver's poll() function. Will poll both queues. If a buffer 296 * is available to dequeue (with dqbuf) from the source queue, this will 297 * indicate that a non-blocking write can be performed, while read will be 298 * returned in case of the destination queue. 299 */ 300 unsigned int v4l2_m2m_poll(struct file *file, struct v4l2_m2m_ctx *m2m_ctx, 301 struct poll_table_struct *wait); 302 303 /** 304 * v4l2_m2m_mmap() - source and destination queues-aware mmap multiplexer 305 * 306 * @file: pointer to struct &file 307 * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx 308 * @vma: pointer to struct &vm_area_struct 309 * 310 * Call from driver's mmap() function. Will handle mmap() for both queues 311 * seamlessly for videobuffer, which will receive normal per-queue offsets and 312 * proper videobuf queue pointers. The differentiation is made outside videobuf 313 * by adding a predefined offset to buffers from one of the queues and 314 * subtracting it before passing it back to videobuf. Only drivers (and 315 * thus applications) receive modified offsets. 316 */ 317 int v4l2_m2m_mmap(struct file *file, struct v4l2_m2m_ctx *m2m_ctx, 318 struct vm_area_struct *vma); 319 320 /** 321 * v4l2_m2m_init() - initialize per-driver m2m data 322 * 323 * @m2m_ops: pointer to struct v4l2_m2m_ops 324 * 325 * Usually called from driver's ``probe()`` function. 326 * 327 * Return: returns an opaque pointer to the internal data to handle M2M context 328 */ 329 struct v4l2_m2m_dev *v4l2_m2m_init(const struct v4l2_m2m_ops *m2m_ops); 330 331 /** 332 * v4l2_m2m_release() - cleans up and frees a m2m_dev structure 333 * 334 * @m2m_dev: opaque pointer to the internal data to handle M2M context 335 * 336 * Usually called from driver's ``remove()`` function. 337 */ 338 void v4l2_m2m_release(struct v4l2_m2m_dev *m2m_dev); 339 340 /** 341 * v4l2_m2m_ctx_init() - allocate and initialize a m2m context 342 * 343 * @m2m_dev: opaque pointer to the internal data to handle M2M context 344 * @drv_priv: driver's instance private data 345 * @queue_init: a callback for queue type-specific initialization function 346 * to be used for initializing videobuf_queues 347 * 348 * Usually called from driver's ``open()`` function. 349 */ 350 struct v4l2_m2m_ctx *v4l2_m2m_ctx_init(struct v4l2_m2m_dev *m2m_dev, 351 void *drv_priv, 352 int (*queue_init)(void *priv, struct vb2_queue *src_vq, struct vb2_queue *dst_vq)); 353 354 static inline void v4l2_m2m_set_src_buffered(struct v4l2_m2m_ctx *m2m_ctx, 355 bool buffered) 356 { 357 m2m_ctx->out_q_ctx.buffered = buffered; 358 } 359 360 static inline void v4l2_m2m_set_dst_buffered(struct v4l2_m2m_ctx *m2m_ctx, 361 bool buffered) 362 { 363 m2m_ctx->cap_q_ctx.buffered = buffered; 364 } 365 366 /** 367 * v4l2_m2m_ctx_release() - release m2m context 368 * 369 * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx 370 * 371 * Usually called from driver's release() function. 372 */ 373 void v4l2_m2m_ctx_release(struct v4l2_m2m_ctx *m2m_ctx); 374 375 /** 376 * v4l2_m2m_buf_queue() - add a buffer to the proper ready buffers list. 377 * 378 * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx 379 * @vbuf: pointer to struct &vb2_v4l2_buffer 380 * 381 * Call from videobuf_queue_ops->ops->buf_queue, videobuf_queue_ops callback. 382 */ 383 void v4l2_m2m_buf_queue(struct v4l2_m2m_ctx *m2m_ctx, 384 struct vb2_v4l2_buffer *vbuf); 385 386 /** 387 * v4l2_m2m_num_src_bufs_ready() - return the number of source buffers ready for 388 * use 389 * 390 * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx 391 */ 392 static inline 393 unsigned int v4l2_m2m_num_src_bufs_ready(struct v4l2_m2m_ctx *m2m_ctx) 394 { 395 return m2m_ctx->out_q_ctx.num_rdy; 396 } 397 398 /** 399 * v4l2_m2m_num_dst_bufs_ready() - return the number of destination buffers 400 * ready for use 401 * 402 * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx 403 */ 404 static inline 405 unsigned int v4l2_m2m_num_dst_bufs_ready(struct v4l2_m2m_ctx *m2m_ctx) 406 { 407 return m2m_ctx->cap_q_ctx.num_rdy; 408 } 409 410 /** 411 * v4l2_m2m_next_buf() - return next buffer from the list of ready buffers 412 * 413 * @q_ctx: pointer to struct @v4l2_m2m_queue_ctx 414 */ 415 void *v4l2_m2m_next_buf(struct v4l2_m2m_queue_ctx *q_ctx); 416 417 /** 418 * v4l2_m2m_next_src_buf() - return next source buffer from the list of ready 419 * buffers 420 * 421 * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx 422 */ 423 static inline void *v4l2_m2m_next_src_buf(struct v4l2_m2m_ctx *m2m_ctx) 424 { 425 return v4l2_m2m_next_buf(&m2m_ctx->out_q_ctx); 426 } 427 428 /** 429 * v4l2_m2m_next_dst_buf() - return next destination buffer from the list of 430 * ready buffers 431 * 432 * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx 433 */ 434 static inline void *v4l2_m2m_next_dst_buf(struct v4l2_m2m_ctx *m2m_ctx) 435 { 436 return v4l2_m2m_next_buf(&m2m_ctx->cap_q_ctx); 437 } 438 439 /** 440 * v4l2_m2m_for_each_dst_buf() - iterate over a list of destination ready 441 * buffers 442 * 443 * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx 444 * @b: current buffer of type struct v4l2_m2m_buffer 445 */ 446 #define v4l2_m2m_for_each_dst_buf(m2m_ctx, b) \ 447 list_for_each_entry(b, &m2m_ctx->cap_q_ctx.rdy_queue, list) 448 449 /** 450 * v4l2_m2m_for_each_src_buf() - iterate over a list of source ready buffers 451 * 452 * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx 453 * @b: current buffer of type struct v4l2_m2m_buffer 454 */ 455 #define v4l2_m2m_for_each_src_buf(m2m_ctx, b) \ 456 list_for_each_entry(b, &m2m_ctx->out_q_ctx.rdy_queue, list) 457 458 /** 459 * v4l2_m2m_for_each_dst_buf_safe() - iterate over a list of destination ready 460 * buffers safely 461 * 462 * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx 463 * @b: current buffer of type struct v4l2_m2m_buffer 464 * @n: used as temporary storage 465 */ 466 #define v4l2_m2m_for_each_dst_buf_safe(m2m_ctx, b, n) \ 467 list_for_each_entry_safe(b, n, &m2m_ctx->cap_q_ctx.rdy_queue, list) 468 469 /** 470 * v4l2_m2m_for_each_src_buf_safe() - iterate over a list of source ready 471 * buffers safely 472 * 473 * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx 474 * @b: current buffer of type struct v4l2_m2m_buffer 475 * @n: used as temporary storage 476 */ 477 #define v4l2_m2m_for_each_src_buf_safe(m2m_ctx, b, n) \ 478 list_for_each_entry_safe(b, n, &m2m_ctx->out_q_ctx.rdy_queue, list) 479 480 /** 481 * v4l2_m2m_get_src_vq() - return vb2_queue for source buffers 482 * 483 * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx 484 */ 485 static inline 486 struct vb2_queue *v4l2_m2m_get_src_vq(struct v4l2_m2m_ctx *m2m_ctx) 487 { 488 return &m2m_ctx->out_q_ctx.q; 489 } 490 491 /** 492 * v4l2_m2m_get_dst_vq() - return vb2_queue for destination buffers 493 * 494 * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx 495 */ 496 static inline 497 struct vb2_queue *v4l2_m2m_get_dst_vq(struct v4l2_m2m_ctx *m2m_ctx) 498 { 499 return &m2m_ctx->cap_q_ctx.q; 500 } 501 502 /** 503 * v4l2_m2m_buf_remove() - take off a buffer from the list of ready buffers and 504 * return it 505 * 506 * @q_ctx: pointer to struct @v4l2_m2m_queue_ctx 507 */ 508 void *v4l2_m2m_buf_remove(struct v4l2_m2m_queue_ctx *q_ctx); 509 510 /** 511 * v4l2_m2m_src_buf_remove() - take off a source buffer from the list of ready 512 * buffers and return it 513 * 514 * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx 515 */ 516 static inline void *v4l2_m2m_src_buf_remove(struct v4l2_m2m_ctx *m2m_ctx) 517 { 518 return v4l2_m2m_buf_remove(&m2m_ctx->out_q_ctx); 519 } 520 521 /** 522 * v4l2_m2m_dst_buf_remove() - take off a destination buffer from the list of 523 * ready buffers and return it 524 * 525 * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx 526 */ 527 static inline void *v4l2_m2m_dst_buf_remove(struct v4l2_m2m_ctx *m2m_ctx) 528 { 529 return v4l2_m2m_buf_remove(&m2m_ctx->cap_q_ctx); 530 } 531 532 /** 533 * v4l2_m2m_buf_remove_by_buf() - take off exact buffer from the list of ready 534 * buffers 535 * 536 * @q_ctx: pointer to struct @v4l2_m2m_queue_ctx 537 * @vbuf: the buffer to be removed 538 */ 539 void v4l2_m2m_buf_remove_by_buf(struct v4l2_m2m_queue_ctx *q_ctx, 540 struct vb2_v4l2_buffer *vbuf); 541 542 /** 543 * v4l2_m2m_src_buf_remove_by_buf() - take off exact source buffer from the list 544 * of ready buffers 545 * 546 * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx 547 * @vbuf: the buffer to be removed 548 */ 549 static inline void v4l2_m2m_src_buf_remove_by_buf(struct v4l2_m2m_ctx *m2m_ctx, 550 struct vb2_v4l2_buffer *vbuf) 551 { 552 v4l2_m2m_buf_remove_by_buf(&m2m_ctx->out_q_ctx, vbuf); 553 } 554 555 /** 556 * v4l2_m2m_dst_buf_remove_by_buf() - take off exact destination buffer from the 557 * list of ready buffers 558 * 559 * @m2m_ctx: m2m context assigned to the instance given by struct &v4l2_m2m_ctx 560 * @vbuf: the buffer to be removed 561 */ 562 static inline void v4l2_m2m_dst_buf_remove_by_buf(struct v4l2_m2m_ctx *m2m_ctx, 563 struct vb2_v4l2_buffer *vbuf) 564 { 565 v4l2_m2m_buf_remove_by_buf(&m2m_ctx->cap_q_ctx, vbuf); 566 } 567 568 struct vb2_v4l2_buffer * 569 v4l2_m2m_buf_remove_by_idx(struct v4l2_m2m_queue_ctx *q_ctx, unsigned int idx); 570 571 static inline struct vb2_v4l2_buffer * 572 v4l2_m2m_src_buf_remove_by_idx(struct v4l2_m2m_ctx *m2m_ctx, unsigned int idx) 573 { 574 return v4l2_m2m_buf_remove_by_idx(&m2m_ctx->out_q_ctx, idx); 575 } 576 577 static inline struct vb2_v4l2_buffer * 578 v4l2_m2m_dst_buf_remove_by_idx(struct v4l2_m2m_ctx *m2m_ctx, unsigned int idx) 579 { 580 return v4l2_m2m_buf_remove_by_idx(&m2m_ctx->cap_q_ctx, idx); 581 } 582 583 /* v4l2 ioctl helpers */ 584 585 int v4l2_m2m_ioctl_reqbufs(struct file *file, void *priv, 586 struct v4l2_requestbuffers *rb); 587 int v4l2_m2m_ioctl_create_bufs(struct file *file, void *fh, 588 struct v4l2_create_buffers *create); 589 int v4l2_m2m_ioctl_querybuf(struct file *file, void *fh, 590 struct v4l2_buffer *buf); 591 int v4l2_m2m_ioctl_expbuf(struct file *file, void *fh, 592 struct v4l2_exportbuffer *eb); 593 int v4l2_m2m_ioctl_qbuf(struct file *file, void *fh, 594 struct v4l2_buffer *buf); 595 int v4l2_m2m_ioctl_dqbuf(struct file *file, void *fh, 596 struct v4l2_buffer *buf); 597 int v4l2_m2m_ioctl_prepare_buf(struct file *file, void *fh, 598 struct v4l2_buffer *buf); 599 int v4l2_m2m_ioctl_streamon(struct file *file, void *fh, 600 enum v4l2_buf_type type); 601 int v4l2_m2m_ioctl_streamoff(struct file *file, void *fh, 602 enum v4l2_buf_type type); 603 int v4l2_m2m_fop_mmap(struct file *file, struct vm_area_struct *vma); 604 unsigned int v4l2_m2m_fop_poll(struct file *file, poll_table *wait); 605 606 #endif /* _MEDIA_V4L2_MEM2MEM_H */ 607 608