Re: [PATCH] s2255drv: cleanup of device structure

[Mauro Carvalho Chehab <mchehab@infradead.org>]

Hi Dean,

Em Mon, 12 Apr 2010 10:19:13 -0700 (PDT)
sensoray-dev <linux-dev@sensoray.com> escreveu:

> # HG changeset patch
> # User Dean Anderson <linux-dev@sensoray.com>
> # Date 1271092523 25200
> # Node ID 686a2330f4a6a4c79e299a17663f0f150031098e
> # Parent  f2f44853e2eb914d4fc6c7004631839b86fb6d0e
> s2255drv: cleanup of device structure
> 
> From: Dean Anderson <linux-dev@sensoray.com>
> 
> cleanup of device structure
> better organization of channels instead of multiple arrays in device
> simplifies open callback by removing search for channel index
> adding v4l2_device_disconnect
> 
> Priority: normal
> 
> Signed-off-by: Dean Anderson <linux-dev@sensoray.com>


Sorry, but the patch didn't apply:

patching file drivers/media/video/s2255drv.c
Hunk #1 succeeded at 190 (offset -1 lines).
Hunk #3 succeeded at 305 (offset -1 lines).
Hunk #5 succeeded at 577 (offset -1 lines).
Hunk #7 succeeded at 622 (offset -1 lines).
Hunk #9 succeeded at 661 (offset -1 lines).
Hunk #11 succeeded at 686 (offset -1 lines).
Hunk #13 succeeded at 754 (offset -1 lines).
Hunk #15 succeeded at 778 (offset -1 lines).
Hunk #17 succeeded at 893 (offset -1 lines).
Hunk #19 succeeded at 1013 (offset -1 lines).
Hunk #21 succeeded at 1243 (offset -1 lines).
Hunk #23 succeeded at 1307 (offset -1 lines).
Hunk #25 succeeded at 1353 (offset -1 lines).
Hunk #27 succeeded at 1414 (offset -1 lines).
Hunk #29 succeeded at 1435 (offset -1 lines).
Hunk #31 succeeded at 1477 (offset -1 lines).
Hunk #33 succeeded at 1531 (offset -1 lines).
Hunk #35 succeeded at 1584 (offset -1 lines).
Hunk #37 succeeded at 1632 (offset -1 lines).
Hunk #39 succeeded at 1711 (offset -1 lines).
Hunk #41 succeeded at 1843 (offset -1 lines).
Hunk #43 succeeded at 1925 (offset -1 lines).
Hunk #44 FAILED at 1947.
Hunk #45 succeeded at 2017 (offset 1 line).
Hunk #46 succeeded at 2044 (offset -1 lines).
Hunk #47 succeeded at 2065 (offset 1 line).
Hunk #48 succeeded at 2084 (offset -1 lines).
Hunk #49 succeeded at 2105 (offset 1 line).
Hunk #50 succeeded at 2132 (offset -1 lines).
Hunk #51 succeeded at 2228 (offset 1 line).
Hunk #52 succeeded at 2240 (offset -1 lines).
Hunk #53 succeeded at 2312 (offset 1 line).
Hunk #54 succeeded at 2337 (offset -1 lines).
Hunk #55 succeeded at 2437 (offset 1 line).
Hunk #56 succeeded at 2465 (offset -1 lines).
Hunk #57 succeeded at 2492 (offset 1 line).
Hunk #58 succeeded at 2548 (offset -1 lines).
Hunk #59 succeeded at 2587 (offset 1 line).
Hunk #60 succeeded at 2626 (offset -1 lines).
Hunk #61 succeeded at 2670 (offset 1 line).
1 out of 61 hunks FAILED -- saving rejects to file drivers/media/video/s2255drv.c.rej
>>> Patch patches/lmml_92061_s2255drv_cleanup_of_device_structure.patch doesn't apply

I might try to fix the failed hunk, but I prefer if you could double check what's going
wrong, since this is a long patch that are replacing some structs.

Please use my -git tree as the basis, since Douglas is currently in a training
and it may take some time until he could be able to sync the -hg tree.




> 
> diff -r f2f44853e2eb -r 686a2330f4a6 linux/drivers/media/video/s2255drv.c
> --- a/linux/drivers/media/video/s2255drv.c	Fri Apr 09 15:51:28 2010 -0700
> +++ b/linux/drivers/media/video/s2255drv.c	Mon Apr 12 10:15:23 2010 -0700
> @@ -191,7 +191,6 @@
>  struct s2255_dmaqueue {
>  	struct list_head	active;
>  	struct s2255_dev	*dev;
> -	int			channel;
>  };
>  
>  /* for firmware loading, fw_state */
> @@ -226,51 +225,60 @@
>  };
>  
>  struct s2255_fmt; /*forward declaration */
> +struct s2255_dev;
> +
> +struct s2255_channel {
> +	struct video_device	vdev;
> +	int			resources;
> +	struct s2255_dmaqueue	vidq;
> +	struct s2255_bufferi	buffer;
> +	struct s2255_mode	mode;
> +	/* jpeg compression */
> +	struct v4l2_jpegcompression jc;
> +	/* capture parameters (for high quality mode full size) */
> +	struct v4l2_captureparm cap_parm;
> +	int			cur_frame;
> +	int			last_frame;
> +
> +	int			b_acquire;
> +	/* allocated image size */
> +	unsigned long		req_image_size;
> +	/* received packet size */
> +	unsigned long		pkt_size;
> +	int			bad_payload;
> +	unsigned long		frame_count;
> +	/* if JPEG image */
> +	int                     jpg_size;
> +	/* if channel configured to default state */
> +	int                     configured;
> +	wait_queue_head_t       wait_setmode;
> +	int                     setmode_ready;
> +	/* video status items */
> +	int                     vidstatus;
> +	wait_queue_head_t       wait_vidstatus;
> +	int                     vidstatus_ready;
> +	unsigned int		width;
> +	unsigned int		height;
> +	const struct s2255_fmt	*fmt;
> +	int idx; /* channel number on device, 0-3 */
> +};
> +
>  
>  struct s2255_dev {
> -	struct video_device	vdev[MAX_CHANNELS];
> +	struct s2255_channel    channel[MAX_CHANNELS];
>  	struct v4l2_device 	v4l2_dev;
> -	atomic_t                channels; /* number of channels registered */
> +	atomic_t                num_channels;
>  	int			frames;
>  	struct mutex		lock;
>  	struct mutex		open_lock;
> -	int			resources[MAX_CHANNELS];
>  	struct usb_device	*udev;
>  	struct usb_interface	*interface;
>  	u8			read_endpoint;
> -
> -	struct s2255_dmaqueue	vidq[MAX_CHANNELS];
>  	struct timer_list	timer;
>  	struct s2255_fw	*fw_data;
>  	struct s2255_pipeinfo	pipe;
> -	struct s2255_bufferi	buffer[MAX_CHANNELS];
> -	struct s2255_mode	mode[MAX_CHANNELS];
> -	/* jpeg compression */
> -	struct v4l2_jpegcompression jc[MAX_CHANNELS];
> -	/* capture parameters (for high quality mode full size) */
> -	struct v4l2_captureparm cap_parm[MAX_CHANNELS];
> -	const struct s2255_fmt	*cur_fmt[MAX_CHANNELS];
> -	int			cur_frame[MAX_CHANNELS];
> -	int			last_frame[MAX_CHANNELS];
>  	u32			cc;	/* current channel */
> -	int			b_acquire[MAX_CHANNELS];
> -	/* allocated image size */
> -	unsigned long		req_image_size[MAX_CHANNELS];
> -	/* received packet size */
> -	unsigned long		pkt_size[MAX_CHANNELS];
> -	int			bad_payload[MAX_CHANNELS];
> -	unsigned long		frame_count[MAX_CHANNELS];
>  	int			frame_ready;
> -	/* if JPEG image */
> -	int                     jpg_size[MAX_CHANNELS];
> -	/* if channel configured to default state */
> -	int                     chn_configured[MAX_CHANNELS];
> -	wait_queue_head_t       wait_setmode[MAX_CHANNELS];
> -	int                     setmode_ready[MAX_CHANNELS];
> -	/* video status items */
> -	int                     vidstatus[MAX_CHANNELS];
> -	wait_queue_head_t       wait_vidstatus[MAX_CHANNELS];
> -	int                     vidstatus_ready[MAX_CHANNELS];
>  	int                     chn_ready;
>  	spinlock_t              slock;
>  	/* dsp firmware version (f2255usb.bin) */
> @@ -298,16 +306,10 @@
>  
>  struct s2255_fh {
>  	struct s2255_dev	*dev;
> -	const struct s2255_fmt	*fmt;
> -	unsigned int		width;
> -	unsigned int		height;
>  	struct videobuf_queue	vb_vidq;
>  	enum v4l2_buf_type	type;
> -	int			channel;
> -	/* mode below is the desired mode.
> -	   mode in s2255_dev is the current mode that was last set */
> -	struct s2255_mode	mode;
> -	int			resources[MAX_CHANNELS];
> +	struct s2255_channel	*channel;
> +	int			resources;
>  };
>  
>  /* current cypress EEPROM firmware version */
> @@ -360,12 +362,11 @@
>  
>  static int s2255_start_readpipe(struct s2255_dev *dev);
>  static void s2255_stop_readpipe(struct s2255_dev *dev);
> -static int s2255_start_acquire(struct s2255_dev *dev, unsigned long chn);
> -static int s2255_stop_acquire(struct s2255_dev *dev, unsigned long chn);
> -static void s2255_fillbuff(struct s2255_dev *dev, struct s2255_buffer *buf,
> -			   int chn, int jpgsize);
> -static int s2255_set_mode(struct s2255_dev *dev, unsigned long chn,
> -			  struct s2255_mode *mode);
> +static int s2255_start_acquire(struct s2255_channel *channel);
> +static int s2255_stop_acquire(struct s2255_channel *channel);
> +static void s2255_fillbuff(struct s2255_channel *chn, struct s2255_buffer *buf,
> +			   int jpgsize);
> +static int s2255_set_mode(struct s2255_channel *chan, struct s2255_mode *mode);
>  static int s2255_board_shutdown(struct s2255_dev *dev);
>  static void s2255_fwload_start(struct s2255_dev *dev, int reset);
>  static void s2255_destroy(struct s2255_dev *dev);
> @@ -577,10 +578,11 @@
>  
>  }
>  
> -static int s2255_got_frame(struct s2255_dev *dev, int chn, int jpgsize)
> +static int s2255_got_frame(struct s2255_channel *channel, int jpgsize)
>  {
> -	struct s2255_dmaqueue *dma_q = &dev->vidq[chn];
> +	struct s2255_dmaqueue *dma_q = &channel->vidq;
>  	struct s2255_buffer *buf;
> +	struct s2255_dev *dev = to_s2255_dev(channel->vdev.v4l2_dev);
>  	unsigned long flags = 0;
>  	int rc = 0;
>  	spin_lock_irqsave(&dev->slock, flags);
> @@ -593,7 +595,7 @@
>  			 struct s2255_buffer, vb.queue);
>  	list_del(&buf->vb.queue);
>  	do_gettimeofday(&buf->vb.ts);
> -	s2255_fillbuff(dev, buf, dma_q->channel, jpgsize);
> +	s2255_fillbuff(channel, buf, jpgsize);
>  	wake_up(&buf->vb.done);
>  	dprintk(2, "%s: [buf/i] [%p/%d]\n", __func__, buf, buf->vb.i);
>  unlock:
> @@ -621,8 +623,8 @@
>   *                  http://v4l.videotechnology.com/
>   *
>   */
> -static void s2255_fillbuff(struct s2255_dev *dev, struct s2255_buffer *buf,
> -			   int chn, int jpgsize)
> +static void s2255_fillbuff(struct s2255_channel *channel,
> +			   struct s2255_buffer *buf, int jpgsize)
>  {
>  	int pos = 0;
>  	struct timeval ts;
> @@ -633,12 +635,11 @@
>  
>  	if (!vbuf)
>  		return;
> -
> -	last_frame = dev->last_frame[chn];
> +	last_frame = channel->last_frame;
>  	if (last_frame != -1) {
> -		frm = &dev->buffer[chn].frame[last_frame];
> +		frm = &channel->buffer.frame[last_frame];
>  		tmpbuf =
> -		    (const char *)dev->buffer[chn].frame[last_frame].lpvbits;
> +		    (const char *)channel->buffer.frame[last_frame].lpvbits;
>  		switch (buf->fmt->fourcc) {
>  		case V4L2_PIX_FMT_YUYV:
>  		case V4L2_PIX_FMT_UYVY:
> @@ -661,7 +662,7 @@
>  		default:
>  			printk(KERN_DEBUG "s2255: unknown format?\n");
>  		}
> -		dev->last_frame[chn] = -1;
> +		channel->last_frame = -1;
>  	} else {
>  		printk(KERN_ERR "s2255: =======no frame\n");
>  		return;
> @@ -671,7 +672,7 @@
>  		(unsigned long)vbuf, pos);
>  	/* tell v4l buffer was filled */
>  
> -	buf->vb.field_count = dev->frame_count[chn] * 2;
> +	buf->vb.field_count = channel->frame_count * 2;
>  	do_gettimeofday(&ts);
>  	buf->vb.ts = ts;
>  	buf->vb.state = VIDEOBUF_DONE;
> @@ -686,8 +687,8 @@
>  			unsigned int *size)
>  {
>  	struct s2255_fh *fh = vq->priv_data;
> -
> -	*size = fh->width * fh->height * (fh->fmt->depth >> 3);
> +	struct s2255_channel *channel = fh->channel;
> +	*size = channel->width * channel->height * (channel->fmt->depth >> 3);
>  
>  	if (0 == *count)
>  		*count = S2255_DEF_BUFS;
> @@ -710,30 +711,31 @@
>  			  enum v4l2_field field)
>  {
>  	struct s2255_fh *fh = vq->priv_data;
> +	struct s2255_channel *channel = fh->channel;
>  	struct s2255_buffer *buf = container_of(vb, struct s2255_buffer, vb);
>  	int rc;
> +	int w = channel->width;
> +	int h = channel->height;
>  	dprintk(4, "%s, field=%d\n", __func__, field);
> -	if (fh->fmt == NULL)
> +	if (channel->fmt == NULL)
>  		return -EINVAL;
>  
> -	if ((fh->width < norm_minw(&fh->dev->vdev[fh->channel])) ||
> -	    (fh->width > norm_maxw(&fh->dev->vdev[fh->channel])) ||
> -	    (fh->height < norm_minh(&fh->dev->vdev[fh->channel])) ||
> -	    (fh->height > norm_maxh(&fh->dev->vdev[fh->channel]))) {
> +	if ((w < norm_minw(&channel->vdev)) ||
> +	    (w > norm_maxw(&channel->vdev)) ||
> +	    (h < norm_minh(&channel->vdev)) ||
> +	    (h > norm_maxh(&channel->vdev))) {
>  		dprintk(4, "invalid buffer prepare\n");
>  		return -EINVAL;
>  	}
> -
> -	buf->vb.size = fh->width * fh->height * (fh->fmt->depth >> 3);
> -
> +	buf->vb.size = w * h * (channel->fmt->depth >> 3);
>  	if (0 != buf->vb.baddr && buf->vb.bsize < buf->vb.size) {
>  		dprintk(4, "invalid buffer prepare\n");
>  		return -EINVAL;
>  	}
>  
> -	buf->fmt = fh->fmt;
> -	buf->vb.width = fh->width;
> -	buf->vb.height = fh->height;
> +	buf->fmt = channel->fmt;
> +	buf->vb.width = w;
> +	buf->vb.height = h;
>  	buf->vb.field = field;
>  
>  	if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
> @@ -753,8 +755,8 @@
>  {
>  	struct s2255_buffer *buf = container_of(vb, struct s2255_buffer, vb);
>  	struct s2255_fh *fh = vq->priv_data;
> -	struct s2255_dev *dev = fh->dev;
> -	struct s2255_dmaqueue *vidq = &dev->vidq[fh->channel];
> +	struct s2255_channel *channel = fh->channel;
> +	struct s2255_dmaqueue *vidq = &channel->vidq;
>  	dprintk(1, "%s\n", __func__);
>  	buf->vb.state = VIDEOBUF_QUEUED;
>  	list_add_tail(&buf->vb.queue, &vidq->active);
> @@ -765,7 +767,7 @@
>  {
>  	struct s2255_buffer *buf = container_of(vb, struct s2255_buffer, vb);
>  	struct s2255_fh *fh = vq->priv_data;
> -	dprintk(4, "%s %d\n", __func__, fh->channel);
> +	dprintk(4, "%s %d\n", __func__, fh->channel->idx);
>  	free_buffer(vq, buf);
>  }
>  
> @@ -777,39 +779,44 @@
>  };
>  
>  
> -static int res_get(struct s2255_dev *dev, struct s2255_fh *fh)
> +static int res_get(struct s2255_fh *fh)
>  {
> +	struct s2255_dev *dev = fh->dev;
>  	/* is it free? */
> +	struct s2255_channel *channel = fh->channel;
>  	mutex_lock(&dev->lock);
> -	if (dev->resources[fh->channel]) {
> +	if (channel->resources) {
>  		/* no, someone else uses it */
>  		mutex_unlock(&dev->lock);
>  		return 0;
>  	}
>  	/* it's free, grab it */
> -	dev->resources[fh->channel] = 1;
> -	fh->resources[fh->channel] = 1;
> +	channel->resources = 1;
> +	fh->resources = 1;
>  	dprintk(1, "s2255: res: get\n");
>  	mutex_unlock(&dev->lock);
>  	return 1;
>  }
>  
> -static int res_locked(struct s2255_dev *dev, struct s2255_fh *fh)
> +static int res_locked(struct s2255_fh *fh)
>  {
> -	return dev->resources[fh->channel];
> +	struct s2255_channel *channel = fh->channel;
> +	return channel->resources;
>  }
>  
>  static int res_check(struct s2255_fh *fh)
>  {
> -	return fh->resources[fh->channel];
> +	return fh->resources;
>  }
>  
>  
> -static void res_free(struct s2255_dev *dev, struct s2255_fh *fh)
> +static void res_free(struct s2255_fh *fh)
>  {
> +	struct s2255_channel *channel = fh->channel;
> +	struct s2255_dev *dev = fh->dev;
>  	mutex_lock(&dev->lock);
> -	dev->resources[fh->channel] = 0;
> -	fh->resources[fh->channel] = 0;
> +	channel->resources = 0;
> +	fh->resources = 0;
>  	mutex_unlock(&dev->lock);
>  	dprintk(1, "res: put\n");
>  }
> @@ -869,12 +876,13 @@
>  			    struct v4l2_format *f)
>  {
>  	struct s2255_fh *fh = priv;
> +	struct s2255_channel *channel = fh->channel;
>  
> -	f->fmt.pix.width = fh->width;
> -	f->fmt.pix.height = fh->height;
> +	f->fmt.pix.width = channel->width;
> +	f->fmt.pix.height = channel->height;
>  	f->fmt.pix.field = fh->vb_vidq.field;
> -	f->fmt.pix.pixelformat = fh->fmt->fourcc;
> -	f->fmt.pix.bytesperline = f->fmt.pix.width * (fh->fmt->depth >> 3);
> +	f->fmt.pix.pixelformat = channel->fmt->fourcc;
> +	f->fmt.pix.bytesperline = f->fmt.pix.width * (channel->fmt->depth >> 3);
>  	f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
>  	return 0;
>  }
> @@ -886,11 +894,10 @@
>  	enum v4l2_field field;
>  	int  b_any_field = 0;
>  	struct s2255_fh *fh = priv;
> -	struct s2255_dev *dev = fh->dev;
> +	struct s2255_channel *channel = fh->channel;
>  	int is_ntsc;
> -
>  	is_ntsc =
> -	    (dev->vdev[fh->channel].current_norm & V4L2_STD_NTSC) ? 1 : 0;
> +		(channel->vdev.current_norm & V4L2_STD_NTSC) ? 1 : 0;
>  
>  	fmt = format_by_fourcc(f->fmt.pix.pixelformat);
>  
> @@ -982,8 +989,10 @@
>  			    struct v4l2_format *f)
>  {
>  	struct s2255_fh *fh = priv;
> +	struct s2255_channel *channel = fh->channel;
>  	const struct s2255_fmt *fmt;
>  	struct videobuf_queue *q = &fh->vb_vidq;
> +	struct s2255_mode mode;
>  	int ret;
>  	int norm;
>  
> @@ -1005,54 +1014,61 @@
>  		goto out_s_fmt;
>  	}
>  
> -	if (res_locked(fh->dev, fh)) {
> +	if (res_locked(fh)) {
>  		dprintk(1, "%s: channel busy\n", __func__);
>  		ret = -EBUSY;
>  		goto out_s_fmt;
>  	}
> -
> -	fh->fmt = fmt;
> -	fh->width = f->fmt.pix.width;
> -	fh->height = f->fmt.pix.height;
> +	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;
> -	norm = norm_minw(&fh->dev->vdev[fh->channel]);
> -	if (fh->width > norm_minw(&fh->dev->vdev[fh->channel])) {
> -		if (fh->height > norm_minh(&fh->dev->vdev[fh->channel])) {
> -			if (fh->dev->cap_parm[fh->channel].capturemode &
> +	norm = norm_minw(&channel->vdev);
> +	if (channel->width > norm_minw(&channel->vdev)) {
> +		if (channel->height > norm_minh(&channel->vdev)) {
> +			if (channel->cap_parm.capturemode &
>  			    V4L2_MODE_HIGHQUALITY)
> -				fh->mode.scale = SCALE_4CIFSI;
> +				mode.scale = SCALE_4CIFSI;
>  			else
> -				fh->mode.scale = SCALE_4CIFS;
> +				mode.scale = SCALE_4CIFS;
>  		} else
> -			fh->mode.scale = SCALE_2CIFS;
> +			mode.scale = SCALE_2CIFS;
>  
>  	} else {
> -		fh->mode.scale = SCALE_1CIFS;
> +		mode.scale = SCALE_1CIFS;
>  	}
> -
>  	/* color mode */
> -	switch (fh->fmt->fourcc) {
> +	switch (channel->fmt->fourcc) {
>  	case V4L2_PIX_FMT_GREY:
> -		fh->mode.color &= ~MASK_COLOR;
> -		fh->mode.color |= COLOR_Y8;
> +		mode.color &= ~MASK_COLOR;
> +		mode.color |= COLOR_Y8;
>  		break;
>  	case V4L2_PIX_FMT_JPEG:
> -		fh->mode.color &= ~MASK_COLOR;
> -		fh->mode.color |= COLOR_JPG;
> -		fh->mode.color |= (fh->dev->jc[fh->channel].quality << 8);
> +		mode.color &= ~MASK_COLOR;
> +		mode.color |= COLOR_JPG;
> +		mode.color |= (channel->jc.quality << 8);
>  		break;
>  	case V4L2_PIX_FMT_YUV422P:
> -		fh->mode.color &= ~MASK_COLOR;
> -		fh->mode.color |= COLOR_YUVPL;
> +		mode.color &= ~MASK_COLOR;
> +		mode.color |= COLOR_YUVPL;
>  		break;
>  	case V4L2_PIX_FMT_YUYV:
>  	case V4L2_PIX_FMT_UYVY:
>  	default:
> -		fh->mode.color &= ~MASK_COLOR;
> -		fh->mode.color |= COLOR_YUVPK;
> +		mode.color &= ~MASK_COLOR;
> +		mode.color |= COLOR_YUVPK;
>  		break;
>  	}
> +	if ((mode.color & MASK_COLOR) != (channel->mode.color & MASK_COLOR))
> +		mode.restart = 1;
> +	else if (mode.scale != channel->mode.scale)
> +		mode.restart = 1;
> +	else if (mode.format != channel->mode.format)
> +		mode.restart = 1;
> +	channel->mode = mode;
> +	(void) s2255_set_mode(channel, &mode);
>  	ret = 0;
>  out_s_fmt:
>  	mutex_unlock(&q->vb_lock);
> @@ -1197,26 +1213,27 @@
>   * 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_dev *dev, unsigned long chn,
> +static int s2255_set_mode(struct s2255_channel *channel,
>  			  struct s2255_mode *mode)
>  {
>  	int res;
>  	__le32 *buffer;
>  	unsigned long chn_rev;
> +	struct s2255_dev *dev = to_s2255_dev(channel->vdev.v4l2_dev);
>  	mutex_lock(&dev->lock);
> -	chn_rev = G_chnmap[chn];
> -	dprintk(3, "%s channel %lu\n", __func__, chn);
> +	chn_rev = G_chnmap[channel->idx];
> +	dprintk(3, "%s channel: %d\n", __func__, channel->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 |= (dev->jc[chn].quality << 8);
> +		mode->color |= (channel->jc.quality << 8);
>  	}
>  	/* save the mode */
> -	dev->mode[chn] = *mode;
> -	dev->req_image_size[chn] = get_transfer_size(mode);
> -	dprintk(1, "%s: reqsize %ld\n", __func__, dev->req_image_size[chn]);
> +	channel->mode = *mode;
> +	channel->req_image_size = get_transfer_size(mode);
> +	dprintk(1, "%s: reqsize %ld\n", __func__, channel->req_image_size);
>  	buffer = kzalloc(512, GFP_KERNEL);
>  	if (buffer == NULL) {
>  		dev_err(&dev->udev->dev, "out of mem\n");
> @@ -1227,38 +1244,38 @@
>  	buffer[0] = IN_DATA_TOKEN;
>  	buffer[1] = (__le32) cpu_to_le32(chn_rev);
>  	buffer[2] = CMD_SET_MODE;
> -	memcpy(&buffer[3], &dev->mode[chn], sizeof(struct s2255_mode));
> -	dev->setmode_ready[chn] = 0;
> +	memcpy(&buffer[3], &channel->mode, sizeof(struct s2255_mode));
> +	channel->setmode_ready = 0;
>  	res = s2255_write_config(dev->udev, (unsigned char *)buffer, 512);
>  	if (debug)
>  		s2255_print_cfg(dev, mode);
>  	kfree(buffer);
>  	/* wait at least 3 frames before continuing */
>  	if (mode->restart) {
> -		wait_event_timeout(dev->wait_setmode[chn],
> -				   (dev->setmode_ready[chn] != 0),
> +		wait_event_timeout(channel->wait_setmode,
> +				   (channel->setmode_ready != 0),
>  				   msecs_to_jiffies(S2255_SETMODE_TIMEOUT));
> -		if (dev->setmode_ready[chn] != 1) {
> +		if (channel->setmode_ready != 1) {
>  			printk(KERN_DEBUG "s2255: no set mode response\n");
>  			res = -EFAULT;
>  		}
>  	}
>  	/* clear the restart flag */
> -	dev->mode[chn].restart = 0;
> +	channel->mode.restart = 0;
>  	mutex_unlock(&dev->lock);
> -	dprintk(1, "%s chn %lu, result: %d\n", __func__, chn, res);
> +	dprintk(1, "%s chn %d, result: %d\n", __func__, channel->idx, res);
>  	return res;
>  }
>  
> -static int s2255_cmd_status(struct s2255_dev *dev, unsigned long chn,
> -			    u32 *pstatus)
> +static int s2255_cmd_status(struct s2255_channel *channel, u32 *pstatus)
>  {
>  	int res;
>  	__le32 *buffer;
>  	u32 chn_rev;
> +	struct s2255_dev *dev = to_s2255_dev(channel->vdev.v4l2_dev);
>  	mutex_lock(&dev->lock);
> -	chn_rev = G_chnmap[chn];
> -	dprintk(4, "%s chan %lu\n", __func__, chn);
> +	chn_rev = G_chnmap[channel->idx];
> +	dprintk(4, "%s chan %d\n", __func__, channel->idx);
>  	buffer = kzalloc(512, GFP_KERNEL);
>  	if (buffer == NULL) {
>  		dev_err(&dev->udev->dev, "out of mem\n");
> @@ -1270,17 +1287,17 @@
>  	buffer[1] = (__le32) cpu_to_le32(chn_rev);
>  	buffer[2] = CMD_STATUS;
>  	*pstatus = 0;
> -	dev->vidstatus_ready[chn] = 0;
> +	channel->vidstatus_ready = 0;
>  	res = s2255_write_config(dev->udev, (unsigned char *)buffer, 512);
>  	kfree(buffer);
> -	wait_event_timeout(dev->wait_vidstatus[chn],
> -			   (dev->vidstatus_ready[chn] != 0),
> +	wait_event_timeout(channel->wait_vidstatus,
> +			   (channel->vidstatus_ready != 0),
>  			   msecs_to_jiffies(S2255_VIDSTATUS_TIMEOUT));
> -	if (dev->vidstatus_ready[chn] != 1) {
> +	if (channel->vidstatus_ready != 1) {
>  		printk(KERN_DEBUG "s2255: no vidstatus response\n");
>  		res = -EFAULT;
>  	}
> -	*pstatus = dev->vidstatus[chn];
> +	*pstatus = channel->vidstatus;
>  	dprintk(4, "%s, vid status %d\n", __func__, *pstatus);
>  	mutex_unlock(&dev->lock);
>  	return res;
> @@ -1291,9 +1308,7 @@
>  	int res;
>  	struct s2255_fh *fh = priv;
>  	struct s2255_dev *dev = fh->dev;
> -	struct s2255_mode *new_mode;
> -	struct s2255_mode *old_mode;
> -	int chn;
> +	struct s2255_channel *channel = fh->channel;
>  	int j;
>  	dprintk(4, "%s\n", __func__);
>  	if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
> @@ -1305,51 +1320,32 @@
>  		return -EINVAL;
>  	}
>  
> -	if (!res_get(dev, fh)) {
> +	if (!res_get(fh)) {
>  		s2255_dev_err(&dev->udev->dev, "stream busy\n");
>  		return -EBUSY;
>  	}
> -
> -	/* send a set mode command everytime with restart.
> -	   in case we switch resolutions or other parameters */
> -	chn = fh->channel;
> -	new_mode = &fh->mode;
> -	old_mode = &fh->dev->mode[chn];
> -
> -	if ((new_mode->color & MASK_COLOR) != (old_mode->color & MASK_COLOR))
> -		new_mode->restart = 1;
> -	else if (new_mode->scale != old_mode->scale)
> -		new_mode->restart = 1;
> -	else if (new_mode->format != old_mode->format)
> -		new_mode->restart = 1;
> -
> -	s2255_set_mode(dev, chn, new_mode);
> -	new_mode->restart = 0;
> -	*old_mode = *new_mode;
> -	dev->cur_fmt[chn] = fh->fmt;
> -	dev->last_frame[chn] = -1;
> -	dev->bad_payload[chn] = 0;
> -	dev->cur_frame[chn] = 0;
> -	dev->frame_count[chn] = 0;
> +	channel->last_frame = -1;
> +	channel->bad_payload = 0;
> +	channel->cur_frame = 0;
> +	channel->frame_count = 0;
>  	for (j = 0; j < SYS_FRAMES; j++) {
> -		dev->buffer[chn].frame[j].ulState = S2255_READ_IDLE;
> -		dev->buffer[chn].frame[j].cur_size = 0;
> +		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(dev, chn);
> -		dev->b_acquire[chn] = 1;
> -	} else {
> -		res_free(dev, fh);
> -	}
> +		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;
> -	struct s2255_dev *dev = fh->dev;
> -	dprintk(4, "%s\n, channel: %d", __func__, fh->channel);
> +	dprintk(4, "%s\n, channel: %d", __func__, fh->channel->idx);
>  	if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
>  		printk(KERN_ERR "invalid fh type0\n");
>  		return -EINVAL;
> @@ -1358,16 +1354,16 @@
>  		printk(KERN_ERR "invalid type i\n");
>  		return -EINVAL;
>  	}
> -	s2255_stop_acquire(dev, fh->channel);
> +	s2255_stop_acquire(fh->channel);
>  	videobuf_streamoff(&fh->vb_vidq);
> -	res_free(dev, fh);
> +	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 s2255_mode mode;
>  	struct videobuf_queue *q = &fh->vb_vidq;
>  	int ret = 0;
>  	mutex_lock(&q->vb_lock);
> @@ -1376,29 +1372,32 @@
>  		ret = -EBUSY;
>  		goto out_s_std;
>  	}
> -	if (res_locked(fh->dev, fh)) {
> +	if (res_locked(fh)) {
>  		dprintk(1, "can't change standard after started\n");
>  		ret = -EBUSY;
>  		goto out_s_std;
>  	}
> -	mode = &fh->mode;
> +	mode = fh->channel->mode;
>  	if (*i & V4L2_STD_NTSC) {
>  		dprintk(4, "%s NTSC\n", __func__);
>  		/* if changing format, reset frame decimation/intervals */
> -		if (mode->format != FORMAT_NTSC) {
> -			mode->format = FORMAT_NTSC;
> -			mode->fdec = FDEC_1;
> +		if (mode.format != FORMAT_NTSC) {
> +			mode.restart = 1;
> +			mode.format = FORMAT_NTSC;
> +			mode.fdec = FDEC_1;
>  		}
>  	} else if (*i & V4L2_STD_PAL) {
>  		dprintk(4, "%s PAL\n", __func__);
> -		mode->format = FORMAT_PAL;
> -		if (mode->format != FORMAT_PAL) {
> -			mode->format = FORMAT_PAL;
> -			mode->fdec = FDEC_1;
> +		if (mode.format != FORMAT_PAL) {
> +			mode.restart = 1;
> +			mode.format = FORMAT_PAL;
> +			mode.fdec = FDEC_1;
>  		}
>  	} else {
>  		ret = -EINVAL;
>  	}
> +	if (mode.restart)
> +		s2255_set_mode(fh->channel, &mode);
>  out_s_std:
>  	mutex_unlock(&q->vb_lock);
>  	return ret;
> @@ -1416,6 +1415,7 @@
>  {
>  	struct s2255_fh *fh = priv;
>  	struct s2255_dev *dev = fh->dev;
> +	struct s2255_channel *channel = fh->channel;
>  	u32 status = 0;
>  	if (inp->index != 0)
>  		return -EINVAL;
> @@ -1424,7 +1424,7 @@
>  	inp->status = 0;
>  	if (dev->dsp_fw_ver >= S2255_MIN_DSP_STATUS) {
>  		int rc;
> -		rc = s2255_cmd_status(dev, fh->channel, &status);
> +		rc = s2255_cmd_status(fh->channel, &status);
>  		dprintk(4, "s2255_cmd_status rc: %d status %x\n", rc, status);
>  		if (rc == 0)
>  			inp->status =  (status & 0x01) ? 0
> @@ -1436,7 +1436,7 @@
>  		strlcpy(inp->name, "Composite", sizeof(inp->name));
>  		break;
>  	case 0x2257:
> -		strlcpy(inp->name, (fh->channel < 2) ? "Composite" : "S-Video",
> +		strlcpy(inp->name, (channel->idx < 2) ? "Composite" : "S-Video",
>  			sizeof(inp->name));
>  		break;
>  	}
> @@ -1460,6 +1460,7 @@
>  			    struct v4l2_queryctrl *qc)
>  {
>  	struct s2255_fh *fh = priv;
> +	struct s2255_channel *channel = fh->channel;
>  	struct s2255_dev *dev = fh->dev;
>  	switch (qc->id) {
>  	case V4L2_CID_BRIGHTNESS:
> @@ -1477,7 +1478,7 @@
>  	case V4L2_CID_PRIVATE_COLORFILTER:
>  		if (dev->dsp_fw_ver < S2255_MIN_DSP_COLORFILTER)
>  			return -EINVAL;
> -		if ((dev->pid == 0x2257) && (fh->channel > 1))
> +		if ((dev->pid == 0x2257) && (channel->idx > 1))
>  			return -EINVAL;
>  		strlcpy(qc->name, "Color Filter", sizeof(qc->name));
>  		qc->type = V4L2_CTRL_TYPE_MENU;
> @@ -1499,25 +1500,26 @@
>  {
>  	struct s2255_fh *fh = priv;
>  	struct s2255_dev *dev = fh->dev;
> +	struct s2255_channel *channel = fh->channel;
>  	switch (ctrl->id) {
>  	case V4L2_CID_BRIGHTNESS:
> -		ctrl->value = fh->mode.bright;
> +		ctrl->value = channel->mode.bright;
>  		break;
>  	case V4L2_CID_CONTRAST:
> -		ctrl->value = fh->mode.contrast;
> +		ctrl->value = channel->mode.contrast;
>  		break;
>  	case V4L2_CID_SATURATION:
> -		ctrl->value = fh->mode.saturation;
> +		ctrl->value = channel->mode.saturation;
>  		break;
>  	case V4L2_CID_HUE:
> -		ctrl->value = fh->mode.hue;
> +		ctrl->value = channel->mode.hue;
>  		break;
>  	case V4L2_CID_PRIVATE_COLORFILTER:
>  		if (dev->dsp_fw_ver < S2255_MIN_DSP_COLORFILTER)
>  			return -EINVAL;
> -		if ((dev->pid == 0x2257) && (fh->channel > 1))
> +		if ((dev->pid == 0x2257) && (channel->idx > 1))
>  			return -EINVAL;
> -		ctrl->value = !((fh->mode.color & MASK_INPUT_TYPE) >> 16);
> +		ctrl->value = !((channel->mode.color & MASK_INPUT_TYPE) >> 16);
>  		break;
>  	default:
>  		return -EINVAL;
> @@ -1530,41 +1532,42 @@
>  			 struct v4l2_control *ctrl)
>  {
>  	struct s2255_fh *fh = priv;
> -	struct s2255_dev *dev = fh->dev;
> -	struct s2255_mode *mode;
> -	mode = &fh->mode;
> +	struct s2255_channel *channel = fh->channel;
> +	struct s2255_dev *dev = to_s2255_dev(channel->vdev.v4l2_dev);
> +	struct s2255_mode mode;
> +	mode = channel->mode;
>  	dprintk(4, "%s\n", __func__);
>  	/* update the mode to the corresponding value */
>  	switch (ctrl->id) {
>  	case V4L2_CID_BRIGHTNESS:
> -		mode->bright = ctrl->value;
> +		mode.bright = ctrl->value;
>  		break;
>  	case V4L2_CID_CONTRAST:
> -		mode->contrast = ctrl->value;
> +		mode.contrast = ctrl->value;
>  		break;
>  	case V4L2_CID_HUE:
> -		mode->hue = ctrl->value;
> +		mode.hue = ctrl->value;
>  		break;
>  	case V4L2_CID_SATURATION:
> -		mode->saturation = ctrl->value;
> +		mode.saturation = ctrl->value;
>  		break;
>  	case V4L2_CID_PRIVATE_COLORFILTER:
>  		if (dev->dsp_fw_ver < S2255_MIN_DSP_COLORFILTER)
>  			return -EINVAL;
> -		if ((dev->pid == 0x2257) && (fh->channel > 1))
> +		if ((dev->pid == 0x2257) && (channel->idx > 1))
>  			return -EINVAL;
> -		mode->color &= ~MASK_INPUT_TYPE;
> -		mode->color |= ((ctrl->value ? 0 : 1) << 16);
> +		mode.color &= ~MASK_INPUT_TYPE;
> +		mode.color |= ((ctrl->value ? 0 : 1) << 16);
>  		break;
>  	default:
>  		return -EINVAL;
>  	}
> -	mode->restart = 0;
> +	mode.restart = 0;
>  	/* set mode here.  Note: stream does not need restarted.
>  	   some V4L programs restart stream unnecessarily
>  	   after a s_crtl.
>  	*/
> -	s2255_set_mode(dev, fh->channel, mode);
> +	s2255_set_mode(fh->channel, &mode);
>  	return 0;
>  }
>  
> @@ -1572,8 +1575,8 @@
>  			 struct v4l2_jpegcompression *jc)
>  {
>  	struct s2255_fh *fh = priv;
> -	struct s2255_dev *dev = fh->dev;
> -	*jc = dev->jc[fh->channel];
> +	struct s2255_channel *channel = fh->channel;
> +	*jc = channel->jc;
>  	dprintk(2, "%s: quality %d\n", __func__, jc->quality);
>  	return 0;
>  }
> @@ -1582,10 +1585,10 @@
>  			 struct v4l2_jpegcompression *jc)
>  {
>  	struct s2255_fh *fh = priv;
> -	struct s2255_dev *dev = fh->dev;
> +	struct s2255_channel *channel = fh->channel;
>  	if (jc->quality < 0 || jc->quality > 100)
>  		return -EINVAL;
> -	dev->jc[fh->channel].quality = jc->quality;
> +	channel->jc.quality = jc->quality;
>  	dprintk(2, "%s: quality %d\n", __func__, jc->quality);
>  	return 0;
>  }
> @@ -1594,17 +1597,17 @@
>  			 struct v4l2_streamparm *sp)
>  {
>  	struct s2255_fh *fh = priv;
> -	struct s2255_dev *dev = fh->dev;
>  	__u32 def_num, def_dem;
> +	struct s2255_channel *channel = fh->channel;
>  	if (sp->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
>  		return -EINVAL;
>  	memset(sp, 0, sizeof(struct v4l2_streamparm));
>  	sp->parm.capture.capability = V4L2_CAP_TIMEPERFRAME;
> -	sp->parm.capture.capturemode = dev->cap_parm[fh->channel].capturemode;
> -	def_num = (fh->mode.format == FORMAT_NTSC) ? 1001 : 1000;
> -	def_dem = (fh->mode.format == FORMAT_NTSC) ? 30000 : 25000;
> +	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.timeperframe.denominator = def_dem;
> -	switch (fh->mode.fdec) {
> +	switch (channel->mode.fdec) {
>  	default:
>  	case FDEC_1:
>  		sp->parm.capture.timeperframe.numerator = def_num;
> @@ -1630,17 +1633,19 @@
>  			 struct v4l2_streamparm *sp)
>  {
>  	struct s2255_fh *fh = priv;
> -	struct s2255_dev *dev = fh->dev;
> +	struct s2255_channel *channel = fh->channel;
> +	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;
>  	/* high quality capture mode requires a stream restart */
> -	if (dev->cap_parm[fh->channel].capturemode
> -	    != sp->parm.capture.capturemode && res_locked(fh->dev, fh))
> +	if (channel->cap_parm.capturemode
> +	    != sp->parm.capture.capturemode && res_locked(fh))
>  		return -EBUSY;
> -	def_num = (fh->mode.format == FORMAT_NTSC) ? 1001 : 1000;
> -	def_dem = (fh->mode.format == FORMAT_NTSC) ? 30000 : 25000;
> +	def_num = (mode.format == FORMAT_NTSC) ? 1001 : 1000;
> +	def_dem = (mode.format == FORMAT_NTSC) ? 30000 : 25000;
>  	if (def_dem != sp->parm.capture.timeperframe.denominator)
>  		sp->parm.capture.timeperframe.numerator = def_num;
>  	else if (sp->parm.capture.timeperframe.numerator <= def_num)
> @@ -1655,9 +1660,9 @@
>  		sp->parm.capture.timeperframe.numerator = def_num * 5;
>  		fdec = FDEC_5;
>  	}
> -	fh->mode.fdec = fdec;
> +	mode.fdec = fdec;
>  	sp->parm.capture.timeperframe.denominator = def_dem;
> -	s2255_set_mode(dev, fh->channel, &fh->mode);
> +	s2255_set_mode(channel, &mode);
>  	dprintk(4, "%s capture mode, %d timeperframe %d/%d, fdec %d\n",
>  		__func__,
>  		sp->parm.capture.capturemode,
> @@ -1707,20 +1712,13 @@
>  static int s2255_open(struct file *file)
>  {
>  	struct video_device *vdev = video_devdata(file);
> -	struct s2255_dev *dev = video_drvdata(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;
> -	int i = 0;
> -	int cur_channel = -1;
>  	int state;
>  	dprintk(1, "s2255: open called (dev=%s)\n",
>  		video_device_node_name(vdev));
> -
> -	for (i = 0; i < MAX_CHANNELS; i++)
> -		if (&dev->vdev[i] == vdev) {
> -			cur_channel = i;
> -			break;
> -		}
>  	/*
>  	 * open lock necessary to prevent multiple instances
>  	 * of v4l-conf (or other programs) from simultaneously
> @@ -1791,24 +1789,20 @@
>  	file->private_data = fh;
>  	fh->dev = dev;
>  	fh->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
> -	fh->mode = dev->mode[cur_channel];
> -	fh->fmt = dev->cur_fmt[cur_channel];
> -	/* default 4CIF NTSC */
> -	fh->width = LINE_SZ_4CIFS_NTSC;
> -	fh->height = NUM_LINES_4CIFS_NTSC * 2;
> -	fh->channel = cur_channel;
> -	/* configure channel to default state */
> -	if (!dev->chn_configured[cur_channel]) {
> -		s2255_set_mode(dev, cur_channel, &fh->mode);
> -		dev->chn_configured[cur_channel] = 1;
> +	fh->channel = channel;
> +	if (!channel->configured) {
> +		/* configure channel to default state */
> +		channel->fmt = &formats[0];
> +		s2255_set_mode(channel, &channel->mode);
> +		channel->configured = 1;
>  	}
>  	dprintk(1, "%s: dev=%s type=%s\n", __func__,
>  		video_device_node_name(vdev), v4l2_type_names[type]);
>  	dprintk(2, "%s: fh=0x%08lx, dev=0x%08lx, vidq=0x%08lx\n", __func__,
>  		(unsigned long)fh, (unsigned long)dev,
> -		(unsigned long)&dev->vidq[cur_channel]);
> +		(unsigned long)&channel->vidq);
>  	dprintk(4, "%s: list_empty active=%d\n", __func__,
> -		list_empty(&dev->vidq[cur_channel].active));
> +		list_empty(&channel->vidq.active));
>  	videobuf_queue_vmalloc_init(&fh->vb_vidq, &s2255_video_qops,
>  				    NULL, &dev->slock,
>  				    fh->type,
> @@ -1850,6 +1844,7 @@
>  	mutex_destroy(&dev->open_lock);
>  	mutex_destroy(&dev->lock);
>  	usb_put_dev(dev->udev);
> +	v4l2_device_unregister(&dev->v4l2_dev);
>  	dprintk(1, "%s", __func__);
>  	kfree(dev);
>  }
> @@ -1859,14 +1854,15 @@
>  	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;
>  	/* turn off stream */
>  	if (res_check(fh)) {
> -		if (dev->b_acquire[fh->channel])
> -			s2255_stop_acquire(dev, fh->channel);
> +		if (channel->b_acquire)
> +			s2255_stop_acquire(fh->channel);
>  		videobuf_streamoff(&fh->vb_vidq);
> -		res_free(dev, fh);
> +		res_free(fh);
>  	}
>  	videobuf_mmap_free(&fh->vb_vidq);
>  	dprintk(1, "%s (dev=%s)\n", __func__, video_device_node_name(vdev));
> @@ -1930,9 +1926,10 @@
>  
>  static void s2255_video_device_release(struct video_device *vdev)
>  {
> -	struct s2255_dev *dev = video_get_drvdata(vdev);
> -	dprintk(4, "%s, chnls: %d \n", __func__, atomic_read(&dev->channels));
> -	if (atomic_dec_and_test(&dev->channels))
> +	struct s2255_dev *dev = to_s2255_dev(vdev->v4l2_dev);
> +	dprintk(4, "%s, chnls: %d \n", __func__,
> +		atomic_read(&dev->num_channels));
> +	if (atomic_dec_and_test(&dev->num_channels))
>  		s2255_destroy(dev);
>  	return;
>  }
> @@ -1951,46 +1948,48 @@
>  	int ret;
>  	int i;
>  	int cur_nr = video_nr;
> +	struct s2255_channel *channel;
>  	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++) {
> -		INIT_LIST_HEAD(&dev->vidq[i].active);
> -		dev->vidq[i].dev = dev;
> -		dev->vidq[i].channel = i;
> +		channel = &dev->channel[i];
> +		INIT_LIST_HEAD(&channel->vidq.active);
> +		channel->vidq.dev = dev;
>  		/* register 4 video devices */
> -		memcpy(&dev->vdev[i], &template, sizeof(struct video_device));
> -		dev->vdev[i].v4l2_dev = &dev->v4l2_dev;
> -		video_set_drvdata(&dev->vdev[i], dev);
> +		channel->vdev = template;
> +		channel->vdev.v4l2_dev = &dev->v4l2_dev;
> +		video_set_drvdata(&channel->vdev, channel);
>  		if (video_nr == -1)
> -			ret = video_register_device(&dev->vdev[i],
> +			ret = video_register_device(&channel->vdev,
>  						    VFL_TYPE_GRABBER,
>  						    video_nr);
>  		else
> -			ret = video_register_device(&dev->vdev[i],
> +			ret = video_register_device(&channel->vdev,
>  						    VFL_TYPE_GRABBER,
>  						    cur_nr + i);
> +
>  		if (ret) {
>  			dev_err(&dev->udev->dev,
>  				"failed to register video device!\n");
>  			break;
>  		}
> -		atomic_inc(&dev->channels);
> +		atomic_inc(&dev->num_channels);
>  		v4l2_info(&dev->v4l2_dev, "V4L2 device registered as %s\n",
> -			  video_device_node_name(&dev->vdev[i]));
> +			  video_device_node_name(&channel->vdev));
>  
>  	}
>  	printk(KERN_INFO "Sensoray 2255 V4L driver Revision: %d.%d\n",
>  	       S2255_MAJOR_VERSION,
>  	       S2255_MINOR_VERSION);
>  	/* if no channels registered, return error and probe will fail*/
> -	if (atomic_read(&dev->channels) == 0) {
> +	if (atomic_read(&dev->num_channels) == 0) {
>  		v4l2_device_unregister(&dev->v4l2_dev);
>  		return ret;
>  	}
> -	if (atomic_read(&dev->channels) != MAX_CHANNELS)
> +	if (atomic_read(&dev->num_channels) != MAX_CHANNELS)
>  		printk(KERN_WARNING "s2255: Not all channels available.\n");
>  	return 0;
>  }
> @@ -2017,12 +2016,11 @@
>  	s32 idx = -1;
>  	struct s2255_framei *frm;
>  	unsigned char *pdata;
> -
> +	struct s2255_channel *channel;
>  	dprintk(100, "buffer to user\n");
> -
> -	idx = dev->cur_frame[dev->cc];
> -	frm = &dev->buffer[dev->cc].frame[idx];
> -
> +	channel = &dev->channel[dev->cc];
> +	idx = channel->cur_frame;
> +	frm = &channel->buffer.frame[idx];
>  	if (frm->ulState == S2255_READ_IDLE) {
>  		int jj;
>  		unsigned int cc;
> @@ -2047,16 +2045,18 @@
>  				}
>  				/* reverse it */
>  				dev->cc = G_chnmap[cc];
> +				channel = &dev->channel[dev->cc];
>  				payload =  pdword[3];
> -				if (payload > dev->req_image_size[dev->cc]) {
> -					dev->bad_payload[dev->cc]++;
> +				if (payload > channel->req_image_size) {
> +					channel->bad_payload++;
>  					/* discard the bad frame */
>  					return -EINVAL;
>  				}
> -				dev->pkt_size[dev->cc] = payload;
> -				dev->jpg_size[dev->cc] = pdword[4];
> +				channel->pkt_size = payload;
> +				channel->jpg_size = pdword[4];
>  				break;
>  			case S2255_MARKER_RESPONSE:
> +
>  				pdata += DEF_USB_BLOCK;
>  				jj += DEF_USB_BLOCK;
>  				if (pdword[1] >= MAX_CHANNELS)
> @@ -2064,12 +2064,13 @@
>  				cc = G_chnmap[pdword[1]];
>  				if (cc >= MAX_CHANNELS)
>  					break;
> +				channel = &dev->channel[cc];
>  				switch (pdword[2]) {
>  				case S2255_RESPONSE_SETMODE:
>  					/* check if channel valid */
>  					/* set mode ready */
> -					dev->setmode_ready[cc] = 1;
> -					wake_up(&dev->wait_setmode[cc]);
> +					channel->setmode_ready = 1;
> +					wake_up(&channel->wait_setmode);
>  					dprintk(5, "setmode ready %d\n", cc);
>  					break;
>  				case S2255_RESPONSE_FW:
> @@ -2084,9 +2085,9 @@
>  					wake_up(&dev->fw_data->wait_fw);
>  					break;
>  				case S2255_RESPONSE_STATUS:
> -					dev->vidstatus[cc] = pdword[3];
> -					dev->vidstatus_ready[cc] = 1;
> -					wake_up(&dev->wait_vidstatus[cc]);
> +					channel->vidstatus = pdword[3];
> +					channel->vidstatus_ready = 1;
> +					wake_up(&channel->wait_vidstatus);
>  					dprintk(5, "got vidstatus %x chan %d\n",
>  						pdword[3], cc);
>  					break;
> @@ -2103,13 +2104,11 @@
>  		if (!bframe)
>  			return -EINVAL;
>  	}
> -
> -
> -	idx = dev->cur_frame[dev->cc];
> -	frm = &dev->buffer[dev->cc].frame[idx];
> -
> +	channel = &dev->channel[dev->cc];
> +	idx = channel->cur_frame;
> +	frm = &channel->buffer.frame[idx];
>  	/* search done.  now find out if should be acquiring on this channel */
> -	if (!dev->b_acquire[dev->cc]) {
> +	if (!channel->b_acquire) {
>  		/* we found a frame, but this channel is turned off */
>  		frm->ulState = S2255_READ_IDLE;
>  		return -EINVAL;
> @@ -2134,30 +2133,28 @@
>  
>  	copy_size = (pipe_info->cur_transfer_size - offset);
>  
> -	size = dev->pkt_size[dev->cc] - PREFIX_SIZE;
> +	size = channel->pkt_size - PREFIX_SIZE;
>  
>  	/* sanity check on pdest */
> -	if ((copy_size + frm->cur_size) < dev->req_image_size[dev->cc])
> +	if ((copy_size + frm->cur_size) < channel->req_image_size)
>  		memcpy(pdest, psrc, copy_size);
>  
>  	frm->cur_size += copy_size;
>  	dprintk(4, "cur_size size %lu size %lu \n", frm->cur_size, size);
>  
>  	if (frm->cur_size >= size) {
> -
> -		u32 cc = dev->cc;
>  		dprintk(2, "****************[%d]Buffer[%d]full*************\n",
> -			cc, idx);
> -		dev->last_frame[cc] = dev->cur_frame[cc];
> -		dev->cur_frame[cc]++;
> +			dev->cc, idx);
> +		channel->last_frame = channel->cur_frame;
> +		channel->cur_frame++;
>  		/* end of system frame ring buffer, start at zero */
> -		if ((dev->cur_frame[cc] == SYS_FRAMES) ||
> -		    (dev->cur_frame[cc] == dev->buffer[cc].dwFrames))
> -			dev->cur_frame[cc] = 0;
> +		if ((channel->cur_frame == SYS_FRAMES) ||
> +		    (channel->cur_frame == channel->buffer.dwFrames))
> +			channel->cur_frame = 0;
>  		/* frame ready */
> -		if (dev->b_acquire[cc])
> -			s2255_got_frame(dev, cc, dev->jpg_size[cc]);
> -		dev->frame_count[cc]++;
> +		if (channel->b_acquire)
> +			s2255_got_frame(channel, channel->jpg_size);
> +		channel->frame_count++;
>  		frm->ulState = S2255_READ_IDLE;
>  		frm->cur_size = 0;
>  
> @@ -2230,16 +2227,12 @@
>   * Create the system ring buffer to copy frames into from the
>   * usb read pipe.
>   */
> -static int s2255_create_sys_buffers(struct s2255_dev *dev, unsigned long chn)
> +static int s2255_create_sys_buffers(struct s2255_channel *channel)
>  {
>  	unsigned long i;
>  	unsigned long reqsize;
>  	dprintk(1, "create sys buffers\n");
> -	if (chn >= MAX_CHANNELS)
> -		return -1;
> -
> -	dev->buffer[chn].dwFrames = SYS_FRAMES;
> -
> +	channel->buffer.dwFrames = SYS_FRAMES;
>  	/* always allocate maximum size(PAL) for system buffers */
>  	reqsize = SYS_FRAMES_MAXSIZE;
>  
> @@ -2248,42 +2241,40 @@
>  
>  	for (i = 0; i < SYS_FRAMES; i++) {
>  		/* allocate the frames */
> -		dev->buffer[chn].frame[i].lpvbits = vmalloc(reqsize);
> -
> -		dprintk(1, "valloc %p chan %lu, idx %lu, pdata %p\n",
> -			&dev->buffer[chn].frame[i], chn, i,
> -			dev->buffer[chn].frame[i].lpvbits);
> -		dev->buffer[chn].frame[i].size = reqsize;
> -		if (dev->buffer[chn].frame[i].lpvbits == NULL) {
> +		channel->buffer.frame[i].lpvbits = vmalloc(reqsize);
> +		dprintk(1, "valloc %p chan %d, idx %lu, pdata %p\n",
> +			&channel->buffer.frame[i], channel->idx, i,
> +			channel->buffer.frame[i].lpvbits);
> +		channel->buffer.frame[i].size = reqsize;
> +		if (channel->buffer.frame[i].lpvbits == NULL) {
>  			printk(KERN_INFO "out of memory.  using less frames\n");
> -			dev->buffer[chn].dwFrames = i;
> +			channel->buffer.dwFrames = i;
>  			break;
>  		}
>  	}
>  
>  	/* make sure internal states are set */
>  	for (i = 0; i < SYS_FRAMES; i++) {
> -		dev->buffer[chn].frame[i].ulState = 0;
> -		dev->buffer[chn].frame[i].cur_size = 0;
> +		channel->buffer.frame[i].ulState = 0;
> +		channel->buffer.frame[i].cur_size = 0;
>  	}
>  
> -	dev->cur_frame[chn] = 0;
> -	dev->last_frame[chn] = -1;
> +	channel->cur_frame = 0;
> +	channel->last_frame = -1;
>  	return 0;
>  }
>  
> -static int s2255_release_sys_buffers(struct s2255_dev *dev,
> -				     unsigned long channel)
> +static int s2255_release_sys_buffers(struct s2255_channel *channel)
>  {
>  	unsigned long i;
>  	dprintk(1, "release sys buffers\n");
>  	for (i = 0; i < SYS_FRAMES; i++) {
> -		if (dev->buffer[channel].frame[i].lpvbits) {
> +		if (channel->buffer.frame[i].lpvbits) {
>  			dprintk(1, "vfree %p\n",
> -				dev->buffer[channel].frame[i].lpvbits);
> -			vfree(dev->buffer[channel].frame[i].lpvbits);
> +				channel->buffer.frame[i].lpvbits);
> +			vfree(channel->buffer.frame[i].lpvbits);
>  		}
> -		dev->buffer[channel].frame[i].lpvbits = NULL;
> +		channel->buffer.frame[i].lpvbits = NULL;
>  	}
>  	return 0;
>  }
> @@ -2320,17 +2311,20 @@
>  			fw_ver & 0xff);
>  
>  	for (j = 0; j < MAX_CHANNELS; j++) {
> -		dev->b_acquire[j] = 0;
> -		dev->mode[j] = mode_def;
> +		struct s2255_channel *channel = &dev->channel[j];
> +		channel->b_acquire = 0;
> +		channel->mode = mode_def;
>  		if (dev->pid == 0x2257 && j > 1)
> -			dev->mode[j].color |= (1 << 16);
> -		dev->jc[j].quality = S2255_DEF_JPEG_QUAL;
> -		dev->cur_fmt[j] = &formats[0];
> -		dev->mode[j].restart = 1;
> -		dev->req_image_size[j] = get_transfer_size(&mode_def);
> -		dev->frame_count[j] = 0;
> +			channel->mode.color |= (1 << 16);
> +		channel->jc.quality = S2255_DEF_JPEG_QUAL;
> +		channel->width = LINE_SZ_4CIFS_NTSC;
> +		channel->height = NUM_LINES_4CIFS_NTSC * 2;
> +		channel->fmt = &formats[0];
> +		channel->mode.restart = 1;
> +		channel->req_image_size = get_transfer_size(&mode_def);
> +		channel->frame_count = 0;
>  		/* create the system buffers */
> -		s2255_create_sys_buffers(dev, j);
> +		s2255_create_sys_buffers(channel);
>  	}
>  	/* start read pipe */
>  	s2255_start_readpipe(dev);
> @@ -2344,14 +2338,12 @@
>  	dprintk(1, "%s: dev: %p", __func__,  dev);
>  
>  	for (i = 0; i < MAX_CHANNELS; i++) {
> -		if (dev->b_acquire[i])
> -			s2255_stop_acquire(dev, i);
> +		if (dev->channel[i].b_acquire)
> +			s2255_stop_acquire(&dev->channel[i]);
>  	}
> -
>  	s2255_stop_readpipe(dev);
> -
>  	for (i = 0; i < MAX_CHANNELS; i++)
> -		s2255_release_sys_buffers(dev, i);
> +		s2255_release_sys_buffers(&dev->channel[i]);
>  	/* release transfer buffer */
>  	kfree(dev->pipe.transfer_buffer);
>  	return 0;
> @@ -2444,29 +2436,26 @@
>  }
>  
>  /* starts acquisition process */
> -static int s2255_start_acquire(struct s2255_dev *dev, unsigned long chn)
> +static int s2255_start_acquire(struct s2255_channel *channel)
>  {
>  	unsigned char *buffer;
>  	int res;
>  	unsigned long chn_rev;
>  	int j;
> -	if (chn >= MAX_CHANNELS) {
> -		dprintk(2, "start acquire failed, bad channel %lu\n", chn);
> -		return -1;
> -	}
> -	chn_rev = G_chnmap[chn];
> +	struct s2255_dev *dev = to_s2255_dev(channel->vdev.v4l2_dev);
> +	chn_rev = G_chnmap[channel->idx];
>  	buffer = kzalloc(512, GFP_KERNEL);
>  	if (buffer == NULL) {
>  		dev_err(&dev->udev->dev, "out of mem\n");
>  		return -ENOMEM;
>  	}
>  
> -	dev->last_frame[chn] = -1;
> -	dev->bad_payload[chn] = 0;
> -	dev->cur_frame[chn] = 0;
> +	channel->last_frame = -1;
> +	channel->bad_payload = 0;
> +	channel->cur_frame = 0;
>  	for (j = 0; j < SYS_FRAMES; j++) {
> -		dev->buffer[chn].frame[j].ulState = 0;
> -		dev->buffer[chn].frame[j].cur_size = 0;
> +		channel->buffer.frame[j].ulState = 0;
> +		channel->buffer.frame[j].cur_size = 0;
>  	}
>  
>  	/* send the start command */
> @@ -2477,21 +2466,18 @@
>  	if (res != 0)
>  		dev_err(&dev->udev->dev, "CMD_START error\n");
>  
> -	dprintk(2, "start acquire exit[%lu] %d \n", chn, res);
> +	dprintk(2, "start acquire exit[%d] %d \n", channel->idx, res);
>  	kfree(buffer);
>  	return 0;
>  }
>  
> -static int s2255_stop_acquire(struct s2255_dev *dev, unsigned long chn)
> +static int s2255_stop_acquire(struct s2255_channel *channel)
>  {
>  	unsigned char *buffer;
>  	int res;
>  	unsigned long chn_rev;
> -	if (chn >= MAX_CHANNELS) {
> -		dprintk(2, "stop acquire failed, bad channel %lu\n", chn);
> -		return -1;
> -	}
> -	chn_rev = G_chnmap[chn];
> +	struct s2255_dev *dev = to_s2255_dev(channel->vdev.v4l2_dev);
> +	chn_rev = G_chnmap[channel->idx];
>  	buffer = kzalloc(512, GFP_KERNEL);
>  	if (buffer == NULL) {
>  		dev_err(&dev->udev->dev, "out of mem\n");
> @@ -2505,8 +2491,8 @@
>  	if (res != 0)
>  		dev_err(&dev->udev->dev, "CMD_STOP error\n");
>  	kfree(buffer);
> -	dev->b_acquire[chn] = 0;
> -	dprintk(4, "%s: chn %lu, res %d\n", __func__, chn, res);
> +	channel->b_acquire = 0;
> +	dprintk(4, "%s: chn %d, res %d\n", __func__, channel->idx, res);
>  	return res;
>  }
>  
> @@ -2563,7 +2549,7 @@
>  		s2255_dev_err(&interface->dev, "out of memory\n");
>  		return -ENOMEM;
>  	}
> -	atomic_set(&dev->channels, 0);
> +	atomic_set(&dev->num_channels, 0);
>  	dev->pid = id->idProduct;
>  	dev->fw_data = kzalloc(sizeof(struct s2255_fw), GFP_KERNEL);
>  	if (!dev->fw_data)
> @@ -2600,8 +2586,10 @@
>  	dev->timer.data = (unsigned long)dev->fw_data;
>  	init_waitqueue_head(&dev->fw_data->wait_fw);
>  	for (i = 0; i < MAX_CHANNELS; i++) {
> -		init_waitqueue_head(&dev->wait_setmode[i]);
> -		init_waitqueue_head(&dev->wait_vidstatus[i]);
> +		struct s2255_channel *channel = &dev->channel[i];
> +		dev->channel[i].idx = i;
> +		init_waitqueue_head(&channel->wait_setmode);
> +		init_waitqueue_head(&channel->wait_vidstatus);
>  	}
>  
>  	dev->fw_data->fw_urb = usb_alloc_urb(0, GFP_KERNEL);
> @@ -2639,7 +2627,7 @@
>  			printk(KERN_INFO "s2255: f2255usb.bin out of date.\n");
>  		if (dev->pid == 0x2257 && *pRel < S2255_MIN_DSP_COLORFILTER)
>  			printk(KERN_WARNING "s2255: 2257 requires firmware %d"
> -			       "or above.\n", S2255_MIN_DSP_COLORFILTER);
> +			       " or above.\n", S2255_MIN_DSP_COLORFILTER);
>  	}
>  	usb_reset_device(dev->udev);
>  	/* load 2255 board specific */
> @@ -2681,25 +2669,23 @@
>  {
>  	struct s2255_dev *dev = to_s2255_dev(usb_get_intfdata(interface));
>  	int i;
> -	int channels = atomic_read(&dev->channels);
> -	v4l2_device_unregister(&dev->v4l2_dev);
> +	int channels = atomic_read(&dev->num_channels);
> +	v4l2_device_disconnect(&dev->v4l2_dev);
>  	/*see comments in the uvc_driver.c usb disconnect function */
> -	atomic_inc(&dev->channels);
> +	atomic_inc(&dev->num_channels);
>  	/* unregister each video device. */
> -	for (i = 0; i < channels; i++) {
> -		if (video_is_registered(&dev->vdev[i]))
> -			video_unregister_device(&dev->vdev[i]);
> -	}
> +	for (i = 0; i < channels; i++)
> +		video_unregister_device(&dev->channel[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->setmode_ready[i] = 1;
> -		wake_up(&dev->wait_setmode[i]);
> -		dev->vidstatus_ready[i] = 1;
> -		wake_up(&dev->wait_vidstatus[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);
>  	}
> -	if (atomic_dec_and_test(&dev->channels))
> +	if (atomic_dec_and_test(&dev->num_channels))
>  		s2255_destroy(dev);
>  	dev_info(&interface->dev, "%s\n", __func__);
>  }
> 
> --
> To unsubscribe from this list: send the line "unsubscribe linux-media" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at  http://vger.kernel.org/majordomo-info.html




Cheers,
Mauro