2 * videobuf2-core.h - Video Buffer 2 Core Framework
4 * Copyright (C) 2010 Samsung Electronics
6 * Author: Pawel Osciak <pawel@osciak.com>
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation.
12 #ifndef _MEDIA_VIDEOBUF2_CORE_H
13 #define _MEDIA_VIDEOBUF2_CORE_H
15 #include <linux/mm_types.h>
16 #include <linux/mutex.h>
17 #include <linux/poll.h>
18 #include <linux/videodev2.h>
19 #include <linux/dma-buf.h>
22 struct vb2_fileio_data;
23 struct vb2_threadio_data;
26 * struct vb2_mem_ops - memory handling/memory allocator operations
27 * @alloc: allocate video memory and, optionally, allocator private data,
28 * return NULL on failure or a pointer to allocator private,
29 * per-buffer data on success; the returned private structure
30 * will then be passed as buf_priv argument to other ops in this
31 * structure. Additional gfp_flags to use when allocating the
32 * are also passed to this operation. These flags are from the
33 * gfp_flags field of vb2_queue.
34 * @put: inform the allocator that the buffer will no longer be used;
35 * usually will result in the allocator freeing the buffer (if
36 * no other users of this buffer are present); the buf_priv
37 * argument is the allocator private per-buffer structure
38 * previously returned from the alloc callback.
39 * @get_dmabuf: acquire userspace memory for a hardware operation; used for
40 * DMABUF memory types.
41 * @get_userptr: acquire userspace memory for a hardware operation; used for
42 * USERPTR memory types; vaddr is the address passed to the
43 * videobuf layer when queuing a video buffer of USERPTR type;
44 * should return an allocator private per-buffer structure
45 * associated with the buffer on success, NULL on failure;
46 * the returned private structure will then be passed as buf_priv
47 * argument to other ops in this structure.
48 * @put_userptr: inform the allocator that a USERPTR buffer will no longer
50 * @attach_dmabuf: attach a shared struct dma_buf for a hardware operation;
51 * used for DMABUF memory types; alloc_ctx is the alloc context
52 * dbuf is the shared dma_buf; returns NULL on failure;
53 * allocator private per-buffer structure on success;
54 * this needs to be used for further accesses to the buffer.
55 * @detach_dmabuf: inform the exporter of the buffer that the current DMABUF
56 * buffer is no longer used; the buf_priv argument is the
57 * allocator private per-buffer structure previously returned
58 * from the attach_dmabuf callback.
59 * @map_dmabuf: request for access to the dmabuf from allocator; the allocator
60 * of dmabuf is informed that this driver is going to use the
62 * @unmap_dmabuf: releases access control to the dmabuf - allocator is notified
63 * that this driver is done using the dmabuf for now.
64 * @prepare: called every time the buffer is passed from userspace to the
65 * driver, useful for cache synchronisation, optional.
66 * @finish: called every time the buffer is passed back from the driver
67 * to the userspace, also optional.
68 * @vaddr: return a kernel virtual address to a given memory buffer
69 * associated with the passed private structure or NULL if no
70 * such mapping exists.
71 * @cookie: return allocator specific cookie for a given memory buffer
72 * associated with the passed private structure or NULL if not
74 * @num_users: return the current number of users of a memory buffer;
75 * return 1 if the videobuf layer (or actually the driver using
76 * it) is the only user.
77 * @mmap: setup a userspace mapping for a given memory buffer under
78 * the provided virtual memory region.
80 * Required ops for USERPTR types: get_userptr, put_userptr.
81 * Required ops for MMAP types: alloc, put, num_users, mmap.
82 * Required ops for read/write access types: alloc, put, num_users, vaddr.
83 * Required ops for DMABUF types: attach_dmabuf, detach_dmabuf, map_dmabuf,
87 void *(*alloc)(void *alloc_ctx, unsigned long size,
88 enum dma_data_direction dma_dir,
90 void (*put)(void *buf_priv);
91 struct dma_buf *(*get_dmabuf)(void *buf_priv, unsigned long flags);
93 void *(*get_userptr)(void *alloc_ctx, unsigned long vaddr,
95 enum dma_data_direction dma_dir);
96 void (*put_userptr)(void *buf_priv);
98 void (*prepare)(void *buf_priv);
99 void (*finish)(void *buf_priv);
101 void *(*attach_dmabuf)(void *alloc_ctx, struct dma_buf *dbuf,
103 enum dma_data_direction dma_dir);
104 void (*detach_dmabuf)(void *buf_priv);
105 int (*map_dmabuf)(void *buf_priv);
106 void (*unmap_dmabuf)(void *buf_priv);
108 void *(*vaddr)(void *buf_priv);
109 void *(*cookie)(void *buf_priv);
111 unsigned int (*num_users)(void *buf_priv);
113 int (*mmap)(void *buf_priv, struct vm_area_struct *vma);
117 * struct vb2_plane - plane information
118 * @mem_priv: private data with this plane
119 * @dbuf: dma_buf - shared buffer object
120 * @dbuf_mapped: flag to show whether dbuf is mapped or not
121 * @bytesused: number of bytes occupied by data in the plane (payload)
122 * @length: size of this plane (NOT the payload) in bytes
123 * @offset: when memory in the associated struct vb2_buffer is
124 * VB2_MEMORY_MMAP, equals the offset from the start of
125 * the device memory for this plane (or is a "cookie" that
126 * should be passed to mmap() called on the video node)
127 * @userptr: when memory is VB2_MEMORY_USERPTR, a userspace pointer
128 * pointing to this plane
129 * @fd: when memory is VB2_MEMORY_DMABUF, a userspace file
130 * descriptor associated with this plane
131 * @m: Union with memtype-specific data (@offset, @userptr or
133 * @data_offset: offset in the plane to the start of data; usually 0,
134 * unless there is a header in front of the data
135 * Should contain enough information to be able to cover all the fields
136 * of struct v4l2_plane at videodev2.h
140 struct dma_buf *dbuf;
141 unsigned int dbuf_mapped;
142 unsigned int bytesused;
146 unsigned long userptr;
149 unsigned int data_offset;
153 * enum vb2_io_modes - queue access methods
154 * @VB2_MMAP: driver supports MMAP with streaming API
155 * @VB2_USERPTR: driver supports USERPTR with streaming API
156 * @VB2_READ: driver supports read() style access
157 * @VB2_WRITE: driver supports write() style access
158 * @VB2_DMABUF: driver supports DMABUF with streaming API
162 VB2_USERPTR = (1 << 1),
164 VB2_WRITE = (1 << 3),
165 VB2_DMABUF = (1 << 4),
169 * enum vb2_buffer_state - current video buffer state
170 * @VB2_BUF_STATE_DEQUEUED: buffer under userspace control
171 * @VB2_BUF_STATE_PREPARING: buffer is being prepared in videobuf
172 * @VB2_BUF_STATE_PREPARED: buffer prepared in videobuf and by the driver
173 * @VB2_BUF_STATE_QUEUED: buffer queued in videobuf, but not in driver
174 * @VB2_BUF_STATE_REQUEUEING: re-queue a buffer to the driver
175 * @VB2_BUF_STATE_ACTIVE: buffer queued in driver and possibly used
176 * in a hardware operation
177 * @VB2_BUF_STATE_DONE: buffer returned from driver to videobuf, but
178 * not yet dequeued to userspace
179 * @VB2_BUF_STATE_ERROR: same as above, but the operation on the buffer
180 * has ended with an error, which will be reported
181 * to the userspace when it is dequeued
183 enum vb2_buffer_state {
184 VB2_BUF_STATE_DEQUEUED,
185 VB2_BUF_STATE_PREPARING,
186 VB2_BUF_STATE_PREPARED,
187 VB2_BUF_STATE_QUEUED,
188 VB2_BUF_STATE_REQUEUEING,
189 VB2_BUF_STATE_ACTIVE,
197 * struct vb2_buffer - represents a video buffer
198 * @vb2_queue: the queue to which this driver belongs
199 * @index: id number of the buffer
201 * @memory: the method, in which the actual data is passed
202 * @num_planes: number of planes in the buffer
203 * on an internal driver queue
204 * @planes: private per-plane information; do not change
207 struct vb2_queue *vb2_queue;
211 unsigned int num_planes;
212 struct vb2_plane planes[VIDEO_MAX_PLANES];
214 /* private: internal use only
216 * state: current buffer state; do not change
217 * queued_entry: entry on the queued buffers list, which holds
218 * all buffers queued from userspace
219 * done_entry: entry on the list that stores all buffers ready
220 * to be dequeued to userspace
222 enum vb2_buffer_state state;
224 struct list_head queued_entry;
225 struct list_head done_entry;
226 #ifdef CONFIG_VIDEO_ADV_DEBUG
228 * Counters for how often these buffer-related ops are
229 * called. Used to check for unbalanced ops.
233 u32 cnt_mem_get_dmabuf;
234 u32 cnt_mem_get_userptr;
235 u32 cnt_mem_put_userptr;
238 u32 cnt_mem_attach_dmabuf;
239 u32 cnt_mem_detach_dmabuf;
240 u32 cnt_mem_map_dmabuf;
241 u32 cnt_mem_unmap_dmabuf;
244 u32 cnt_mem_num_users;
253 /* This counts the number of calls to vb2_buffer_done() */
259 * struct vb2_ops - driver-specific callbacks
261 * @queue_setup: called from VIDIOC_REQBUFS and VIDIOC_CREATE_BUFS
262 * handlers before memory allocation, or, if
263 * *num_planes != 0, after the allocation to verify a
264 * smaller number of buffers. Driver should return
265 * the required number of buffers in *num_buffers, the
266 * required number of planes per buffer in *num_planes; the
267 * size of each plane should be set in the sizes[] array
268 * and optional per-plane allocator specific context in the
269 * alloc_ctxs[] array. When called from VIDIOC_REQBUFS,
270 * fmt == NULL, the driver has to use the currently
271 * configured format and *num_buffers is the total number
272 * of buffers, that are being allocated. When called from
273 * VIDIOC_CREATE_BUFS, fmt != NULL and it describes the
274 * target frame format (if the format isn't valid the
275 * callback must return -EINVAL). In this case *num_buffers
276 * are being allocated additionally to q->num_buffers.
277 * @wait_prepare: release any locks taken while calling vb2 functions;
278 * it is called before an ioctl needs to wait for a new
279 * buffer to arrive; required to avoid a deadlock in
280 * blocking access type.
281 * @wait_finish: reacquire all locks released in the previous callback;
282 * required to continue operation after sleeping while
283 * waiting for a new buffer to arrive.
284 * @buf_init: called once after allocating a buffer (in MMAP case)
285 * or after acquiring a new USERPTR buffer; drivers may
286 * perform additional buffer-related initialization;
287 * initialization failure (return != 0) will prevent
288 * queue setup from completing successfully; optional.
289 * @buf_prepare: called every time the buffer is queued from userspace
290 * and from the VIDIOC_PREPARE_BUF ioctl; drivers may
291 * perform any initialization required before each
292 * hardware operation in this callback; drivers can
293 * access/modify the buffer here as it is still synced for
294 * the CPU; drivers that support VIDIOC_CREATE_BUFS must
295 * also validate the buffer size; if an error is returned,
296 * the buffer will not be queued in driver; optional.
297 * @buf_finish: called before every dequeue of the buffer back to
298 * userspace; the buffer is synced for the CPU, so drivers
299 * can access/modify the buffer contents; drivers may
300 * perform any operations required before userspace
301 * accesses the buffer; optional. The buffer state can be
302 * one of the following: DONE and ERROR occur while
303 * streaming is in progress, and the PREPARED state occurs
304 * when the queue has been canceled and all pending
305 * buffers are being returned to their default DEQUEUED
306 * state. Typically you only have to do something if the
307 * state is VB2_BUF_STATE_DONE, since in all other cases
308 * the buffer contents will be ignored anyway.
309 * @buf_cleanup: called once before the buffer is freed; drivers may
310 * perform any additional cleanup; optional.
311 * @start_streaming: called once to enter 'streaming' state; the driver may
312 * receive buffers with @buf_queue callback before
313 * @start_streaming is called; the driver gets the number
314 * of already queued buffers in count parameter; driver
315 * can return an error if hardware fails, in that case all
316 * buffers that have been already given by the @buf_queue
317 * callback are to be returned by the driver by calling
318 * @vb2_buffer_done(VB2_BUF_STATE_QUEUED).
319 * If you need a minimum number of buffers before you can
320 * start streaming, then set @min_buffers_needed in the
321 * vb2_queue structure. If that is non-zero then
322 * start_streaming won't be called until at least that
323 * many buffers have been queued up by userspace.
324 * @stop_streaming: called when 'streaming' state must be disabled; driver
325 * should stop any DMA transactions or wait until they
326 * finish and give back all buffers it got from buf_queue()
327 * callback by calling @vb2_buffer_done() with either
328 * VB2_BUF_STATE_DONE or VB2_BUF_STATE_ERROR; may use
329 * vb2_wait_for_all_buffers() function
330 * @buf_queue: passes buffer vb to the driver; driver may start
331 * hardware operation on this buffer; driver should give
332 * the buffer back by calling vb2_buffer_done() function;
333 * it is allways called after calling STREAMON ioctl;
334 * might be called before start_streaming callback if user
335 * pre-queued buffers before calling STREAMON.
338 int (*queue_setup)(struct vb2_queue *q, const void *parg,
339 unsigned int *num_buffers, unsigned int *num_planes,
340 unsigned int sizes[], void *alloc_ctxs[]);
342 void (*wait_prepare)(struct vb2_queue *q);
343 void (*wait_finish)(struct vb2_queue *q);
345 int (*buf_init)(struct vb2_buffer *vb);
346 int (*buf_prepare)(struct vb2_buffer *vb);
347 void (*buf_finish)(struct vb2_buffer *vb);
348 void (*buf_cleanup)(struct vb2_buffer *vb);
350 int (*start_streaming)(struct vb2_queue *q, unsigned int count);
351 void (*stop_streaming)(struct vb2_queue *q);
353 void (*buf_queue)(struct vb2_buffer *vb);
359 * struct vb2_queue - a videobuf queue
361 * @type: queue type (see V4L2_BUF_TYPE_* in linux/videodev2.h
362 * @io_modes: supported io methods (see vb2_io_modes enum)
363 * @fileio_read_once: report EOF after reading the first buffer
364 * @fileio_write_immediately: queue buffer after each write() call
365 * @allow_zero_bytesused: allow bytesused == 0 to be passed to the driver
366 * @lock: pointer to a mutex that protects the vb2_queue struct. The
367 * driver can set this to a mutex to let the v4l2 core serialize
368 * the queuing ioctls. If the driver wants to handle locking
369 * itself, then this should be set to NULL. This lock is not used
370 * by the videobuf2 core API.
371 * @owner: The filehandle that 'owns' the buffers, i.e. the filehandle
372 * that called reqbufs, create_buffers or started fileio.
373 * This field is not used by the videobuf2 core API, but it allows
374 * drivers to easily associate an owner filehandle with the queue.
375 * @ops: driver-specific callbacks
376 * @mem_ops: memory allocator specific callbacks
377 * @drv_priv: driver private data
378 * @buf_struct_size: size of the driver-specific buffer structure;
379 * "0" indicates the driver doesn't want to use a custom buffer
380 * structure type. for example, sizeof(struct vb2_v4l2_buffer)
381 * will be used for v4l2.
382 * @timestamp_flags: Timestamp flags; V4L2_BUF_FLAG_TIMESTAMP_* and
383 * V4L2_BUF_FLAG_TSTAMP_SRC_*
384 * @gfp_flags: additional gfp flags used when allocating the buffers.
385 * Typically this is 0, but it may be e.g. GFP_DMA or __GFP_DMA32
386 * to force the buffer allocation to a specific memory zone.
387 * @min_buffers_needed: the minimum number of buffers needed before
388 * start_streaming() can be called. Used when a DMA engine
389 * cannot be started unless at least this number of buffers
390 * have been queued into the driver.
393 * Private elements (won't appear at the DocBook):
394 * @mmap_lock: private mutex used when buffers are allocated/freed/mmapped
395 * @memory: current memory type used
396 * @bufs: videobuf buffer structures
397 * @num_buffers: number of allocated/used buffers
398 * @queued_list: list of buffers currently queued from userspace
399 * @queued_count: number of buffers queued and ready for streaming.
400 * @owned_by_drv_count: number of buffers owned by the driver
401 * @done_list: list of buffers ready to be dequeued to userspace
402 * @done_lock: lock to protect done_list list
403 * @done_wq: waitqueue for processes waiting for buffers ready to be dequeued
404 * @alloc_ctx: memory type/allocator-specific contexts for each plane
405 * @streaming: current streaming state
406 * @start_streaming_called: start_streaming() was called successfully and we
408 * @error: a fatal error occurred on the queue
409 * @waiting_for_buffers: used in poll() to check if vb2 is still waiting for
410 * buffers. Only set for capture queues if qbuf has not yet been
411 * called since poll() needs to return POLLERR in that situation.
412 * @last_buffer_dequeued: used in poll() and DQBUF to immediately return if the
413 * last decoded buffer was already dequeued. Set for capture queues
414 * when a buffer with the V4L2_BUF_FLAG_LAST is dequeued.
415 * @fileio: file io emulator internal data, used only if emulator is active
416 * @threadio: thread io internal data, used only if thread is active
419 enum v4l2_buf_type type;
420 unsigned int io_modes;
421 unsigned fileio_read_once:1;
422 unsigned fileio_write_immediately:1;
423 unsigned allow_zero_bytesused:1;
426 struct v4l2_fh *owner;
428 const struct vb2_ops *ops;
429 const struct vb2_mem_ops *mem_ops;
431 unsigned int buf_struct_size;
434 u32 min_buffers_needed;
436 /* private: internal use only */
437 struct mutex mmap_lock;
438 enum v4l2_memory memory;
439 struct vb2_buffer *bufs[VIDEO_MAX_FRAME];
440 unsigned int num_buffers;
442 struct list_head queued_list;
443 unsigned int queued_count;
445 atomic_t owned_by_drv_count;
446 struct list_head done_list;
447 spinlock_t done_lock;
448 wait_queue_head_t done_wq;
450 void *alloc_ctx[VIDEO_MAX_PLANES];
451 unsigned int plane_sizes[VIDEO_MAX_PLANES];
453 unsigned int streaming:1;
454 unsigned int start_streaming_called:1;
455 unsigned int error:1;
456 unsigned int waiting_for_buffers:1;
457 unsigned int last_buffer_dequeued:1;
459 struct vb2_fileio_data *fileio;
460 struct vb2_threadio_data *threadio;
462 #ifdef CONFIG_VIDEO_ADV_DEBUG
464 * Counters for how often these queue-related ops are
465 * called. Used to check for unbalanced ops.
468 u32 cnt_wait_prepare;
470 u32 cnt_start_streaming;
471 u32 cnt_stop_streaming;
475 void *vb2_plane_vaddr(struct vb2_buffer *vb, unsigned int plane_no);
476 void *vb2_plane_cookie(struct vb2_buffer *vb, unsigned int plane_no);
478 void vb2_buffer_done(struct vb2_buffer *vb, enum vb2_buffer_state state);
479 void vb2_discard_done(struct vb2_queue *q);
480 int vb2_wait_for_all_buffers(struct vb2_queue *q);
482 int vb2_querybuf(struct vb2_queue *q, struct v4l2_buffer *b);
483 int vb2_reqbufs(struct vb2_queue *q, struct v4l2_requestbuffers *req);
485 int vb2_create_bufs(struct vb2_queue *q, struct v4l2_create_buffers *create);
486 int vb2_prepare_buf(struct vb2_queue *q, struct v4l2_buffer *b);
488 int __must_check vb2_queue_init(struct vb2_queue *q);
490 void vb2_queue_release(struct vb2_queue *q);
491 void vb2_queue_error(struct vb2_queue *q);
493 int vb2_qbuf(struct vb2_queue *q, struct v4l2_buffer *b);
494 int vb2_expbuf(struct vb2_queue *q, struct v4l2_exportbuffer *eb);
495 int vb2_dqbuf(struct vb2_queue *q, struct v4l2_buffer *b, bool nonblocking);
497 int vb2_streamon(struct vb2_queue *q, enum v4l2_buf_type type);
498 int vb2_streamoff(struct vb2_queue *q, enum v4l2_buf_type type);
500 int vb2_mmap(struct vb2_queue *q, struct vm_area_struct *vma);
502 unsigned long vb2_get_unmapped_area(struct vb2_queue *q,
506 unsigned long flags);
508 unsigned int vb2_poll(struct vb2_queue *q, struct file *file, poll_table *wait);
509 size_t vb2_read(struct vb2_queue *q, char __user *data, size_t count,
510 loff_t *ppos, int nonblock);
511 size_t vb2_write(struct vb2_queue *q, const char __user *data, size_t count,
512 loff_t *ppos, int nonblock);
515 * vb2_thread_fnc - callback function for use with vb2_thread
517 * This is called whenever a buffer is dequeued in the thread.
519 typedef int (*vb2_thread_fnc)(struct vb2_buffer *vb, void *priv);
522 * vb2_thread_start() - start a thread for the given queue.
524 * @fnc: callback function
525 * @priv: priv pointer passed to the callback function
526 * @thread_name:the name of the thread. This will be prefixed with "vb2-".
528 * This starts a thread that will queue and dequeue until an error occurs
529 * or @vb2_thread_stop is called.
531 * This function should not be used for anything else but the videobuf2-dvb
532 * support. If you think you have another good use-case for this, then please
533 * contact the linux-media mailinglist first.
535 int vb2_thread_start(struct vb2_queue *q, vb2_thread_fnc fnc, void *priv,
536 const char *thread_name);
539 * vb2_thread_stop() - stop the thread for the given queue.
542 int vb2_thread_stop(struct vb2_queue *q);
545 * vb2_is_streaming() - return streaming status of the queue
548 static inline bool vb2_is_streaming(struct vb2_queue *q)
554 * vb2_fileio_is_active() - return true if fileio is active.
557 * This returns true if read() or write() is used to stream the data
558 * as opposed to stream I/O. This is almost never an important distinction,
559 * except in rare cases. One such case is that using read() or write() to
560 * stream a format using V4L2_FIELD_ALTERNATE is not allowed since there
561 * is no way you can pass the field information of each buffer to/from
562 * userspace. A driver that supports this field format should check for
563 * this in the queue_setup op and reject it if this function returns true.
565 static inline bool vb2_fileio_is_active(struct vb2_queue *q)
571 * vb2_is_busy() - return busy status of the queue
574 * This function checks if queue has any buffers allocated.
576 static inline bool vb2_is_busy(struct vb2_queue *q)
578 return (q->num_buffers > 0);
582 * vb2_get_drv_priv() - return driver private data associated with the queue
585 static inline void *vb2_get_drv_priv(struct vb2_queue *q)
591 * vb2_set_plane_payload() - set bytesused for the plane plane_no
592 * @vb: buffer for which plane payload should be set
593 * @plane_no: plane number for which payload should be set
594 * @size: payload in bytes
596 static inline void vb2_set_plane_payload(struct vb2_buffer *vb,
597 unsigned int plane_no, unsigned long size)
599 if (plane_no < vb->num_planes)
600 vb->planes[plane_no].bytesused = size;
604 * vb2_get_plane_payload() - get bytesused for the plane plane_no
605 * @vb: buffer for which plane payload should be set
606 * @plane_no: plane number for which payload should be set
608 static inline unsigned long vb2_get_plane_payload(struct vb2_buffer *vb,
609 unsigned int plane_no)
611 if (plane_no < vb->num_planes)
612 return vb->planes[plane_no].bytesused;
617 * vb2_plane_size() - return plane size in bytes
618 * @vb: buffer for which plane size should be returned
619 * @plane_no: plane number for which size should be returned
621 static inline unsigned long
622 vb2_plane_size(struct vb2_buffer *vb, unsigned int plane_no)
624 if (plane_no < vb->num_planes)
625 return vb->planes[plane_no].length;
630 * vb2_start_streaming_called() - return streaming status of driver
633 static inline bool vb2_start_streaming_called(struct vb2_queue *q)
635 return q->start_streaming_called;
639 * vb2_clear_last_buffer_dequeued() - clear last buffer dequeued flag of queue
642 static inline void vb2_clear_last_buffer_dequeued(struct vb2_queue *q)
644 q->last_buffer_dequeued = false;
648 * The following functions are not part of the vb2 core API, but are simple
649 * helper functions that you can use in your struct v4l2_file_operations,
650 * struct v4l2_ioctl_ops and struct vb2_ops. They will serialize if vb2_queue->lock
651 * or video_device->lock is set, and they will set and test vb2_queue->owner
652 * to check if the calling filehandle is permitted to do the queuing operation.
655 /* struct v4l2_ioctl_ops helpers */
657 int vb2_ioctl_reqbufs(struct file *file, void *priv,
658 struct v4l2_requestbuffers *p);
659 int vb2_ioctl_create_bufs(struct file *file, void *priv,
660 struct v4l2_create_buffers *p);
661 int vb2_ioctl_prepare_buf(struct file *file, void *priv,
662 struct v4l2_buffer *p);
663 int vb2_ioctl_querybuf(struct file *file, void *priv, struct v4l2_buffer *p);
664 int vb2_ioctl_qbuf(struct file *file, void *priv, struct v4l2_buffer *p);
665 int vb2_ioctl_dqbuf(struct file *file, void *priv, struct v4l2_buffer *p);
666 int vb2_ioctl_streamon(struct file *file, void *priv, enum v4l2_buf_type i);
667 int vb2_ioctl_streamoff(struct file *file, void *priv, enum v4l2_buf_type i);
668 int vb2_ioctl_expbuf(struct file *file, void *priv,
669 struct v4l2_exportbuffer *p);
671 /* struct v4l2_file_operations helpers */
673 int vb2_fop_mmap(struct file *file, struct vm_area_struct *vma);
674 int vb2_fop_release(struct file *file);
675 int _vb2_fop_release(struct file *file, struct mutex *lock);
676 ssize_t vb2_fop_write(struct file *file, const char __user *buf,
677 size_t count, loff_t *ppos);
678 ssize_t vb2_fop_read(struct file *file, char __user *buf,
679 size_t count, loff_t *ppos);
680 unsigned int vb2_fop_poll(struct file *file, poll_table *wait);
682 unsigned long vb2_fop_get_unmapped_area(struct file *file, unsigned long addr,
683 unsigned long len, unsigned long pgoff, unsigned long flags);
686 /* struct vb2_ops helpers, only use if vq->lock is non-NULL. */
688 void vb2_ops_wait_prepare(struct vb2_queue *vq);
689 void vb2_ops_wait_finish(struct vb2_queue *vq);
691 #endif /* _MEDIA_VIDEOBUF2_CORE_H */