[REVIEW] au0828-video.c

[Hans Verkuil <hverkuil@xs4all.nl>]

Hi Shuah,

This is the video.c review with your patch applied.

> /*
>  * Auvitek AU0828 USB Bridge (Analog video support)
>  *
>  * Copyright (C) 2009 Devin Heitmueller <dheitmueller@linuxtv.org>
>  * Copyright (C) 2005-2008 Auvitek International, Ltd.
>  *
>  * This program is free software; you can redistribute it and/or
>  * modify it under the terms of the GNU General Public License
>  * As published by the Free Software Foundation; either version 2
>  * of the License, or (at your option) any later version.
>  *
>  * This program is distributed in the hope that it will be useful,
>  * but WITHOUT ANY WARRANTY; without even the implied warranty of
>  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
>  * GNU General Public License for more details.
>  *
>  * You should have received a copy of the GNU General Public License
>  * along with this program; if not, write to the Free Software
>  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
>  * 02110-1301, USA.
>  */
> 
> /* Developer Notes:
>  *
>  * VBI support is not yet working

I'll see if I can get this to work quickly. If not, then we should
probably just strip the VBI support from this driver. It's pointless to
have non-functioning VBI support.

>  * The hardware scaler supported is unimplemented
>  * AC97 audio support is unimplemented (only i2s audio mode)
>  *
>  */
> 
> #include "au0828.h"
> 
> #include <linux/module.h>
> #include <linux/slab.h>
> #include <linux/init.h>
> #include <linux/device.h>
> #include <media/v4l2-common.h>
> #include <media/v4l2-ioctl.h>
> #include <media/v4l2-event.h>
> #include <media/tuner.h>
> #include "au0828-reg.h"

<snip>

> 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 au0828_dev *dev = vb2_get_drv_priv(vq);
> 	unsigned long size;
> 
> 	if (fmt)
> 		size = fmt->fmt.pix.sizeimage;
> 	else
> 		size =
> 		    (dev->width * dev->height * dev->bytesperline + 7) >> 3;

This is wrong. It should be 'size = dev->bytesperline * dev->height;'


If fmt is set, then you need to check if the fmt size is large enough for
the current format.

> 
> 	if (size == 0)

This should be 'size < img_size'.

> 		return -EINVAL;
> 
> 	if (0 == *nbuffers)
> 		*nbuffers = 32;

Bogus check.

> 
> 	*nplanes = 1;
> 	sizes[0] = size;
> 
> 	return 0;
> }

I would rewrite this function as:

{      
       struct au0828_dev *dev = vb2_get_drv_priv(vq);
       unsigned img_size = dev->bytesperline * dev->height;
       unsigned long size;

       size = fmt ? fmt->fmt.pix.sizeimage : img_size;
       if (size < img_size)
               return -EINVAL;
                   
       *nplanes = 1;
       sizes[0] = size;
       return 0;
}

> 
> static int
> buffer_prepare(struct vb2_buffer *vb)
> {
> 	struct au0828_buffer *buf = container_of(vb, struct au0828_buffer, vb);
> 	struct au0828_dev    *dev = vb2_get_drv_priv(vb->vb2_queue);
> 
> 	buf->length = (dev->width * dev->height * 16 + 7) >> 3;

Use buf->length = dev->bytesperline * dev->height;

> 
> 	if (vb2_plane_size(vb, 0) < buf->length) {
> 		pr_err("%s data will not fit into plane (%lu < %lu)\n",
> 			__func__, vb2_plane_size(vb, 0), buf->length);
> 		return -EINVAL;
> 	}
> 	vb2_set_plane_payload(&buf->vb, 0, buf->length);
> 	return 0;
> }
> 
> static void
> buffer_queue(struct vb2_buffer *vb)
> {
> 	struct au0828_buffer    *buf     = container_of(vb,
> 							struct au0828_buffer,
> 							vb);
> 	struct au0828_dev       *dev     = vb2_get_drv_priv(vb->vb2_queue);
> 	struct au0828_dmaqueue  *vidq    = &dev->vidq;
> 	unsigned long flags = 0;
> 
> 	buf->mem = vb2_plane_vaddr(vb, 0);
> 	buf->length = vb2_plane_size(vb, 0);
> 
> 	spin_lock_irqsave(&dev->slock, flags);
> 	list_add_tail(&buf->list, &vidq->active);
> 	spin_unlock_irqrestore(&dev->slock, flags);
> }
> 
> static int au0828_i2s_init(struct au0828_dev *dev)
> {
> 	/* Enable i2s mode */
> 	au0828_writereg(dev, AU0828_AUDIOCTRL_50C, 0x01);
> 	return 0;
> }
> 
> /*
>  * Auvitek au0828 analog stream enable
>  */
> static int au0828_analog_stream_enable(struct au0828_dev *d)
> {
> 	struct usb_interface *iface;
> 	int ret, h, w;
> 
> 	dprintk(1, "au0828_analog_stream_enable called\n");
> 
> 	iface = usb_ifnum_to_if(d->usbdev, 0);
> 	if (iface && iface->cur_altsetting->desc.bAlternateSetting != 5) {
> 		dprintk(1, "Changing intf#0 to alt 5\n");
> 		/* set au0828 interface0 to AS5 here again */
> 		ret = usb_set_interface(d->usbdev, 0, 5);
> 		if (ret < 0) {
> 			pr_info("Au0828 can't set alt setting to 5!\n");
> 			return -EBUSY;
> 		}
> 	}
> 
> 	h = d->height / 2 + 2;
> 	w = d->width * 2;
> 
> 	au0828_writereg(d, AU0828_SENSORCTRL_VBI_103, 0x00);
> 	au0828_writereg(d, 0x106, 0x00);
> 	/* set x position */
> 	au0828_writereg(d, 0x110, 0x00);
> 	au0828_writereg(d, 0x111, 0x00);
> 	au0828_writereg(d, 0x114, w & 0xff);
> 	au0828_writereg(d, 0x115, w >> 8);
> 	/* set y position */
> 	au0828_writereg(d, 0x112, 0x00);
> 	au0828_writereg(d, 0x113, 0x00);
> 	au0828_writereg(d, 0x116, h & 0xff);
> 	au0828_writereg(d, 0x117, h >> 8);
> 	au0828_writereg(d, AU0828_SENSORCTRL_100, 0xb3);
> 
> 	return 0;
> }
> 
> static int au0828_analog_stream_disable(struct au0828_dev *d)
> {
> 	dprintk(1, "au0828_analog_stream_disable called\n");
> 	au0828_writereg(d, AU0828_SENSORCTRL_100, 0x0);
> 	return 0;
> }
> 
> static void au0828_analog_stream_reset(struct au0828_dev *dev)
> {
> 	dprintk(1, "au0828_analog_stream_reset called\n");
> 	au0828_writereg(dev, AU0828_SENSORCTRL_100, 0x0);
> 	mdelay(30);
> 	au0828_writereg(dev, AU0828_SENSORCTRL_100, 0xb3);
> }
> 
> /*
>  * Some operations needs to stop current streaming
>  */
> static int au0828_stream_interrupt(struct au0828_dev *dev)
> {
> 	int ret = 0;
> 
> 	dev->stream_state = STREAM_INTERRUPT;
> 	if (dev->dev_state == DEV_DISCONNECTED)
> 		return -ENODEV;
> 	else if (ret) {
> 		dev->dev_state = DEV_MISCONFIGURED;
> 		dprintk(1, "%s device is misconfigured!\n", __func__);
> 		return ret;
> 	}
> 	return 0;
> }
> 
> int au0828_start_analog_streaming(struct vb2_queue *vq, unsigned int count)
> {
> 	struct au0828_dev *dev = vb2_get_drv_priv(vq);
> 	int rc = 0;
> 
> 	dprintk(1, "au0828_start_analog_streaming called %d\n",
> 		dev->streaming_users);
> 
> 	/* Make sure streaming is not already in progress for this type
> 	   of filehandle (e.g. video, vbi) */
> 	if (vb2_is_streaming(vq))
> 		return -EBUSY;

Can never happen, so this test can be removed.

> 

You need to initialize the counters:

       if (vq->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
               dev->field_count = 0;
       else
               dev->vbi_field_count = 0;

I would also recommend renaming 'field' to 'frame', since you're counting
frames, not fields.


> 	if (dev->streaming_users == 0) {
> 		/* If we were doing ac97 instead of i2s, it would go here...*/
> 		au0828_i2s_init(dev);
> 		rc = au0828_init_isoc(dev, AU0828_ISO_PACKETS_PER_URB,
> 				   AU0828_MAX_ISO_BUFS, dev->max_pkt_size,
> 				   au0828_isoc_copy);
> 		if (rc < 0) {
> 			pr_info("au0828_init_isoc failed\n");
> 			return rc;
> 		}
> 
> 		if (vq->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
> 			v4l2_device_call_all(&dev->v4l2_dev, 0, video,
> 						s_stream, 1);
> 			dev->vid_timeout_running = 1;
> 			mod_timer(&dev->vid_timeout, jiffies + (HZ / 10));
> 		} else if (vq->type == V4L2_BUF_TYPE_VBI_CAPTURE) {
> 			dev->vbi_timeout_running = 1;
> 			mod_timer(&dev->vbi_timeout, jiffies + (HZ / 10));
> 		}
> 	}
> 	dev->streaming_users++;
> 	return rc;
> }
> 
> static void au0828_stop_streaming(struct vb2_queue *vq)
> {
> 	struct au0828_dev *dev = vb2_get_drv_priv(vq);
> 	struct au0828_dmaqueue *vidq = &dev->vidq;
> 	unsigned long flags = 0;
> 	int i;
> 
> 	dprintk(1, "au0828_stop_streaming called %d\n", dev->streaming_users);
> 
> 	if (!vb2_is_streaming(vq))
> 		return;

Unnecessary test.

> 
> 	if (dev->streaming_users-- == 1)
> 		au0828_uninit_isoc(dev);
> 	dprintk(1, "au0828_stop_streaming %d\n", dev->streaming_users);
> 
> 	spin_lock_irqsave(&dev->slock, flags);
> 	if (dev->isoc_ctl.buf != NULL) {
> 		vb2_buffer_done(&dev->isoc_ctl.buf->vb, VB2_BUF_STATE_ERROR);
> 		dev->isoc_ctl.buf = NULL;
> 	}
> 	while (!list_empty(&vidq->active)) {
> 		struct au0828_buffer *buf;
> 
> 		buf = list_entry(vidq->active.next, struct au0828_buffer, list);
> 		vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
> 		list_del(&buf->list);
> 	}
> 
> 	dev->vid_timeout_running = 0;
> 	del_timer_sync(&dev->vid_timeout);
> 
> 	v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_stream, 0);
> 
> 	for (i = 0; i < AU0828_MAX_INPUT; i++) {
> 		if (AUVI_INPUT(i).audio_setup == NULL)
> 			continue;
> 		(AUVI_INPUT(i).audio_setup)(dev, 0);
> 	}
> 	spin_unlock_irqrestore(&dev->slock, flags);

Very bad. This unlock should go before the 'dev->vid_timeout_running = 0;' line.
The way it is now the lines between the spinlock run without interrupts, so
calls like del_timer_sync() will complain about scheduling in atomic context.

Hint: you should turn on at least the basic lock checks that the kernel offers
when testing.

> }
> 
> void au0828_stop_vbi_streaming(struct vb2_queue *vq)
> {
> 	struct au0828_dev *dev = vb2_get_drv_priv(vq);
> 	struct au0828_dmaqueue *vbiq = &dev->vbiq;
> 	unsigned long flags = 0;
> 
> 	dprintk(1, "au0828_stop_vbi_streaming called %d\n",
> 		dev->streaming_users);
> 	if (!vb2_is_streaming(vq))
> 		return;
> 
> 	if (dev->streaming_users-- == 1)
> 		au0828_uninit_isoc(dev);
> 	dprintk(1, "au0828_stop_vbi_streaming %d\n", dev->streaming_users);
> 
> 	spin_lock_irqsave(&dev->slock, flags);
> 	if (dev->isoc_ctl.vbi_buf != NULL) {
> 		vb2_buffer_done(&dev->isoc_ctl.vbi_buf->vb,
> 				VB2_BUF_STATE_ERROR);
> 		dev->isoc_ctl.vbi_buf = NULL;
> 	}
> 	while (!list_empty(&vbiq->active)) {
> 		struct au0828_buffer *buf;
> 
> 		buf = list_entry(vbiq->active.next, struct au0828_buffer, list);
> 		list_del(&buf->list);
> 		vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
> 	}
> 
> 	dev->vbi_timeout_running = 0;
> 	del_timer_sync(&dev->vbi_timeout);
> 
> 	spin_unlock_irqrestore(&dev->slock, flags);

Same problem here, move up the spin_unlock to before the 'dev->vbi_timeout_running = 0;'
line.

> }
> 
> static struct vb2_ops au0828_video_qops = {
> 	.queue_setup     = queue_setup,
> 	.buf_prepare     = buffer_prepare,
> 	.buf_queue       = buffer_queue,
> 	.start_streaming = au0828_start_analog_streaming,
> 	.stop_streaming  = au0828_stop_streaming,
> 	.wait_prepare    = vb2_ops_wait_prepare,
> 	.wait_finish     = vb2_ops_wait_finish,
> };
> 
> /* ------------------------------------------------------------------
>    V4L2 interface
>    ------------------------------------------------------------------*/
> /*
>  * au0828_analog_unregister
>  * unregister v4l2 devices
>  */
> void au0828_analog_unregister(struct au0828_dev *dev)
> {
> 	dprintk(1, "au0828_analog_unregister called\n");
> 	mutex_lock(&au0828_sysfs_lock);
> 
> 	if (dev->vdev)
> 		video_unregister_device(dev->vdev);
> 	if (dev->vbi_dev)
> 		video_unregister_device(dev->vbi_dev);
> 
> 	mutex_unlock(&au0828_sysfs_lock);
> }
> 
> /* This function ensures that video frames continue to be delivered even if
>    the ITU-656 input isn't receiving any data (thereby preventing applications
>    such as tvtime from hanging) */

Why would tvtime be hanging? Make a separate patch that just removes all this
timeout nonsense. If there are no frames, then tvtime (and any other app) should
just wait for frames to arrive. And ctrl-C should always be able to break the app
(or they can timeout themselves).

It's not the driver's responsibility to do this and it only makes the code overly
complex.

> static void au0828_vid_buffer_timeout(unsigned long data)
> {
> 	struct au0828_dev *dev = (struct au0828_dev *) data;
> 	struct au0828_dmaqueue *dma_q = &dev->vidq;
> 	struct au0828_buffer *buf;
> 	unsigned char *vid_data;
> 	unsigned long flags = 0;
> 
> 	spin_lock_irqsave(&dev->slock, flags);
> 
> 	buf = dev->isoc_ctl.buf;
> 	if (buf != NULL) {
> 		vid_data = vb2_plane_vaddr(&buf->vb, 0);
> 		memset(vid_data, 0x00, buf->length); /* Blank green frame */
> 		buffer_filled(dev, dma_q, buf);
> 	}
> 	get_next_buf(dma_q, &buf);
> 
> 	if (dev->vid_timeout_running == 1)
> 		mod_timer(&dev->vid_timeout, jiffies + (HZ / 10));
> 
> 	spin_unlock_irqrestore(&dev->slock, flags);
> }
> 
> static void au0828_vbi_buffer_timeout(unsigned long data)
> {
> 	struct au0828_dev *dev = (struct au0828_dev *) data;
> 	struct au0828_dmaqueue *dma_q = &dev->vbiq;
> 	struct au0828_buffer *buf;
> 	unsigned char *vbi_data;
> 	unsigned long flags = 0;
> 
> 	spin_lock_irqsave(&dev->slock, flags);
> 
> 	buf = dev->isoc_ctl.vbi_buf;
> 	if (buf != NULL) {
> 		vbi_data = vb2_plane_vaddr(&buf->vb, 0);
> 		memset(vbi_data, 0x00, buf->length);
> 		vbi_buffer_filled(dev, dma_q, buf);
> 	}
> 	vbi_get_next_buf(dma_q, &buf);
> 
> 	if (dev->vbi_timeout_running == 1)
> 		mod_timer(&dev->vbi_timeout, jiffies + (HZ / 10));
> 	spin_unlock_irqrestore(&dev->slock, flags);
> }
> 
> static int au0828_v4l2_open(struct file *filp)
> {
> 	struct video_device *vdev = video_devdata(filp);
> 	struct au0828_dev *dev = video_drvdata(filp);
> 	int type;
> 	int ret = 0;
> 
> 	switch (vdev->vfl_type) {
> 	case VFL_TYPE_GRABBER:
> 		type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
> 		break;
> 	case VFL_TYPE_VBI:
> 		type = V4L2_BUF_TYPE_VBI_CAPTURE;
> 		break;
> 	default:
> 		return -EINVAL;
> 	}
> 
> 	dprintk(1,
> 		"%s called std_set %d dev_state %d stream users %d users %d\n",
> 		__func__, dev->std_set_in_tuner_core, dev->dev_state,
> 		dev->streaming_users, dev->users);
> 
> 	if (mutex_lock_interruptible(&dev->lock))
> 		return -ERESTARTSYS;
> 
> 	ret = v4l2_fh_open(filp);
> 	if (ret) {
> 		au0828_isocdbg("%s: v4l2_fh_open() returned error %d\n",
> 				__func__, ret);
> 		mutex_unlock(&dev->lock);
> 		return ret;
> 	}
> 
> 	if (dev->users == 0) {

Replace with 'v4l2_fh_is_singular_file(filp)'. That way you can drop the user field.
This can be a separate patch.

> 		au0828_analog_stream_enable(dev);
> 		au0828_analog_stream_reset(dev);
> 		dev->stream_state = STREAM_OFF;
> 		dev->dev_state |= DEV_INITIALIZED;
> 	}
> 	dev->users++;
> 	mutex_unlock(&dev->lock);
> 	return ret;
> }
> 
> static int au0828_v4l2_close(struct file *filp)
> {
> 	int ret;
> 	struct au0828_dev *dev = video_drvdata(filp);
> 	struct video_device *vdev = video_devdata(filp);
> 
> 	dprintk(1,
> 		"%s called std_set %d dev_state %d stream users %d users %d\n",
> 		__func__, dev->std_set_in_tuner_core, dev->dev_state,
> 		dev->streaming_users, dev->users);
> 
> 	vb2_fop_release(filp);

Drop this vb2_fop_release() call, will move to the end of the function.

> 	mutex_lock(&dev->lock);

Change to:

	mutex_lock(&dev->lock);

> 	if (vdev->vfl_type == VFL_TYPE_GRABBER && dev->vid_timeout_running) {
> 		/* Cancel timeout thread in case they didn't call streamoff */
> 		dev->vid_timeout_running = 0;
> 		del_timer_sync(&dev->vid_timeout);
> 	} else if (vdev->vfl_type == VFL_TYPE_VBI &&
> 			dev->vbi_timeout_running) {
> 		/* Cancel timeout thread in case they didn't call streamoff */
> 		dev->vbi_timeout_running = 0;
> 		del_timer_sync(&dev->vbi_timeout);
> 	}
> 
> 	if (dev->dev_state == DEV_DISCONNECTED)
> 		goto end;
> 
> 	if (dev->users == 1) {

And:

	if (v4l2_fh_is_singular_file(filp))

> 		/* Save some power by putting tuner to sleep */
> 		v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_power, 0);
> 		dev->std_set_in_tuner_core = 0;
> 
> 		/* When close the device, set the usb intf0 into alt0 to free
> 		   USB bandwidth */
> 		ret = usb_set_interface(dev->usbdev, 0, 0);
> 		if (ret < 0)
> 			pr_info("Au0828 can't set alternate to 0!\n");
> 	}
> end:

And the release goes here:

	_vb2_fop_release(filp, NULL);

> 	dev->users--;
> 	mutex_unlock(&dev->lock);
> 	wake_up_interruptible_nr(&dev->open, 1);

Huh? Seems unused and certainly looks very bogus.

> 	return 0;
> }
> 
> /* Must be called with dev->lock held */
> static void au0828_init_tuner(struct au0828_dev *dev)
> {
> 	struct v4l2_frequency f = {
> 		.frequency = dev->ctrl_freq,
> 		.type = V4L2_TUNER_ANALOG_TV,
> 	};
> 
> 	dprintk(1, "%s called std_set %d dev_state %d\n", __func__,
> 		dev->std_set_in_tuner_core, dev->dev_state);
> 
> 	if (dev->std_set_in_tuner_core)
> 		return;
> 	dev->std_set_in_tuner_core = 1;
> 	i2c_gate_ctrl(dev, 1);
> 	/* If we've never sent the standard in tuner core, do so now.
> 	   We don't do this at device probe because we don't want to
> 	   incur the cost of a firmware load */
> 	v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_std, dev->std);
> 	v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_frequency, &f);
> 	i2c_gate_ctrl(dev, 0);
> }
> 
> static int au0828_set_format(struct au0828_dev *dev, unsigned int cmd,
> 			     struct v4l2_format *format)
> {
> 	int ret;
> 	int width = format->fmt.pix.width;
> 	int height = format->fmt.pix.height;
> 
> 	/* If they are demanding a format other than the one we support,
> 	   bail out (tvtime asks for UYVY and then retries with YUYV) */
> 	if (format->fmt.pix.pixelformat != V4L2_PIX_FMT_UYVY)
> 		return -EINVAL;
> 
> 	/* format->fmt.pix.width only support 720 and height 480 */
> 	if (width != 720)
> 		width = 720;
> 	if (height != 480)
> 		height = 480;
> 
> 	format->fmt.pix.width = width;
> 	format->fmt.pix.height = height;
> 	format->fmt.pix.pixelformat = V4L2_PIX_FMT_UYVY;
> 	format->fmt.pix.bytesperline = width * 2;
> 	format->fmt.pix.sizeimage = width * height * 2;
> 	format->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
> 	format->fmt.pix.field = V4L2_FIELD_INTERLACED;
> 	format->fmt.pix.priv = 0;
> 
> 	if (cmd == VIDIOC_TRY_FMT)
> 		return 0;
> 
> 	/* maybe set new image format, driver current only support 720*480 */
> 	dev->width = width;
> 	dev->height = height;
> 	dev->frame_size = width * height * 2;
> 	dev->field_size = width * height;
> 	dev->bytesperline = width * 2;
> 
> 	if (dev->stream_state == STREAM_ON) {
> 		dprintk(1, "VIDIOC_SET_FMT: interrupting stream!\n");
> 		ret = au0828_stream_interrupt(dev);
> 		if (ret != 0) {
> 			dprintk(1, "error interrupting video stream!\n");
> 			return ret;
> 		}
> 	}
> 
> 	au0828_analog_stream_enable(dev);
> 
> 	return 0;
> }
> 
> static int vidioc_querycap(struct file *file, void  *priv,
> 			   struct v4l2_capability *cap)
> {
> 	struct video_device *vdev = video_devdata(file);
> 	struct au0828_dev *dev = video_drvdata(file);
> 
> 	dprintk(1, "%s called std_set %d dev_state %d\n", __func__,
> 		dev->std_set_in_tuner_core, dev->dev_state);
> 
> 	strlcpy(cap->driver, "au0828", sizeof(cap->driver));
> 	strlcpy(cap->card, dev->board.name, sizeof(cap->card));
> 	usb_make_path(dev->usbdev, cap->bus_info, sizeof(cap->bus_info));
> 
> 	/* set the device capabilities */
> 	cap->device_caps = V4L2_CAP_AUDIO |
> 		V4L2_CAP_READWRITE |
> 		V4L2_CAP_STREAMING |
> 		V4L2_CAP_TUNER;
> 	if (vdev->vfl_type == VFL_TYPE_GRABBER)
> 		cap->device_caps |= V4L2_CAP_VIDEO_CAPTURE;
> 	else
> 		cap->device_caps |= V4L2_CAP_VBI_CAPTURE;
> 	cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS |
> 		V4L2_CAP_VBI_CAPTURE | V4L2_CAP_VIDEO_CAPTURE;
> 	return 0;
> }
> 
> static int vidioc_enum_fmt_vid_cap(struct file *file, void  *priv,
> 					struct v4l2_fmtdesc *f)
> {
> 	if (f->index)
> 		return -EINVAL;
> 
> 	dprintk(1, "%s called\n", __func__);
> 
> 	f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
> 	strcpy(f->description, "Packed YUV2");
> 
> 	f->flags = 0;
> 	f->pixelformat = V4L2_PIX_FMT_UYVY;
> 
> 	return 0;
> }
> 
> static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
> 					struct v4l2_format *f)
> {
> 	struct au0828_dev *dev = video_drvdata(file);
> 
> 	dprintk(1, "%s called std_set %d dev_state %d\n", __func__,
> 		dev->std_set_in_tuner_core, dev->dev_state);
> 
> 	f->fmt.pix.width = dev->width;
> 	f->fmt.pix.height = dev->height;
> 	f->fmt.pix.pixelformat = V4L2_PIX_FMT_UYVY;
> 	f->fmt.pix.bytesperline = dev->bytesperline;
> 	f->fmt.pix.sizeimage = dev->frame_size;
> 	f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M; /* NTSC/PAL */
> 	f->fmt.pix.field = V4L2_FIELD_INTERLACED;
> 	f->fmt.pix.priv = 0;
> 	return 0;
> }
> 
> static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
> 				  struct v4l2_format *f)
> {
> 	struct au0828_dev *dev = video_drvdata(file);
> 
> 	dprintk(1, "%s called std_set %d dev_state %d\n", __func__,
> 		dev->std_set_in_tuner_core, dev->dev_state);
> 
> 	return au0828_set_format(dev, VIDIOC_TRY_FMT, f);
> }
> 
> static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
> 				struct v4l2_format *f)
> {
> 	struct au0828_dev *dev = video_drvdata(file);
> 	int rc;
> 
> 	dprintk(1, "%s called std_set %d dev_state %d\n", __func__,
> 		dev->std_set_in_tuner_core, dev->dev_state);
> 
> 	rc = check_dev(dev);
> 	if (rc < 0)
> 		return rc;
> 
> 	if (vb2_is_busy(&dev->vb_vidq)) {
> 		pr_info("%s queue busy\n", __func__);
> 		rc = -EBUSY;
> 		goto out;
> 	}
> 
> 	rc = au0828_set_format(dev, VIDIOC_S_FMT, f);
> out:
> 	return rc;
> }
> 
> static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id norm)
> {
> 	struct au0828_dev *dev = video_drvdata(file);
> 
> 	dprintk(1, "%s called std_set %d dev_state %d\n", __func__,
> 		dev->std_set_in_tuner_core, dev->dev_state);
> 
> 	if (norm == dev->std)
> 		return 0;
> 
> 	if (dev->streaming_users > 0)
> 		return -EBUSY;
> 
> 	dev->std = norm;
> 
> 	au0828_init_tuner(dev);
> 
> 	i2c_gate_ctrl(dev, 1);
> 
> 	/*
> 	 * FIXME: when we support something other than 60Hz standards,
> 	 * we are going to have to make the au0828 bridge adjust the size
> 	 * of its capture buffer, which is currently hardcoded at 720x480
> 	 */
> 
> 	v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_std, norm);
> 
> 	i2c_gate_ctrl(dev, 0);
> 
> 	return 0;
> }
> 
> static int vidioc_g_std(struct file *file, void *priv, v4l2_std_id *norm)
> {
> 	struct au0828_dev *dev = video_drvdata(file);
> 
> 	dprintk(1, "%s called std_set %d dev_state %d\n", __func__,
> 		dev->std_set_in_tuner_core, dev->dev_state);
> 
> 	*norm = dev->std;
> 	return 0;
> }
> 
> static int vidioc_enum_input(struct file *file, void *priv,
> 				struct v4l2_input *input)
> {
> 	struct au0828_dev *dev = video_drvdata(file);
> 	unsigned int tmp;
> 
> 	static const char *inames[] = {
> 		[AU0828_VMUX_UNDEFINED] = "Undefined",
> 		[AU0828_VMUX_COMPOSITE] = "Composite",
> 		[AU0828_VMUX_SVIDEO] = "S-Video",
> 		[AU0828_VMUX_CABLE] = "Cable TV",
> 		[AU0828_VMUX_TELEVISION] = "Television",
> 		[AU0828_VMUX_DVB] = "DVB",
> 		[AU0828_VMUX_DEBUG] = "tv debug"
> 	};
> 
> 	dprintk(1, "%s called std_set %d dev_state %d\n", __func__,
> 		dev->std_set_in_tuner_core, dev->dev_state);
> 
> 	tmp = input->index;
> 
> 	if (tmp >= AU0828_MAX_INPUT)
> 		return -EINVAL;
> 	if (AUVI_INPUT(tmp).type == 0)
> 		return -EINVAL;
> 
> 	input->index = tmp;
> 	strcpy(input->name, inames[AUVI_INPUT(tmp).type]);
> 	if ((AUVI_INPUT(tmp).type == AU0828_VMUX_TELEVISION) ||
> 	    (AUVI_INPUT(tmp).type == AU0828_VMUX_CABLE)) {
> 		input->type |= V4L2_INPUT_TYPE_TUNER;
> 		input->audioset = 1;
> 	} else {
> 		input->type |= V4L2_INPUT_TYPE_CAMERA;
> 		input->audioset = 2;
> 	}
> 
> 	input->std = dev->vdev->tvnorms;
> 
> 	return 0;
> }
> 
> static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
> {
> 	struct au0828_dev *dev = video_drvdata(file);
> 
> 	dprintk(1, "%s called std_set %d dev_state %d\n", __func__,
> 		dev->std_set_in_tuner_core, dev->dev_state);
> 
> 	*i = dev->ctrl_input;
> 	return 0;
> }
> 
> static void au0828_s_input(struct au0828_dev *dev, int index)
> {
> 	int i;
> 
> 	dprintk(1, "%s called std_set %d dev_state %d\n", __func__,
> 		dev->std_set_in_tuner_core, dev->dev_state);
> 
> 	switch (AUVI_INPUT(index).type) {
> 	case AU0828_VMUX_SVIDEO:
> 		dev->input_type = AU0828_VMUX_SVIDEO;
> 		dev->ctrl_ainput = 1;
> 		break;
> 	case AU0828_VMUX_COMPOSITE:
> 		dev->input_type = AU0828_VMUX_COMPOSITE;
> 		dev->ctrl_ainput = 1;
> 		break;
> 	case AU0828_VMUX_TELEVISION:
> 		dev->input_type = AU0828_VMUX_TELEVISION;
> 		dev->ctrl_ainput = 0;
> 		break;
> 	default:
> 		dprintk(1, "unknown input type set [%d]\n",
> 			AUVI_INPUT(index).type);
> 		break;
> 	}
> 
> 	v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_routing,
> 			AUVI_INPUT(index).vmux, 0, 0);
> 
> 	for (i = 0; i < AU0828_MAX_INPUT; i++) {
> 		int enable = 0;
> 		if (AUVI_INPUT(i).audio_setup == NULL)
> 			continue;
> 
> 		if (i == index)
> 			enable = 1;
> 		else
> 			enable = 0;
> 		if (enable) {
> 			(AUVI_INPUT(i).audio_setup)(dev, enable);
> 		} else {
> 			/* Make sure we leave it turned on if some
> 			   other input is routed to this callback */
> 			if ((AUVI_INPUT(i).audio_setup) !=
> 			    ((AUVI_INPUT(index).audio_setup))) {
> 				(AUVI_INPUT(i).audio_setup)(dev, enable);
> 			}
> 		}
> 	}
> 
> 	v4l2_device_call_all(&dev->v4l2_dev, 0, audio, s_routing,
> 			AUVI_INPUT(index).amux, 0, 0);
> }
> 
> static int vidioc_s_input(struct file *file, void *priv, unsigned int index)
> {
> 	struct au0828_dev *dev = video_drvdata(file);
> 
> 	dprintk(1, "VIDIOC_S_INPUT in function %s, input=%d\n", __func__,
> 		index);
> 	if (index >= AU0828_MAX_INPUT)
> 		return -EINVAL;
> 	if (AUVI_INPUT(index).type == 0)
> 		return -EINVAL;
> 	dev->ctrl_input = index;
> 	au0828_s_input(dev, index);
> 	return 0;
> }
> 
> static int vidioc_enumaudio(struct file *file, void *priv, struct v4l2_audio *a)
> {
> 	if (a->index > 1)
> 		return -EINVAL;
> 
> 	dprintk(1, "%s called\n", __func__);
> 
> 	if (a->index == 0)
> 		strcpy(a->name, "Television");
> 	else
> 		strcpy(a->name, "Line in");
> 
> 	a->capability = V4L2_AUDCAP_STEREO;
> 	return 0;
> }
> 
> static int vidioc_g_audio(struct file *file, void *priv, struct v4l2_audio *a)
> {
> 	struct au0828_dev *dev = video_drvdata(file);
> 
> 	dprintk(1, "%s called std_set %d dev_state %d\n", __func__,
> 		dev->std_set_in_tuner_core, dev->dev_state);
> 
> 	a->index = dev->ctrl_ainput;
> 	if (a->index == 0)
> 		strcpy(a->name, "Television");
> 	else
> 		strcpy(a->name, "Line in");
> 
> 	a->capability = V4L2_AUDCAP_STEREO;
> 	return 0;
> }
> 
> static int vidioc_s_audio(struct file *file, void *priv, const struct v4l2_audio *a)
> {
> 	struct au0828_dev *dev = video_drvdata(file);
> 
> 	if (a->index != dev->ctrl_ainput)
> 		return -EINVAL;
> 
> 	dprintk(1, "%s called std_set %d dev_state %d\n", __func__,
> 		dev->std_set_in_tuner_core, dev->dev_state);
> 	return 0;
> }
> 
> static int vidioc_g_tuner(struct file *file, void *priv, struct v4l2_tuner *t)
> {
> 	struct au0828_dev *dev = video_drvdata(file);
> 
> 	if (t->index != 0)
> 		return -EINVAL;
> 
> 	dprintk(1, "%s called std_set %d dev_state %d\n", __func__,
> 		dev->std_set_in_tuner_core, dev->dev_state);
> 
> 	strcpy(t->name, "Auvitek tuner");
> 
> 	au0828_init_tuner(dev);
> 	i2c_gate_ctrl(dev, 1);
> 	v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, g_tuner, t);
> 	i2c_gate_ctrl(dev, 0);
> 	return 0;
> }
> 
> static int vidioc_s_tuner(struct file *file, void *priv,
> 				const struct v4l2_tuner *t)
> {
> 	struct au0828_dev *dev = video_drvdata(file);
> 
> 	if (t->index != 0)
> 		return -EINVAL;
> 
> 	dprintk(1, "%s called std_set %d dev_state %d\n", __func__,
> 		dev->std_set_in_tuner_core, dev->dev_state);
> 
> 	au0828_init_tuner(dev);
> 	i2c_gate_ctrl(dev, 1);
> 	v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_tuner, t);
> 	i2c_gate_ctrl(dev, 0);
> 
> 	dprintk(1, "VIDIOC_S_TUNER: signal = %x, afc = %x\n", t->signal,
> 		t->afc);
> 
> 	return 0;
> 
> }
> 
> static int vidioc_g_frequency(struct file *file, void *priv,
> 				struct v4l2_frequency *freq)
> {
> 	struct au0828_dev *dev = video_drvdata(file);
> 
> 	if (freq->tuner != 0)
> 		return -EINVAL;
> 	dprintk(1, "%s called std_set %d dev_state %d\n", __func__,
> 		dev->std_set_in_tuner_core, dev->dev_state);
> 	freq->frequency = dev->ctrl_freq;
> 	return 0;
> }
> 
> static int vidioc_s_frequency(struct file *file, void *priv,
> 				const struct v4l2_frequency *freq)
> {
> 	struct au0828_dev *dev = video_drvdata(file);
> 	struct v4l2_frequency new_freq = *freq;
> 
> 	if (freq->tuner != 0)
> 		return -EINVAL;
> 
> 	dprintk(1, "%s called std_set %d dev_state %d\n", __func__,
> 		dev->std_set_in_tuner_core, dev->dev_state);
> 
> 	au0828_init_tuner(dev);
> 	i2c_gate_ctrl(dev, 1);
> 
> 	v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_frequency, freq);
> 	/* Get the actual set (and possibly clamped) frequency */
> 	v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, g_frequency, &new_freq);
> 	dev->ctrl_freq = new_freq.frequency;
> 
> 	i2c_gate_ctrl(dev, 0);
> 
> 	au0828_analog_stream_reset(dev);
> 
> 	return 0;
> }
> 
> 
> /* RAW VBI ioctls */
> 
> static int vidioc_g_fmt_vbi_cap(struct file *file, void *priv,
> 				struct v4l2_format *format)
> {
> 	struct au0828_dev *dev = video_drvdata(file);
> 
> 	dprintk(1, "%s called std_set %d dev_state %d\n", __func__,
> 		dev->std_set_in_tuner_core, dev->dev_state);
> 
> 	format->fmt.vbi.samples_per_line = dev->vbi_width;
> 	format->fmt.vbi.sample_format = V4L2_PIX_FMT_GREY;
> 	format->fmt.vbi.offset = 0;
> 	format->fmt.vbi.flags = 0;
> 	format->fmt.vbi.sampling_rate = 6750000 * 4 / 2;
> 
> 	format->fmt.vbi.count[0] = dev->vbi_height;
> 	format->fmt.vbi.count[1] = dev->vbi_height;
> 	format->fmt.vbi.start[0] = 21;
> 	format->fmt.vbi.start[1] = 284;
> 	memset(format->fmt.vbi.reserved, 0, sizeof(format->fmt.vbi.reserved));
> 
> 	return 0;
> }
> 
> static int vidioc_cropcap(struct file *file, void *priv,
> 			  struct v4l2_cropcap *cc)
> {
> 	struct au0828_dev *dev = video_drvdata(file);
> 
> 	if (cc->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
> 		return -EINVAL;
> 
> 	dprintk(1, "%s called std_set %d dev_state %d\n", __func__,
> 		dev->std_set_in_tuner_core, dev->dev_state);
> 
> 	cc->bounds.left = 0;
> 	cc->bounds.top = 0;
> 	cc->bounds.width = dev->width;
> 	cc->bounds.height = dev->height;
> 
> 	cc->defrect = cc->bounds;
> 
> 	cc->pixelaspect.numerator = 54;
> 	cc->pixelaspect.denominator = 59;
> 
> 	return 0;
> }
> 
> #ifdef CONFIG_VIDEO_ADV_DEBUG
> static int vidioc_g_register(struct file *file, void *priv,
> 			     struct v4l2_dbg_register *reg)
> {
> 	struct au0828_dev *dev = video_drvdata(file);
> 
> 	dprintk(1, "%s called std_set %d dev_state %d\n", __func__,
> 		dev->std_set_in_tuner_core, dev->dev_state);
> 
> 	reg->val = au0828_read(dev, reg->reg);
> 	reg->size = 1;
> 	return 0;
> }
> 
> static int vidioc_s_register(struct file *file, void *priv,
> 			     const struct v4l2_dbg_register *reg)
> {
> 	struct au0828_dev *dev = video_drvdata(file);
> 
> 	dprintk(1, "%s called std_set %d dev_state %d\n", __func__,
> 		dev->std_set_in_tuner_core, dev->dev_state);
> 
> 	return au0828_writereg(dev, reg->reg, reg->val);
> }
> #endif
> 
> static int vidioc_log_status(struct file *file, void *fh)
> {
> 	struct video_device *vdev = video_devdata(file);
> 
> 	dprintk(1, "%s called\n", __func__);
> 
> 	v4l2_ctrl_log_status(file, fh);
> 	v4l2_device_call_all(vdev->v4l2_dev, 0, core, log_status);
> 	return 0;
> }
> 
> void au0828_v4l2_suspend(struct au0828_dev *dev)
> {
> 	struct urb *urb;
> 	int i;
> 
> 	pr_info("stopping V4L2\n");
> 
> 	if (dev->stream_state == STREAM_ON) {
> 		pr_info("stopping V4L2 active URBs\n");
> 		au0828_analog_stream_disable(dev);
> 		/* stop urbs */
> 		for (i = 0; i < dev->isoc_ctl.num_bufs; i++) {
> 			urb = dev->isoc_ctl.urb[i];
> 			if (urb) {
> 				if (!irqs_disabled())
> 					usb_kill_urb(urb);
> 				else
> 					usb_unlink_urb(urb);
> 			}
> 		}
> 	}
> 
> 	if (dev->vid_timeout_running)
> 		del_timer_sync(&dev->vid_timeout);
> 	if (dev->vbi_timeout_running)
> 		del_timer_sync(&dev->vbi_timeout);
> }
> 
> void au0828_v4l2_resume(struct au0828_dev *dev)
> {
> 	int i, rc;
> 
> 	pr_info("restarting V4L2\n");
> 
> 	if (dev->stream_state == STREAM_ON) {
> 		au0828_stream_interrupt(dev);
> 		au0828_init_tuner(dev);
> 	}
> 
> 	if (dev->vid_timeout_running)
> 		mod_timer(&dev->vid_timeout, jiffies + (HZ / 10));
> 	if (dev->vbi_timeout_running)
> 		mod_timer(&dev->vbi_timeout, jiffies + (HZ / 10));
> 
> 	/* If we were doing ac97 instead of i2s, it would go here...*/
> 	au0828_i2s_init(dev);
> 
> 	au0828_analog_stream_enable(dev);
> 
> 	if (!(dev->stream_state == STREAM_ON)) {
> 		au0828_analog_stream_reset(dev);
> 		/* submit urbs */
> 		for (i = 0; i < dev->isoc_ctl.num_bufs; i++) {
> 			rc = usb_submit_urb(dev->isoc_ctl.urb[i], GFP_ATOMIC);
> 			if (rc) {
> 				au0828_isocdbg("submit of urb %i failed (error=%i)\n",
> 					       i, rc);
> 				au0828_uninit_isoc(dev);
> 			}
> 		}
> 	}
> }
> 
> static struct v4l2_file_operations au0828_v4l_fops = {
> 	.owner      = THIS_MODULE,
> 	.open       = au0828_v4l2_open,
> 	.release    = au0828_v4l2_close,
> 	.read       = vb2_fop_read,
> 	.poll       = vb2_fop_poll,
> 	.mmap       = vb2_fop_mmap,
> 	.unlocked_ioctl = video_ioctl2,
> };
> 
> static const struct v4l2_ioctl_ops video_ioctl_ops = {
> 	.vidioc_querycap            = vidioc_querycap,
> 	.vidioc_enum_fmt_vid_cap    = vidioc_enum_fmt_vid_cap,
> 	.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_g_fmt_vbi_cap       = vidioc_g_fmt_vbi_cap,
> 	.vidioc_try_fmt_vbi_cap     = vidioc_g_fmt_vbi_cap,
> 	.vidioc_s_fmt_vbi_cap       = vidioc_g_fmt_vbi_cap,
> 	.vidioc_enumaudio           = vidioc_enumaudio,
> 	.vidioc_g_audio             = vidioc_g_audio,
> 	.vidioc_s_audio             = vidioc_s_audio,
> 	.vidioc_cropcap             = vidioc_cropcap,
> 
> 	.vidioc_reqbufs             = vb2_ioctl_reqbufs,
> 	.vidioc_create_bufs         = vb2_ioctl_create_bufs,
> 	.vidioc_prepare_buf         = vb2_ioctl_prepare_buf,
> 	.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            = vb2_ioctl_streamon,
> 	.vidioc_streamoff           = vb2_ioctl_streamoff,
> 
> 	.vidioc_g_tuner             = vidioc_g_tuner,
> 	.vidioc_s_tuner             = vidioc_s_tuner,
> 	.vidioc_g_frequency         = vidioc_g_frequency,
> 	.vidioc_s_frequency         = vidioc_s_frequency,
> #ifdef CONFIG_VIDEO_ADV_DEBUG
> 	.vidioc_g_register          = vidioc_g_register,
> 	.vidioc_s_register          = vidioc_s_register,
> #endif
> 	.vidioc_log_status	    = vidioc_log_status,
> 	.vidioc_subscribe_event     = v4l2_ctrl_subscribe_event,
> 	.vidioc_unsubscribe_event   = v4l2_event_unsubscribe,
> };
> 
> static const struct video_device au0828_video_template = {
> 	.fops                       = &au0828_v4l_fops,
> 	.release                    = video_device_release,
> 	.ioctl_ops 		    = &video_ioctl_ops,
> 	.tvnorms                    = V4L2_STD_NTSC_M | V4L2_STD_PAL_M,
> };
> 
> static int au0828_vb2_setup(struct au0828_dev *dev)
> {
> 	int rc;
> 	struct vb2_queue *q;
> 
> 	/* Setup Videobuf2 for Video capture */
> 	q = &dev->vb_vidq;
> 	q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
> 	q->io_modes = VB2_READ | VB2_MMAP | VB2_USERPTR | VB2_DMABUF;
> 	q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
> 	q->drv_priv = dev;
> 	q->buf_struct_size = sizeof(struct au0828_buffer);
> 	q->ops = &au0828_video_qops;
> 	q->mem_ops = &vb2_vmalloc_memops;
> 
> 	rc = vb2_queue_init(q);
> 	if (rc < 0)
> 		return rc;
> 
> 	/* Setup Videobuf2 for VBI capture */
> 	q = &dev->vb_vbiq;
> 	q->type = V4L2_BUF_TYPE_VBI_CAPTURE;
> 	q->io_modes = VB2_READ | VB2_MMAP | VB2_USERPTR;
> 	q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
> 	q->drv_priv = dev;
> 	q->buf_struct_size = sizeof(struct au0828_buffer);
> 	q->ops = &au0828_vbi_qops;
> 	q->mem_ops = &vb2_vmalloc_memops;
> 
> 	rc = vb2_queue_init(q);
> 	if (rc < 0)
> 		return rc;
> 
> 	return 0;
> }
> 
> /**************************************************************************/
> 
> int au0828_analog_register(struct au0828_dev *dev,
> 			   struct usb_interface *interface)
> {
> 	int retval = -ENOMEM;
> 	struct usb_host_interface *iface_desc;
> 	struct usb_endpoint_descriptor *endpoint;
> 	int i, ret;
> 
> 	dprintk(1, "au0828_analog_register called for intf#%d!\n",
> 		interface->cur_altsetting->desc.bInterfaceNumber);
> 
> 	/* set au0828 usb interface0 to as5 */
> 	retval = usb_set_interface(dev->usbdev,
> 			interface->cur_altsetting->desc.bInterfaceNumber, 5);
> 	if (retval != 0) {
> 		pr_info("Failure setting usb interface0 to as5\n");
> 		return retval;
> 	}
> 
> 	/* Figure out which endpoint has the isoc interface */
> 	iface_desc = interface->cur_altsetting;
> 	for (i = 0; i < iface_desc->desc.bNumEndpoints; i++) {
> 		endpoint = &iface_desc->endpoint[i].desc;
> 		if (((endpoint->bEndpointAddress & USB_ENDPOINT_DIR_MASK)
> 		     == USB_DIR_IN) &&
> 		    ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
> 		     == USB_ENDPOINT_XFER_ISOC)) {
> 
> 			/* we find our isoc in endpoint */
> 			u16 tmp = le16_to_cpu(endpoint->wMaxPacketSize);
> 			dev->max_pkt_size = (tmp & 0x07ff) *
> 				(((tmp & 0x1800) >> 11) + 1);
> 			dev->isoc_in_endpointaddr = endpoint->bEndpointAddress;
> 			dprintk(1,
> 				"Found isoc endpoint 0x%02x, max size = %d\n",
> 				dev->isoc_in_endpointaddr, dev->max_pkt_size);
> 		}
> 	}
> 	if (!(dev->isoc_in_endpointaddr)) {
> 		pr_info("Could not locate isoc endpoint\n");
> 		kfree(dev);
> 		return -ENODEV;
> 	}
> 
> 	init_waitqueue_head(&dev->open);
> 	spin_lock_init(&dev->slock);
> 
> 	/* init video dma queues */
> 	INIT_LIST_HEAD(&dev->vidq.active);
> 	INIT_LIST_HEAD(&dev->vbiq.active);
> 
> 	dev->vid_timeout.function = au0828_vid_buffer_timeout;
> 	dev->vid_timeout.data = (unsigned long) dev;
> 	init_timer(&dev->vid_timeout);
> 
> 	dev->vbi_timeout.function = au0828_vbi_buffer_timeout;
> 	dev->vbi_timeout.data = (unsigned long) dev;
> 	init_timer(&dev->vbi_timeout);
> 
> 	dev->width = NTSC_STD_W;
> 	dev->height = NTSC_STD_H;
> 	dev->field_size = dev->width * dev->height;
> 	dev->frame_size = dev->field_size << 1;
> 	dev->bytesperline = dev->width << 1;
> 	dev->vbi_width = 720;
> 	dev->vbi_height = 1;
> 	dev->ctrl_ainput = 0;
> 	dev->ctrl_freq = 960;
> 	dev->std = V4L2_STD_NTSC_M;
> 	au0828_s_input(dev, 0);
> 
> 	/* allocate and fill v4l2 video struct */
> 	dev->vdev = video_device_alloc();
> 	if (NULL == dev->vdev) {
> 		dprintk(1, "Can't allocate video_device.\n");
> 		return -ENOMEM;
> 	}
> 
> 	/* allocate the VBI struct */
> 	dev->vbi_dev = video_device_alloc();

I recommend that these video_device structs are embedded in au0828_dev.
That way you don't need to check for errors here.

> 	if (NULL == dev->vbi_dev) {
> 		dprintk(1, "Can't allocate vbi_device.\n");
> 		ret = -ENOMEM;
> 		goto err_vdev;
> 	}
> 
> 	mutex_init(&dev->vb_queue_lock);
> 	mutex_init(&dev->vb_vbi_queue_lock);
> 
> 	/* Fill the video capture device struct */
> 	*dev->vdev = au0828_video_template;
> 	dev->vdev->v4l2_dev = &dev->v4l2_dev;
> 	dev->vdev->lock = &dev->lock;
> 	dev->vdev->queue = &dev->vb_vidq;
> 	dev->vdev->queue->lock = &dev->vb_queue_lock;
> 	strcpy(dev->vdev->name, "au0828a video");
> 
> 	/* Setup the VBI device */
> 	*dev->vbi_dev = au0828_video_template;
> 	dev->vbi_dev->v4l2_dev = &dev->v4l2_dev;
> 	dev->vbi_dev->lock = &dev->lock;
> 	dev->vbi_dev->queue = &dev->vb_vbiq;
> 	dev->vbi_dev->queue->lock = &dev->vb_vbi_queue_lock;
> 	strcpy(dev->vbi_dev->name, "au0828a vbi");
> 
> 	/* Register the v4l2 device */
> 	video_set_drvdata(dev->vdev, dev);
> 	retval = video_register_device(dev->vdev, VFL_TYPE_GRABBER, -1);
> 	if (retval != 0) {
> 		dprintk(1, "unable to register video device (error = %d).\n",
> 			retval);
> 		ret = -ENODEV;
> 		goto err_vbi_dev;
> 	}
> 
> 	/* Register the vbi device */
> 	video_set_drvdata(dev->vbi_dev, dev);
> 	retval = video_register_device(dev->vbi_dev, VFL_TYPE_VBI, -1);
> 	if (retval != 0) {
> 		dprintk(1, "unable to register vbi device (error = %d).\n",
> 			retval);
> 		ret = -ENODEV;
> 		goto err_vbi_dev;
> 	}
> 
> 	/* initialize videobuf2 stuff */
> 	retval = au0828_vb2_setup(dev);

This should be done *before* calling video_register_device.

> 	if (retval != 0) {
> 		dprintk(1, "unable to setup videobuf2 queues (error = %d).\n",
> 			retval);
> 		ret = -ENODEV;
> 		goto err_vbi_dev;
> 	}
> 
> 	dprintk(1, "%s completed!\n", __func__);
> 
> 	return 0;
> 
> err_vbi_dev:
> 	video_device_release(dev->vbi_dev);
> err_vdev:
> 	video_device_release(dev->vdev);
> 	return ret;
> }
> 

Regards,

	Hans