V4L/DVB (12742): em28xx: add raw VBI support for NTSC (28abf083) · Commits · e / devices / android_kernel_xiaomi_markw

drivers/media/video/em28xx/Makefile

+1 −1

Original line number	Original line	Diff line number	Diff line
	em28xx-objs := em28xx-video.o em28xx-i2c.o em28xx-cards.o em28xx-core.o \		em28xx-objs := em28xx-video.o em28xx-i2c.o em28xx-cards.o em28xx-core.o \
	em28xx-input.o		em28xx-input.o em28xx-vbi.o

	em28xx-alsa-objs := em28xx-audio.o		em28xx-alsa-objs := em28xx-audio.o

drivers/media/video/em28xx/em28xx-cards.c

+2 −0

Original line number	Original line	Diff line number	Diff line
	@@ -2590,6 +2590,8 @@ static int em28xx_init_dev(struct em28xx *devhandle, struct usb_device udev,
	/* init video dma queues */		/* init video dma queues */
	INIT_LIST_HEAD(&dev->vidq.active);		INIT_LIST_HEAD(&dev->vidq.active);
	INIT_LIST_HEAD(&dev->vidq.queued);		INIT_LIST_HEAD(&dev->vidq.queued);
			INIT_LIST_HEAD(&dev->vbiq.active);
			INIT_LIST_HEAD(&dev->vbiq.queued);


	if (dev->board.has_msp34xx) {		if (dev->board.has_msp34xx) {

drivers/media/video/em28xx/em28xx-core.c

+4 −1

Original line number	Original line	Diff line number	Diff line
	@@ -964,6 +964,7 @@ int em28xx_init_isoc(struct em28xx *dev, int max_packets,
	int (isoc_copy) (struct em28xx dev, struct urb *urb))		int (isoc_copy) (struct em28xx dev, struct urb *urb))
	{		{
	struct em28xx_dmaqueue *dma_q = &dev->vidq;		struct em28xx_dmaqueue *dma_q = &dev->vidq;
			struct em28xx_dmaqueue *vbi_dma_q = &dev->vbiq;
	int i;		int i;
	int sb_size, pipe;		int sb_size, pipe;
	struct urb *urb;		struct urb *urb;
	@@ -993,7 +994,8 @@ int em28xx_init_isoc(struct em28xx *dev, int max_packets,
	}		}

	dev->isoc_ctl.max_pkt_size = max_pkt_size;		dev->isoc_ctl.max_pkt_size = max_pkt_size;
	dev->isoc_ctl.buf = NULL;		dev->isoc_ctl.vid_buf = NULL;
			dev->isoc_ctl.vbi_buf = NULL;

	sb_size = max_packets * dev->isoc_ctl.max_pkt_size;		sb_size = max_packets * dev->isoc_ctl.max_pkt_size;

	@@ -1043,6 +1045,7 @@ int em28xx_init_isoc(struct em28xx *dev, int max_packets,
	}		}

	init_waitqueue_head(&dma_q->wq);		init_waitqueue_head(&dma_q->wq);
			init_waitqueue_head(&vbi_dma_q->wq);

	em28xx_capture_start(dev, 1);		em28xx_capture_start(dev, 1);

drivers/media/video/em28xx/em28xx-vbi.c

0 → 100644

+150 −0

Original line number	Original line	Diff line number	Diff line
			/*
			em28xx-vbi.c - VBI driver for em28xx

			Copyright (C) 2009 Devin Heitmueller <dheitmueller@kernellabs.com>

			This work was sponsored by EyeMagnet Limited.

			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.
			*/

			#include <linux/kernel.h>
			#include <linux/module.h>
			#include <linux/init.h>
			#include <linux/slab.h>

			#include "em28xx.h"

			static unsigned int vbibufs = 5;
			module_param(vbibufs,int,0644);
			MODULE_PARM_DESC(vbibufs,"number of vbi buffers, range 2-32");

			static unsigned int vbi_debug;
			module_param(vbi_debug,int,0644);
			MODULE_PARM_DESC(vbi_debug,"enable debug messages [vbi]");

			#define dprintk(level,fmt, arg...) if (vbi_debug >= level) \
			printk(KERN_DEBUG "%s: " fmt, dev->core->name , ## arg)

			/* ------------------------------------------------------------------ */

			static void
			free_buffer(struct videobuf_queue vq, struct em28xx_buffer buf)
			{
			struct em28xx_fh *fh = vq->priv_data;
			struct em28xx *dev = fh->dev;
			unsigned long flags = 0;
			if (in_interrupt())
			BUG();

			/* We used to wait for the buffer to finish here, but this didn't work
			because, as we were keeping the state as VIDEOBUF_QUEUED,
			videobuf_queue_cancel marked it as finished for us.
			(Also, it could wedge forever if the hardware was misconfigured.)

			This should be safe; by the time we get here, the buffer isn't
			queued anymore. If we ever start marking the buffers as
			VIDEOBUF_ACTIVE, it won't be, though.
			*/
			spin_lock_irqsave(&dev->slock, flags);
			if (dev->isoc_ctl.vbi_buf == buf)
			dev->isoc_ctl.vbi_buf = NULL;
			spin_unlock_irqrestore(&dev->slock, flags);

			videobuf_vmalloc_free(&buf->vb);
			buf->vb.state = VIDEOBUF_NEEDS_INIT;
			}

			static int
			vbi_setup(struct videobuf_queue q, unsigned int count, unsigned int *size)
			{
			size = 720 12 * 2;
			if (0 == *count)
			*count = vbibufs;
			if (*count < 2)
			*count = 2;
			if (*count > 32)
			*count = 32;
			return 0;
			}

			static int
			vbi_prepare(struct videobuf_queue q, struct videobuf_buffer vb,
			enum v4l2_field field)
			{
			struct em28xx_fh *fh = q->priv_data;
			struct em28xx_buffer *buf = container_of(vb, struct em28xx_buffer, vb);
			int rc = 0;
			unsigned int size;

			size = 720 * 12 * 2;

			buf->vb.size = size;

			if (0 != buf->vb.baddr && buf->vb.bsize < buf->vb.size)
			return -EINVAL;

			buf->vb.width = 720;
			buf->vb.height = 12;
			buf->vb.field = field;

			if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
			rc = videobuf_iolock(q, &buf->vb, NULL);
			if (rc < 0)
			goto fail;
			}

			buf->vb.state = VIDEOBUF_PREPARED;
			return 0;

			fail:
			free_buffer(q, buf);
			return rc;
			}

			static void
			vbi_queue(struct videobuf_queue vq, struct videobuf_buffer vb)
			{
			struct em28xx_buffer *buf = container_of(vb,
			struct em28xx_buffer,
			vb);
			struct em28xx_fh *fh = vq->priv_data;
			struct em28xx *dev = fh->dev;
			struct em28xx_dmaqueue *vbiq = &dev->vbiq;

			buf->vb.state = VIDEOBUF_QUEUED;
			list_add_tail(&buf->vb.queue, &vbiq->active);
			}

			static void vbi_release(struct videobuf_queue q, struct videobuf_buffer vb)
			{
			struct em28xx_buffer *buf = container_of(vb, struct em28xx_buffer, vb);
			free_buffer(q, buf);
			}

			struct videobuf_queue_ops em28xx_vbi_qops = {
			.buf_setup = vbi_setup,
			.buf_prepare = vbi_prepare,
			.buf_queue = vbi_queue,
			.buf_release = vbi_release,
			};

			/* ------------------------------------------------------------------ */
			/*
			* Local variables:
			* c-basic-offset: 8
			* End:
			*/

drivers/media/video/em28xx/em28xx-video.c

+266 −24

Original line number	Original line	Diff line number	Diff line
	@@ -163,7 +163,24 @@ static inline void buffer_filled(struct em28xx *dev,
	buf->vb.field_count++;		buf->vb.field_count++;
	do_gettimeofday(&buf->vb.ts);		do_gettimeofday(&buf->vb.ts);

	dev->isoc_ctl.buf = NULL;		dev->isoc_ctl.vid_buf = NULL;

			list_del(&buf->vb.queue);
			wake_up(&buf->vb.done);
			}

			static inline void vbi_buffer_filled(struct em28xx *dev,
			struct em28xx_dmaqueue *dma_q,
			struct em28xx_buffer *buf)
			{
			/* Advice that buffer was filled */
			em28xx_isocdbg("[%p/%d] wakeup\n", buf, buf->vb.i);

			buf->vb.state = VIDEOBUF_DONE;
			buf->vb.field_count++;
			do_gettimeofday(&buf->vb.ts);

			dev->isoc_ctl.vbi_buf = NULL;

	list_del(&buf->vb.queue);		list_del(&buf->vb.queue);
	wake_up(&buf->vb.done);		wake_up(&buf->vb.done);
	@@ -256,6 +273,63 @@ static void em28xx_copy_video(struct em28xx *dev,
	dma_q->pos += len;		dma_q->pos += len;
	}		}

			static void em28xx_copy_vbi(struct em28xx *dev,
			struct em28xx_dmaqueue *dma_q,
			struct em28xx_buffer *buf,
			unsigned char *p,
			unsigned char *outp, unsigned long len)
			{
			void startwrite, startread;
			int offset;
			int bytesperline = 720;

			if (dev == NULL) {
			printk("dev is null\n");
			return;
			}

			if (dma_q == NULL) {
			printk("dma_q is null\n");
			return;
			}
			if (buf == NULL) {
			return;
			}
			if (p == NULL) {
			printk("p is null\n");
			return;
			}
			if (outp == NULL) {
			printk("outp is null\n");
			return;
			}

			if (dma_q->pos + len > buf->vb.size)
			len = buf->vb.size - dma_q->pos;

			if ((p[0] == 0x33 && p[1] == 0x95) \|\|
			(p[0] == 0x88 && p[1] == 0x88)) {
			/* Header field, advance past it */
			p += 4;
			} else {
			len += 4;
			}

			startread = p;

			startwrite = outp + dma_q->pos;
			offset = dma_q->pos;

			/* Make sure the bottom field populates the second half of the frame */
			if (buf->top_field == 0) {
			startwrite += bytesperline * 0x0c;
			offset += bytesperline * 0x0c;
			}

			memcpy(startwrite, startread, len);
			dma_q->pos += len;
			}

	static inline void print_err_status(struct em28xx *dev,		static inline void print_err_status(struct em28xx *dev,
	int packet, int status)		int packet, int status)
	{		{
	@@ -306,7 +380,7 @@ static inline void get_next_buf(struct em28xx_dmaqueue *dma_q,

	if (list_empty(&dma_q->active)) {		if (list_empty(&dma_q->active)) {
	em28xx_isocdbg("No active queue to serve\n");		em28xx_isocdbg("No active queue to serve\n");
	dev->isoc_ctl.buf = NULL;		dev->isoc_ctl.vid_buf = NULL;
	*buf = NULL;		*buf = NULL;
	return;		return;
	}		}
	@@ -318,7 +392,34 @@ static inline void get_next_buf(struct em28xx_dmaqueue *dma_q,
	outp = videobuf_to_vmalloc(&(*buf)->vb);		outp = videobuf_to_vmalloc(&(*buf)->vb);
	memset(outp, 0, (*buf)->vb.size);		memset(outp, 0, (*buf)->vb.size);

	dev->isoc_ctl.buf = *buf;		dev->isoc_ctl.vid_buf = *buf;

			return;
			}

			/*
			* video-buf generic routine to get the next available VBI buffer
			*/
			static inline void vbi_get_next_buf(struct em28xx_dmaqueue *dma_q,
			struct em28xx_buffer **buf)
			{
			struct em28xx *dev = container_of(dma_q, struct em28xx, vbiq);
			char *outp;

			if (list_empty(&dma_q->active)) {
			em28xx_isocdbg("No active queue to serve\n");
			dev->isoc_ctl.vbi_buf = NULL;
			*buf = NULL;
			return;
			}

			/* Get the next buffer */
			*buf = list_entry(dma_q->active.next, struct em28xx_buffer, vb.queue);
			/* Cleans up buffer - Usefull for testing for frame/URB loss */
			outp = videobuf_to_vmalloc(&(*buf)->vb);
			memset(outp, 0x00, (*buf)->vb.size);

			dev->isoc_ctl.vbi_buf = *buf;

	return;		return;
	}		}
	@@ -346,7 +447,7 @@ static inline int em28xx_isoc_copy(struct em28xx dev, struct urb urb)
	return 0;		return 0;
	}		}

	buf = dev->isoc_ctl.buf;		buf = dev->isoc_ctl.vid_buf;
	if (buf != NULL)		if (buf != NULL)
	outp = videobuf_to_vmalloc(&buf->vb);		outp = videobuf_to_vmalloc(&buf->vb);

	@@ -416,6 +517,7 @@ static inline int em28xx_isoc_copy_vbi(struct em28xx dev, struct urb urb)
	{		{
	struct em28xx_buffer buf, vbi_buf;		struct em28xx_buffer buf, vbi_buf;
	struct em28xx_dmaqueue *dma_q = &dev->vidq;		struct em28xx_dmaqueue *dma_q = &dev->vidq;
			struct em28xx_dmaqueue *vbi_dma_q = &dev->vbiq;
	unsigned char *outp = NULL;		unsigned char *outp = NULL;
	unsigned char *vbioutp = NULL;		unsigned char *vbioutp = NULL;
	int i, len = 0, rc = 1;		int i, len = 0, rc = 1;
	@@ -434,9 +536,14 @@ static inline int em28xx_isoc_copy_vbi(struct em28xx dev, struct urb urb)
	return 0;		return 0;
	}		}

	buf = dev->isoc_ctl.buf;		buf = dev->isoc_ctl.vid_buf;
	if (buf != NULL)		if (buf != NULL)
	outp = videobuf_to_vmalloc(&buf->vb);		outp = videobuf_to_vmalloc(&buf->vb);

			vbi_buf = dev->isoc_ctl.vbi_buf;
			if (vbi_buf != NULL)
			vbioutp = videobuf_to_vmalloc(&vbi_buf->vb);

	for (i = 0; i < urb->number_of_packets; i++) {		for (i = 0; i < urb->number_of_packets; i++) {
	int status = urb->iso_frame_desc[i].status;		int status = urb->iso_frame_desc[i].status;

	@@ -480,12 +587,41 @@ static inline int em28xx_isoc_copy_vbi(struct em28xx dev, struct urb urb)
	printk("djh c should never happen\n");		printk("djh c should never happen\n");
	} else if ((dev->vbi_read + len) < vbi_size) {		} else if ((dev->vbi_read + len) < vbi_size) {
	/* This entire frame is VBI data */		/* This entire frame is VBI data */
			if (dev->vbi_read == 0 &&
			(!(dev->cur_field & 1))) {
			/* Brand new frame */
			if (vbi_buf != NULL)
			vbi_buffer_filled(dev,
			vbi_dma_q,
			vbi_buf);
			vbi_get_next_buf(vbi_dma_q, &vbi_buf);
			if (vbi_buf == NULL)
			vbioutp = NULL;
			else {
			vbioutp = videobuf_to_vmalloc(&vbi_buf->vb);
			}
			}

			if (dev->vbi_read == 0) {
			vbi_dma_q->pos = 0;
			if (vbi_buf != NULL) {
			if (dev->cur_field & 1)
			vbi_buf->top_field = 0;
			else
			vbi_buf->top_field = 1;
			}
			}

	dev->vbi_read += len;		dev->vbi_read += len;
			em28xx_copy_vbi(dev, vbi_dma_q, vbi_buf, p,
			vbioutp, len);
	} else {		} else {
	/* Some of this frame is VBI data and some is		/* Some of this frame is VBI data and some is
	video data */		video data */
	int vbi_data_len = vbi_size - dev->vbi_read;		int vbi_data_len = vbi_size - dev->vbi_read;
	dev->vbi_read += vbi_data_len;		dev->vbi_read += vbi_data_len;
			em28xx_copy_vbi(dev, vbi_dma_q, vbi_buf, p,
			vbioutp, vbi_data_len);
	dev->capture_type = 1;		dev->capture_type = 1;
	p += vbi_data_len;		p += vbi_data_len;
	len -= vbi_data_len;		len -= vbi_data_len;
	@@ -570,8 +706,8 @@ static void free_buffer(struct videobuf_queue vq, struct em28xx_buffer buf)
	VIDEOBUF_ACTIVE, it won't be, though.		VIDEOBUF_ACTIVE, it won't be, though.
	*/		*/
	spin_lock_irqsave(&dev->slock, flags);		spin_lock_irqsave(&dev->slock, flags);
	if (dev->isoc_ctl.buf == buf)		if (dev->isoc_ctl.vid_buf == buf)
	dev->isoc_ctl.buf = NULL;		dev->isoc_ctl.vid_buf = NULL;
	spin_unlock_irqrestore(&dev->slock, flags);		spin_unlock_irqrestore(&dev->slock, flags);

	videobuf_vmalloc_free(&buf->vb);		videobuf_vmalloc_free(&buf->vb);
	@@ -1542,8 +1678,12 @@ static int vidioc_streamon(struct file file, void priv,
	mutex_lock(&dev->lock);		mutex_lock(&dev->lock);
	rc = res_get(fh);		rc = res_get(fh);

	if (likely(rc >= 0))		if (likely(rc >= 0)) {
			if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
	rc = videobuf_streamon(&fh->vb_vidq);		rc = videobuf_streamon(&fh->vb_vidq);
			else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE)
			rc = videobuf_streamon(&fh->vb_vbiq);
			}

	mutex_unlock(&dev->lock);		mutex_unlock(&dev->lock);

	@@ -1561,14 +1701,19 @@ static int vidioc_streamoff(struct file file, void priv,
	if (rc < 0)		if (rc < 0)
	return rc;		return rc;

	if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)		if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
			fh->type != V4L2_BUF_TYPE_VBI_CAPTURE)
	return -EINVAL;		return -EINVAL;
	if (type != fh->type)		if (type != fh->type)
	return -EINVAL;		return -EINVAL;

	mutex_lock(&dev->lock);		mutex_lock(&dev->lock);

			if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
	videobuf_streamoff(&fh->vb_vidq);		videobuf_streamoff(&fh->vb_vidq);
			else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE)
			videobuf_streamoff(&fh->vb_vbiq);

	res_free(fh);		res_free(fh);

	mutex_unlock(&dev->lock);		mutex_unlock(&dev->lock);
	@@ -1589,6 +1734,7 @@ static int vidioc_querycap(struct file file, void priv,
	cap->version = EM28XX_VERSION_CODE;		cap->version = EM28XX_VERSION_CODE;

	cap->capabilities =		cap->capabilities =
			V4L2_CAP_VBI_CAPTURE \|
	V4L2_CAP_SLICED_VBI_CAPTURE \|		V4L2_CAP_SLICED_VBI_CAPTURE \|
	V4L2_CAP_VIDEO_CAPTURE \|		V4L2_CAP_VIDEO_CAPTURE \|
	V4L2_CAP_READWRITE \| V4L2_CAP_STREAMING;		V4L2_CAP_READWRITE \| V4L2_CAP_STREAMING;
	@@ -1660,6 +1806,45 @@ static int vidioc_try_set_sliced_vbi_cap(struct file file, void priv,
	return 0;		return 0;
	}		}

			/* RAW VBI ioctls */

			static int vidioc_g_fmt_vbi_cap(struct file file, void priv,
			struct v4l2_format *format)
			{
			format->fmt.vbi.samples_per_line = 720;
			format->fmt.vbi.sample_format = V4L2_PIX_FMT_GREY;
			format->fmt.vbi.offset = 0;
			format->fmt.vbi.flags = 0;

			/* Varies by video standard (NTSC, PAL, etc.) */
			/* FIXME: hard-coded for NTSC support */
			format->fmt.vbi.sampling_rate = 6750000 * 4 / 2; /* FIXME: ??? */
			format->fmt.vbi.count[0] = 12;
			format->fmt.vbi.count[1] = 12;
			format->fmt.vbi.start[0] = 10;
			format->fmt.vbi.start[1] = 273;

			return 0;
			}

			static int vidioc_s_fmt_vbi_cap(struct file file, void priv,
			struct v4l2_format *format)
			{
			format->fmt.vbi.samples_per_line = 720;
			format->fmt.vbi.sample_format = V4L2_PIX_FMT_GREY;
			format->fmt.vbi.offset = 0;
			format->fmt.vbi.flags = 0;

			/* Varies by video standard (NTSC, PAL, etc.) */
			/* FIXME: hard-coded for NTSC support */
			format->fmt.vbi.sampling_rate = 6750000 * 4 / 2; /* FIXME: ??? */
			format->fmt.vbi.count[0] = 12;
			format->fmt.vbi.count[1] = 12;
			format->fmt.vbi.start[0] = 10;
			format->fmt.vbi.start[1] = 273;

			return 0;
			}

	static int vidioc_reqbufs(struct file file, void priv,		static int vidioc_reqbufs(struct file file, void priv,
	struct v4l2_requestbuffers *rb)		struct v4l2_requestbuffers *rb)
	@@ -1672,7 +1857,10 @@ static int vidioc_reqbufs(struct file file, void priv,
	if (rc < 0)		if (rc < 0)
	return rc;		return rc;

			if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
	return videobuf_reqbufs(&fh->vb_vidq, rb);		return videobuf_reqbufs(&fh->vb_vidq, rb);
			else
			return videobuf_reqbufs(&fh->vb_vbiq, rb);
	}		}

	static int vidioc_querybuf(struct file file, void priv,		static int vidioc_querybuf(struct file file, void priv,
	@@ -1686,7 +1874,18 @@ static int vidioc_querybuf(struct file file, void priv,
	if (rc < 0)		if (rc < 0)
	return rc;		return rc;

			if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
	return videobuf_querybuf(&fh->vb_vidq, b);		return videobuf_querybuf(&fh->vb_vidq, b);
			else {
			/* FIXME: I'm not sure yet whether this is a bug in zvbi or
			the videobuf framework, but we probably shouldn't be
			returning a buffer larger than that which was asked for.
			At a minimum, it causes a crash in zvbi since it does
			a memcpy based on the source buffer length */
			int result = videobuf_querybuf(&fh->vb_vbiq, b);
			b->length = 17280;
			return result;
			}
	}		}

	static int vidioc_qbuf(struct file file, void priv, struct v4l2_buffer *b)		static int vidioc_qbuf(struct file file, void priv, struct v4l2_buffer *b)
	@@ -1699,7 +1898,11 @@ static int vidioc_qbuf(struct file file, void priv, struct v4l2_buffer *b)
	if (rc < 0)		if (rc < 0)
	return rc;		return rc;

			if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
	return videobuf_qbuf(&fh->vb_vidq, b);		return videobuf_qbuf(&fh->vb_vidq, b);
			else {
			return videobuf_qbuf(&fh->vb_vbiq, b);
			}
	}		}

	static int vidioc_dqbuf(struct file file, void priv, struct v4l2_buffer *b)		static int vidioc_dqbuf(struct file file, void priv, struct v4l2_buffer *b)
	@@ -1712,7 +1915,12 @@ static int vidioc_dqbuf(struct file file, void priv, struct v4l2_buffer *b)
	if (rc < 0)		if (rc < 0)
	return rc;		return rc;

	return videobuf_dqbuf(&fh->vb_vidq, b, file->f_flags & O_NONBLOCK);		if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
			return videobuf_dqbuf(&fh->vb_vidq, b, file->f_flags &
			O_NONBLOCK);
			else
			return videobuf_dqbuf(&fh->vb_vbiq, b, file->f_flags &
			O_NONBLOCK);
	}		}

	#ifdef CONFIG_VIDEO_V4L1_COMPAT		#ifdef CONFIG_VIDEO_V4L1_COMPAT
	@@ -1720,7 +1928,10 @@ static int vidiocgmbuf(struct file file, void priv, struct video_mbuf *mbuf)
	{		{
	struct em28xx_fh *fh = priv;		struct em28xx_fh *fh = priv;

			if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
	return videobuf_cgmbuf(&fh->vb_vidq, mbuf, 8);		return videobuf_cgmbuf(&fh->vb_vidq, mbuf, 8);
			else
			return videobuf_cgmbuf(&fh->vb_vbiq, mbuf, 8);
	}		}
	#endif		#endif

	@@ -1884,10 +2095,18 @@ static int em28xx_v4l2_open(struct file *filp)
	else		else
	field = V4L2_FIELD_INTERLACED;		field = V4L2_FIELD_INTERLACED;

			if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
	videobuf_queue_vmalloc_init(&fh->vb_vidq, &em28xx_video_qops,		videobuf_queue_vmalloc_init(&fh->vb_vidq, &em28xx_video_qops,
	NULL, &dev->slock, fh->type, field,		NULL, &dev->slock, fh->type, field,
	sizeof(struct em28xx_buffer), fh);		sizeof(struct em28xx_buffer), fh);

			if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE)
			videobuf_queue_vmalloc_init(&fh->vb_vbiq, &em28xx_vbi_qops,
			NULL, &dev->slock,
			V4L2_BUF_TYPE_VBI_CAPTURE,
			V4L2_FIELD_SEQ_TB,
			sizeof(struct em28xx_buffer), fh);

	mutex_unlock(&dev->lock);		mutex_unlock(&dev->lock);

	return errCode;		return errCode;
	@@ -1948,7 +2167,7 @@ static int em28xx_v4l2_close(struct file *filp)
	if (res_check(fh))		if (res_check(fh))
	res_free(fh);		res_free(fh);

	if (dev->users == 1) {		if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE && dev->users == 1) {
	videobuf_stop(&fh->vb_vidq);		videobuf_stop(&fh->vb_vidq);
	videobuf_mmap_free(&fh->vb_vidq);		videobuf_mmap_free(&fh->vb_vidq);

	@@ -1977,6 +2196,12 @@ static int em28xx_v4l2_close(struct file *filp)
	"0 (error=%i)\n", errCode);		"0 (error=%i)\n", errCode);
	}		}
	}		}

			if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE) {
			videobuf_stop(&fh->vb_vbiq);
			videobuf_mmap_free(&fh->vb_vbiq);
			}

	kfree(fh);		kfree(fh);
	dev->users--;		dev->users--;
	wake_up_interruptible_nr(&dev->open, 1);		wake_up_interruptible_nr(&dev->open, 1);
	@@ -2015,6 +2240,17 @@ em28xx_v4l2_read(struct file filp, char __user buf, size_t count,
	return videobuf_read_stream(&fh->vb_vidq, buf, count, pos, 0,		return videobuf_read_stream(&fh->vb_vidq, buf, count, pos, 0,
	filp->f_flags & O_NONBLOCK);		filp->f_flags & O_NONBLOCK);
	}		}


			if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE) {
			mutex_lock(&dev->lock);
			rc = res_get(fh);
			mutex_unlock(&dev->lock);

			return videobuf_read_stream(&fh->vb_vbiq, buf, count, pos, 0,
			filp->f_flags & O_NONBLOCK);
			}

	return 0;		return 0;
	}		}

	@@ -2039,10 +2275,12 @@ static unsigned int em28xx_v4l2_poll(struct file filp, poll_table wait)
	if (unlikely(rc < 0))		if (unlikely(rc < 0))
	return POLLERR;		return POLLERR;

	if (V4L2_BUF_TYPE_VIDEO_CAPTURE != fh->type)		if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
	return POLLERR;

	return videobuf_poll_stream(filp, &fh->vb_vidq, wait);		return videobuf_poll_stream(filp, &fh->vb_vidq, wait);
			else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE)
			return videobuf_poll_stream(filp, &fh->vb_vbiq, wait);
			else
			return POLLERR;
	}		}

	/*		/*
	@@ -2091,6 +2329,8 @@ static const struct v4l2_ioctl_ops video_ioctl_ops = {
	.vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,		.vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
	.vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,		.vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
	.vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,		.vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
			.vidioc_g_fmt_vbi_cap = vidioc_g_fmt_vbi_cap,
			.vidioc_s_fmt_vbi_cap = vidioc_s_fmt_vbi_cap,
	.vidioc_g_audio = vidioc_g_audio,		.vidioc_g_audio = vidioc_g_audio,
	.vidioc_s_audio = vidioc_s_audio,		.vidioc_s_audio = vidioc_s_audio,
	.vidioc_cropcap = vidioc_cropcap,		.vidioc_cropcap = vidioc_cropcap,
	@@ -2136,7 +2376,9 @@ static const struct video_device em28xx_video_template = {
	.minor = -1,		.minor = -1,

	.tvnorms = V4L2_STD_ALL,		.tvnorms = V4L2_STD_ALL,
	.current_norm = V4L2_STD_PAL,		/* FIXME: we need this to be NTSC for VBI to work - it should
			be moved to a per-board definition */
			.current_norm = V4L2_STD_NTSC,
	};		};

	static const struct v4l2_file_operations radio_fops = {		static const struct v4l2_file_operations radio_fops = {