Re: [PATCH] s2255drv: port to videobuf2

[Dean Anderson <linux-dev@xxxxxxxxxxxx>]

On 2014-02-03 03:51, Hans Verkuil wrote:
> Hi Dean,
>
> Some specific comments below, but first two general comments:
>
> It is easier to review if at least the removal of the old s2255_fh 
> struct
> was done as a separate patch. It's always good to try and keep the 
> changes
> in patches as small as possible. The actual vb2 conversion is always a
> 'big bang' patch, that's unavoidable, but it's easier if it isn't 
> mixed in
> with other changes that are not directly related to the vb2 
> conversion.


I figured removal of s2255_fh was a natural part of the videobuf2 
conversion process, but I can break it up.
I also did change some formatting and naming changes (s2255_channel to 
s2255_vc) that can be postponed.

> And did you also run the v4l2-compliance utility for this driver? 
> That's
> useful to check that everything it still correct.

Thanks for the comments.  I'll do a v2 soon with v4l2-compliance fully 
tested too.

I added some comments below too.



> On 01/31/2014 06:35 PM, Dean Anderson wrote:
> > Update s2255drv to use videobuf2 instead of videobuf.
> > s2255_fh file handle removed and driver simplified.
> >
> > Signed-off-by: Dean Anderson <linux-dev@xxxxxxxxxxxx>
> > ---
> >  drivers/media/usb/s2255/s2255drv.c | 1170 
> > +++++++++++++++---------------------
> >  1 file changed, 473 insertions(+), 697 deletions(-)
> >
> > diff --git a/drivers/media/usb/s2255/s2255drv.c 
> > b/drivers/media/usb/s2255/s2255drv.c
> > index c6bdccc..d6e9332 100644
> > --- a/drivers/media/usb/s2255/s2255drv.c
> > +++ b/drivers/media/usb/s2255/s2255drv.c
>
> <snip>
>
> > @@ -666,146 +641,131 @@ static void s2255_fillbuff(struct 
> > s2255_channel *channel,
> >  	dprintk(dev, 2, "s2255fill at : Buffer 0x%08lx size= %d\n",
> >  		(unsigned long)vbuf, pos);
> >  	/* tell v4l buffer was filled */
> > -	buf->vb.field_count = channel->frame_count * 2;
> > -	v4l2_get_timestamp(&buf->vb.ts);
> > -	buf->vb.state = VIDEOBUF_DONE;
> > +	vc->field_count = vc->frame_count * 2;
> > +	buf->vb.v4l2_buf.field = vc->field;
> > +	buf->vb.v4l2_buf.sequence = vc->field_count >> 1;
>
> Just drop field_count (left-over from vivi) and use frame_count 
> directly.
>
> > +	v4l2_get_timestamp(&buf->vb.v4l2_buf.timestamp);
> > +	vb2_buffer_done(&buf->vb, VB2_BUF_STATE_DONE);
> >  }
> >
> > +/*
> > + * setup the contraints of the queue
> > + */
> > +static int queue_setup(struct vb2_queue *vq, const struct 
> > v4l2_format *fmt,
> > +				unsigned int *nbuffers, unsigned int *nplanes,
> > +				unsigned int sizes[], void *alloc_ctxs[])
> > +{
> > +	struct s2255_vc *vc = vb2_get_drv_priv(vq);
> > +	unsigned long size;
> >
> > -/* 
> > ------------------------------------------------------------------
> > -   Videobuf operations
> > -   
> > ------------------------------------------------------------------*/
> > +	size = vc->width * vc->height * (vc->fmt->depth >> 3);
> >
> > -static int buffer_setup(struct videobuf_queue *vq, unsigned int 
> > *count,
> > -			unsigned int *size)
> > -{
> > -	struct s2255_fh *fh = vq->priv_data;
> > -	struct s2255_channel *channel = fh->channel;
> > -	*size = channel->width * channel->height * (channel->fmt->depth >> 
> > 3);
> > +	if (0 == *nbuffers)
> > +		*nbuffers = S2255_DEF_BUFS;
>
> Unfortunately vivi was a bad example to use for this (I'm going to 
> post patches
> to fix vivi to avoid this in the future).
>
> What really needs to happen is that you test against the minimum 
> number of
> buffers required to stream (usually somewhere between 1 and 3, test 
> with e.g.
> qv4l2 or v4l2-ctl) and if it is less, set *nbuffers to that minimum.
>
> > -	if (0 == *count)
> > -		*count = S2255_DEF_BUFS;
> > +	if (size * *nbuffers > vid_limit * 1024 * 1024)
> > +		*nbuffers = (vid_limit * 1024 * 1024) / size;
> >
> > -	if (*size * *count > vid_limit * 1024 * 1024)
> > -		*count = (vid_limit * 1024 * 1024) / *size;
>
> This vid_limit makes no sense. If the application wants 32 buffers
> (the maximum),
> then it should be able to get 32 buffers if there is enough memory. 
> Having a
> vid_limit is pointless. I plan on removing this from vivi as well.
>
> > +	if (size == 0)
> > +		return -EINVAL;
> >
> > +	*nplanes = 1;
> > +	sizes[0] = size;
> >  	return 0;
> >  }
> >
> > -static void free_buffer(struct videobuf_queue *vq, struct 
> > s2255_buffer *buf)
> > -{
> > -	videobuf_vmalloc_free(&buf->vb);
> > -	buf->vb.state = VIDEOBUF_NEEDS_INIT;
> > -}
> >
> > -static int buffer_prepare(struct videobuf_queue *vq, struct 
> > videobuf_buffer *vb,
> > -			  enum v4l2_field field)
> > +static int buffer_prepare(struct vb2_buffer *vb)
> >  {
> > -	struct s2255_fh *fh = vq->priv_data;
> > -	struct s2255_channel *channel = fh->channel;
> > +	struct s2255_vc *vc = vb2_get_drv_priv(vb->vb2_queue);
> >  	struct s2255_buffer *buf = container_of(vb, struct s2255_buffer, 
> > vb);
> > -	int rc;
> > -	int w = channel->width;
> > -	int h = channel->height;
> > -	dprintk(fh->dev, 4, "%s, field=%d\n", __func__, field);
> > -	if (channel->fmt == NULL)
> > -		return -EINVAL;
> > +	unsigned long size;
> > +	int w = vc->width;
> > +	int h = vc->height;
> >
> > -	if ((w < norm_minw(channel)) ||
> > -	    (w > norm_maxw(channel)) ||
> > -	    (h < norm_minh(channel)) ||
> > -	    (h > norm_maxh(channel))) {
> > -		dprintk(fh->dev, 4, "invalid buffer prepare\n");
> > +	if (vc->fmt == NULL)
> >  		return -EINVAL;
> > -	}
> > -	buf->vb.size = w * h * (channel->fmt->depth >> 3);
> > -	if (0 != buf->vb.baddr && buf->vb.bsize < buf->vb.size) {
> > -		dprintk(fh->dev, 4, "invalid buffer prepare\n");
> > +
> > +	if ((w < norm_minw(vc)) ||
> > +	    (w > norm_maxw(vc)) ||
> > +	    (h < norm_minh(vc)) ||
> > +	    (h > norm_maxh(vc))) {
> > +		dprintk(vc->dev, 4, "invalid buffer prepare\n");
> >  		return -EINVAL;
> >  	}
> > +	size = w * h * (vc->fmt->depth >> 3);
> >
> > -	buf->fmt = channel->fmt;
> > -	buf->vb.width = w;
> > -	buf->vb.height = h;
> > -	buf->vb.field = field;
> > -
> > -	if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
> > -		rc = videobuf_iolock(vq, &buf->vb, NULL);
> > -		if (rc < 0)
> > -			goto fail;
> > -	}
> > +	if (vb2_plane_size(vb, 0) < size)
> > +		return -EINVAL;
> >
> > -	buf->vb.state = VIDEOBUF_PREPARED;
> > +	vb2_set_plane_payload(&buf->vb, 0, size);
> > +	buf->fmt = vc->fmt;
>
> buf->fmt can be dropped. It's used in only one place, and there 
> vc->fmt can be
> used as well. I need to remove that in vivi as well.
>
> >  	return 0;
> > -fail:
> > -	free_buffer(vq, buf);
> > -	return rc;
> >  }
> >
> > -static void buffer_queue(struct videobuf_queue *vq, struct 
> > videobuf_buffer *vb)
> > +static void buffer_queue(struct vb2_buffer *vb)
> >  {
> >  	struct s2255_buffer *buf = container_of(vb, struct s2255_buffer, 
> > vb);
> > -	struct s2255_fh *fh = vq->priv_data;
> > -	struct s2255_channel *channel = fh->channel;
> > -	struct s2255_dmaqueue *vidq = &channel->vidq;
> > -	dprintk(fh->dev, 1, "%s\n", __func__);
> > -	buf->vb.state = VIDEOBUF_QUEUED;
> > -	list_add_tail(&buf->vb.queue, &vidq->active);
> > -}
> > -
> > -static void buffer_release(struct videobuf_queue *vq,
> > -			   struct videobuf_buffer *vb)
> > -{
> > -	struct s2255_buffer *buf = container_of(vb, struct s2255_buffer, 
> > vb);
> > -	struct s2255_fh *fh = vq->priv_data;
> > -	dprintk(fh->dev, 4, "%s %d\n", __func__, fh->channel->idx);
> > -	free_buffer(vq, buf);
> > -}
> > -
> > -static struct videobuf_queue_ops s2255_video_qops = {
> > -	.buf_setup = buffer_setup,
> > -	.buf_prepare = buffer_prepare,
> > -	.buf_queue = buffer_queue,
> > -	.buf_release = buffer_release,
> > -};
> > -
> > -
> > -static int res_get(struct s2255_fh *fh)
> > -{
> > -	struct s2255_channel *channel = fh->channel;
> > -	/* is it free? */
> > -	if (channel->resources)
> > -		return 0; /* no, someone else uses it */
> > -	/* it's free, grab it */
> > -	channel->resources = 1;
> > -	fh->resources = 1;
> > -	dprintk(fh->dev, 1, "s2255: res: get\n");
> > -	return 1;
> > +	struct s2255_vc *vc = vb2_get_drv_priv(vb->vb2_queue);
> > +	struct s2255_dev *dev = vc->dev;
> > +	unsigned long flags = 0;
>
> Please add an empty line here to make it more readable. In general, 
> after
> declaring variables add a newline before starting the actual code.
>
> > +	dprintk(dev, 1, "%s\n", __func__);
> > +	spin_lock_irqsave(&vc->qlock, flags);
> > +	list_add_tail(&buf->list, &vc->buf_list);
> > +	spin_unlock_irqrestore(&vc->qlock, flags);
> >  }
> >
> > -static int res_locked(struct s2255_fh *fh)
> > +/* begin streaming on a 2255 video channel */
> > +static int start_streaming(struct vb2_queue *vq, unsigned int count)
> >  {
> > -	return fh->channel->resources;
> > +	struct s2255_vc *vc = vb2_get_drv_priv(vq);
> > +	int j;
> > +	vc->last_frame = -1;
> > +	vc->bad_payload = 0;
> > +	vc->cur_frame = 0;
> > +	vc->frame_count = 0;
> > +	for (j = 0; j < SYS_FRAMES; j++) {
> > +		vc->buffer.frame[j].ulState = S2255_READ_IDLE;
> > +		vc->buffer.frame[j].cur_size = 0;
> > +	}
> > +	s2255_start_acquire(vc);
>
> I noticed that s2255_start_acquire can fail and that that is not 
> checked here.
> In fact, s2255_start_acquire also ignores an error from 
> s2255_write_config().
> Several s2255 functions allocate a 512 buffer and release it again 
> after use.
> Would it not make more sense to allocate that buffer in probe() and 
> use that
> everywhere?


I don't like this dynamic memory allocation either.  I'll make a 
separate patch after the videobuf2 change.


> > +	return 0;
> >  }
> >
> > -static int res_check(struct s2255_fh *fh)
> > +/* abort streaming and wait for last buffer */
> > +static int stop_streaming(struct vb2_queue *vq)
> >  {
> > -	return fh->resources;
> > +	struct s2255_vc *vc = vb2_get_drv_priv(vq);
> > +	struct s2255_buffer *buf, *node;
> > +	unsigned long flags;
> > +	s2255_stop_acquire(vc);
> > +	spin_lock_irqsave(&vc->qlock, flags);
> > +	list_for_each_entry_safe(buf, node, &vc->buf_list, list) {
> > +		list_del(&buf->list);
> > +		vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
> > +		dprintk(vc->dev, 2, "[%p/%d] done\n",
> > +			buf, buf->vb.v4l2_buf.index);
> > +	}
> > +	spin_unlock_irqrestore(&vc->qlock, flags);
> > +	return 0;
> >  }
> >
> > +static struct vb2_ops s2255_video_qops = {
> > +	.queue_setup = queue_setup,
> > +	.buf_prepare = buffer_prepare,
> > +	.buf_queue = buffer_queue,
> > +	.start_streaming = start_streaming,
> > +	.stop_streaming = stop_streaming,
> > +	.wait_prepare = vb2_ops_wait_prepare,
> > +	.wait_finish = vb2_ops_wait_finish,
> >
> > -static void res_free(struct s2255_fh *fh)
> > -{
> > -	struct s2255_channel *channel = fh->channel;
> > -	channel->resources = 0;
> > -	fh->resources = 0;
> > -}
> > +};
> >
> >  static int vidioc_querycap(struct file *file, void *priv,
> >  			   struct v4l2_capability *cap)
> >  {
> > -	struct s2255_fh *fh = file->private_data;
> > -	struct s2255_dev *dev = fh->dev;
> > +	struct s2255_vc *vc = video_drvdata(file);
> > +	struct s2255_dev *dev = vc->dev;
> >
> >  	strlcpy(cap->driver, "s2255", sizeof(cap->driver));
> >  	strlcpy(cap->card, "s2255", sizeof(cap->card));
> > @@ -833,19 +793,18 @@ static int vidioc_enum_fmt_vid_cap(struct file 
> > *file, void *priv,
> >  static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
> >  			    struct v4l2_format *f)
> >  {
> > -	struct s2255_fh *fh = priv;
> > -	struct s2255_channel *channel = fh->channel;
> > -	int is_ntsc = channel->std & V4L2_STD_525_60;
> > +	struct s2255_vc *vc = video_drvdata(file);
> > +	int is_ntsc = vc->std & V4L2_STD_525_60;
> >
> > -	f->fmt.pix.width = channel->width;
> > -	f->fmt.pix.height = channel->height;
> > +	f->fmt.pix.width = vc->width;
> > +	f->fmt.pix.height = vc->height;
> >  	if (f->fmt.pix.height >=
> >  	    (is_ntsc ? NUM_LINES_1CIFS_NTSC : NUM_LINES_1CIFS_PAL) * 2)
> >  		f->fmt.pix.field = V4L2_FIELD_INTERLACED;
> >  	else
> >  		f->fmt.pix.field = V4L2_FIELD_TOP;
> > -	f->fmt.pix.pixelformat = channel->fmt->fourcc;
> > -	f->fmt.pix.bytesperline = f->fmt.pix.width * (channel->fmt->depth 
> > >> 3);
> > +	f->fmt.pix.pixelformat = vc->fmt->fourcc;
> > +	f->fmt.pix.bytesperline = f->fmt.pix.width * (vc->fmt->depth >> 3);
> >  	f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
> >  	f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
> >  	f->fmt.pix.priv = 0;
> > @@ -857,9 +816,8 @@ static int vidioc_try_fmt_vid_cap(struct file 
> > *file, void *priv,
> >  {
> >  	const struct s2255_fmt *fmt;
> >  	enum v4l2_field field;
> > -	struct s2255_fh *fh = priv;
> > -	struct s2255_channel *channel = fh->channel;
> > -	int is_ntsc = channel->std & V4L2_STD_525_60;
> > +	struct s2255_vc *vc = video_drvdata(file);
> > +	int is_ntsc = vc->std & V4L2_STD_525_60;
> >
> >  	fmt = format_by_fourcc(f->fmt.pix.pixelformat);
> >
> > @@ -868,7 +826,7 @@ static int vidioc_try_fmt_vid_cap(struct file 
> > *file, void *priv,
> >
> >  	field = f->fmt.pix.field;
> >
> > -	dprintk(fh->dev, 50, "%s NTSC: %d suggested width: %d, height: 
> > %d\n",
> > +	dprintk(vc->dev, 50, "%s NTSC: %d suggested width: %d, height: 
> > %d\n",
> >  		__func__, is_ntsc, f->fmt.pix.width, f->fmt.pix.height);
> >  	if (is_ntsc) {
> >  		/* NTSC */
> > @@ -910,7 +868,8 @@ static int vidioc_try_fmt_vid_cap(struct file 
> > *file, void *priv,
> >  	f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
> >  	f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
> >  	f->fmt.pix.priv = 0;
> > -	dprintk(fh->dev, 50, "%s: set width %d height %d field %d\n", 
> > __func__,
> > +	f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
> > +	dprintk(vc->dev, 50, "%s: set width %d height %d field %d\n", 
> > __func__,
> >  		f->fmt.pix.width, f->fmt.pix.height, f->fmt.pix.field);
> >  	return 0;
> >  }
> > @@ -918,14 +877,13 @@ static int vidioc_try_fmt_vid_cap(struct file 
> > *file, void *priv,
> >  static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
> >  			    struct v4l2_format *f)
> >  {
> > -	struct s2255_fh *fh = priv;
> > -	struct s2255_channel *channel = fh->channel;
> > +	struct s2255_vc *vc = video_drvdata(file);
> >  	const struct s2255_fmt *fmt;
> > -	struct videobuf_queue *q = &fh->vb_vidq;
> > +	struct vb2_queue *q = &vc->vb_vidq;
> >  	struct s2255_mode mode;
> >  	int ret;
> >
> > -	ret = vidioc_try_fmt_vid_cap(file, fh, f);
> > +	ret = vidioc_try_fmt_vid_cap(file, vc, f);
> >
> >  	if (ret < 0)
> >  		return ret;
> > @@ -934,29 +892,24 @@ static int vidioc_s_fmt_vid_cap(struct file 
> > *file, void *priv,
> >
> >  	if (fmt == NULL)
> >  		return -EINVAL;
> > +	/*
> > +	 * It is not allowed to change the format while buffers for use 
> > with
> > +	 * streaming have already been allocated.
> > +	 */
> > +	if (vb2_is_busy(q))
> > +		return -EBUSY;
> >
> > -	mutex_lock(&q->vb_lock);
> > -
> > -	if (videobuf_queue_is_busy(&fh->vb_vidq)) {
> > -		dprintk(fh->dev, 1, "queue busy\n");
> > -		ret = -EBUSY;
> > -		goto out_s_fmt;
> > -	}
> > -
> > -	if (res_locked(fh)) {
> > -		dprintk(fh->dev, 1, "%s: channel busy\n", __func__);
> > -		ret = -EBUSY;
> > -		goto out_s_fmt;
> > -	}
> > -	mode = channel->mode;
> > -	channel->fmt = fmt;
> > -	channel->width = f->fmt.pix.width;
> > -	channel->height = f->fmt.pix.height;
> > -	fh->vb_vidq.field = f->fmt.pix.field;
> > -	fh->type = f->type;
> > -	if (channel->width > norm_minw(channel)) {
> > -		if (channel->height > norm_minh(channel)) {
> > -			if (channel->cap_parm.capturemode &
> > +	/* change format */
> > +	mode = vc->mode;
> > +	vc->fmt = fmt;
> > +	vc->width = f->fmt.pix.width;
> > +	vc->height = f->fmt.pix.height;
> > +	vc->field = f->fmt.pix.field;
> > +	vc->type = f->type;
> > +
> > +	if (vc->width > norm_minw(vc)) {
> > +		if (vc->height > norm_minh(vc)) {
> > +			if (vc->cap_parm.capturemode &
> >  			    V4L2_MODE_HIGHQUALITY)
> >  				mode.scale = SCALE_4CIFSI;
> >  			else
> > @@ -968,7 +921,7 @@ static int vidioc_s_fmt_vid_cap(struct file 
> > *file, void *priv,
> >  		mode.scale = SCALE_1CIFS;
> >  	}
> >  	/* color mode */
> > -	switch (channel->fmt->fourcc) {
> > +	switch (vc->fmt->fourcc) {
> >  	case V4L2_PIX_FMT_GREY:
> >  		mode.color &= ~MASK_COLOR;
> >  		mode.color |= COLOR_Y8;
> > @@ -977,7 +930,7 @@ static int vidioc_s_fmt_vid_cap(struct file 
> > *file, void *priv,
> >  	case V4L2_PIX_FMT_MJPEG:
> >  		mode.color &= ~MASK_COLOR;
> >  		mode.color |= COLOR_JPG;
> > -		mode.color |= (channel->jpegqual << 8);
> > +		mode.color |= (vc->jpegqual << 8);
> >  		break;
> >  	case V4L2_PIX_FMT_YUV422P:
> >  		mode.color &= ~MASK_COLOR;
> > @@ -990,51 +943,15 @@ static int vidioc_s_fmt_vid_cap(struct file 
> > *file, void *priv,
> >  		mode.color |= COLOR_YUVPK;
> >  		break;
> >  	}
> > -	if ((mode.color & MASK_COLOR) != (channel->mode.color & 
> > MASK_COLOR))
> > +	if ((mode.color & MASK_COLOR) != (vc->mode.color & MASK_COLOR))
> >  		mode.restart = 1;
> > -	else if (mode.scale != channel->mode.scale)
> > +	else if (mode.scale != vc->mode.scale)
> >  		mode.restart = 1;
> > -	else if (mode.format != channel->mode.format)
> > +	else if (mode.format != vc->mode.format)
> >  		mode.restart = 1;
> > -	channel->mode = mode;
> > -	(void) s2255_set_mode(channel, &mode);
> > -	ret = 0;
> > -out_s_fmt:
> > -	mutex_unlock(&q->vb_lock);
> > -	return ret;
> > -}
> > -
> > -static int vidioc_reqbufs(struct file *file, void *priv,
> > -			  struct v4l2_requestbuffers *p)
> > -{
> > -	int rc;
> > -	struct s2255_fh *fh = priv;
> > -	rc = videobuf_reqbufs(&fh->vb_vidq, p);
> > -	return rc;
> > -}
> > -
> > -static int vidioc_querybuf(struct file *file, void *priv, struct 
> > v4l2_buffer *p)
> > -{
> > -	int rc;
> > -	struct s2255_fh *fh = priv;
> > -	rc = videobuf_querybuf(&fh->vb_vidq, p);
> > -	return rc;
> > -}
> > -
> > -static int vidioc_qbuf(struct file *file, void *priv, struct 
> > v4l2_buffer *p)
> > -{
> > -	int rc;
> > -	struct s2255_fh *fh = priv;
> > -	rc = videobuf_qbuf(&fh->vb_vidq, p);
> > -	return rc;
> > -}
> > -
> > -static int vidioc_dqbuf(struct file *file, void *priv, struct 
> > v4l2_buffer *p)
> > -{
> > -	int rc;
> > -	struct s2255_fh *fh = priv;
> > -	rc = videobuf_dqbuf(&fh->vb_vidq, p, file->f_flags & O_NONBLOCK);
> > -	return rc;
> > +	vc->mode = mode;
> > +	(void) s2255_set_mode(vc, &mode);
> > +	return 0;
> >  }
> >
> >  /* write to the configuration pipe, synchronously */
> > @@ -1115,16 +1032,6 @@ static u32 get_transfer_size(struct s2255_mode 
> > *mode)
> >  	return usbInSize;
> >  }
> >
> > -static void s2255_print_cfg(struct s2255_dev *sdev, struct 
> > s2255_mode *mode)
> > -{
> > -	struct device *dev = &sdev->udev->dev;
> > -	dev_info(dev, 
> > "------------------------------------------------\n");
> > -	dev_info(dev, "format: %d\nscale %d\n", mode->format, mode->scale);
> > -	dev_info(dev, "fdec: %d\ncolor %d\n", mode->fdec, mode->color);
> > -	dev_info(dev, "bright: 0x%x\n", mode->bright);
> > -	dev_info(dev, 
> > "------------------------------------------------\n");
> > -}
> > -
> >  /*
> >   * set mode is the function which controls the DSP.
> >   * the restart parameter in struct s2255_mode should be set whenever
> > @@ -1133,28 +1040,28 @@ static void s2255_print_cfg(struct s2255_dev 
> > *sdev, struct s2255_mode *mode)
> >   * When the restart parameter is set, we sleep for ONE frame to 
> > allow the
> >   * DSP time to get the new frame
> >   */
> > -static int s2255_set_mode(struct s2255_channel *channel,
> > +static int s2255_set_mode(struct s2255_vc *vc,
> >  			  struct s2255_mode *mode)
> >  {
> >  	int res;
> >  	__le32 *buffer;
> >  	unsigned long chn_rev;
> > -	struct s2255_dev *dev = to_s2255_dev(channel->vdev.v4l2_dev);
> > +	struct s2255_dev *dev = to_s2255_dev(vc->vdev.v4l2_dev);
> >  	int i;
> >
> > -	chn_rev = G_chnmap[channel->idx];
> > -	dprintk(dev, 3, "%s channel: %d\n", __func__, channel->idx);
> > +	chn_rev = G_chnmap[vc->idx];
> > +	dprintk(dev, 3, "%s channel: %d\n", __func__, vc->idx);
> >  	/* if JPEG, set the quality */
> >  	if ((mode->color & MASK_COLOR) == COLOR_JPG) {
> >  		mode->color &= ~MASK_COLOR;
> >  		mode->color |= COLOR_JPG;
> >  		mode->color &= ~MASK_JPG_QUALITY;
> > -		mode->color |= (channel->jpegqual << 8);
> > +		mode->color |= (vc->jpegqual << 8);
> >  	}
> >  	/* save the mode */
> > -	channel->mode = *mode;
> > -	channel->req_image_size = get_transfer_size(mode);
> > -	dprintk(dev, 1, "%s: reqsize %ld\n", __func__, 
> > channel->req_image_size);
> > +	vc->mode = *mode;
> > +	vc->req_image_size = get_transfer_size(mode);
> > +	dprintk(dev, 1, "%s: reqsize %ld\n", __func__, vc->req_image_size);
> >  	buffer = kzalloc(512, GFP_KERNEL);
> >  	if (buffer == NULL) {
> >  		dev_err(&dev->udev->dev, "out of mem\n");
> > @@ -1165,36 +1072,38 @@ static int s2255_set_mode(struct 
> > s2255_channel *channel,
> >  	buffer[1] = (__le32) cpu_to_le32(chn_rev);
> >  	buffer[2] = CMD_SET_MODE;
> >  	for (i = 0; i < sizeof(struct s2255_mode) / sizeof(u32); i++)
> > -		buffer[3 + i] = cpu_to_le32(((u32 *)&channel->mode)[i]);
> > -	channel->setmode_ready = 0;
> > +		buffer[3 + i] = cpu_to_le32(((u32 *)&vc->mode)[i]);
> > +	vc->setmode_ready = 0;
> >  	res = s2255_write_config(dev->udev, (unsigned char *)buffer, 512);
> > -	if (debug)
> > -		s2255_print_cfg(dev, mode);
> > +
> > +	dprintk(dev, 1, "format: %d\nscale %d\n", mode->format, 
> > mode->scale);
> > +	dprintk(dev, 1, "fdec: %d\ncolor %d\n", mode->fdec, mode->color);
> > +
> >  	kfree(buffer);
> >  	/* wait at least 3 frames before continuing */
> >  	if (mode->restart) {
> > -		wait_event_timeout(channel->wait_setmode,
> > -				   (channel->setmode_ready != 0),
> > +		wait_event_timeout(vc->wait_setmode,
> > +				   (vc->setmode_ready != 0),
> >  				   msecs_to_jiffies(S2255_SETMODE_TIMEOUT));
> > -		if (channel->setmode_ready != 1) {
> > +		if (vc->setmode_ready != 1) {
> >  			dprintk(dev, 0, "s2255: no set mode response\n");
> >  			res = -EFAULT;
> >  		}
> >  	}
> >  	/* clear the restart flag */
> > -	channel->mode.restart = 0;
> > -	dprintk(dev, 1, "%s chn %d, result: %d\n", __func__, channel->idx, 
> > res);
> > +	vc->mode.restart = 0;
> > +	dprintk(dev, 1, "%s chn %d, result: %d\n", __func__, vc->idx, res);
> >  	return res;
> >  }
> >
> > -static int s2255_cmd_status(struct s2255_channel *channel, u32 
> > *pstatus)
> > +static int s2255_cmd_status(struct s2255_vc *vc, u32 *pstatus)
> >  {
> >  	int res;
> >  	__le32 *buffer;
> >  	u32 chn_rev;
> > -	struct s2255_dev *dev = to_s2255_dev(channel->vdev.v4l2_dev);
> > -	chn_rev = G_chnmap[channel->idx];
> > -	dprintk(dev, 4, "%s chan %d\n", __func__, channel->idx);
> > +	struct s2255_dev *dev = to_s2255_dev(vc->vdev.v4l2_dev);
> > +	chn_rev = G_chnmap[vc->idx];
> > +	dprintk(dev, 4, "%s chan %d\n", __func__, vc->idx);
> >  	buffer = kzalloc(512, GFP_KERNEL);
> >  	if (buffer == NULL) {
> >  		dev_err(&dev->udev->dev, "out of mem\n");
> > @@ -1205,127 +1114,70 @@ static int s2255_cmd_status(struct 
> > s2255_channel *channel, u32 *pstatus)
> >  	buffer[1] = (__le32) cpu_to_le32(chn_rev);
> >  	buffer[2] = CMD_STATUS;
> >  	*pstatus = 0;
> > -	channel->vidstatus_ready = 0;
> > +	vc->vidstatus_ready = 0;
> >  	res = s2255_write_config(dev->udev, (unsigned char *)buffer, 512);
> >  	kfree(buffer);
> > -	wait_event_timeout(channel->wait_vidstatus,
> > -			   (channel->vidstatus_ready != 0),
> > +	wait_event_timeout(vc->wait_vidstatus,
> > +			   (vc->vidstatus_ready != 0),
> >  			   msecs_to_jiffies(S2255_VIDSTATUS_TIMEOUT));
> > -	if (channel->vidstatus_ready != 1) {
> > +	if (vc->vidstatus_ready != 1) {
> >  		dprintk(dev, 0, "s2255: no vidstatus response\n");
> >  		res = -EFAULT;
> >  	}
> > -	*pstatus = channel->vidstatus;
> > +	*pstatus = vc->vidstatus;
> >  	dprintk(dev, 4, "%s, vid status %d\n", __func__, *pstatus);
> >  	return res;
> >  }
> >
> > -static int vidioc_streamon(struct file *file, void *priv, enum 
> > v4l2_buf_type i)
> > -{
> > -	int res;
> > -	struct s2255_fh *fh = priv;
> > -	struct s2255_dev *dev = fh->dev;
> > -	struct s2255_channel *channel = fh->channel;
> > -	int j;
> > -	dprintk(dev, 4, "%s\n", __func__);
> > -	if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
> > -		dev_err(&dev->udev->dev, "invalid fh type0\n");
> > -		return -EINVAL;
> > -	}
> > -	if (i != fh->type) {
> > -		dev_err(&dev->udev->dev, "invalid fh type1\n");
> > -		return -EINVAL;
> > -	}
> > -
> > -	if (!res_get(fh)) {
> > -		s2255_dev_err(&dev->udev->dev, "stream busy\n");
> > -		return -EBUSY;
> > -	}
> > -	channel->last_frame = -1;
> > -	channel->bad_payload = 0;
> > -	channel->cur_frame = 0;
> > -	channel->frame_count = 0;
> > -	for (j = 0; j < SYS_FRAMES; j++) {
> > -		channel->buffer.frame[j].ulState = S2255_READ_IDLE;
> > -		channel->buffer.frame[j].cur_size = 0;
> > -	}
> > -	res = videobuf_streamon(&fh->vb_vidq);
> > -	if (res == 0) {
> > -		s2255_start_acquire(channel);
> > -		channel->b_acquire = 1;
> > -	} else
> > -		res_free(fh);
> > -
> > -	return res;
> > -}
> > -
> > -static int vidioc_streamoff(struct file *file, void *priv, enum 
> > v4l2_buf_type i)
> > -{
> > -	struct s2255_fh *fh = priv;
> > -	dprintk(fh->dev, 4, "%s\n, channel: %d", __func__, 
> > fh->channel->idx);
> > -	if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
> > -		dprintk(fh->dev, 1, "invalid fh type0\n");
> > -		return -EINVAL;
> > -	}
> > -	if (i != fh->type)
> > -		return -EINVAL;
> > -	s2255_stop_acquire(fh->channel);
> > -	videobuf_streamoff(&fh->vb_vidq);
> > -	res_free(fh);
> > -	return 0;
> > -}
> > -
> >  static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id 
> > i)
> >  {
> > -	struct s2255_fh *fh = priv;
> >  	struct s2255_mode mode;
> > -	struct videobuf_queue *q = &fh->vb_vidq;
> > -	struct s2255_channel *channel = fh->channel;
> > +	struct s2255_vc *vc = video_drvdata(file);
> > +	struct vb2_queue *q = &vc->vb_vidq;
> >  	int ret = 0;
> >
> > -	mutex_lock(&q->vb_lock);
> > -	if (res_locked(fh)) {
> > -		dprintk(fh->dev, 1, "can't change standard after started\n");
> > -		ret = -EBUSY;
> > -		goto out_s_std;
> > -	}
> > -	mode = fh->channel->mode;
> > +	/*
> > +	 * Changing the standard implies a format change, which is not 
> > allowed
> > +	 * while buffers for use with streaming have already been 
> > allocated.
> > +	 */
> > +	if (vb2_is_busy(q))
> > +		return -EBUSY;
> > +
> > +	mode = vc->mode;
> >  	if (i & V4L2_STD_525_60) {
> > -		dprintk(fh->dev, 4, "%s 60 Hz\n", __func__);
> > +		dprintk(vc->dev, 4, "%s 60 Hz\n", __func__);
> >  		/* if changing format, reset frame decimation/intervals */
> >  		if (mode.format != FORMAT_NTSC) {
> >  			mode.restart = 1;
> >  			mode.format = FORMAT_NTSC;
> >  			mode.fdec = FDEC_1;
> > -			channel->width = LINE_SZ_4CIFS_NTSC;
> > -			channel->height = NUM_LINES_4CIFS_NTSC * 2;
> > +			vc->width = LINE_SZ_4CIFS_NTSC;
> > +			vc->height = NUM_LINES_4CIFS_NTSC * 2;
> >  		}
> >  	} else if (i & V4L2_STD_625_50) {
> > -		dprintk(fh->dev, 4, "%s 50 Hz\n", __func__);
> > +		dprintk(vc->dev, 4, "%s 50 Hz\n", __func__);
> >  		if (mode.format != FORMAT_PAL) {
> >  			mode.restart = 1;
> >  			mode.format = FORMAT_PAL;
> >  			mode.fdec = FDEC_1;
> > -			channel->width = LINE_SZ_4CIFS_PAL;
> > -			channel->height = NUM_LINES_4CIFS_PAL * 2;
> > +			vc->width = LINE_SZ_4CIFS_PAL;
> > +			vc->height = NUM_LINES_4CIFS_PAL * 2;
> >  		}
> >  	} else {
> >  		ret = -EINVAL;
> >  		goto out_s_std;
> >  	}
> > -	fh->channel->std = i;
> > +	vc->std = i;
> >  	if (mode.restart)
> > -		s2255_set_mode(fh->channel, &mode);
> > +		s2255_set_mode(vc, &mode);
> >  out_s_std:
> > -	mutex_unlock(&q->vb_lock);
> >  	return ret;
> >  }
> >
> >  static int vidioc_g_std(struct file *file, void *priv, v4l2_std_id 
> > *i)
> >  {
> > -	struct s2255_fh *fh = priv;
> > -
> > -	*i = fh->channel->std;
> > +	struct s2255_vc *vc = video_drvdata(file);
> > +	*i = vc->std;
> >  	return 0;
> >  }
> >
> > @@ -1339,9 +1191,8 @@ static int vidioc_g_std(struct file *file, void 
> > *priv, v4l2_std_id *i)
> >  static int vidioc_enum_input(struct file *file, void *priv,
> >  			     struct v4l2_input *inp)
> >  {
> > -	struct s2255_fh *fh = priv;
> > -	struct s2255_dev *dev = fh->dev;
> > -	struct s2255_channel *channel = fh->channel;
> > +	struct s2255_vc *vc = video_drvdata(file);
> > +	struct s2255_dev *dev = vc->dev;
> >  	u32 status = 0;
> >  	if (inp->index != 0)
> >  		return -EINVAL;
> > @@ -1350,7 +1201,7 @@ static int vidioc_enum_input(struct file *file, 
> > void *priv,
> >  	inp->status = 0;
> >  	if (dev->dsp_fw_ver >= S2255_MIN_DSP_STATUS) {
> >  		int rc;
> > -		rc = s2255_cmd_status(fh->channel, &status);
> > +		rc = s2255_cmd_status(vc, &status);
> >  		dprintk(dev, 4, "s2255_cmd_status rc: %d status %x\n",
> >  			rc, status);
> >  		if (rc == 0)
> > @@ -1363,7 +1214,7 @@ static int vidioc_enum_input(struct file *file, 
> > void *priv,
> >  		strlcpy(inp->name, "Composite", sizeof(inp->name));
> >  		break;
> >  	case 0x2257:
> > -		strlcpy(inp->name, (channel->idx < 2) ? "Composite" : "S-Video",
> > +		strlcpy(inp->name, (vc->idx < 2) ? "Composite" : "S-Video",
> >  			sizeof(inp->name));
> >  		break;
> >  	}
> > @@ -1384,10 +1235,10 @@ static int vidioc_s_input(struct file *file, 
> > void *priv, unsigned int i)
> >
> >  static int s2255_s_ctrl(struct v4l2_ctrl *ctrl)
> >  {
> > -	struct s2255_channel *channel =
> > -		container_of(ctrl->handler, struct s2255_channel, hdl);
> > +	struct s2255_vc *vc =
> > +		container_of(ctrl->handler, struct s2255_vc, hdl);
> >  	struct s2255_mode mode;
> > -	mode = channel->mode;
> > +	mode = vc->mode;
> >  	/* update the mode to the corresponding value */
> >  	switch (ctrl->id) {
> >  	case V4L2_CID_BRIGHTNESS:
> > @@ -1407,7 +1258,7 @@ static int s2255_s_ctrl(struct v4l2_ctrl *ctrl)
> >  		mode.color |= !ctrl->val << 16;
> >  		break;
> >  	case V4L2_CID_JPEG_COMPRESSION_QUALITY:
> > -		channel->jpegqual = ctrl->val;
> > +		vc->jpegqual = ctrl->val;
> >  		return 0;
> >  	default:
> >  		return -EINVAL;
> > @@ -1417,48 +1268,44 @@ static int s2255_s_ctrl(struct v4l2_ctrl 
> > *ctrl)
> >  	   some V4L programs restart stream unnecessarily
> >  	   after a s_crtl.
> >  	*/
> > -	s2255_set_mode(channel, &mode);
> > +	s2255_set_mode(vc, &mode);
> >  	return 0;
> >  }
> >
> >  static int vidioc_g_jpegcomp(struct file *file, void *priv,
> >  			 struct v4l2_jpegcompression *jc)
> >  {
> > -	struct s2255_fh *fh = priv;
> > -	struct s2255_channel *channel = fh->channel;
> > -
> > +	struct s2255_vc *vc = video_drvdata(file);
> >  	memset(jc, 0, sizeof(*jc));
> > -	jc->quality = channel->jpegqual;
> > -	dprintk(fh->dev, 2, "%s: quality %d\n", __func__, jc->quality);
> > +	jc->quality = vc->jpegqual;
> > +	dprintk(vc->dev, 2, "%s: quality %d\n", __func__, jc->quality);
> >  	return 0;
> >  }
> >
> >  static int vidioc_s_jpegcomp(struct file *file, void *priv,
> >  			 const struct v4l2_jpegcompression *jc)
> >  {
> > -	struct s2255_fh *fh = priv;
> > -	struct s2255_channel *channel = fh->channel;
> > +	struct s2255_vc *vc = video_drvdata(file);
> >  	if (jc->quality < 0 || jc->quality > 100)
> >  		return -EINVAL;
> > -	v4l2_ctrl_s_ctrl(channel->jpegqual_ctrl, jc->quality);
> > -	dprintk(fh->dev, 2, "%s: quality %d\n", __func__, jc->quality);
> > +	v4l2_ctrl_s_ctrl(vc->jpegqual_ctrl, jc->quality);
> > +	dprintk(vc->dev, 2, "%s: quality %d\n", __func__, jc->quality);
> >  	return 0;
> >  }
> >
> >  static int vidioc_g_parm(struct file *file, void *priv,
> >  			 struct v4l2_streamparm *sp)
> >  {
> > -	struct s2255_fh *fh = priv;
> > +	struct s2255_vc *vc = video_drvdata(file);
> >  	__u32 def_num, def_dem;
> > -	struct s2255_channel *channel = fh->channel;
> >  	if (sp->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
> >  		return -EINVAL;
> >  	sp->parm.capture.capability = V4L2_CAP_TIMEPERFRAME;
> > -	sp->parm.capture.capturemode = channel->cap_parm.capturemode;
> > -	def_num = (channel->mode.format == FORMAT_NTSC) ? 1001 : 1000;
> > -	def_dem = (channel->mode.format == FORMAT_NTSC) ? 30000 : 25000;
> > +	sp->parm.capture.capturemode = vc->cap_parm.capturemode;
> > +	def_num = (vc->mode.format == FORMAT_NTSC) ? 1001 : 1000;
> > +	def_dem = (vc->mode.format == FORMAT_NTSC) ? 30000 : 25000;
> >  	sp->parm.capture.timeperframe.denominator = def_dem;
> > -	switch (channel->mode.fdec) {
> > +	switch (vc->mode.fdec) {
> >  	default:
> >  	case FDEC_1:
> >  		sp->parm.capture.timeperframe.numerator = def_num;
> > @@ -1473,7 +1320,7 @@ static int vidioc_g_parm(struct file *file, 
> > void *priv,
> >  		sp->parm.capture.timeperframe.numerator = def_num * 5;
> >  		break;
> >  	}
> > -	dprintk(fh->dev, 4, "%s capture mode, %d timeperframe %d/%d\n",
> > +	dprintk(vc->dev, 4, "%s capture mode, %d timeperframe %d/%d\n",
> >  		__func__,
> >  		sp->parm.capture.capturemode,
> >  		sp->parm.capture.timeperframe.numerator,
> > @@ -1484,18 +1331,19 @@ static int vidioc_g_parm(struct file *file, 
> > void *priv,
> >  static int vidioc_s_parm(struct file *file, void *priv,
> >  			 struct v4l2_streamparm *sp)
> >  {
> > -	struct s2255_fh *fh = priv;
> > -	struct s2255_channel *channel = fh->channel;
> > +	struct s2255_vc *vc = video_drvdata(file);
> >  	struct s2255_mode mode;
> >  	int fdec = FDEC_1;
> >  	__u32 def_num, def_dem;
> >  	if (sp->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
> >  		return -EINVAL;
> > -	mode = channel->mode;
> > +	mode = vc->mode;
> >  	/* high quality capture mode requires a stream restart */
> > -	if (channel->cap_parm.capturemode
> > -	    != sp->parm.capture.capturemode && res_locked(fh))
> > +	if ((vc->cap_parm.capturemode != sp->parm.capture.capturemode)
> > +	    && vb2_is_busy(&vc->vb_vidq))
> >  		return -EBUSY;
> > +
> > +	vc->cap_parm.capturemode = sp->parm.capture.capturemode;
> >  	def_num = (mode.format == FORMAT_NTSC) ? 1001 : 1000;
> >  	def_dem = (mode.format == FORMAT_NTSC) ? 30000 : 25000;
> >  	if (def_dem != sp->parm.capture.timeperframe.denominator)
> > @@ -1514,8 +1362,8 @@ static int vidioc_s_parm(struct file *file, 
> > void *priv,
> >  	}
> >  	mode.fdec = fdec;
> >  	sp->parm.capture.timeperframe.denominator = def_dem;
> > -	s2255_set_mode(channel, &mode);
> > -	dprintk(fh->dev, 4, "%s capture mode, %d timeperframe %d/%d, fdec 
> > %d\n",
> > +	s2255_set_mode(vc, &mode);
> > +	dprintk(vc->dev, 4, "%s capture mode, %d timeperframe %d/%d, fdec 
> > %d\n",
> >  		__func__,
> >  		sp->parm.capture.capturemode,
> >  		sp->parm.capture.timeperframe.numerator,
> > @@ -1538,9 +1386,8 @@ static const struct v4l2_frmsize_discrete 
> > pal_sizes[] = {
> >  static int vidioc_enum_framesizes(struct file *file, void *priv,
> >  			    struct v4l2_frmsizeenum *fe)
> >  {
> > -	struct s2255_fh *fh = priv;
> > -	struct s2255_channel *channel = fh->channel;
> > -	int is_ntsc = channel->std & V4L2_STD_525_60;
> > +	struct s2255_vc *vc = video_drvdata(file);
> > +	int is_ntsc = vc->std & V4L2_STD_525_60;
> >  	const struct s2255_fmt *fmt;
> >
> >  	if (fe->index >= NUM_SIZE_ENUMS)
> > @@ -1557,11 +1404,10 @@ static int vidioc_enum_framesizes(struct file 
> > *file, void *priv,
> >  static int vidioc_enum_frameintervals(struct file *file, void *priv,
> >  			    struct v4l2_frmivalenum *fe)
> >  {
> > -	struct s2255_fh *fh = priv;
> > -	struct s2255_channel *channel = fh->channel;
> > +	struct s2255_vc *vc = video_drvdata(file);
> >  	const struct s2255_fmt *fmt;
> >  	const struct v4l2_frmsize_discrete *sizes;
> > -	int is_ntsc = channel->std & V4L2_STD_525_60;
> > +	int is_ntsc = vc->std & V4L2_STD_525_60;
> >  #define NUM_FRAME_ENUMS 4
> >  	int frm_dec[NUM_FRAME_ENUMS] = {1, 2, 3, 5};
> >  	int i;
> > @@ -1584,22 +1430,25 @@ static int vidioc_enum_frameintervals(struct 
> > file *file, void *priv,
> >  	fe->type = V4L2_FRMIVAL_TYPE_DISCRETE;
> >  	fe->discrete.denominator = is_ntsc ? 30000 : 25000;
> >  	fe->discrete.numerator = (is_ntsc ? 1001 : 1000) * 
> > frm_dec[fe->index];
> > -	dprintk(fh->dev, 4, "%s discrete %d/%d\n", __func__,
> > +	dprintk(vc->dev, 4, "%s discrete %d/%d\n", __func__,
> >  		fe->discrete.numerator,
> >  		fe->discrete.denominator);
> >  	return 0;
> >  }
> >
> > -static int __s2255_open(struct file *file)
> > +static int s2255_open(struct file *file)
> >  {
> > -	struct video_device *vdev = video_devdata(file);
> > -	struct s2255_channel *channel = video_drvdata(file);
> > -	struct s2255_dev *dev = to_s2255_dev(vdev->v4l2_dev);
> > -	struct s2255_fh *fh;
> > -	enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
> > +	struct s2255_vc *vc = video_drvdata(file);
> > +	struct s2255_dev *dev = vc->dev;
> >  	int state;
> > -	dprintk(dev, 1, "s2255: open called (dev=%s)\n",
> > -		video_device_node_name(vdev));
> > +	int rc = 0;
> > +
> > +	/* allocate + initialize per filehandle data */
> > +	rc = v4l2_fh_open(file);
> > +	if (rc != 0)
> > +		return rc;
> > +
> > +	/* load firmware */
> >  	state = atomic_read(&dev->fw_data->fw_state);
> >  	switch (state) {
> >  	case S2255_FW_DISCONNECTING:
> > @@ -1661,66 +1510,23 @@ static int __s2255_open(struct file *file)
> >  		pr_info("%s: unknown state\n", __func__);
> >  		return -EFAULT;
> >  	}
> > -	/* allocate + initialize per filehandle data */
> > -	fh = kzalloc(sizeof(*fh), GFP_KERNEL);
> > -	if (NULL == fh)
> > -		return -ENOMEM;
> > -	v4l2_fh_init(&fh->fh, vdev);
> > -	v4l2_fh_add(&fh->fh);
> > -	file->private_data = &fh->fh;
> > -	fh->dev = dev;
> > -	fh->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
> > -	fh->channel = channel;
> > -	if (!channel->configured) {
> > +
> > +	if (!vc->configured) {
> > +		int rc;
> >  		/* configure channel to default state */
> > -		channel->fmt = &formats[0];
> > -		s2255_set_mode(channel, &channel->mode);
> > -		channel->configured = 1;
> > -	}
> > -	dprintk(dev, 1, "%s: dev=%s type=%s\n", __func__,
> > -		video_device_node_name(vdev), v4l2_type_names[type]);
> > -	dprintk(dev, 2, "%s: fh=0x%08lx, dev=0x%08lx, vidq=0x%08lx\n", 
> > __func__,
> > -		(unsigned long)fh, (unsigned long)dev,
> > -		(unsigned long)&channel->vidq);
> > -	dprintk(dev, 4, "%s: list_empty active=%d\n", __func__,
> > -		list_empty(&channel->vidq.active));
> > -	videobuf_queue_vmalloc_init(&fh->vb_vidq, &s2255_video_qops,
> > -				    NULL, &dev->slock,
> > -				    fh->type,
> > -				    V4L2_FIELD_INTERLACED,
> > -				    sizeof(struct s2255_buffer),
> > -				    fh, vdev->lock);
> > +		vc->fmt = &formats[0];
> > +		rc = s2255_set_mode(vc, &vc->mode);
> > +		if (rc != 0) {
> > +			/* resend set mode. */
> > +			rc = s2255_set_mode(vc, &vc->mode);
> > +		}
> > +		if (rc == 0)
> > +			vc->configured = 1;
> > +	}
> > +	dprintk(dev, 2, "%s:\n", __func__);
> >  	return 0;
> >  }
> >
> > -static int s2255_open(struct file *file)
> > -{
> > -	struct video_device *vdev = video_devdata(file);
> > -	int ret;
> > -
> > -	if (mutex_lock_interruptible(vdev->lock))
> > -		return -ERESTARTSYS;
> > -	ret = __s2255_open(file);
> > -	mutex_unlock(vdev->lock);
> > -	return ret;
> > -}
> > -
> > -static unsigned int s2255_poll(struct file *file,
> > -			       struct poll_table_struct *wait)
> > -{
> > -	struct s2255_fh *fh = file->private_data;
> > -	struct s2255_dev *dev = fh->dev;
> > -	int rc = v4l2_ctrl_poll(file, wait);
> > -
> > -	dprintk(dev, 100, "%s\n", __func__);
> > -	if (V4L2_BUF_TYPE_VIDEO_CAPTURE != fh->type)
> > -		return POLLERR;
> > -	mutex_lock(&dev->lock);
> > -	rc |= videobuf_poll_stream(file, &fh->vb_vidq, wait);
> > -	mutex_unlock(&dev->lock);
> > -	return rc;
> > -}
> > -
> >  static void s2255_destroy(struct s2255_dev *dev)
> >  {
> >  	dprintk(dev, 1, "%s", __func__);
> > @@ -1744,57 +1550,14 @@ static void s2255_destroy(struct s2255_dev 
> > *dev)
> >  	kfree(dev);
> >  }
> >
> > -static int s2255_release(struct file *file)
> > -{
> > -	struct s2255_fh *fh = file->private_data;
> > -	struct s2255_dev *dev = fh->dev;
> > -	struct video_device *vdev = video_devdata(file);
> > -	struct s2255_channel *channel = fh->channel;
> > -	if (!dev)
> > -		return -ENODEV;
> > -	mutex_lock(&dev->lock);
> > -	/* turn off stream */
> > -	if (res_check(fh)) {
> > -		if (channel->b_acquire)
> > -			s2255_stop_acquire(fh->channel);
> > -		videobuf_streamoff(&fh->vb_vidq);
> > -		res_free(fh);
> > -	}
> > -	videobuf_mmap_free(&fh->vb_vidq);
> > -	mutex_unlock(&dev->lock);
> > -	dprintk(dev, 1, "%s[%s]\n", __func__, 
> > video_device_node_name(vdev));
> > -	v4l2_fh_del(&fh->fh);
> > -	v4l2_fh_exit(&fh->fh);
> > -	kfree(fh);
> > -	return 0;
> > -}
> > -
> > -static int s2255_mmap_v4l(struct file *file, struct vm_area_struct 
> > *vma)
> > -{
> > -	struct s2255_fh *fh = file->private_data;
> > -	struct s2255_dev *dev;
> > -	int ret;
> > -	if (!fh)
> > -		return -ENODEV;
> > -	dev = fh->dev;
> > -	dprintk(dev, 4, "%s, vma=0x%08lx\n", __func__, (unsigned long)vma);
> > -	if (mutex_lock_interruptible(&dev->lock))
> > -		return -ERESTARTSYS;
> > -	ret = videobuf_mmap_mapper(&fh->vb_vidq, vma);
> > -	mutex_unlock(&dev->lock);
> > -	dprintk(dev, 4, "%s vma start=0x%08lx, size=%ld, ret=%d\n", 
> > __func__,
> > -		(unsigned long)vma->vm_start,
> > -		(unsigned long)vma->vm_end - (unsigned long)vma->vm_start, ret);
> > -	return ret;
> > -}
> > -
> >  static const struct v4l2_file_operations s2255_fops_v4l = {
> >  	.owner = THIS_MODULE,
> >  	.open = s2255_open,
> > -	.release = s2255_release,
> > -	.poll = s2255_poll,
> > -	.unlocked_ioctl = video_ioctl2,	/* V4L2 ioctl handler */
> > -	.mmap = s2255_mmap_v4l,
> > +	.release = vb2_fop_release,
> > +	.unlocked_ioctl = video_ioctl2,
> > +	.read = vb2_fop_read,
> > +	.mmap = vb2_fop_mmap,
> > +	.poll = vb2_fop_poll,
> >  };
> >
> >  static const struct v4l2_ioctl_ops s2255_ioctl_ops = {
> > @@ -1803,17 +1566,17 @@ static const struct v4l2_ioctl_ops 
> > s2255_ioctl_ops = {
> >  	.vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
> >  	.vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
> >  	.vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
> > -	.vidioc_reqbufs = vidioc_reqbufs,
> > -	.vidioc_querybuf = vidioc_querybuf,
> > -	.vidioc_qbuf = vidioc_qbuf,
> > -	.vidioc_dqbuf = vidioc_dqbuf,
> > +	.vidioc_reqbufs =  vb2_ioctl_reqbufs,
> > +	.vidioc_querybuf = vb2_ioctl_querybuf,
> > +	.vidioc_qbuf = vb2_ioctl_qbuf,
> > +	.vidioc_dqbuf = vb2_ioctl_dqbuf,
> >  	.vidioc_s_std = vidioc_s_std,
> >  	.vidioc_g_std = vidioc_g_std,
> >  	.vidioc_enum_input = vidioc_enum_input,
> >  	.vidioc_g_input = vidioc_g_input,
> >  	.vidioc_s_input = vidioc_s_input,
> > -	.vidioc_streamon = vidioc_streamon,
> > -	.vidioc_streamoff = vidioc_streamoff,
> > +	.vidioc_streamon = vb2_ioctl_streamon,
> > +	.vidioc_streamoff = vb2_ioctl_streamoff,
> >  	.vidioc_s_jpegcomp = vidioc_s_jpegcomp,
> >  	.vidioc_g_jpegcomp = vidioc_g_jpegcomp,
> >  	.vidioc_s_parm = vidioc_s_parm,
> > @@ -1828,13 +1591,13 @@ static const struct v4l2_ioctl_ops 
> > s2255_ioctl_ops = {
> >  static void s2255_video_device_release(struct video_device *vdev)
> >  {
> >  	struct s2255_dev *dev = to_s2255_dev(vdev->v4l2_dev);
> > -	struct s2255_channel *channel =
> > -		container_of(vdev, struct s2255_channel, vdev);
> > +	struct s2255_vc *vc =
> > +		container_of(vdev, struct s2255_vc, vdev);
> >
> >  	dprintk(dev, 4, "%s, chnls: %d\n", __func__,
> >  		atomic_read(&dev->num_channels));
> >
> > -	v4l2_ctrl_handler_free(&channel->hdl);
> > +	v4l2_ctrl_handler_free(&vc->hdl);
> >
> >  	if (atomic_dec_and_test(&dev->num_channels))
> >  		s2255_destroy(dev);
> > @@ -1868,64 +1631,82 @@ static int s2255_probe_v4l(struct s2255_dev 
> > *dev)
> >  	int ret;
> >  	int i;
> >  	int cur_nr = video_nr;
> > -	struct s2255_channel *channel;
> > +	struct vb2_queue *q;
> > +	struct s2255_vc *vc;
> >  	ret = v4l2_device_register(&dev->interface->dev, &dev->v4l2_dev);
> >  	if (ret)
> >  		return ret;
> >  	/* initialize all video 4 linux */
> >  	/* register 4 video devices */
> >  	for (i = 0; i < MAX_CHANNELS; i++) {
> > -		channel = &dev->channel[i];
> > -		INIT_LIST_HEAD(&channel->vidq.active);
> > +		vc = &dev->vc[i];
> > +		INIT_LIST_HEAD(&vc->buf_list);
> >
> > -		v4l2_ctrl_handler_init(&channel->hdl, 6);
> > -		v4l2_ctrl_new_std(&channel->hdl, &s2255_ctrl_ops,
> > +		v4l2_ctrl_handler_init(&vc->hdl, 6);
> > +		v4l2_ctrl_new_std(&vc->hdl, &s2255_ctrl_ops,
> >  				V4L2_CID_BRIGHTNESS, -127, 127, 1, DEF_BRIGHT);
> > -		v4l2_ctrl_new_std(&channel->hdl, &s2255_ctrl_ops,
> > +		v4l2_ctrl_new_std(&vc->hdl, &s2255_ctrl_ops,
> >  				V4L2_CID_CONTRAST, 0, 255, 1, DEF_CONTRAST);
> > -		v4l2_ctrl_new_std(&channel->hdl, &s2255_ctrl_ops,
> > +		v4l2_ctrl_new_std(&vc->hdl, &s2255_ctrl_ops,
> >  				V4L2_CID_SATURATION, 0, 255, 1, DEF_SATURATION);
> > -		v4l2_ctrl_new_std(&channel->hdl, &s2255_ctrl_ops,
> > +		v4l2_ctrl_new_std(&vc->hdl, &s2255_ctrl_ops,
> >  				V4L2_CID_HUE, 0, 255, 1, DEF_HUE);
> > -		channel->jpegqual_ctrl = v4l2_ctrl_new_std(&channel->hdl,
> > +		vc->jpegqual_ctrl = v4l2_ctrl_new_std(&vc->hdl,
> >  				&s2255_ctrl_ops,
> >  				V4L2_CID_JPEG_COMPRESSION_QUALITY,
> >  				0, 100, 1, S2255_DEF_JPEG_QUAL);
> >  		if (dev->dsp_fw_ver >= S2255_MIN_DSP_COLORFILTER &&
> > -		    (dev->pid != 0x2257 || channel->idx <= 1))
> > -			v4l2_ctrl_new_custom(&channel->hdl, &color_filter_ctrl,
> > +		    (dev->pid != 0x2257 || vc->idx <= 1))
> > +			v4l2_ctrl_new_custom(&vc->hdl, &color_filter_ctrl,
> >  					     NULL);
> > -		if (channel->hdl.error) {
> > -			ret = channel->hdl.error;
> > -			v4l2_ctrl_handler_free(&channel->hdl);
> > +		if (vc->hdl.error) {
> > +			ret = vc->hdl.error;
> > +			v4l2_ctrl_handler_free(&vc->hdl);
> >  			dev_err(&dev->udev->dev, "couldn't register control\n");
> >  			break;
> >  		}
> > -		channel->vidq.dev = dev;
> > +		q = &vc->vb_vidq;
> > +		memset(q, 0, sizeof(vc->vb_vidq));
> > +		q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
> > +		q->io_modes = VB2_MMAP | VB2_READ;
>
> You can add VB2_USERPTR here as well, that should work out-of-the-box.
>
> > +		q->drv_priv = vc;
> > +		q->lock = &vc->vb_lock;
> > +		q->buf_struct_size = sizeof(struct s2255_buffer);
> > +		q->mem_ops = &vb2_vmalloc_memops;
> > +		q->ops = &s2255_video_qops;
> > +		q->timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
> > +		ret = vb2_queue_init(q);
> > +		if (ret != 0) {
> > +			dev_err(&dev->udev->dev,
> > +				"%s vb2_queue_init err: 0x%x\n", __func__, ret);
> > +			break;
> > +		}
> >  		/* register 4 video devices */
> > -		channel->vdev = template;
> > -		channel->vdev.ctrl_handler = &channel->hdl;
> > -		channel->vdev.lock = &dev->lock;
> > -		channel->vdev.v4l2_dev = &dev->v4l2_dev;
> > -		set_bit(V4L2_FL_USE_FH_PRIO, &channel->vdev.flags);
> > -		video_set_drvdata(&channel->vdev, channel);
> > +		vc->vdev = template;
> > +		vc->vdev.queue = q;
> > +		vc->vdev.ctrl_handler = &vc->hdl;
> > +		/* main device lock */
> > +		vc->vdev.lock = &dev->lock;
> > +		vc->vdev.v4l2_dev = &dev->v4l2_dev;
> > +		set_bit(V4L2_FL_USE_FH_PRIO, &vc->vdev.flags);
> > +		video_set_drvdata(&vc->vdev, vc);
> >  		if (video_nr == -1)
> > -			ret = video_register_device(&channel->vdev,
> > +			ret = video_register_device(&vc->vdev,
> >  						    VFL_TYPE_GRABBER,
> >  						    video_nr);
> >  		else
> > -			ret = video_register_device(&channel->vdev,
> > +			ret = video_register_device(&vc->vdev,
> >  						    VFL_TYPE_GRABBER,
> >  						    cur_nr + i);
> >
> >  		if (ret) {
> >  			dev_err(&dev->udev->dev,
> > -				"failed to register video device!\n");
> > +				"failed to register vid device: 0x%x!\n", ret);
> >  			break;
> >  		}
> >  		atomic_inc(&dev->num_channels);
> >  		v4l2_info(&dev->v4l2_dev, "V4L2 device registered as %s\n",
> > -			  video_device_node_name(&channel->vdev));
> > +			  video_device_node_name(&vc->vdev));
> >
> >  	}
> >  	pr_info("Sensoray 2255 V4L driver Revision: %s\n",
> > @@ -1962,11 +1743,11 @@ static int save_frame(struct s2255_dev *dev, 
> > struct s2255_pipeinfo *pipe_info)
> >  	s32 idx = -1;
> >  	struct s2255_framei *frm;
> >  	unsigned char *pdata;
> > -	struct s2255_channel *ch;
> > +	struct s2255_vc *vc;
> >  	dprintk(dev, 100, "buffer to user\n");
> > -	ch = &dev->channel[dev->cc];
> > -	idx = ch->cur_frame;
> > -	frm = &ch->buffer.frame[idx];
> > +	vc = &dev->vc[dev->cc];
> > +	idx = vc->cur_frame;
> > +	frm = &vc->buffer.frame[idx];
> >  	if (frm->ulState == S2255_READ_IDLE) {
> >  		int jj;
> >  		unsigned int cc;
> > @@ -1990,15 +1771,15 @@ static int save_frame(struct s2255_dev *dev, 
> > struct s2255_pipeinfo *pipe_info)
> >  				}
> >  				/* reverse it */
> >  				dev->cc = G_chnmap[cc];
> > -				ch = &dev->channel[dev->cc];
> > +				vc = &dev->vc[dev->cc];
> >  				payload =  le32_to_cpu(pdword[3]);
> > -				if (payload > ch->req_image_size) {
> > -					ch->bad_payload++;
> > +				if (payload > vc->req_image_size) {
> > +					vc->bad_payload++;
> >  					/* discard the bad frame */
> >  					return -EINVAL;
> >  				}
> > -				ch->pkt_size = payload;
> > -				ch->jpg_size = le32_to_cpu(pdword[4]);
> > +				vc->pkt_size = payload;
> > +				vc->jpg_size = le32_to_cpu(pdword[4]);
> >  				break;
> >  			case S2255_MARKER_RESPONSE:
> >
> > @@ -2009,13 +1790,13 @@ static int save_frame(struct s2255_dev *dev, 
> > struct s2255_pipeinfo *pipe_info)
> >  				cc = G_chnmap[le32_to_cpu(pdword[1])];
> >  				if (cc >= MAX_CHANNELS)
> >  					break;
> > -				ch = &dev->channel[cc];
> > +				vc = &dev->vc[cc];
> >  				switch (pdword[2]) {
> >  				case S2255_RESPONSE_SETMODE:
> >  					/* check if channel valid */
> >  					/* set mode ready */
> > -					ch->setmode_ready = 1;
> > -					wake_up(&ch->wait_setmode);
> > +					vc->setmode_ready = 1;
> > +					wake_up(&vc->wait_setmode);
> >  					dprintk(dev, 5, "setmode rdy %d\n", cc);
> >  					break;
> >  				case S2255_RESPONSE_FW:
> > @@ -2029,9 +1810,9 @@ static int save_frame(struct s2255_dev *dev, 
> > struct s2255_pipeinfo *pipe_info)
> >  					wake_up(&dev->fw_data->wait_fw);
> >  					break;
> >  				case S2255_RESPONSE_STATUS:
> > -					ch->vidstatus = le32_to_cpu(pdword[3]);
> > -					ch->vidstatus_ready = 1;
> > -					wake_up(&ch->wait_vidstatus);
> > +					vc->vidstatus = le32_to_cpu(pdword[3]);
> > +					vc->vidstatus_ready = 1;
> > +					wake_up(&vc->wait_vidstatus);
> >  					dprintk(dev, 5, "vstat %x chan %d\n",
> >  						le32_to_cpu(pdword[3]), cc);
> >  					break;
> > @@ -2048,11 +1829,12 @@ static int save_frame(struct s2255_dev *dev, 
> > struct s2255_pipeinfo *pipe_info)
> >  		if (!bframe)
> >  			return -EINVAL;
> >  	}
> > -	ch = &dev->channel[dev->cc];
> > -	idx = ch->cur_frame;
> > -	frm = &ch->buffer.frame[idx];
> > +	vc = &dev->vc[dev->cc];
> > +	idx = vc->cur_frame;
> > +	frm = &vc->buffer.frame[idx];
> > +
> >  	/* search done.  now find out if should be acquiring on this 
> > channel */
> > -	if (!ch->b_acquire) {
> > +	if (!vb2_is_streaming(&vc->vb_vidq)) {
> >  		/* we found a frame, but this channel is turned off */
> >  		frm->ulState = S2255_READ_IDLE;
> >  		return -EINVAL;
> > @@ -2066,7 +1848,6 @@ static int save_frame(struct s2255_dev *dev, 
> > struct s2255_pipeinfo *pipe_info)
> >  	/* skip the marker 512 bytes (and offset if out of sync) */
> >  	psrc = (u8 *)pipe_info->transfer_buffer + offset;
> >
> > -
> >  	if (frm->lpvbits == NULL) {
> >  		dprintk(dev, 1, "s2255 frame buffer == NULL.%p %p %d %d",
> >  			frm, dev, dev->cc, idx);
> > @@ -2074,13 +1855,11 @@ static int save_frame(struct s2255_dev *dev, 
> > struct s2255_pipeinfo *pipe_info)
> >  	}
> >
> >  	pdest = frm->lpvbits + frm->cur_size;
> > -
> >  	copy_size = (pipe_info->cur_transfer_size - offset);
> > -
> > -	size = ch->pkt_size - PREFIX_SIZE;
> > +	size = vc->pkt_size - PREFIX_SIZE;
> >
> >  	/* sanity check on pdest */
> > -	if ((copy_size + frm->cur_size) < ch->req_image_size)
> > +	if ((copy_size + frm->cur_size) < vc->req_image_size)
> >  		memcpy(pdest, psrc, copy_size);
> >
> >  	frm->cur_size += copy_size;
> > @@ -2089,19 +1868,18 @@ static int save_frame(struct s2255_dev *dev, 
> > struct s2255_pipeinfo *pipe_info)
> >  	if (frm->cur_size >= size) {
> >  		dprintk(dev, 2, "******[%d]Buffer[%d]full*******\n",
> >  			dev->cc, idx);
> > -		ch->last_frame = ch->cur_frame;
> > -		ch->cur_frame++;
> > +		vc->last_frame = vc->cur_frame;
> > +		vc->cur_frame++;
> >  		/* end of system frame ring buffer, start at zero */
> > -		if ((ch->cur_frame == SYS_FRAMES) ||
> > -		    (ch->cur_frame == ch->buffer.dwFrames))
> > -			ch->cur_frame = 0;
> > +		if ((vc->cur_frame == SYS_FRAMES) ||
> > +		    (vc->cur_frame == vc->buffer.dwFrames))
> > +			vc->cur_frame = 0;
> >  		/* frame ready */
> > -		if (ch->b_acquire)
> > -			s2255_got_frame(ch, ch->jpg_size);
> > -		ch->frame_count++;
> > +		if (vb2_is_streaming(&vc->vb_vidq))
> > +			s2255_got_frame(vc, vc->jpg_size);
> > +		vc->frame_count++;
> >  		frm->ulState = S2255_READ_IDLE;
> >  		frm->cur_size = 0;
> > -
> >  	}
> >  	/* done successfully */
> >  	return 0;
> > @@ -2121,7 +1899,7 @@ static void s2255_read_video_callback(struct 
> > s2255_dev *dev,
> >  	/* otherwise copy to the system buffers */
> >  	res = save_frame(dev, pipe_info);
> >  	if (res != 0)
> > -		dprintk(dev, 4, "s2255: read callback failed\n");
> > +		dprintk(dev, 50, "s2255: read callback: %d\n", res);
> >
> >  	dprintk(dev, 50, "callback read video done\n");
> >  	return;
> > @@ -2171,11 +1949,11 @@ static int s2255_get_fx2fw(struct s2255_dev 
> > *dev)
> >   * Create the system ring buffer to copy frames into from the
> >   * usb read pipe.
> >   */
> > -static int s2255_create_sys_buffers(struct s2255_channel *channel)
> > +static int s2255_create_sys_buffers(struct s2255_vc *vc)
> >  {
> >  	unsigned long i;
> >  	unsigned long reqsize;
> > -	channel->buffer.dwFrames = SYS_FRAMES;
> > +	vc->buffer.dwFrames = SYS_FRAMES;
> >  	/* always allocate maximum size(PAL) for system buffers */
> >  	reqsize = SYS_FRAMES_MAXSIZE;
> >
> > @@ -2184,33 +1962,33 @@ static int s2255_create_sys_buffers(struct 
> > s2255_channel *channel)
> >
> >  	for (i = 0; i < SYS_FRAMES; i++) {
> >  		/* allocate the frames */
> > -		channel->buffer.frame[i].lpvbits = vmalloc(reqsize);
> > -		channel->buffer.frame[i].size = reqsize;
> > -		if (channel->buffer.frame[i].lpvbits == NULL) {
> > +		vc->buffer.frame[i].lpvbits = vmalloc(reqsize);
> > +		vc->buffer.frame[i].size = reqsize;
> > +		if (vc->buffer.frame[i].lpvbits == NULL) {
> >  			pr_info("out of memory.  using less frames\n");
> > -			channel->buffer.dwFrames = i;
> > +			vc->buffer.dwFrames = i;
> >  			break;
> >  		}
> >  	}
> >
> >  	/* make sure internal states are set */
> >  	for (i = 0; i < SYS_FRAMES; i++) {
> > -		channel->buffer.frame[i].ulState = 0;
> > -		channel->buffer.frame[i].cur_size = 0;
> > +		vc->buffer.frame[i].ulState = 0;
> > +		vc->buffer.frame[i].cur_size = 0;
> >  	}
> >
> > -	channel->cur_frame = 0;
> > -	channel->last_frame = -1;
> > +	vc->cur_frame = 0;
> > +	vc->last_frame = -1;
> >  	return 0;
> >  }
> >
> > -static int s2255_release_sys_buffers(struct s2255_channel *channel)
> > +static int s2255_release_sys_buffers(struct s2255_vc *vc)
> >  {
> >  	unsigned long i;
> >  	for (i = 0; i < SYS_FRAMES; i++) {
> > -		if (channel->buffer.frame[i].lpvbits)
> > -			vfree(channel->buffer.frame[i].lpvbits);
> > -		channel->buffer.frame[i].lpvbits = NULL;
> > +		if (vc->buffer.frame[i].lpvbits)
> > +			vfree(vc->buffer.frame[i].lpvbits);
> > +		vc->buffer.frame[i].lpvbits = NULL;
> >  	}
> >  	return 0;
> >  }
> > @@ -2244,21 +2022,20 @@ static int s2255_board_init(struct s2255_dev 
> > *dev)
> >  		pr_info("s2255: newer USB firmware available\n");
> >
> >  	for (j = 0; j < MAX_CHANNELS; j++) {
> > -		struct s2255_channel *channel = &dev->channel[j];
> > -		channel->b_acquire = 0;
> > -		channel->mode = mode_def;
> > +		struct s2255_vc *vc = &dev->vc[j];
> > +		vc->mode = mode_def;
> >  		if (dev->pid == 0x2257 && j > 1)
> > -			channel->mode.color |= (1 << 16);
> > -		channel->jpegqual = S2255_DEF_JPEG_QUAL;
> > -		channel->width = LINE_SZ_4CIFS_NTSC;
> > -		channel->height = NUM_LINES_4CIFS_NTSC * 2;
> > -		channel->std = V4L2_STD_NTSC_M;
> > -		channel->fmt = &formats[0];
> > -		channel->mode.restart = 1;
> > -		channel->req_image_size = get_transfer_size(&mode_def);
> > -		channel->frame_count = 0;
> > +			vc->mode.color |= (1 << 16);
> > +		vc->jpegqual = S2255_DEF_JPEG_QUAL;
> > +		vc->width = LINE_SZ_4CIFS_NTSC;
> > +		vc->height = NUM_LINES_4CIFS_NTSC * 2;
> > +		vc->std = V4L2_STD_NTSC_M;
> > +		vc->fmt = &formats[0];
> > +		vc->mode.restart = 1;
> > +		vc->req_image_size = get_transfer_size(&mode_def);
> > +		vc->frame_count = 0;
> >  		/* create the system buffers */
> > -		s2255_create_sys_buffers(channel);
> > +		s2255_create_sys_buffers(vc);
> >  	}
> >  	/* start read pipe */
> >  	s2255_start_readpipe(dev);
> > @@ -2270,14 +2047,13 @@ static int s2255_board_shutdown(struct 
> > s2255_dev *dev)
> >  {
> >  	u32 i;
> >  	dprintk(dev, 1, "%s: dev: %p", __func__,  dev);
> > -
> >  	for (i = 0; i < MAX_CHANNELS; i++) {
> > -		if (dev->channel[i].b_acquire)
> > -			s2255_stop_acquire(&dev->channel[i]);
> > +		if (vb2_is_streaming(&dev->vc[i].vb_vidq))
> > +			s2255_stop_acquire(&dev->vc[i]);
> >  	}
> >  	s2255_stop_readpipe(dev);
> >  	for (i = 0; i < MAX_CHANNELS; i++)
> > -		s2255_release_sys_buffers(&dev->channel[i]);
> > +		s2255_release_sys_buffers(&dev->vc[i]);
> >  	/* release transfer buffer */
> >  	kfree(dev->pipe.transfer_buffer);
> >  	return 0;
> > @@ -2366,26 +2142,26 @@ static int s2255_start_readpipe(struct 
> > s2255_dev *dev)
> >  }
> >
> >  /* starts acquisition process */
> > -static int s2255_start_acquire(struct s2255_channel *channel)
> > +static int s2255_start_acquire(struct s2255_vc *vc)
> >  {
> >  	unsigned char *buffer;
> >  	int res;
> >  	unsigned long chn_rev;
> >  	int j;
> > -	struct s2255_dev *dev = to_s2255_dev(channel->vdev.v4l2_dev);
> > -	chn_rev = G_chnmap[channel->idx];
> > +	struct s2255_dev *dev = to_s2255_dev(vc->vdev.v4l2_dev);
> > +	chn_rev = G_chnmap[vc->idx];
> >  	buffer = kzalloc(512, GFP_KERNEL);
> >  	if (buffer == NULL) {
> >  		dev_err(&dev->udev->dev, "out of mem\n");
> >  		return -ENOMEM;
> >  	}
> >
> > -	channel->last_frame = -1;
> > -	channel->bad_payload = 0;
> > -	channel->cur_frame = 0;
> > +	vc->last_frame = -1;
> > +	vc->bad_payload = 0;
> > +	vc->cur_frame = 0;
> >  	for (j = 0; j < SYS_FRAMES; j++) {
> > -		channel->buffer.frame[j].ulState = 0;
> > -		channel->buffer.frame[j].cur_size = 0;
> > +		vc->buffer.frame[j].ulState = 0;
> > +		vc->buffer.frame[j].cur_size = 0;
> >  	}
> >
> >  	/* send the start command */
> > @@ -2396,18 +2172,18 @@ static int s2255_start_acquire(struct 
> > s2255_channel *channel)
> >  	if (res != 0)
> >  		dev_err(&dev->udev->dev, "CMD_START error\n");
> >
> > -	dprintk(dev, 2, "start acquire exit[%d] %d\n", channel->idx, res);
> > +	dprintk(dev, 2, "start acquire exit[%d] %d\n", vc->idx, res);
> >  	kfree(buffer);
> >  	return 0;
> >  }
> >
> > -static int s2255_stop_acquire(struct s2255_channel *channel)
> > +static int s2255_stop_acquire(struct s2255_vc *vc)
> >  {
> >  	unsigned char *buffer;
> >  	int res;
> >  	unsigned long chn_rev;
> > -	struct s2255_dev *dev = to_s2255_dev(channel->vdev.v4l2_dev);
> > -	chn_rev = G_chnmap[channel->idx];
> > +	struct s2255_dev *dev = to_s2255_dev(vc->vdev.v4l2_dev);
> > +	chn_rev = G_chnmap[vc->idx];
> >  	buffer = kzalloc(512, GFP_KERNEL);
> >  	if (buffer == NULL) {
> >  		dev_err(&dev->udev->dev, "out of mem\n");
> > @@ -2421,8 +2197,7 @@ static int s2255_stop_acquire(struct 
> > s2255_channel *channel)
> >  	if (res != 0)
> >  		dev_err(&dev->udev->dev, "CMD_STOP error\n");
> >  	kfree(buffer);
> > -	channel->b_acquire = 0;
> > -	dprintk(dev, 4, "%s: chn %d, res %d\n", __func__, channel->idx, 
> > res);
> > +	dprintk(dev, 4, "%s: chn %d, res %d\n", __func__, vc->idx, res);
> >  	return res;
> >  }
> >
> > @@ -2512,11 +2287,13 @@ static int s2255_probe(struct usb_interface 
> > *interface,
> >  	dev->timer.data = (unsigned long)dev->fw_data;
> >  	init_waitqueue_head(&dev->fw_data->wait_fw);
> >  	for (i = 0; i < MAX_CHANNELS; i++) {
> > -		struct s2255_channel *channel = &dev->channel[i];
> > -		channel->idx = i;
> > -		channel->dev = dev;
> > -		init_waitqueue_head(&channel->wait_setmode);
> > -		init_waitqueue_head(&channel->wait_vidstatus);
> > +		struct s2255_vc *vc = &dev->vc[i];
> > +		vc->idx = i;
> > +		vc->dev = dev;
> > +		init_waitqueue_head(&vc->wait_setmode);
> > +		init_waitqueue_head(&vc->wait_vidstatus);
> > +		spin_lock_init(&vc->qlock);
> > +		mutex_init(&vc->vb_lock);
> >  	}
> >
> >  	dev->fw_data->fw_urb = usb_alloc_urb(0, GFP_KERNEL);
> > @@ -2562,8 +2339,7 @@ static int s2255_probe(struct usb_interface 
> > *interface,
> >  	retval = s2255_board_init(dev);
> >  	if (retval)
> >  		goto errorBOARDINIT;
> > -	spin_lock_init(&dev->slock);
> > -	s2255_fwload_start(dev, 0);
> > +	s2255_fwload_start(dev, 1);
> >  	/* loads v4l specific */
> >  	retval = s2255_probe_v4l(dev);
> >  	if (retval)
> > @@ -2604,15 +2380,15 @@ static void s2255_disconnect(struct 
> > usb_interface *interface)
> >  	atomic_inc(&dev->num_channels);
> >  	/* unregister each video device. */
> >  	for (i = 0; i < channels; i++)
> > -		video_unregister_device(&dev->channel[i].vdev);
> > +		video_unregister_device(&dev->vc[i].vdev);
> >  	/* wake up any of our timers */
> >  	atomic_set(&dev->fw_data->fw_state, S2255_FW_DISCONNECTING);
> >  	wake_up(&dev->fw_data->wait_fw);
> >  	for (i = 0; i < MAX_CHANNELS; i++) {
> > -		dev->channel[i].setmode_ready = 1;
> > -		wake_up(&dev->channel[i].wait_setmode);
> > -		dev->channel[i].vidstatus_ready = 1;
> > -		wake_up(&dev->channel[i].wait_vidstatus);
> > +		dev->vc[i].setmode_ready = 1;
> > +		wake_up(&dev->vc[i].wait_setmode);
> > +		dev->vc[i].vidstatus_ready = 1;
> > +		wake_up(&dev->vc[i].wait_vidstatus);
> >  	}
> >  	if (atomic_dec_and_test(&dev->num_channels))
> >  		s2255_destroy(dev);
>
> Regards,
>
> 	Hans
--
To unsubscribe from this list: send the line "unsubscribe linux-media" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at  http://vger.kernel.org/majordomo-info.html