media: vb2: videobuf -> videobuf2

}

/*

 * __vb2_queue_alloc() - allocate videobuf buffer structures and (for MMAP type)

 * __vb2_queue_alloc() - allocate vb2 buffer structures and (for MMAP type)

 * video buffer memory for all buffers/planes on the queue and initializes the

 * queue

 *

			    VB2_MAX_FRAME - q->num_buffers);

	for (buffer = 0; buffer < num_buffers; ++buffer) {

		/* Allocate videobuf buffer structures */

		/* Allocate vb2 buffer structures */

		vb = kzalloc(q->buf_struct_size, GFP_KERNEL);

		if (!vb) {

			dprintk(q, 1, "memory alloc for buffer struct failed\n");

	}

#endif

	/* Free videobuf buffers */

	/* Free vb2 buffers */

	for (buffer = q->num_buffers - buffers; buffer < q->num_buffers;

	     ++buffer) {

		kfree(q->bufs[buffer]);

	if (pb)

		call_void_bufop(q, fill_user_buffer, vb, pb);

	/* Remove from videobuf queue */

	/* Remove from vb2 queue */

	list_del(&vb->queued_entry);

	q->queued_count--;

 * __vb2_queue_cancel() - cancel and stop (pause) streaming

 *

 * Removes all queued buffers from driver's queue and all buffers queued by

 * userspace from videobuf's queue. Returns to state after reqbufs.

 * userspace from vb2's queue. Returns to state after reqbufs.

 */

static void __vb2_queue_cancel(struct vb2_queue *q)

{

	q->uses_qbuf = 0;

	/*

	 * Remove all buffers from videobuf's list...

	 * Remove all buffers from vb2's list...

	 */

	INIT_LIST_HEAD(&q->queued_list);

	/*

	/*

	 * Cancel will pause streaming and remove all buffers from the driver

	 * and videobuf, effectively returning control over them to userspace.

	 * and vb2, effectively returning control over them to userspace.

	 *

	 * Note that we do this even if q->streaming == 0: if you prepare or

	 * queue buffers, and then call streamoff without ever having called

 *

 * some helper function for simple DVB cards which simply DMA the

 * complete transport stream and let the computer sort everything else

 * (i.e. we are using the software demux, ...).  Also uses the

 * video-buf to manage DMA buffers.

 * (i.e. we are using the software demux, ...).  Also uses vb2

 * to manage DMA buffers.

 *

 * (c) 2004 Gerd Knorr <kraxel@bytesex.org> [SUSE Labs]

 */

		/*

		 * Single-planar buffers do not use planes array,

		 * so fill in relevant v4l2_buffer struct fields instead.

		 * In videobuf we use our internal V4l2_planes struct for

		 * In vb2 we use our internal V4l2_planes struct for

		 * single-planar buffers as well, for simplicity.

		 *

		 * If bytesused == 0 for the output buffer, then fall back

/*

 * vb2_querybuf() - query video buffer information

 * @q:		videobuf queue

 * @q:		vb2 queue

 * @b:		buffer struct passed from userspace to vidioc_querybuf handler

 *		in driver

 *

 *		 DMABUF memory types.

 * @get_userptr: acquire userspace memory for a hardware operation; used for

 *		 USERPTR memory types; vaddr is the address passed to the

 *		 videobuf layer when queuing a video buffer of USERPTR type;

 *		 videobuf2 layer when queuing a video buffer of USERPTR type;

 *		 should return an allocator private per-buffer structure

 *		 associated with the buffer on success, ERR_PTR() on failure;

 *		 the returned private structure will then be passed as @buf_priv

 *		associated with the passed private structure or NULL if not

 *		available.

 * @num_users:	return the current number of users of a memory buffer;

 *		return 1 if the videobuf layer (or actually the driver using

 *		return 1 if the videobuf2 layer (or actually the driver using

 *		it) is the only user.

 * @mmap:	setup a userspace mapping for a given memory buffer under

 *		the provided virtual memory region.

 * enum vb2_buffer_state - current video buffer state.

 * @VB2_BUF_STATE_DEQUEUED:	buffer under userspace control.

 * @VB2_BUF_STATE_IN_REQUEST:	buffer is queued in media request.

 * @VB2_BUF_STATE_PREPARING:	buffer is being prepared in videobuf.

 * @VB2_BUF_STATE_QUEUED:	buffer queued in videobuf, but not in driver.

 * @VB2_BUF_STATE_PREPARING:	buffer is being prepared in videobuf2.

 * @VB2_BUF_STATE_QUEUED:	buffer queued in videobuf2, but not in driver.

 * @VB2_BUF_STATE_ACTIVE:	buffer queued in driver and possibly used

 *				in a hardware operation.

 * @VB2_BUF_STATE_DONE:		buffer returned from driver to videobuf, but

 * @VB2_BUF_STATE_DONE:		buffer returned from driver to videobuf2, but

 *				not yet dequeued to userspace.

 * @VB2_BUF_STATE_ERROR:	same as above, but the operation on the buffer

 *				has ended with an error, which will be reported

};

/**

 * struct vb2_queue - a videobuf queue.

 * struct vb2_queue - a videobuf2 queue.

 *

 * @type:	private buffer type whose content is defined by the vb2-core

 *		caller. For example, for V4L2, it should match

 * @mmap_lock:	private mutex used when buffers are allocated/freed/mmapped

 * @memory:	current memory type used

 * @dma_dir:	DMA mapping direction.

 * @bufs:	videobuf buffer structures

 * @bufs:	videobuf2 buffer structures

 * @num_buffers: number of allocated/used buffers

 * @queued_list: list of buffers currently queued from userspace

 * @queued_count: number of buffers queued and ready for streaming.

void *vb2_plane_cookie(struct vb2_buffer *vb, unsigned int plane_no);

/**

 * vb2_buffer_done() - inform videobuf that an operation on a buffer

 * vb2_buffer_done() - inform videobuf2 that an operation on a buffer

 *	is finished.

 * @vb:		pointer to &struct vb2_buffer to be used.

 * @state:	state of the buffer, as defined by &enum vb2_buffer_state.

	struct dvb_frontend	*frontend;

	struct vb2_queue	dvbq;

	/* video-buf-dvb state info */

	/* vb2-dvb state info */

	struct mutex		lock;

	int			nfeeds;