Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 382c31a9 authored by Hans Verkuil's avatar Hans Verkuil Committed by Mauro Carvalho Chehab
Browse files

[media] solo6x10: convert encoder nodes to vb2 



As a consequence the ioctl op has been replaced by unlocked_ioctl.
Since we are now using the core lock the locking scheme has been
simplified as well.

Signed-off-by: default avatarHans Verkuil <hans.verkuil@cisco.com>
Signed-off-by: default avatarMauro Carvalho Chehab <mchehab@redhat.com>
parent a7eb931d

drivers/staging/media/solo6x10/Kconfig

+1 −0
Original line number Diff line number Diff line
@@ -2,6 +2,7 @@ config SOLO6X10 
	tristate "Softlogic 6x10 MPEG codec cards"

	depends on PCI && VIDEO_DEV && SND && I2C

	select VIDEOBUF_DMA_SG

	select VIDEOBUF2_DMA_SG

	select SND_PCM

	---help---

	  This driver supports the Softlogic based MPEG-4 and h.264 codec

drivers/staging/media/solo6x10/solo6x10.h

+8 −5
Original line number Diff line number Diff line
@@ -40,6 +40,7 @@ 
#include <media/v4l2-device.h>

#include <media/v4l2-ctrls.h>

#include <media/videobuf-core.h>

#include <media/videobuf2-core.h>



#include "registers.h"
@@ -135,6 +136,11 @@ struct solo_p2m_dev { 


#define OSD_TEXT_MAX		44



struct solo_vb2_buf {

	struct vb2_buffer vb;

	struct list_head list;

};



enum solo_enc_types {

	SOLO_ENC_TYPE_STD,

	SOLO_ENC_TYPE_EXT,
@@ -146,10 +152,8 @@ struct solo_enc_dev { 
	struct v4l2_ctrl_handler hdl;

	struct video_device	*vfd;

	/* General accounting */

	struct mutex		enable_lock;

	struct mutex		lock;

	spinlock_t		motion_lock;

	atomic_t		readers;

	atomic_t		mpeg_readers;

	u8			ch;

	u8			mode, gop, qp, interlaced, interval;

	u8			bw_weight;
@@ -169,9 +173,8 @@ struct solo_enc_dev { 
	int			jpeg_len;



	u32			fmt;

	u8			enc_on;

	enum solo_enc_types	type;

	struct videobuf_queue	vidq;

	struct vb2_queue	vidq;

	struct list_head	vidq_active;

	int			desc_count;

	int			desc_nelts;

drivers/staging/media/solo6x10/v4l2-enc.c

+131 −374
Original line number Diff line number Diff line
@@ -30,7 +30,7 @@ 
#include <media/v4l2-ioctl.h>

#include <media/v4l2-common.h>

#include <media/v4l2-event.h>

#include <media/videobuf-dma-sg.h>

#include <media/videobuf2-dma-sg.h>



#include "solo6x10.h"

#include "tw28.h"
@@ -181,7 +181,6 @@ static void solo_motion_toggle(struct solo_enc_dev *solo_enc, int on) 
	spin_unlock_irqrestore(&solo_enc->motion_lock, flags);

}



/* MUST be called with solo_enc->enable_lock held */

static void solo_update_mode(struct solo_enc_dev *solo_enc)

{

	struct solo_dev *solo_dev = solo_enc->solo_dev;
@@ -264,43 +263,22 @@ static void solo_update_mode(struct solo_enc_dev *solo_enc) 
	       jpeg_dqt[solo_g_jpeg_qp(solo_dev, solo_enc->ch)], DQT_LEN);

}



/* MUST be called with solo_enc->enable_lock held */

static int __solo_enc_on(struct solo_enc_dev *solo_enc)

static int solo_enc_on(struct solo_enc_dev *solo_enc)

{

	u8 ch = solo_enc->ch;

	struct solo_dev *solo_dev = solo_enc->solo_dev;

	u8 interval;



	BUG_ON(!mutex_is_locked(&solo_enc->enable_lock));



	if (solo_enc->enc_on)

		return 0;



	solo_update_mode(solo_enc);



	/* Make sure to bw check on first reader */

	if (!atomic_read(&solo_enc->readers)) {

	/* Make sure to do a bandwidth check */

	if (solo_enc->bw_weight > solo_dev->enc_bw_remain)

		return -EBUSY;

		else

	solo_dev->enc_bw_remain -= solo_enc->bw_weight;

	}



	solo_enc->enc_on = 1;



	if (solo_enc->type == SOLO_ENC_TYPE_EXT)

		solo_reg_write(solo_dev, SOLO_CAP_CH_COMP_ENA_E(ch), 1);



	/* Reset the encoder if we are the first mpeg reader, else only reset

	 * on the first mjpeg reader. */

	if (solo_enc->fmt == V4L2_PIX_FMT_MPEG) {

		atomic_inc(&solo_enc->readers);

		if (atomic_inc_return(&solo_enc->mpeg_readers) > 1)

			return 0;

	} else if (atomic_inc_return(&solo_enc->readers) > 1) {

		return 0;

	}



	/* Disable all encoding for this channel */

	solo_reg_write(solo_dev, SOLO_CAP_CH_SCALE(ch), 0);
@@ -329,47 +307,16 @@ static int __solo_enc_on(struct solo_enc_dev *solo_enc) 
	return 0;

}



static int solo_enc_on(struct solo_enc_dev *solo_enc)

{

	int ret;



	mutex_lock(&solo_enc->enable_lock);

	ret = __solo_enc_on(solo_enc);

	mutex_unlock(&solo_enc->enable_lock);



	return ret;

}



static void __solo_enc_off(struct solo_enc_dev *solo_enc)

static void solo_enc_off(struct solo_enc_dev *solo_enc)

{

	struct solo_dev *solo_dev = solo_enc->solo_dev;



	BUG_ON(!mutex_is_locked(&solo_enc->enable_lock));



	if (!solo_enc->enc_on)

		return;



	solo_enc->enc_on = 0;



	if (solo_enc->fmt == V4L2_PIX_FMT_MPEG)

		atomic_dec(&solo_enc->mpeg_readers);



	if (atomic_dec_return(&solo_enc->readers) > 0)

		return;



	solo_dev->enc_bw_remain += solo_enc->bw_weight;



	solo_reg_write(solo_dev, SOLO_CAP_CH_SCALE(solo_enc->ch), 0);

	solo_reg_write(solo_dev, SOLO_CAP_CH_COMP_ENA_E(solo_enc->ch), 0);

}



static void solo_enc_off(struct solo_enc_dev *solo_enc)

{

	mutex_lock(&solo_enc->enable_lock);

	__solo_enc_off(solo_enc);

	mutex_unlock(&solo_enc->enable_lock);

}



static int enc_get_mpeg_dma(struct solo_dev *solo_dev, dma_addr_t dma,

			      unsigned int off, unsigned int size)

{
@@ -403,7 +350,7 @@ static int enc_get_mpeg_dma(struct solo_dev *solo_dev, dma_addr_t dma, 
/* Build a descriptor queue out of an SG list and send it to the P2M for

 * processing. */

static int solo_send_desc(struct solo_enc_dev *solo_enc, int skip,

			  struct videobuf_dmabuf *vbuf, int off, int size,

			  struct vb2_dma_sg_desc *vbuf, int off, int size,

			  unsigned int base, unsigned int base_size)

{

	struct solo_dev *solo_dev = solo_enc->solo_dev;
@@ -416,7 +363,7 @@ static int solo_send_desc(struct solo_enc_dev *solo_enc, int skip, 


	solo_enc->desc_count = 1;



	for_each_sg(vbuf->sglist, sg, vbuf->sglen, i) {

	for_each_sg(vbuf->sglist, sg, vbuf->num_pages, i) {

		struct solo_p2m_desc *desc;

		dma_addr_t dma;

		int len;
@@ -487,61 +434,62 @@ static int solo_send_desc(struct solo_enc_dev *solo_enc, int skip, 
				 solo_enc->desc_count - 1);

}



static int solo_fill_jpeg(struct solo_enc_dev *solo_enc, struct videobuf_buffer *vb,

			  struct videobuf_dmabuf *vbuf, struct vop_header *vh)

static int solo_fill_jpeg(struct solo_enc_dev *solo_enc,

		struct vb2_buffer *vb, struct vop_header *vh)

{

	struct solo_dev *solo_dev = solo_enc->solo_dev;

	struct solo_videobuf *svb = (struct solo_videobuf *)vb;

	struct vb2_dma_sg_desc *vbuf = vb2_dma_sg_plane_desc(vb, 0);

	int frame_size;

	int ret;



	svb->flags |= V4L2_BUF_FLAG_KEYFRAME;

	vb->v4l2_buf.flags |= V4L2_BUF_FLAG_KEYFRAME;



	if (vb->bsize < (vh->jpeg_size + solo_enc->jpeg_len))

	if (vb2_plane_size(vb, 0) < vh->jpeg_size + solo_enc->jpeg_len)

		return -EIO;



	vb->width = solo_enc->width;

	vb->height = solo_enc->height;

	vb->size = vh->jpeg_size + solo_enc->jpeg_len;



	sg_copy_from_buffer(vbuf->sglist, vbuf->sglen,

	sg_copy_from_buffer(vbuf->sglist, vbuf->num_pages,

			solo_enc->jpeg_header,

			solo_enc->jpeg_len);



	frame_size = (vh->jpeg_size + solo_enc->jpeg_len + (DMA_ALIGN - 1))

		& ~(DMA_ALIGN - 1);

	vb2_set_plane_payload(vb, 0, vh->jpeg_size + solo_enc->jpeg_len);



	return solo_send_desc(solo_enc, solo_enc->jpeg_len, vbuf, vh->jpeg_off,

	dma_map_sg(&solo_dev->pdev->dev, vbuf->sglist, vbuf->num_pages,

			DMA_FROM_DEVICE);

	ret = solo_send_desc(solo_enc, solo_enc->jpeg_len, vbuf, vh->jpeg_off,

			frame_size, SOLO_JPEG_EXT_ADDR(solo_dev),

			SOLO_JPEG_EXT_SIZE(solo_dev));

	dma_unmap_sg(&solo_dev->pdev->dev, vbuf->sglist, vbuf->num_pages,

			DMA_FROM_DEVICE);

	return ret;

}



static int solo_fill_mpeg(struct solo_enc_dev *solo_enc, struct videobuf_buffer *vb,

			  struct videobuf_dmabuf *vbuf, struct vop_header *vh)

static int solo_fill_mpeg(struct solo_enc_dev *solo_enc,

		struct vb2_buffer *vb, struct vop_header *vh)

{

	struct solo_dev *solo_dev = solo_enc->solo_dev;

	struct solo_videobuf *svb = (struct solo_videobuf *)vb;

	struct vb2_dma_sg_desc *vbuf = vb2_dma_sg_plane_desc(vb, 0);

	int frame_off, frame_size;

	int skip = 0;

	int ret;



	if (vb->bsize < vh->mpeg_size)

	if (vb2_plane_size(vb, 0) < vh->mpeg_size)

		return -EIO;



	vb->width = vh->hsize << 4;

	vb->height = vh->vsize << 4;

	vb->size = vh->mpeg_size;



	/* If this is a key frame, add extra header */

	if (!vh->vop_type) {

		sg_copy_from_buffer(vbuf->sglist, vbuf->sglen,

		sg_copy_from_buffer(vbuf->sglist, vbuf->num_pages,

				solo_enc->vop,

				solo_enc->vop_len);



		skip = solo_enc->vop_len;

		vb->size += solo_enc->vop_len;



		svb->flags |= V4L2_BUF_FLAG_KEYFRAME;

		vb->v4l2_buf.flags |= V4L2_BUF_FLAG_KEYFRAME;

		vb2_set_plane_payload(vb, 0, vh->mpeg_size + solo_enc->vop_len);

	} else {

		svb->flags |= V4L2_BUF_FLAG_PFRAME;

		vb->v4l2_buf.flags |= V4L2_BUF_FLAG_PFRAME;

		vb2_set_plane_payload(vb, 0, vh->mpeg_size);

	}



	/* Now get the actual mpeg payload */
@@ -550,93 +498,67 @@ static int solo_fill_mpeg(struct solo_enc_dev *solo_enc, struct videobuf_buffer 
	frame_size = (vh->mpeg_size + skip + (DMA_ALIGN - 1))

		& ~(DMA_ALIGN - 1);



	return solo_send_desc(solo_enc, skip, vbuf, frame_off, frame_size,

	dma_map_sg(&solo_dev->pdev->dev, vbuf->sglist, vbuf->num_pages,

			DMA_FROM_DEVICE);

	ret = solo_send_desc(solo_enc, skip, vbuf, frame_off, frame_size,

			SOLO_MP4E_EXT_ADDR(solo_dev),

			SOLO_MP4E_EXT_SIZE(solo_dev));

	dma_unmap_sg(&solo_dev->pdev->dev, vbuf->sglist, vbuf->num_pages,

			DMA_FROM_DEVICE);

	return ret;

}



static int solo_enc_fillbuf(struct solo_enc_dev *solo_enc,

			    struct videobuf_buffer *vb,

			    struct solo_enc_buf *enc_buf)

			    struct vb2_buffer *vb, struct solo_enc_buf *enc_buf)

{

	struct solo_videobuf *svb = (struct solo_videobuf *)vb;

	struct videobuf_dmabuf *vbuf = NULL;

	struct vop_header *vh = enc_buf->vh;

	int ret;



	vbuf = videobuf_to_dma(vb);

	if (WARN_ON_ONCE(!vbuf)) {

		ret = -EIO;

		goto vbuf_error;

	}



	/* Setup some common flags for both types */

	svb->flags = V4L2_BUF_FLAG_TIMECODE;

	vb->ts.tv_sec = vh->sec;

	vb->ts.tv_usec = vh->usec;



	/* Check for motion flags */

	if (solo_is_motion_on(solo_enc)) {

		svb->flags |= V4L2_BUF_FLAG_MOTION_ON;

		vb->v4l2_buf.flags |= V4L2_BUF_FLAG_MOTION_ON;

		if (enc_buf->motion)

			svb->flags |= V4L2_BUF_FLAG_MOTION_DETECTED;

			vb->v4l2_buf.flags |= V4L2_BUF_FLAG_MOTION_DETECTED;

	}



	if (solo_enc->fmt == V4L2_PIX_FMT_MPEG)

		ret = solo_fill_mpeg(solo_enc, vb, vbuf, vh);

		ret = solo_fill_mpeg(solo_enc, vb, vh);

	else

		ret = solo_fill_jpeg(solo_enc, vb, vbuf, vh);



vbuf_error:

	/* On error, we push this buffer back into the queue. The

	 * videobuf-core doesn't handle error packets very well. Plus

	 * we recover nicely internally anyway. */

	if (ret) {

		unsigned long flags;

		ret = solo_fill_jpeg(solo_enc, vb, vh);



		spin_lock_irqsave(&solo_enc->av_lock, flags);

		list_add(&vb->queue, &solo_enc->vidq_active);

		vb->state = VIDEOBUF_QUEUED;

		spin_unlock_irqrestore(&solo_enc->av_lock, flags);

	} else {

		vb->state = VIDEOBUF_DONE;

		vb->field_count++;

		vb->width = solo_enc->width;

		vb->height = solo_enc->height;



		wake_up(&vb->done);

	if (!ret) {

		vb->v4l2_buf.sequence++;

		vb->v4l2_buf.timestamp.tv_sec = vh->sec;

		vb->v4l2_buf.timestamp.tv_usec = vh->usec;

	}



	vb2_buffer_done(vb, ret ? VB2_BUF_STATE_ERROR : VB2_BUF_STATE_DONE);



	return ret;

}



static void solo_enc_handle_one(struct solo_enc_dev *solo_enc,

				struct solo_enc_buf *enc_buf)

{

	struct videobuf_buffer *vb;

	struct solo_vb2_buf *vb;

	unsigned long flags;



	mutex_lock(&solo_enc->enable_lock);



	mutex_lock(&solo_enc->lock);

	if (solo_enc->type != enc_buf->type)

		goto unlock;



	if (list_empty(&solo_enc->vidq_active))

		goto unlock;



	spin_lock_irqsave(&solo_enc->av_lock, flags);



	vb = list_first_entry(&solo_enc->vidq_active,

			struct videobuf_buffer, queue);



	list_del(&vb->queue);

	vb->state = VIDEOBUF_ACTIVE;



	if (list_empty(&solo_enc->vidq_active)) {

		spin_unlock_irqrestore(&solo_enc->av_lock, flags);

		goto unlock;

	}

	vb = list_first_entry(&solo_enc->vidq_active, struct solo_vb2_buf, list);

	list_del(&vb->list);

	spin_unlock_irqrestore(&solo_enc->av_lock, flags);



	solo_enc_fillbuf(solo_enc, vb, enc_buf);

	solo_enc_fillbuf(solo_enc, &vb->vb, enc_buf);

unlock:

	mutex_unlock(&solo_enc->enable_lock);

	mutex_unlock(&solo_enc->lock);

}



void solo_enc_v4l2_isr(struct solo_dev *solo_dev)
@@ -723,85 +645,29 @@ static int solo_ring_thread(void *data) 
	return 0;

}



static int solo_enc_buf_setup(struct videobuf_queue *vq, unsigned int *count,

			      unsigned int *size)

static int solo_enc_queue_setup(struct vb2_queue *q, const struct v4l2_format *fmt,

			   unsigned int *num_buffers, unsigned int *num_planes,

			   unsigned int sizes[], void *alloc_ctxs[])

{

	*size = FRAME_BUF_SIZE;

	sizes[0] = FRAME_BUF_SIZE;

	*num_planes = 1;



	if (*count < MIN_VID_BUFFERS)

		*count = MIN_VID_BUFFERS;

	if (*num_buffers < MIN_VID_BUFFERS)

		*num_buffers = MIN_VID_BUFFERS;



	return 0;

}



static int solo_enc_buf_prepare(struct videobuf_queue *vq,

				struct videobuf_buffer *vb,

				enum v4l2_field field)

static void solo_enc_buf_queue(struct vb2_buffer *vb)

{

	vb->size = FRAME_BUF_SIZE;

	if (vb->baddr != 0 && vb->bsize < vb->size)

		return -EINVAL;



	/* This property only change when queue is idle */

	vb->field = field;

	struct vb2_queue *vq = vb->vb2_queue;

	struct solo_enc_dev *solo_enc = vb2_get_drv_priv(vq);

	struct solo_vb2_buf *solo_vb =

		container_of(vb, struct solo_vb2_buf, vb);



	if (vb->state == VIDEOBUF_NEEDS_INIT) {

		int rc = videobuf_iolock(vq, vb, NULL);

		if (rc < 0) {

			struct videobuf_dmabuf *dma = videobuf_to_dma(vb);

			videobuf_dma_unmap(vq->dev, dma);

			videobuf_dma_free(dma);



			return rc;

		}

	}

	vb->state = VIDEOBUF_PREPARED;



	return 0;

}



static void solo_enc_buf_queue(struct videobuf_queue *vq,

			       struct videobuf_buffer *vb)

{

	struct solo_enc_dev *solo_enc = vq->priv_data;



	vb->state = VIDEOBUF_QUEUED;

	list_add_tail(&vb->queue, &solo_enc->vidq_active);

}



static void solo_enc_buf_release(struct videobuf_queue *vq,

				 struct videobuf_buffer *vb)

{

	struct videobuf_dmabuf *dma = videobuf_to_dma(vb);

	videobuf_dma_unmap(vq->dev, dma);

	videobuf_dma_free(dma);

	vb->state = VIDEOBUF_NEEDS_INIT;

}



static const struct videobuf_queue_ops solo_enc_video_qops = {

	.buf_setup	= solo_enc_buf_setup,

	.buf_prepare	= solo_enc_buf_prepare,

	.buf_queue	= solo_enc_buf_queue,

	.buf_release	= solo_enc_buf_release,

};



static unsigned int solo_enc_poll(struct file *file,

				  struct poll_table_struct *wait)

{

	struct solo_enc_dev *solo_enc = video_drvdata(file);

	unsigned long req_events = poll_requested_events(wait);

	unsigned res = v4l2_ctrl_poll(file, wait);



	if (!(req_events & (POLLIN | POLLRDNORM)))

		return res;

	return videobuf_poll_stream(file, &solo_enc->vidq, wait);

}



static int solo_enc_mmap(struct file *file, struct vm_area_struct *vma)

{

	struct solo_enc_dev *solo_enc = video_drvdata(file);



	return videobuf_mmap_mapper(&solo_enc->vidq, vma);

	spin_lock(&solo_enc->av_lock);

	list_add_tail(&solo_vb->list, &solo_enc->vidq_active);

	spin_unlock(&solo_enc->av_lock);

}



static int solo_ring_start(struct solo_dev *solo_dev)
@@ -835,50 +701,36 @@ static void solo_ring_stop(struct solo_dev *solo_dev) 
	solo_irq_off(solo_dev, SOLO_IRQ_ENCODER);

}



static int solo_enc_open(struct file *file)

{

	struct solo_enc_dev *solo_enc = video_drvdata(file);

	struct solo_dev *solo_dev = solo_enc->solo_dev;

	int ret = v4l2_fh_open(file);



	if (ret)

		return ret;

	ret = solo_ring_start(solo_dev);

	if (ret) {

		v4l2_fh_release(file);

		return ret;

	}

	return 0;

}



static ssize_t solo_enc_read(struct file *file, char __user *data,

			     size_t count, loff_t *ppos)

static int solo_enc_start_streaming(struct vb2_queue *q, unsigned int count)

{

	struct solo_enc_dev *solo_enc = video_drvdata(file);

	struct solo_enc_dev *solo_enc = vb2_get_drv_priv(q);

	int ret;



	/* Make sure the encoder is on */

	ret = solo_enc_on(solo_enc);

	if (ret)

		return ret;



	return videobuf_read_stream(&solo_enc->vidq, data, count, ppos, 0,

				    file->f_flags & O_NONBLOCK);

	return solo_ring_start(solo_enc->solo_dev);

}



static int solo_enc_release(struct file *file)

static int solo_enc_stop_streaming(struct vb2_queue *q)

{

	struct solo_enc_dev *solo_enc = video_drvdata(file);

	struct solo_dev *solo_dev = solo_enc->solo_dev;

	struct solo_enc_dev *solo_enc = vb2_get_drv_priv(q);



	solo_enc_off(solo_enc);

	videobuf_stop(&solo_enc->vidq);

	videobuf_mmap_free(&solo_enc->vidq);

	solo_ring_stop(solo_dev);



	return v4l2_fh_release(file);

	INIT_LIST_HEAD(&solo_enc->vidq_active);

	solo_ring_stop(solo_enc->solo_dev);

	return 0;

}



static struct vb2_ops solo_enc_video_qops = {

	.queue_setup	= solo_enc_queue_setup,

	.buf_queue	= solo_enc_buf_queue,

	.start_streaming = solo_enc_start_streaming,

	.stop_streaming = solo_enc_stop_streaming,

	.wait_prepare	= vb2_ops_wait_prepare,

	.wait_finish	= vb2_ops_wait_finish,

};



static int solo_enc_querycap(struct file *file, void  *priv,

			     struct v4l2_capability *cap)

{
@@ -1007,23 +859,13 @@ static int solo_enc_set_fmt_cap(struct file *file, void *priv, 
	struct v4l2_pix_format *pix = &f->fmt.pix;

	int ret;



	mutex_lock(&solo_enc->enable_lock);

	if (vb2_is_busy(&solo_enc->vidq))

		return -EBUSY;



	ret = solo_enc_try_fmt_cap(file, priv, f);

	if (ret)

		return ret;



	/* We cannot change width/height in mid read */

	if (!ret && atomic_read(&solo_enc->readers) > 0) {

		if (pix->width != solo_enc->width ||

		    pix->height != solo_enc->height)

			ret = -EBUSY;

	}

	if (ret) {

		mutex_unlock(&solo_enc->enable_lock);

		return ret;

	}



	if (pix->width == solo_dev->video_hsize)

		solo_enc->mode = SOLO_ENC_MODE_D1;

	else
@@ -1034,9 +876,6 @@ static int solo_enc_set_fmt_cap(struct file *file, void *priv, 


	if (pix->priv)

		solo_enc->type = SOLO_ENC_TYPE_EXT;



	mutex_unlock(&solo_enc->enable_lock);



	return 0;

}
@@ -1058,80 +897,6 @@ static int solo_enc_get_fmt_cap(struct file *file, void *priv, 
	return 0;

}



static int solo_enc_reqbufs(struct file *file, void *priv,

			    struct v4l2_requestbuffers *req)

{

	struct solo_enc_dev *solo_enc = video_drvdata(file);



	return videobuf_reqbufs(&solo_enc->vidq, req);

}



static int solo_enc_querybuf(struct file *file, void *priv,

			     struct v4l2_buffer *buf)

{

	struct solo_enc_dev *solo_enc = video_drvdata(file);



	return videobuf_querybuf(&solo_enc->vidq, buf);

}



static int solo_enc_qbuf(struct file *file, void *priv,

			 struct v4l2_buffer *buf)

{

	struct solo_enc_dev *solo_enc = video_drvdata(file);



	return videobuf_qbuf(&solo_enc->vidq, buf);

}



static int solo_enc_dqbuf(struct file *file, void *priv,

			  struct v4l2_buffer *buf)

{

	struct solo_enc_dev *solo_enc = video_drvdata(file);

	struct solo_videobuf *svb;

	int ret;



	/* Make sure the encoder is on */

	ret = solo_enc_on(solo_enc);

	if (ret)

		return ret;



	ret = videobuf_dqbuf(&solo_enc->vidq, buf, file->f_flags & O_NONBLOCK);

	if (ret)

		return ret;



	/* Copy over the flags */

	svb = (struct solo_videobuf *)solo_enc->vidq.bufs[buf->index];

	buf->flags |= svb->flags;



	return 0;

}



static int solo_enc_streamon(struct file *file, void *priv,

			     enum v4l2_buf_type i)

{

	struct solo_enc_dev *solo_enc = video_drvdata(file);



	if (i != V4L2_BUF_TYPE_VIDEO_CAPTURE)

		return -EINVAL;



	return videobuf_streamon(&solo_enc->vidq);

}



static int solo_enc_streamoff(struct file *file, void *priv,

			      enum v4l2_buf_type i)

{

	struct solo_enc_dev *solo_enc = video_drvdata(file);

	int ret;



	if (i != V4L2_BUF_TYPE_VIDEO_CAPTURE)

		return -EINVAL;



	ret = videobuf_streamoff(&solo_enc->vidq);

	if (!ret)

		solo_enc_off(solo_enc);



	return ret;

}



static int solo_enc_s_std(struct file *file, void *priv, v4l2_std_id i)

{

	return 0;
@@ -1220,12 +985,8 @@ static int solo_s_parm(struct file *file, void *priv, 
	struct solo_dev *solo_dev = solo_enc->solo_dev;

	struct v4l2_captureparm *cp = &sp->parm.capture;



	mutex_lock(&solo_enc->enable_lock);



	if (atomic_read(&solo_enc->mpeg_readers) > 0) {

		mutex_unlock(&solo_enc->enable_lock);

	if (vb2_is_streaming(&solo_enc->vidq))

		return -EBUSY;

	}



	if ((cp->timeperframe.numerator == 0) ||

	    (cp->timeperframe.denominator == 0)) {
@@ -1246,9 +1007,6 @@ static int solo_s_parm(struct file *file, void *priv, 
	cp->readbuffers = 2;



	solo_update_mode(solo_enc);



	mutex_unlock(&solo_enc->enable_lock);



	return 0;

}
@@ -1297,10 +1055,8 @@ static int solo_s_ctrl(struct v4l2_ctrl *ctrl) 
		solo_motion_toggle(solo_enc, ctrl->val);

		return 0;

	case V4L2_CID_OSD_TEXT:

		mutex_lock(&solo_enc->enable_lock);

		strcpy(solo_enc->osd_text, ctrl->string);

		err = solo_osd_print(solo_enc);

		mutex_unlock(&solo_enc->enable_lock);

		return err;

	default:

		return -EINVAL;
@@ -1311,12 +1067,12 @@ static int solo_s_ctrl(struct v4l2_ctrl *ctrl) 


static const struct v4l2_file_operations solo_enc_fops = {

	.owner			= THIS_MODULE,

	.open			= solo_enc_open,

	.release		= solo_enc_release,

	.read			= solo_enc_read,

	.poll			= solo_enc_poll,

	.mmap			= solo_enc_mmap,

	.ioctl			= video_ioctl2,

	.open			= v4l2_fh_open,

	.release		= vb2_fop_release,

	.read			= vb2_fop_read,

	.poll			= vb2_fop_poll,

	.mmap			= vb2_fop_mmap,

	.unlocked_ioctl		= video_ioctl2,

};



static const struct v4l2_ioctl_ops solo_enc_ioctl_ops = {
@@ -1332,12 +1088,12 @@ static const struct v4l2_ioctl_ops solo_enc_ioctl_ops = { 
	.vidioc_s_fmt_vid_cap		= solo_enc_set_fmt_cap,

	.vidioc_g_fmt_vid_cap		= solo_enc_get_fmt_cap,

	/* Streaming I/O */

	.vidioc_reqbufs			= solo_enc_reqbufs,

	.vidioc_querybuf		= solo_enc_querybuf,

	.vidioc_qbuf			= solo_enc_qbuf,

	.vidioc_dqbuf			= solo_enc_dqbuf,

	.vidioc_streamon		= solo_enc_streamon,

	.vidioc_streamoff		= solo_enc_streamoff,

	.vidioc_reqbufs			= vb2_ioctl_reqbufs,

	.vidioc_querybuf		= vb2_ioctl_querybuf,

	.vidioc_qbuf			= vb2_ioctl_qbuf,

	.vidioc_dqbuf			= vb2_ioctl_dqbuf,

	.vidioc_streamon		= vb2_ioctl_streamon,

	.vidioc_streamoff		= vb2_ioctl_streamoff,

	/* Frame size and interval */

	.vidioc_enum_framesizes		= solo_enum_framesizes,

	.vidioc_enum_frameintervals	= solo_enum_frameintervals,
@@ -1434,29 +1190,36 @@ static struct solo_enc_dev *solo_enc_alloc(struct solo_dev *solo_dev, 


	solo_enc->solo_dev = solo_dev;

	solo_enc->ch = ch;

	mutex_init(&solo_enc->lock);

	spin_lock_init(&solo_enc->av_lock);

	INIT_LIST_HEAD(&solo_enc->vidq_active);

	solo_enc->fmt = V4L2_PIX_FMT_MPEG;

	solo_enc->type = SOLO_ENC_TYPE_STD;



	atomic_set(&solo_enc->readers, 0);



	solo_enc->qp = SOLO_DEFAULT_QP;

	solo_enc->gop = solo_dev->fps;

	solo_enc->interval = 1;

	solo_enc->mode = SOLO_ENC_MODE_CIF;

	solo_enc->motion_thresh = SOLO_DEF_MOT_THRESH;



	solo_enc->vidq.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

	solo_enc->vidq.io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ;

	solo_enc->vidq.ops = &solo_enc_video_qops;

	solo_enc->vidq.mem_ops = &vb2_dma_sg_memops;

	solo_enc->vidq.drv_priv = solo_enc;

	solo_enc->vidq.gfp_flags = __GFP_DMA32;

	solo_enc->vidq.timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;

	solo_enc->vidq.buf_struct_size = sizeof(struct solo_vb2_buf);

	solo_enc->vidq.lock = &solo_enc->lock;

	ret = vb2_queue_init(&solo_enc->vidq);

	if (ret)

		goto hdl_free;

	spin_lock(&solo_enc->av_lock);

	solo_update_mode(solo_enc);

	spin_unlock(&solo_enc->av_lock);



	mutex_init(&solo_enc->enable_lock);

	spin_lock_init(&solo_enc->motion_lock);



	atomic_set(&solo_enc->readers, 0);

	atomic_set(&solo_enc->mpeg_readers, 0);



	/* Initialize this per encoder */

	solo_enc->jpeg_len = sizeof(jpeg_header);

	memcpy(solo_enc->jpeg_header, jpeg_header, solo_enc->jpeg_len);
@@ -1469,14 +1232,6 @@ static struct solo_enc_dev *solo_enc_alloc(struct solo_dev *solo_dev, 
	if (solo_enc->desc_items == NULL)

		goto hdl_free;



	videobuf_queue_sg_init(&solo_enc->vidq, &solo_enc_video_qops,

				&solo_dev->pdev->dev,

				&solo_enc->av_lock,

				V4L2_BUF_TYPE_VIDEO_CAPTURE,

				V4L2_FIELD_INTERLACED,

				sizeof(struct solo_videobuf),

				solo_enc, NULL);



	solo_enc->vfd = video_device_alloc();

	if (!solo_enc->vfd)

		goto pci_free;
@@ -1484,6 +1239,8 @@ static struct solo_enc_dev *solo_enc_alloc(struct solo_dev *solo_dev, 
	*solo_enc->vfd = solo_enc_template;

	solo_enc->vfd->v4l2_dev = &solo_dev->v4l2_dev;

	solo_enc->vfd->ctrl_handler = hdl;

	solo_enc->vfd->queue = &solo_enc->vidq;

	solo_enc->vfd->lock = &solo_enc->lock;

	set_bit(V4L2_FL_USE_FH_PRIO, &solo_enc->vfd->flags);

	video_set_drvdata(solo_enc->vfd, solo_enc);

	ret = video_register_device(solo_enc->vfd, VFL_TYPE_GRABBER, nr);