[PATCH 1/7] Adding empia base driver

[Markus Rechberger]

    em2880-dvb:
    * supporting the digital part of Empia based devices, which
includes ATSC, ISDB-T and DVB-T

    em28xx-aad.c:
    * alternative audio driver, can be used instead of em28xx-audio if
alsa is not available
    or not compiled into the kernel, it provides a raw interface to
the PCM samples

    em28xx-audio.c:
    * em28xx alsa driver and audio driver for FM radio

    em28xx-audioep.c:
    * em28xx alsa driver for devices which are set to vendor specific
audio on interface 1,
    in that case snd-usb-audio will not attach to the interface and
em28xx-audioep will be needed

    em28xx-cards.c:
    * card definition and initial setup of devices.

    em28xx-core.c:
    * core videohandling and VBI frame slicing

    em28xx-i2c.c:
    * i2c setup and GPIO setup handling of the devices (including
em2888 based ones)

    em28xx-input.c:
    * currently mostly disabled since the linuxtv input handling is
broken by design and racy

    em28xx-keymaps.c:
    * keymap references of some remotes (could be merged into
ir-common, although as mentioned
    this should be in userland done by lirc).

    em28xx-video.c:
    * inode handling for analog TV, radio and VBI, also some device probing

    em28xx-webcam.c:
    * videology webcam specific i2c commands
commit a18816f6b91629eb6038aed4815e4fb94ddc0a6b
Author: Markus Rechberger <mrechberger@xxxxxxxxxx>
Date:   Wed Oct 22 21:56:45 2008 +0200

    Adding empia base driver
    
    em2880-dvb:
    * supporting the digital part of Empia based devices, which includes ATSC, ISDB-T and DVB-T
    
    em28xx-aad.c:
    * alternative audio driver, can be used instead of em28xx-audio if alsa is not available
    or not compiled into the kernel, it provides a raw interface to the PCM samples
    
    em28xx-audio.c:
    * em28xx alsa driver and audio driver for FM radio
    
    em28xx-audioep.c:
    * em28xx alsa driver for devices which are set to vendor specific audio on interface 1,
    in that case snd-usb-audio will not attach to the interface and em28xx-audioep will be needed
    
    em28xx-cards.c:
    * card definition and initial setup of devices.
    
    em28xx-core.c:
    * core videohandling and VBI frame slicing
    
    em28xx-i2c.c:
    * i2c setup and GPIO setup handling of the devices (including em2888 based ones)
    
    em28xx-input.c:
    * currently mostly disabled since the linuxtv input handling is broken by design and racy
    
    em28xx-keymaps.c:
    * keymap references of some remotes (could be merged into ir-common, although as mentioned
    this should be in userland done by lirc).
    
    em28xx-video.c:
    * inode handling for analog TV, radio and VBI, also some device probing
    
    em28xx-webcam.c:
    * videology webcam specific i2c commands

Signed-off-by: Markus Rechberger <mrechberger@xxxxxxxxxx>

diff --git a/drivers/media/video/Kconfig b/drivers/media/video/Kconfig
index 47102c2..a726c59 100644
--- a/drivers/media/video/Kconfig
+++ b/drivers/media/video/Kconfig
@@ -783,6 +783,8 @@ source "drivers/media/video/pvrusb2/Kconfig"
 
 source "drivers/media/video/em28xx/Kconfig"
 
+source "drivers/media/video/empia/Kconfig"
+
 source "drivers/media/video/usbvision/Kconfig"
 
 source "drivers/media/video/usbvideo/Kconfig"
diff --git a/drivers/media/video/Makefile b/drivers/media/video/Makefile
index 16962f3..9357368 100644
--- a/drivers/media/video/Makefile
+++ b/drivers/media/video/Makefile
@@ -64,6 +64,7 @@ obj-$(CONFIG_VIDEO_MEYE) += meye.o
 obj-$(CONFIG_VIDEO_SAA7134) += saa7134/
 obj-$(CONFIG_VIDEO_CX88) += cx88/
 obj-$(CONFIG_VIDEO_EM28XX) += em28xx/
+obj-$(CONFIG_VIDEO_EMPIA) += empia/
 obj-$(CONFIG_VIDEO_USBVISION) += usbvision/
 obj-$(CONFIG_VIDEO_TVP5150) += tvp5150.o
 obj-$(CONFIG_VIDEO_PVRUSB2) += pvrusb2/
diff --git a/drivers/media/video/empia/Kconfig b/drivers/media/video/empia/Kconfig
new file mode 100644
index 0000000..6bd0ac3
--- /dev/null
+++ b/drivers/media/video/empia/Kconfig
@@ -0,0 +1,61 @@
+config VIDEO_EMPIA
+	tristate "Empia EM28xx USB video capture support"
+	depends on VIDEO_DEV && I2C
+	select VIDEO_BUF
+	select VIDEO_TUNER
+	select VIDEO_SAA711X if VIDEO_HELPER_CHIPS_AUTO
+	select VIDEO_TVP5150 if VIDEO_HELPER_CHIPS_AUTO
+	---help---
+	  This em28xx driver has been worked on since 2006 and constantly
+	  improved to support the latest available devices including
+	  different TV standards as well as VBI.
+
+	  the difference between this and the other em28xx driver is that
+	  it's well tested and supports more devices.
+
+config VIDEO_EMPIA_DTV
+	tristate "Empia EM288x/EM275x DVB-T support"
+	depends on VIDEO_EMPIA && DVB_CORE
+	select FW_LOADER
+	select DVB_TUNER_MT2060
+	select DVB_TUNER_QT1010
+	select DVB_LGDT3304
+	select DVB_MT352 if !DVB_FE_CUSTOMISE
+	select DVB_ZL10353 if !DVB_FE_CUSTOMISE
+	select DVB_LGDT330X if !DVB_FE_CUSTOMISE
+	select DVB_LGDT3304 if !DVB_FE_CUSTOMISE
+	---help---
+	  Support for Empia em288x/em2870 DVB-T/ATSC and ISDB-T extension
+
+	  If unsure say N.
+
+config VIDEO_EMPIA_AUDIO
+	tristate "Empia EM28xx USB Audio support"
+	depends on VIDEO_EMPIA
+	---help---
+	  This is an audio driver for Em28x[1/2] based usb video devices,
+	  this will be used by Hauppauge HVR 900 for analogue TV
+	  instead of snd-usb-audio.
+
+	  To compile this driver as a module, choose M here: the
+	  module will be called em28xx
+
+config VIDEO_EMPIA_AUDIOEP
+	tristate "Empia EM28xx USB Audio support (second configuration)"
+	depends on VIDEO_EMPIA
+	---help---
+	  This is another audiodriver for em28xx based devices which have
+	  a vendor specific audio interface on interface 1.
+
+	  choose yes if unsure, the driver will only attach if your
+	  Empia device has such a configuration
+
+config VIDEO_EMPIA_AAD_AUDIO
+	tristate "Empia EM28xx USB Audio support (not alsa compatible)"
+	depends on VIDEO_EMPIA
+	---help---
+	  This driver adds vendor specific audio support to em28xx based devices
+	  It can be used as an alternative if alsa is not available or enabled
+	  in the kernel (eg. to support audio with OSS).
+
+	  choose no if unsure
diff --git a/drivers/media/video/empia/Makefile b/drivers/media/video/empia/Makefile
new file mode 100644
index 0000000..9ee2376
--- /dev/null
+++ b/drivers/media/video/empia/Makefile
@@ -0,0 +1,19 @@
+em28xx-objs     := em28xx-video.o em28xx-i2c.o em28xx-cards.o em28xx-core.o \
+		   em28xx-input.o em28xx-webcam.o em28xx-keymaps.o
+
+em28xx-dvb-objs   := em2880-dvb.o 
+
+obj-$(CONFIG_VIDEO_EMPIA) += em28xx.o
+obj-$(CONFIG_VIDEO_EMPIA_AUDIO) += em28xx-audio.o
+obj-$(CONFIG_VIDEO_EMPIA_AUDIOEP) += em28xx-audioep.o
+obj-$(CONFIG_VIDEO_EMPIA_AAD_AUDIO) += em28xx-aad.o
+obj-$(CONFIG_VIDEO_EMPIA_DTV) += em28xx-dvb.o
+obj-$(CONFIG_VIDEO_EMPIA) += cx25843/
+obj-$(CONFIG_VIDEO_EMPIA_DTV) += lgdt3304/
+obj-$(CONFIG_VIDEO_EMPIA) += xc3028/
+obj-$(CONFIG_VIDEO_EMPIA) += xc5000/
+
+EXTRA_CFLAGS += -Idrivers/media/video
+EXTRA_CFLAGS += -Idrivers/media/dvb/dvb-core
+EXTRA_CFLAGS += -Idrivers/media/dvb/frontends
+EXTRA_CFLAGS += -Idrivers/media/common/tuners
diff --git a/drivers/media/video/empia/em2880-dvb.c b/drivers/media/video/empia/em2880-dvb.c
new file mode 100644
index 0000000..bd38018
--- /dev/null
+++ b/drivers/media/video/empia/em2880-dvb.c
@@ -0,0 +1,1139 @@
+/*
+ *  Empiatech em2880 DVB-T extension
+ *
+ *  Copyright (C) 2006/2007/2008 Markus Rechberger <mrechberger@xxxxxxxxxx>
+ *
+ *  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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/init.h>
+#include <linux/list.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/slab.h>
+#include <linux/delay.h>
+#include <linux/kthread.h>
+#include <linux/suspend.h>
+#include <linux/dvb/frontend.h>
+#include <linux/usb.h>
+#include <linux/version.h>
+
+#include "em28xx.h"
+
+#include <media/tuner.h>
+#include <media/v4l2-common.h>
+#include "dvb_frontend.h"
+
+#include "zl10353.h"
+#include "mt352.h"
+#include "xc5000/xc5000_control.h"
+#ifdef MICRONAS_DRX3975D
+#include "drx3973d/drx3973d_demod.h"
+#endif
+#include "lgdt3304/lgdt3304.h"
+#include "qt1010.h"
+#include "mt2060.h"
+#ifdef ADIMTV102
+#include "adimtv102/adimtv102.h"
+#endif
+
+#include "lgdt330x.h"
+#include "sharp/s921_module.h"
+
+#define EM2880_DVB_NUM_PACKETS 64
+#define EM2880_URB_COUNT 32
+
+#if defined DVB_DEFINE_MOD_OPT_ADAPTER_NR
+DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
+#endif
+
+
+#define xc3028_offset_8mhz 2750000;
+#define xc3028_offset_7mhz 2250000;
+#define xc3028_offset_6mhz 2750000;
+#define xc3028_offset_atsc 1750000;
+
+
+MODULE_DESCRIPTION("Empiatech em2880 DVB-T extension");
+MODULE_AUTHOR("Markus Rechberger <mrechberger@xxxxxxxxx>");
+MODULE_LICENSE("GPL");
+
+#ifdef MICRONAS_DRX3975D
+DRX3973DData_t DRX3973DData_g = {
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	DRX_UIO_MODE_DISABLE,
+	DRX_UIO_MODE_DISABLE,
+	{
+		DRX3973D_AGC_CTRL_AUTO,
+		0,
+		0,
+		0,
+		0,
+		0
+	},
+	{
+		DRX3973D_AGC_CTRL_AUTO,
+		0,
+		0,
+		0,
+		0,
+		0
+	},
+	DRX3973D_IFFILTER_SAW,
+	FALSE,
+	DRX_BANDWIDTH_8MHZ,
+	FALSE,
+	DRX3973D_APPENV_PORTABLE,
+	TRUE,
+	FALSE,
+#ifndef _CH_
+	{
+		"01234567890",
+		"01234567890"
+	},
+	{
+		{
+			DRX_MODULE_UNKNOWN,
+			(char *)(NULL),
+			0,
+			0,
+			0,
+			(char *)(NULL)
+		},
+		{
+			DRX_MODULE_UNKNOWN,
+			(char *)(NULL),
+			0,
+			0,
+			0,
+			(char *)(NULL)
+		}
+	},
+	{
+		{
+			(pDRXVersion_t)(NULL),
+			(pDRXVersionList_t)(NULL)
+		},
+		{
+			(pDRXVersion_t)(NULL),
+			(pDRXVersionList_t)(NULL)
+		}
+	},
+	DRX3973D_SPIN_UNKNOWN,
+	{
+	},
+	FALSE,
+
+#if (DRXD_TYPE_B)
+	DRX3973D_I2C_INIT_ASEL
+#endif
+
+
+
+#endif
+};
+
+/**
+ * \var DRX3973DDefaultAddr_g
+ * \brief Default I2C address and device identifier.
+ */
+I2CDeviceAddr_t DRX3973DDefaultAddr_g = {
+#define DRX3973D_DEF_I2C_ADDR (0xe0)>>1
+	DRX3973D_DEF_I2C_ADDR,     /* i2c address */
+#define DRX3973D_DEF_DEMOD_DEV_ID   (1)
+	DRX3973D_DEF_DEMOD_DEV_ID,  /* device id */
+	NULL       /* private data structure */
+};
+
+/**
+ * \var DRX3973DDefaultCommAttr_g
+ * \brief Default common attributes of a drx3973d demodulator instance.
+ */
+DRXCommonAttr_t DRX3973DDefaultCommAttr_g = {
+	(pu8_t)NULL,
+	0,
+	TRUE,
+	4560,
+	48000L,
+	12000L,
+	0L,
+	FALSE,
+	TRUE,
+	TRUE,
+	TRUE,
+	FALSE,
+	FALSE,
+	FALSE,
+	FALSE,
+	FALSE,
+	FALSE,
+	32000000UL,
+	FALSE,
+	(pDRXScanParam_t)(NULL),
+	0,
+	0,
+	FALSE,
+	0L,
+	0L,
+	100,
+	DRX_LOCKED,
+	FALSE,
+	DRX_POWER_DOWN,
+	1,
+	0L,
+	0L
+};
+
+#endif
+
+static unsigned int debug;
+module_param(debug, int, 0644);
+MODULE_PARM_DESC(debug, "em2880-dvb debug level (default off)");
+
+#define dprintk(lvl, fmt, args...) if (debug >= lvl) do {\
+	printk(fmt, ##args); } while (0)
+
+
+static int em2880_set_alternate(struct em2880_dvb *dvb_dev);
+
+/* ------------------------------------------------------------------ */
+
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 19)
+static void em2880_complete_irq(struct urb *urb, struct pt_regs *ptregs)
+{
+#else
+static void em2880_complete_irq(struct urb *urb)
+{
+#endif
+	struct em2880_dvb *dvb_dev = urb->context;
+	int i;
+	int status;
+
+	if (dvb_dev == NULL) {
+		dprintk(1, "em2880-dev.c: device not valid!\n");
+		return;
+	}
+
+	if (debug && urb->status < 0) {
+		printk(KERN_ERR"%s:%u:%s(): status = %i\n", __FILE__,
+				__LINE__, __func__, urb->status);
+	}
+
+	switch (urb->status) {
+		case -ESHUTDOWN:
+			return;
+			break;
+	}
+
+	if (urb->status == -ENOENT)
+		return;
+
+	for (i = 0; i < urb->number_of_packets; i++) {
+		if (urb->iso_frame_desc[i].status != 0) {
+			dprintk(1, "em2880-dvb.c: status != 0\n");
+			continue;
+		} else if (urb->iso_frame_desc[i].actual_length > 0)
+			dvb_dmx_swfilter(&dvb_dev->demux,
+					urb->transfer_buffer +
+					urb->iso_frame_desc[i].offset,
+					urb->iso_frame_desc[i]
+					.actual_length);
+	}
+
+	status = usb_submit_urb(urb, GFP_ATOMIC);
+	if (status)
+		dprintk(1, "resubmitting urb failed!\n");
+}
+
+static void em2880_stop_stream(struct em2880_dvb *dvb_dev)
+{
+	int i;
+	int arg;
+	for (i = 0; i < EM2880_DVB_NUM_BUFS; i++) {
+		if (dvb_dev->urb[i]) {
+			usb_kill_urb(dvb_dev->urb[i]);
+			if (dvb_dev->transfer_buffer[i]) {
+				usb_buffer_free(dvb_dev->udev,
+						(EM2880_DVB_NUM_PACKETS *
+						 dvb_dev->dtv_packetsize),
+						dvb_dev->transfer_buffer[i],
+						dvb_dev->urb[i]->transfer_dma);
+			}
+			usb_free_urb(dvb_dev->urb[i]);
+		}
+		dvb_dev->urb[i] = NULL;
+		dvb_dev->transfer_buffer[i] = NULL;
+	}
+	arg=EM28XX_REG_OFF;
+	dvb_dev->em28xx_dev->em28xx_gpio_control(dvb_dev->em28xx_dev, EM28XX_LED1_ON, &arg);
+
+}
+
+static int em2880_start_stream(struct em2880_dvb *dvb_dev)
+{
+	int i, errCode;
+	int arg;
+	const int sb_size = EM2880_DVB_NUM_PACKETS * dvb_dev->dtv_packetsize;
+
+	dprintk(1, "em2880-dvb.c: got start stream request %s\n", __func__);
+	arg=EM28XX_REG_ON;
+	dvb_dev->em28xx_dev->em28xx_gpio_control(dvb_dev->em28xx_dev, EM28XX_LED1_ON, &arg);
+
+	em2880_set_alternate(dvb_dev);
+
+	/* allocate urbs */
+
+	for (i = 0; i < EM2880_DVB_NUM_BUFS; i++) {
+		struct urb *urb;
+		int j, k;
+		/* allocate transfer buffer */
+		urb = usb_alloc_urb(EM2880_DVB_NUM_PACKETS, GFP_KERNEL);
+		if (!urb) {
+			dprintk(1, "cannot alloc urb %i\n", i);
+			return -ENOMEM;
+		}
+		dvb_dev->transfer_buffer[i] =
+			usb_buffer_alloc(dvb_dev->udev, sb_size,
+					GFP_KERNEL, &urb->transfer_dma);
+
+		if (!dvb_dev->transfer_buffer[i]) {
+			dprintk(1, "unable to allocate %i bytes for transfer"
+				   "buffer %i\n", sb_size, i);
+
+			return -ENOMEM;
+		}
+		memset(dvb_dev->transfer_buffer[i], 0, sb_size);
+		urb->dev = dvb_dev->udev;
+		urb->context = dvb_dev;
+		urb->pipe = usb_rcvisocpipe(dvb_dev->udev, 0x84);
+		urb->transfer_flags = URB_ISO_ASAP;
+		urb->interval = 1;
+		urb->transfer_buffer = dvb_dev->transfer_buffer[i];
+		urb->complete = em2880_complete_irq;
+		urb->number_of_packets = EM2880_DVB_NUM_PACKETS;
+		urb->transfer_buffer_length = sb_size;
+		for (j = k = 0; j < EM2880_DVB_NUM_PACKETS;
+				j++, k += dvb_dev->dtv_packetsize) {
+			urb->iso_frame_desc[j].offset = k;
+			urb->iso_frame_desc[j].length =
+				dvb_dev->dtv_packetsize;
+		}
+		dvb_dev->urb[i] = urb;
+	}
+
+	/* submit urbs */
+	for (i = 0; i < EM2880_DVB_NUM_BUFS; i++) {
+		errCode = usb_submit_urb(dvb_dev->urb[i], GFP_KERNEL);
+		if (errCode) {
+			dprintk(1, "submit of urb %i failed (error=%i)\n",
+					i,
+					errCode);
+			return errCode;
+		}
+	}
+	return 0;
+}
+
+static int em2880_set_alternate(struct em2880_dvb *dvb_dev)
+{
+	int errCode;
+	errCode = usb_set_interface(dvb_dev->udev, dvb_dev->em28xx_dev->usb_interface, 1);
+
+	return errCode;
+}
+
+static int em2880_start_feed(struct dvb_demux_feed *dvbdmxfeed)
+{
+	struct dvb_demux *demux = dvbdmxfeed->demux;
+	struct em2880_dvb *dvb_dev = demux->priv;
+	dprintk(1, "em2880-dvb.c: got start feed request %s\n", __func__);
+
+	if (mutex_lock_interruptible(&dvb_dev->sem))
+		return -ERESTARTSYS;
+
+	if (dvb_dev->streaming == 0)
+		em2880_start_stream(dvb_dev);
+
+	dvb_dev->streaming++;
+	mutex_unlock(&dvb_dev->sem);
+	return 0;
+}
+
+static int em2880_stop_feed(struct dvb_demux_feed *dvbdmxfeed)
+{
+	struct dvb_demux *demux = dvbdmxfeed->demux;
+	struct em2880_dvb *dvb_dev = demux->priv;
+
+	dprintk(1, "em2880-dvb.c: got stop feed request %s\n", __func__);
+
+	if (mutex_lock_interruptible(&dvb_dev->sem))
+		return -ERESTARTSYS;
+	if (0 == --dvb_dev->streaming)
+		em2880_stop_stream(dvb_dev);
+	mutex_unlock(&dvb_dev->sem);
+	return 0;
+}
+
+static int em28xx_ts_bus_ctrl_int(struct em28xx *dev, int acquire)
+{
+	u8 gpio;
+	gpio = dev->em28xx_read_reg(dev, 04);
+	gpio &= ~((u8)0x3);
+
+	if (acquire == 1)
+		gpio |= 1;
+
+	return dev->em28xx_write_regs(dev, 0x04, &gpio, 1);
+}
+
+static int em28xx_ts_bus_ctrl(struct dvb_frontend *fe, int acquire)
+{
+	struct em28xx *dev = fe->dvb->priv;
+	return dev->em28xx_acquire(dev, EM28XX_DVBT, acquire);
+}
+
+static struct zl10353_config em2880_zl10353_dev = {
+	.demod_address = (0x1e >> 1),
+	.no_tuner = 1,
+	.parallel_ts = 1,
+	.if2 = 45600
+};
+
+struct bcode {
+	int reg;
+	char *txt;
+	int len;
+	int delay;
+};
+
+
+static int mt352_pinnacle_init(struct dvb_frontend *fe)
+{
+	int i;
+	struct bcode zlconf[]={
+			{0x1e,"\x8a\x2c",2,0},
+			{0x1e,"\x89\x38",2,0},
+			{0x1e,"\x50\x80",2,0},
+			{0x1e,"\x8e\x40",2,0},
+			{0x1e,"\x69\x00",2,0},
+			{0x1e,"\x6a\xff",2,0},
+			{0x1e,"\x6b\xff",2,0},
+			{0x1e,"\x6c\x00",2,0},
+			{0x1e,"\x6d\xff",2,0},
+			{0x1e,"\x6e\x00",2,0},
+			{0x1e,"\x6f\x40",2,0},
+			{0x1e,"\x70\x40",2,0},
+			{0x1e,"\x68\xa0",2,0},
+
+			{0x1e,"\x56\x31",2,0}, // set input frequency
+			{0x1e,"\x57\xb8",2,0},
+			{0x1e,"\x75\x33",2,0},
+
+			{0x1e,"\x7c\x00",2,0},
+			{0x1e,"\x7d\x4d",2,0},
+			{0x1e,"\xb5\x7a",2,0},
+			{0x1e,"\x51\x40",2,0},
+			{0x1e,"\x52\x80",2,0},
+			{0x1e,"\x53\x50",2,0},
+			{0x1e,"\x5d\x01",2,0},
+			{}
+	};
+	for(i=0;zlconf[i].txt;i++)
+		fe->ops.write(fe, zlconf[i].txt,zlconf[i].len);
+	return 0;
+}
+
+
+static struct mt352_config em2880_mt352_dev = {
+	.demod_address = (0x1e >> 1),
+	.no_tuner = 1,
+	//.parallel_ts = 1,
+	.if2 = 45600,
+	.demod_init = mt352_pinnacle_init,
+};
+
+
+static struct zl10353_config em2880_zl10353_pinnacle = {
+	.demod_address = (0x1e >> 1),
+	.no_tuner = 1,
+	.parallel_ts = 1,
+};
+
+static struct zl10353_config em2880_kworld_355u_dev = {
+	.demod_address = (0x1e >> 1),
+	.no_tuner = 1,
+	.parallel_ts = 1,
+};
+
+static struct lgdt330x_config em2880_lgdt3303_dev = {
+	.demod_address = 0x0e,
+	.demod_chip = LGDT3303
+};
+
+static struct mt2060_config em2870_mt2060_config = {
+	.i2c_address = 0x60
+};
+
+static struct qt1010_config em2870_qt1010_config = {
+	.i2c_address = 0x62
+};
+
+static int kworld355u_i2c_gate_ctrl(struct dvb_frontend *fe, int enable)
+{
+	struct zl10353_state {
+		struct i2c_adapter *i2c;
+		struct dvb_frontend frontend;
+
+		struct zl10353_config config;
+
+		enum fe_bandwidth bandwidth;
+	};
+	struct zl10353_state *state = fe->demodulator_priv;
+
+	struct em28xx *dev = state->i2c->algo_data;
+
+	return em28xx_ts_bus_ctrl_int(dev, enable);
+}
+
+static struct lgdt3304_config lgdt3304_atsc_config = {
+	.i2c_address = 0x0e
+};
+
+static int em28xx_set_params(struct dvb_frontend *fe,
+		struct dvb_frontend_parameters *params)
+{
+	struct em28xx *dev = fe->dvb->priv;
+	struct em2880_dvb *dvbdev = dev->dvb_dev;
+	int i;
+	unsigned long frequency = params->frequency;
+	struct dvb_ofdm_parameters *op = &params->u.ofdm;
+
+	if (!dev->tuner)
+		return -EINVAL;
+
+	switch (fe->ops.info.type) {
+	case FE_OFDM:
+		if (dev->dvbnorm->bandwidth !=
+				op->bandwidth) {
+			for (i = 0; dev->board->dvbnorms[i].tv_mode || dev->board->dvbnorms[i].index; i++) {
+				if (dev->board->dvbnorms[i].bandwidth == op->bandwidth) {
+					switch (dev->tuner_type) {
+					case TUNER_XCEIVE_XC3028:
+					{
+						struct xc3028_init_cmd cmd;
+						dvbdev->bw_index = i;
+						cmd.new_tv_mode_ptr = dev->board->dvbnorms[i].tv_mode;
+						cmd.new_channel_map_ptr = dev->board->dvbnorms[i].channelmap;
+						dev->dvbnorm = &dev->board->dvbnorms[i];
+						if (dev->tuner->tuner_cmd)
+							dev->tuner->tuner_cmd(dev->tuner, XC3028_INIT_TUNER, &cmd);
+						break;
+					}
+					case TUNER_XCEIVE_XC5000:
+					{
+						struct xc_std_conf cmd;
+						dvbdev->bw_index = i;
+						cmd.index = dev->board->dvbnorms[i].index;
+						dev->dvbnorm = &dev->board->dvbnorms[i];
+						dev->tuner->tuner_cmd(dev->tuner, XC5000_SET_MODE, &cmd);
+						break;
+					}
+					}
+					break;
+				}
+			}
+		}
+
+		if (dev->tuner->set_frequency) {
+			switch (params->u.ofdm.bandwidth) {
+			case BANDWIDTH_AUTO:
+			case BANDWIDTH_8_MHZ:
+				frequency -= xc3028_offset_8mhz;
+				break;
+			case BANDWIDTH_7_MHZ:
+				frequency -= xc3028_offset_7mhz;
+				break;
+			case BANDWIDTH_6_MHZ:
+				frequency -= xc3028_offset_6mhz;
+				break;
+			default:
+				return -EINVAL;
+			}
+			dev->tuner->set_frequency(dev->tuner, frequency);
+			dev->dctl_freq = frequency;
+		}
+		break;
+	case FE_QAM:
+		switch (dev->tuner_type) {
+		case TUNER_XCEIVE_XC3028:
+		{
+			struct xc3028_init_cmd cmd;
+			dvbdev->bw_index = 0;
+			cmd.new_tv_mode_ptr = dev->board->qamnorms[0].tv_mode;
+			cmd.new_channel_map_ptr = dev->board->qamnorms[0].channelmap;
+			dev->qamnorm = &dev->board->qamnorms[0];
+			if (dev->tuner->tuner_cmd)
+				dev->tuner->tuner_cmd(dev->tuner, XC3028_INIT_TUNER, &cmd);
+			break;
+		}
+		case TUNER_XCEIVE_XC5000:
+		{
+			struct xc_std_conf cmd;
+			dvbdev->bw_index = 0;
+			cmd.index = dev->board->atscnorms[0].index;
+			dev->atscnorm = &dev->board->atscnorms[0];
+			dev->tuner->tuner_cmd(dev->tuner, XC5000_SET_MODE, &cmd);
+			break;
+		}
+		}
+		frequency -= xc3028_offset_atsc;
+
+		dev->tuner->set_frequency(dev->tuner, frequency);
+		dev->dctl_freq = frequency;
+		break;
+	case FE_ATSC:
+		switch (dev->tuner_type) {
+		case TUNER_XCEIVE_XC3028:
+		{
+			struct xc3028_init_cmd cmd;
+			dvbdev->bw_index = 0;
+			cmd.new_tv_mode_ptr = dev->board->atscnorms[0].tv_mode;
+			cmd.new_channel_map_ptr = dev->board->atscnorms[0].channelmap;
+			dev->atscnorm = &dev->board->atscnorms[0];
+			if (dev->tuner->tuner_cmd)
+				dev->tuner->tuner_cmd(dev->tuner, XC3028_INIT_TUNER, &cmd);
+			break;
+		}
+		case TUNER_XCEIVE_XC5000:
+		{
+			struct xc_std_conf cmd;
+			dvbdev->bw_index = 0;
+			cmd.index = dev->board->atscnorms[0].index;
+			dev->atscnorm = &dev->board->atscnorms[0];
+			dev->tuner->tuner_cmd(dev->tuner, XC5000_SET_MODE, &cmd);
+			break;
+		}
+		}
+
+		frequency -= xc3028_offset_atsc;
+		dev->tuner->set_frequency(dev->tuner, frequency);
+		dev->dctl_freq = frequency;
+		break;
+	case FE_QPSK:
+		printk(KERN_INFO"FE_QPSK currently not supported\n");
+		break;
+	}
+
+	return 0;
+}
+
+static int em28xx_get_frequency(struct dvb_frontend *fe, u32 *frequency)
+{
+	struct em28xx *dev = fe->dvb->priv;
+	*frequency = dev->dctl_freq;
+	return 0;
+}
+
+static int em28xx_get_bandwidth(struct dvb_frontend *fe, u32 *bandwidth)
+{
+	struct em28xx *dev = fe->dvb->priv;
+	struct em2880_dvb *dvbdev = dev->dvb_dev;
+	*bandwidth = (u32)dev->board->dvbnorms[dvbdev->bw_index].bandwidth;
+	return 0;
+}
+
+static int em28xx_dvb_init(struct dvb_frontend *fe)
+{
+	struct em28xx *dev = fe->dvb->priv;
+	int gpio_arg;
+
+	printk(KERN_INFO"em28xx_dvb_init\n");
+
+	if (dev->mode != V4L2_TUNER_DIGITAL_TV) {
+		printk(KERN_INFO"switching over from %d\n", dev->mode);
+		gpio_arg = EM28XX_REG_OFF;
+		dev->em28xx_gpio_control(dev, EM28XX_ANALOG_ON,    &gpio_arg);
+
+		gpio_arg = EM28XX_REG_ON;
+		dev->em28xx_gpio_control(dev, EM28XX_TS1_ON,       &gpio_arg);
+		dev->em28xx_gpio_control(dev, EM28XX_TUNER1_ON,    &gpio_arg);
+		dev->em28xx_gpio_control(dev, EM28XX_DEMOD1_RESET, NULL);
+		mdelay(100);
+	}
+	dev->mode = V4L2_TUNER_DIGITAL_TV;
+	msleep(100);
+	switch (dev->tuner_type) {
+	case TUNER_XCEIVE_XC3028:
+	{
+		struct xc3028_init_cmd cmd;
+		if (dev->dev_modes & EM28XX_DVBT) {
+			cmd.new_tv_mode_ptr = dev->dvbnorm->tv_mode;
+			cmd.new_channel_map_ptr = dev->dvbnorm->channelmap;
+		} else if (dev->dev_modes & EM28XX_ATSC) {
+			cmd.new_tv_mode_ptr = dev->atscnorm->tv_mode;
+			cmd.new_channel_map_ptr = dev->atscnorm->channelmap;
+		}
+			
+		if (dev->tuner && dev->tuner->tuner_cmd)
+			dev->tuner->tuner_cmd(dev->tuner, XC3028_INIT_TUNER, &cmd);
+		break;
+	}
+	case TUNER_XCEIVE_XC5000:
+	{
+		struct xc_std_conf cmd;
+		if (dev->dev_modes & EM28XX_DVBT) {
+			cmd.index = dev->dvbnorm->index;
+		} else if (dev->dev_modes & EM28XX_ATSC) {
+			cmd.index = dev->atscnorm->index;
+		}
+
+		printk(KERN_INFO"initializing: %d\n", dev->dvbnorm->index);
+		dev->tuner->tuner_cmd(dev->tuner, XC5000_INIT_TUNER, NULL);
+
+		if (dev->tuner && dev->tuner->tuner_cmd)
+			dev->tuner->tuner_cmd(dev->tuner, XC5000_SET_MODE, &cmd);
+	}
+	}
+
+	return 0;
+}
+
+static int em28xx_s921_init(struct dvb_frontend *fe)
+{
+	struct em28xx *dev = fe->dvb->priv;
+	struct em2880_dvb *dvbdev = dev->dvb_dev;
+	switch (dev->em_type) {
+	case EM2875:
+		dev->em28xx_write_regs_req(dev, 0x00, 0x5f, "\x01", 1);
+		break;
+	default:
+		break;
+	}
+	if (dvbdev->init_override)
+		dvbdev->init_override(fe);
+
+	return 0;
+}
+
+static int em28xx_zl10353_init(struct dvb_frontend *fe)
+{
+	struct em28xx *dev = fe->dvb->priv;
+	struct em2880_dvb *dvbdev = dev->dvb_dev;
+
+	int gpio_arg;
+
+//	if (dev->mode != V4L2_TUNER_DIGITAL_TV) {
+		dev->em28xx_write_regs_req(dev, 0x00, 0x48, "\x00", 1);
+		dev->em28xx_write_regs_req(dev, 0x00, 0x12, "\x77", 1);
+
+		gpio_arg = EM28XX_REG_OFF;
+		dev->em28xx_gpio_control(dev, EM28XX_ANALOG_ON,    &gpio_arg);
+		gpio_arg = EM28XX_REG_ON;
+		dev->em28xx_gpio_control(dev, EM28XX_TS1_ON,       &gpio_arg);
+		dev->em28xx_gpio_control(dev, EM28XX_TUNER1_ON,    &gpio_arg);
+		dev->em28xx_gpio_control(dev, EM28XX_DECODER_SLEEP, &gpio_arg);
+		dev->em28xx_gpio_control(dev, EM28XX_DEMOD1_RESET, NULL);
+		mdelay(100);
+//	}
+	dev->mode = V4L2_TUNER_DIGITAL_TV;
+	msleep(100);
+
+	if (dvbdev->init_override)
+		dvbdev->init_override(fe);
+
+	switch (dev->em_type) {
+	case EM2888:
+		dev->em28xx_write_regs_req(dev, 0x00, 0x5f, "\x01", 1);
+		/* TODO move this to zl10353, though keep backward compatibility */
+		dev->em28xx_write_regs_req(dev, 0x02, 0x1e, "\x50\x0b", 2);
+		dev->em28xx_write_regs_req(dev, 0x02, 0x1e, "\x51\x64", 2);
+		break;
+	case EM2875:
+		dev->em28xx_write_regs_req(dev, 0x00, 0x5f, "\x01", 1);
+		break;
+	default:
+		dev->em28xx_write_regs_req(dev, 0x02, 0x1e, "\x50\x0b", 2);
+		dev->em28xx_write_regs_req(dev, 0x02, 0x1e, "\x51\x44", 2);
+		break;
+	}
+	return 0;
+}
+
+
+static int em28xx_zl10353_sleep(struct dvb_frontend *fe)
+{
+	struct em28xx *dev = fe->dvb->priv;
+//	int gpio_arg = EM28XX_REG_OFF;
+	if (dev->mode == V4L2_TUNER_DIGITAL_TV && dev->powersaving) {
+//		dev->em28xx_gpio_control(dev, EM28XX_TS1_ON,       &gpio_arg);
+		printk(KERN_INFO"powered down zl10353\n");
+	}
+	return 0;
+}
+
+
+static int em28xx_dvb_sleep(struct dvb_frontend *fe)
+{
+	struct em28xx *dev = fe->dvb->priv;
+#if 0
+	int gpio_arg;
+#endif
+	if (dev->mode == V4L2_TUNER_DIGITAL_TV && dev->powersaving) {
+//		dev->tuner->shutdown(dev->tuner);
+#if 0
+		gpio_arg = EM28XX_REG_OFF;
+		dev->em28xx_gpio_control(dev, EM28XX_TUNER1_ON,    &gpio_arg);
+		printk(KERN_INFO"powered down xc3028\n");
+#endif
+	}
+	return 0;
+}
+
+#ifdef ADIMTV102
+struct adimtv102_config dmbt_adim_config = {
+	.i2c_address = 0xc2>>1
+};
+
+#endif
+
+struct s921_config sharp_isdbt_config = {
+	.i2c_address = 0x30>>1
+};
+
+static int em2880_dvb_init(struct em28xx *dev)
+{
+	struct em2880_dvb *dvb_dev;
+	int err;
+	u16 if1 = 1220;
+	int gpio_arg;
+	int i;
+	struct dvb_demux *dvbdemux;
+
+	printk(KERN_INFO"em2880-dvb.c: DVB Init\n");
+	if (NULL == dev) {
+		dprintk(1, "em2880-dvb.c: no device attached?\n");
+		return -ENOMEM;
+	}
+
+	dvb_dev = kzalloc(sizeof(struct em2880_dvb), GFP_KERNEL);
+	if (!dvb_dev) {
+		dprintk(1, "out of memory!\n");
+		return -ENOMEM;
+	}
+
+	mutex_init(&dvb_dev->sem);
+
+	dev->em28xx_write_regs_req(dev, 0x00, 0x48, "\x00", 1);
+	dev->em28xx_write_regs_req(dev, 0x00, 0x12, "\x77", 1);
+
+
+	if (dev->dvbnorm == NULL) {
+		kfree(dvb_dev);
+		return -EINVAL;
+	}
+
+	gpio_arg = EM28XX_REG_OFF;
+	dev->em28xx_gpio_control(dev, EM28XX_ANALOG_ON,    &gpio_arg);
+	gpio_arg = EM28XX_REG_ON;
+	dev->em28xx_gpio_control(dev, EM28XX_TS1_ON,       &gpio_arg);
+	dev->em28xx_gpio_control(dev, EM28XX_TUNER1_ON,    &gpio_arg);
+	dev->em28xx_gpio_control(dev, EM28XX_DECODER_SLEEP, &gpio_arg);
+	dev->em28xx_gpio_control(dev, EM28XX_DEMOD1_RESET, NULL);
+	mdelay(100);
+	dev->mode = V4L2_TUNER_DIGITAL_TV;
+
+
+	switch (dev->model) {
+	case EM2880_BOARD_HAUPPAUGE_WINTV_HVR_900_R2:
+	case EM2882_BOARD_PINNACLE_HYBRID_PRO:
+#ifdef MICRONAS_DRX3975D
+		dvb_dev->frontend = dvb_attach(drx3973d_attach,
+				&DRX3973DDefaultCommAttr_g,
+				&DRX3973DDefaultAddr_g,
+				&DRX3973DData_g,
+				&dev->i2c_adap);
+#endif
+		break;
+	case EM2883_BOARD_TERRATEC_HYBRID_XS_FM:
+	case EM2880_BOARD_HAUPPAUGE_WINTV_HVR_900:
+	case EM2880_BOARD_TERRATEC_HYBRID_XS:
+	case EM2880_BOARD_TERRATEC_HYBRID_XS_FR:
+	case EM2882_BOARD_TERRATEC_HYBRID_XS:
+	case EM2882_BOARD_LEADTEK_PALMTOP_DTV_200H:	
+	case EM2870_BOARD_TERRATEC_XS:
+	case EM2881_BOARD_PINNACLE_HYBRID_PRO:
+	case EM2881_BOARD_DNT_DA2_HYBRID:
+	case EM2880_BOARD_MSI_DIGIVOX_AD:
+	case EM2880_BOARD_MSI_DIGIVOX_AD_II:
+	case EM2870_BOARD_KWORLD_350U:
+	case EM2883_BOARD_KWORLD_HYBRID_E323:
+	case EM2888_BOARD_KWORLD_HYBRID_E329:
+	case EM2888_BOARD_EMPIA_HYBRID:
+	case EM2880_BOARD_TERRATEC_PRODIGY_XS:
+		dvb_dev->frontend = dvb_attach(zl10353_attach,
+				&em2880_zl10353_dev, &dev->i2c_adap);
+		if (dvb_dev->frontend == NULL)
+		dvb_dev->frontend = dvb_attach(mt352_attach,
+				&em2880_mt352_dev, &dev->i2c_adap);
+ 		
+		break;
+	case EM2870_BOARD_TERRATEC_XS_MT2060:
+		dvb_dev->frontend = dvb_attach(zl10353_attach,
+				&em2880_zl10353_pinnacle, &dev->i2c_adap);
+		break;
+	case EM2883_BOARD_HAUPPAUGE_WINTV_HVR_950:
+	case EM2883_BOARD_PINNACLE_PCTV_HD_PRO:
+	case EM2883_BOARD_KWORLD_HYBRID_A316:
+	case EM2883_BOARD_ATI_TVWONDER600:
+		dvb_dev->frontend = dvb_attach(lgdt330x_attach,
+				&em2880_lgdt3303_dev, &dev->i2c_adap);
+		break;
+	case EM2870_BOARD_KWORLD_355U:
+	case EM2870_BOARD_COMPRO_VIDEOMATE:
+		em28xx_ts_bus_ctrl_int(dev, 0);
+		/* fall through */
+	case EM2870_BOARD_PINNACLE_PCTV_DVB:
+		dvb_dev->frontend = dvb_attach(zl10353_attach,
+				&em2880_kworld_355u_dev,
+				&dev->i2c_adap);
+		break;
+	case EM2883_BOARD_EMPIA_HYBRID_ATSC:
+	case EM2883_BOARD_EQUINUX_TUBESTICK_ATSC:
+		dvb_dev->frontend = dvb_attach(lgdt3304_attach,
+				&lgdt3304_atsc_config, &dev->i2c_adap);
+		break;
+	case EM2875_BOARD_SAMPLE_ISDBT:
+		
+#if 1
+		dvb_dev->frontend = dvb_attach(s921_attach,
+				&sharp_isdbt_config, &dev->i2c_adap);
+#endif
+		if (dvb_dev->frontend) {
+			dvb_dev->frontend->tuner_priv = dev;
+			dvb_dev->init_override = dvb_dev->frontend->ops.init;
+			dvb_dev->frontend->ops.init = em28xx_s921_init;
+		} else {
+			printk("failed to initialize s921\n");
+		}
+		break;
+	case EM2879_BOARD_SAMPLE_DMB:
+#if 0
+		dvb_dev->frontend = dvb_attach(dmb_attach,
+				&sharp_dmb_config, &dev->i2c_adap);
+#endif
+		break;
+	default:
+		printk(KERN_INFO"em2880-dvb.c: unsupported device\n");
+		kfree(dvb_dev);
+		return -EINVAL;
+	}
+
+	if (dvb_dev->frontend && dev->model != EM2875_BOARD_SAMPLE_ISDBT) {
+		switch (dev->tuner_type) {
+		case TUNER_XCEIVE_XC3028:
+		case TUNER_XCEIVE_XC5000:
+			dvb_dev->frontend->tuner_priv = dev;
+			dvb_dev->frontend->ops.tuner_ops.set_params =
+				em28xx_set_params;
+			dvb_dev->frontend->ops.tuner_ops.get_frequency =
+				em28xx_get_frequency;
+			dvb_dev->frontend->ops.tuner_ops.get_bandwidth =
+				em28xx_get_bandwidth;
+
+			/* xc3028 powersaving mode */
+			dvb_dev->frontend->ops.tuner_ops.init =
+				em28xx_dvb_init;
+			dvb_dev->frontend->ops.tuner_ops.sleep =
+				em28xx_dvb_sleep;
+			break;
+		case TUNER_MT2060:
+			dvb_attach(mt2060_attach, dvb_dev->frontend,
+					&dev->i2c_adap, &em2870_mt2060_config,
+					if1);
+			break;
+		case TUNER_QT1010:
+			dvb_dev->frontend->ops.i2c_gate_ctrl =
+				kworld355u_i2c_gate_ctrl;
+			dvb_attach(qt1010_attach, dvb_dev->frontend,
+					&dev->i2c_adap, &em2870_qt1010_config);
+			break;
+		case TUNER_ADIMTV102:
+#ifdef ADIMTV102
+			dvb_attach(adimtv102_attach, dvb_dev->frontend, &dev->i2c_adap, &dmbt_adim_config);
+#endif
+			break;
+		default:
+			printk(KERN_INFO"unsupported tuner (%d)\n",
+					dev->tuner_type);
+		}
+
+		/* zl10353 powersaving */
+		dvb_dev->init_override = dvb_dev->frontend->ops.init;
+
+		dvb_dev->frontend->ops.sleep = em28xx_zl10353_sleep;
+		dvb_dev->frontend->ops.init = em28xx_zl10353_init;
+	}
+
+	if (NULL == dvb_dev->frontend) {
+		printk(KERN_INFO"em2880-dvb.c: failed initializing zl10353"
+		       "DVB-T demodulator\n");
+		printk(KERN_INFO"em2880-dvb.c: retrying with mt352 DVB-T"
+				"demodulator\n");
+		if (NULL == dvb_dev->frontend) {
+			printk(KERN_INFO"em2880-dvb.c: no luck with mt352"
+			       "demodulator, not attaching em2880-dvb\n");
+			kfree(dvb_dev);
+			return -ENODEV;
+		}
+	}
+
+	/* this is not backward compatible */
+#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 20)
+	dvb_dev->frontend->ops.ts_bus_ctrl = em28xx_ts_bus_ctrl;
+#endif
+
+	dvb_register_adapter(&dvb_dev->adapter, "em2880 DVB-T", THIS_MODULE,
+			&dev->udev->dev
+#if defined DVB_DEFINE_MOD_OPT_ADAPTER_NR
+			,adapter_nr
+#endif
+	);
+
+	
+	for (i=0; i<dev->uif->altsetting[1].desc.bNumEndpoints; i++) {
+		if (dev->uif->altsetting[1].endpoint[i].desc.bEndpointAddress == 0x84) {
+			dvb_dev->dtv_packetsize = dev->uif->altsetting[1].
+					endpoint[i].desc.wMaxPacketSize;
+			break;
+		}
+	}
+
+	dvb_dev->adapter.priv = dev;
+
+	dvb_register_frontend(&dvb_dev->adapter, dvb_dev->frontend);
+
+	dvb_dev->demux.priv = dvb_dev;
+	dvb_dev->demux.filternum = 256;
+	dvb_dev->demux.feednum = 256;
+	dvb_dev->demux.start_feed = em2880_start_feed;
+	dvb_dev->demux.stop_feed = em2880_stop_feed;
+	dvb_dev->demux.dmx.capabilities = DMX_TS_FILTERING |
+					DMX_SECTION_FILTERING |
+					DMX_MEMORY_BASED_FILTERING;
+
+	err = dvb_dmx_init(&dvb_dev->demux);
+	if (err < 0) {
+		dprintk(1, "dvb_dmx_init failed!\n");
+		kfree(dvb_dev);
+		return -1;
+	}
+
+	dvb_dev->dmxdev.filternum = dvb_dev->demux.filternum;
+	dvb_dev->dmxdev.demux = &dvb_dev->demux.dmx;
+	dvb_dev->dmxdev.capabilities = 0;
+
+	err = dvb_dmxdev_init(&dvb_dev->dmxdev, &dvb_dev->adapter);
+
+	if (err < 0) {
+		dprintk(1, "dvb_dmxdev failed!\n");
+		dvb_dmxdev_release(&dvb_dev->dmxdev);
+		kfree(dvb_dev);
+		return -1;
+	}
+
+	dvb_dev->udev = dev->udev;
+	dvb_dev->em28xx_dev = dev; /* FIXME get rid of this */
+
+	dev->dvb_dev = dvb_dev;
+
+	dvbdemux = &dvb_dev->demux;
+	dvb_net_init(&dvb_dev->adapter, &dvb_dev->dvbnet, &dvbdemux->dmx);
+
+	return 0;
+}
+
+static int em2880_dvb_fini(struct em28xx *dev)
+{
+	struct em2880_dvb *dvb_dev = dev->dvb_dev;
+	if (!dev) {
+		dprintk(1, "fini already called!\n");
+		return -1;
+	}
+	if (!dev->dvb_dev) {
+		dprintk(1, "dvb_dev not initialized!\n");
+		return -1;
+	}
+	dvb_dev = dev->dvb_dev;
+
+	dprintk(1, "releasing dvb device!\n");
+
+	dvb_net_release(&dvb_dev->dvbnet);
+	dvb_unregister_frontend(dvb_dev->frontend);
+	dvb_frontend_detach(dvb_dev->frontend);
+
+	dvb_dev->demux.dmx.close(&dvb_dev->demux.dmx);
+	dvb_dmxdev_release(&dvb_dev->dmxdev);
+	dvb_dmx_release(&dvb_dev->demux);
+
+	dvb_unregister_adapter(&dvb_dev->adapter);
+
+	dprintk(1, "dvb_fini\n");
+	if (dev->dvb_dev) {
+		dprintk(1, "freeing dvb_dev\n");
+		kfree(dev->dvb_dev);
+		dev->dvb_dev = NULL;
+	}
+	return 0;
+}
+
+static struct em28xx_ops dvb_ops = {
+	.id	= EM28XX_DVBT | EM28XX_ATSC | EM28XX_ISDB | EM28XX_DMB,
+	.name	= "Em2880 DVB Extension",
+	.init	= em2880_dvb_init,
+	.fini	= em2880_dvb_fini,
+};
+
+static int __init em2880_dvb_register(void)
+{
+	return em28xx_register_extension(&dvb_ops);
+}
+
+static void __exit em2880_dvb_unregister(void)
+{
+	em28xx_unregister_extension(&dvb_ops);
+}
+
+module_init(em2880_dvb_register);
+module_exit(em2880_dvb_unregister);
+
+/* ------------------------------------------------------------------ */
+/*
+ * Local variables:
+ * c-basic-offset: 8
+ * End:
+ */
diff --git a/drivers/media/video/empia/em28xx-aad.c b/drivers/media/video/empia/em28xx-aad.c
new file mode 100644
index 0000000..7c6dcb6
--- /dev/null
+++ b/drivers/media/video/empia/em28xx-aad.c
@@ -0,0 +1,404 @@
+/* 
+ * Em28xx-aad Empia Alternative Audio Driver
+ *
+ * This is a vendor specific driver which provides a vendor specific
+ * audio interface for Empia based devices.
+ *
+ * Copyright (C) 2008 Empia Technology Inc.
+ * Copyright (C) 2008 Sundtek Ltd.
+ *
+ */
+
+#include <linux/version.h>
+#include <linux/init.h>
+#include <linux/list.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/fs.h>
+#include <linux/poll.h>
+#include <linux/wait.h>
+#include <linux/string.h>
+#include <linux/timer.h>
+#include <linux/delay.h>
+#include <linux/proc_fs.h>
+#include <linux/i2c.h>
+#include <linux/usb.h>
+#include <linux/types.h>
+#include <linux/errno.h>
+#include <linux/sched.h>
+#include <linux/fcntl.h>
+#include <asm/uaccess.h>
+
+#include "em28xx-aad.h"
+#include "em28xx.h"
+
+static unsigned long em28xx_aad_devices; /* map */
+static int em28xx_aad_register(struct em28xx *dev);
+
+void em28xx_aad_unregister(struct em28xx_aad_info **int_aad);
+
+static int em28xx_maxdevs;
+
+static LIST_HEAD(em28xx_aad_devlist);
+
+/* ringbuffer implementation, taken from empia radio application */
+
+#define AAD_BUFFER_SIZE 20000
+
+static struct aad_rb_info *aad_rb_init(void);
+static struct aad_rb_info *aad_rb_init(void) {
+	struct aad_rb_info *rb = kzalloc(sizeof(struct aad_rb_info), GFP_KERNEL);
+        rb->left = rb->right = rb->pos = 0;
+	rb->bufsize = AAD_BUFFER_SIZE;
+        rb->buffer = kzalloc(AAD_BUFFER_SIZE*sizeof(u8), GFP_KERNEL);
+        if (rb->buffer == NULL)
+            return 0;
+	spin_lock_init(&rb->__aad_lock);
+	return rb;
+};
+
+void aad_rb_free(struct aad_rb_info **rb) {
+	kfree((*rb)->buffer);
+	kfree((*rb));
+}
+
+static inline u32 aad_rb_get_buffer_size(struct aad_rb_info *rb) {
+	if (rb->left > rb->right)
+		return (rb->bufsize - rb->left + rb->right);
+	else if(rb->left < rb->right)
+		return (rb->right - rb->left);
+	else if(rb->left == rb->right)
+		return 0;
+	return 0;
+}
+
+static void aad_rb_reset_buffer(struct aad_rb_info *rb) {
+        unsigned long flags;
+        spin_lock_irqsave(&rb->__aad_lock, flags);
+        rb->left = rb->right = rb->pos = 0;
+        spin_unlock_irqrestore(&rb->__aad_lock, flags);
+}
+
+static inline u32 aad_rb_free_buffer_size(struct aad_rb_info *rb) {
+	u32 cur_buffsize = aad_rb_get_buffer_size(rb);
+	if (rb->bufsize - cur_buffsize > 0)
+		return rb->bufsize - cur_buffsize - 1;
+	return rb->bufsize - 1;
+}
+
+static int aad_rb_write_data(struct aad_rb_info *rb, u8 *data, ssize_t size) {
+	int len = size;
+	//int len2;
+	int free;
+	unsigned long flags;
+	/* lock */
+        spin_lock_irqsave(&rb->__aad_lock, flags);
+	free = aad_rb_free_buffer_size(rb);
+
+	if (size > free)
+		size = free - free % sizeof(u32); /* alignment */
+
+	if (free == 0) {
+                if(printk_ratelimit()) 
+                    printk("dropping data!\n");
+		/* unlock */
+                spin_unlock_irqrestore(&rb->__aad_lock, flags);
+		return 0;
+	}
+	if (rb->right + size >= rb->bufsize - 1) {
+		len = rb->bufsize - rb->right;
+		memcpy(&rb->buffer[rb->right], data, len);
+		memcpy(rb->buffer, data+len, size - len);
+		rb->right = size - len;
+	} else {
+		memcpy(&rb->buffer[rb->right], data, size);
+		rb->right += size;
+	}
+	/* unlock */
+        spin_unlock_irqrestore(&rb->__aad_lock, flags);
+	return 0;
+}
+
+/* this is a bit complicated since we cannot do memcpy/copy_to_user within the
+ * spinlocked block, it might work fine with most systems although the target
+ * systems just blew up */
+
+static int aad_rb_read_data(struct em28xx_aad_info *aad, u8 *buffer, ssize_t size) {
+	int len;
+	int bufsize;
+	unsigned int left;
+        unsigned long flags;
+        struct aad_rb_info *rb = aad->__aad_rb[aad->__curr_rb];
+	/* lock */
+        spin_lock_irqsave(&rb->__aad_lock, flags);
+
+
+	if (aad_rb_get_buffer_size(rb) == 0) {
+		/* unlock */
+                spin_unlock_irqrestore(&rb->__aad_lock, flags);
+		return 0;
+	}
+
+	bufsize = aad_rb_get_buffer_size(rb);
+	if (size > bufsize)
+		size = bufsize;
+
+	size -= size % 8; /* alignment */
+
+        aad->__curr_rb ^= 1; /* switch rb buffer so the irq can write to the other buffer during
+                                the copy routine */
+
+        aad->__write_rb = aad->__aad_rb[aad->__curr_rb];
+
+	if (rb->left + size >= rb->bufsize -1) {
+		len = rb->bufsize - rb->left;
+		left = rb->left;
+		rb->left = size - len;
+        	spin_unlock_irqrestore(&rb->__aad_lock, flags);
+		copy_to_user(buffer, &rb->buffer[left], len);
+		copy_to_user(&buffer[len], rb->buffer, size - len);
+	} else {
+		left = rb->left;
+		rb->left += size;
+        	spin_unlock_irqrestore(&rb->__aad_lock, flags);
+		copy_to_user(buffer, &rb->buffer[left], size);
+	}
+
+        /* reset our backed up ringbuffer */
+	
+        aad_rb_reset_buffer(rb);
+	/* unlock */
+	return size;
+}
+
+/* end ringbuffer implementation */
+
+/* usb code */
+
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19)
+static void em28xx_aad_isocirq(struct urb *urb, struct pt_regs *regs)
+#else
+static void em28xx_aad_isocirq(struct urb *urb)
+#endif
+{
+    struct em28xx_aad_info *aad = urb->context;
+    u8 *cp;
+    int i;
+    for(i=0;i<urb->number_of_packets;i++){
+        int length=urb->iso_frame_desc[i].actual_length;
+        cp=(unsigned char *) urb->transfer_buffer + urb->iso_frame_desc[i].offset;
+
+        if(!length)
+            continue;
+
+
+        if (urb->iso_frame_desc[i].status)
+            continue;
+
+        aad_rb_write_data(aad->__write_rb, cp, length);
+
+    }
+    urb->status = 0;
+
+    if(usb_submit_urb(urb, GFP_ATOMIC))
+        printk("unable to submit urb\n");
+}
+
+static int aad_audio_isoc_deinit(struct em28xx_aad_info *aad)
+{
+    int i;
+    for(i=0;i<AAD_AUDIO_BUFS;i++){
+        usb_kill_urb(aad->urb[i]);
+        usb_free_urb(aad->urb[i]);
+        aad->urb[i]=NULL;
+    }
+    return 0;
+}
+
+static int aad_audio_isoc_init(struct em28xx_aad_info *aad)
+{
+    int i;
+    int errCode;
+    const int sb_size=AAD_NUM_AUDIO_PACKETS * AAD_AUDIO_MAX_PACKET_SIZE;
+
+    printk("aad_isoc audio init\n");
+
+    for(i=0;i<AAD_AUDIO_BUFS;i++){
+        struct urb *urb;
+        int j,k;
+        aad->transfer_buffer[i]=kmalloc(sb_size,GFP_ATOMIC);
+
+        if(!aad->transfer_buffer[i])
+            return -ENOMEM;
+
+        memset(aad->transfer_buffer[i],0x80,sb_size);
+        urb = usb_alloc_urb(AAD_NUM_AUDIO_PACKETS,GFP_ATOMIC);
+
+        if(urb){
+            urb->dev=aad->__aad_udev;
+            urb->context=aad;
+            urb->pipe=usb_rcvisocpipe(aad->__aad_udev, 0x83);
+            urb->transfer_flags = URB_ISO_ASAP;
+            urb->transfer_buffer = aad->transfer_buffer[i];
+            urb->interval=1;
+            urb->complete = em28xx_aad_isocirq;
+            urb->number_of_packets = AAD_NUM_AUDIO_PACKETS;
+            urb->transfer_buffer_length = sb_size;
+            for(j=k=0; j<AAD_NUM_AUDIO_PACKETS;j++,k+=AAD_AUDIO_MAX_PACKET_SIZE){
+                urb->iso_frame_desc[j].offset = k;
+                urb->iso_frame_desc[j].length=AAD_AUDIO_MAX_PACKET_SIZE;
+            }
+            aad->urb[i]=urb;
+        } else
+            return -ENOMEM;
+
+    }
+    for(i=0;i<AAD_AUDIO_BUFS;i++){
+        errCode = usb_submit_urb(aad->urb[i], GFP_ATOMIC);
+        if (errCode){
+            aad_audio_isoc_deinit(aad);
+            return errCode;
+        }
+    }
+    return 0;
+}
+
+/* cheap usercheck */
+static int aad_users;
+
+static int aad_open(struct inode *inode, struct file *file) {
+	struct em28xx_aad_info *aad = NULL;
+	struct list_head *list;
+
+	if (aad_users != 0) 
+		return -EBUSY;
+	aad_users++;
+        /* TODO: support multiple devices here */
+	list_for_each(list, &em28xx_aad_devlist) {
+		aad = list_entry(list, struct em28xx_aad_info, __aad_devlist);
+		break;
+	}
+
+	if (aad == NULL)
+		return -EINVAL;
+
+	printk("found device entry!\n");
+
+	file->private_data = aad;
+
+        aad_rb_reset_buffer(aad->__write_rb);
+        aad->__aad_callback(aad->__cb_priv, EM28XX_ENABLE_AUDIO, NULL);
+        aad_audio_isoc_init(aad);
+	return 0;
+}
+
+static ssize_t aad_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos) {
+	struct em28xx_aad_info *aad = NULL;
+	ssize_t retval;
+	aad = filp->private_data;
+	retval = aad_rb_read_data(aad, buf, count);
+	return retval;
+}
+
+static int aad_release(struct inode *inode, struct file *file) {
+        struct em28xx_aad_info *aad;
+        aad = file->private_data;
+	aad_users--;
+        aad_audio_isoc_deinit(aad);
+	return 0;
+}
+
+static struct file_operations em28xx_aad_fops = {
+        .owner   = THIS_MODULE,
+        .open    = aad_open,
+        .read    = aad_read,
+        .release = aad_release,
+};
+
+static int em28xx_aad_register(struct em28xx *dev) {
+	struct em28xx_aad_info *aad;
+	int id;
+	aad = kzalloc(sizeof(struct em28xx_aad_info), GFP_KERNEL);
+	id = find_first_zero_bit(&em28xx_aad_devices, sizeof(u32));
+	em28xx_aad_devices |= (1<<id);
+	aad->__id = id;
+        aad->__aad_udev = dev->udev;
+        aad->__aad_callback = dev->em28xx_aad_control;
+        aad->__cb_priv = dev;
+        dev->aad = aad;
+	snprintf(aad->__aad_devname, 50, "aad%d", id);
+	printk("em28xx-aad: registered /dev/%s\n",aad->__aad_devname);
+
+	aad->__aad_major = register_chrdev(0, aad->__aad_devname, &em28xx_aad_fops);
+	aad->__aad_class = class_create(THIS_MODULE, aad->__aad_devname);
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 26)
+	aad->__aad_cdev  = class_device_create(aad->__aad_class, NULL, MKDEV(aad->__aad_major, 0), NULL, aad->__aad_devname);
+#else
+/* XXX now in 2.6.27 device_create == device_create_drvdata ... */
+/* dvb-core/dvbdev.c uses d_c_drvdata already, imitate that since I don't
+ * know any better...  XXX  */
+        aad->__aad_cdev  = device_create_drvdata(aad->__aad_class, NULL,
+                MKDEV(aad->__aad_major, 0), NULL, aad->__aad_devname);
+#endif
+
+	INIT_LIST_HEAD(&aad->__aad_devlist);
+	list_add_tail(&aad->__aad_devlist, &em28xx_aad_devlist);
+
+        /* we cannot copy out from the ringpuffer while it is spinlocked with 2.6.17 */
+	aad->__aad_rb[0] = aad_rb_init();
+	aad->__aad_rb[1] = aad_rb_init();
+        aad->__write_rb = aad->__aad_rb[0];
+        aad->__curr_rb = 0;
+	return 0;
+}
+
+void em28xx_aad_unregister(struct em28xx_aad_info **aad_int) {
+	struct em28xx_aad_info *aad = (*aad_int);
+	em28xx_aad_devices &= ~ (1<<aad->__id);
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 26)
+	class_device_destroy(aad->__aad_class, MKDEV(aad->__aad_major, 0));
+#else
+        device_destroy(aad->__aad_class, MKDEV(aad->__aad_major, 0));
+#endif
+	unregister_chrdev(0, aad->__aad_devname);
+	class_destroy(aad->__aad_class);
+	aad_rb_free(&aad->__aad_rb[0]);
+	aad_rb_free(&aad->__aad_rb[1]);
+        list_del(&aad->__aad_devlist);
+
+	kfree(aad);
+}
+
+static int em28xx_aad_fini(struct em28xx *dev) {
+    em28xx_aad_unregister(&dev->aad);
+    dev->aad = NULL;
+    return 0;
+}
+
+static struct em28xx_ops audio_ops = {
+	.id	= EM28XX_AUDIO,
+	.name	= "Em28xx Alternative Audio Driver",
+	.init	= em28xx_aad_register,
+	.fini	= em28xx_aad_fini,
+};
+
+static int __init  em28xx_aad_init(void) {
+	printk("initializing Empia Audio Driver\n");
+	printk("Copyright (C) 2008 Empia Technology Inc\n");
+	printk("Copyright (C) 2008 Sundtek Ltd.\n");
+
+	em28xx_maxdevs = sizeof(int);
+	return em28xx_register_extension(&audio_ops);
+}
+
+static void __exit em28xx_aad_exit(void) {
+	printk("releasing Empia Audio Driver\n");
+	em28xx_unregister_extension(&audio_ops);
+}
+
+MODULE_AUTHOR("Empia Technology Inc./Sundtek Ltd.");
+MODULE_DESCRIPTION("Alternative Audio Driver for Empia based devices");
+MODULE_LICENSE("GPL");
+
+module_init(em28xx_aad_init);
+module_exit(em28xx_aad_exit);
diff --git a/drivers/media/video/empia/em28xx-aad.h b/drivers/media/video/empia/em28xx-aad.h
new file mode 100644
index 0000000..fd39ed1
--- /dev/null
+++ b/drivers/media/video/empia/em28xx-aad.h
@@ -0,0 +1,46 @@
+#ifndef __EM28XX_AAD_H
+#define __EM28XX_AAD_H
+
+#include <linux/poll.h>
+#include <linux/fs.h>
+#include <linux/device.h>
+#include <linux/mutex.h>
+#include <linux/compiler.h> /* need __user */
+
+#define MAX_AAD_DEVS 10
+
+struct aad_rb_info {
+    spinlock_t __aad_lock;
+    u32 left;
+    u32 right;
+    u32 pos;
+    u32 bufsize;
+    u8 *buffer;
+};
+
+#define AAD_AUDIO_BUFS 3
+#define AAD_NUM_AUDIO_PACKETS 64
+#define AAD_AUDIO_MAX_PACKET_SIZE 196 /* static value */
+
+struct em28xx_aad_info {
+    u32 __id;
+    u8 __aad_devname[50];
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 26)
+    struct class_device *__aad_cdev;
+#else
+    struct device *__aad_cdev;
+#endif
+    int __aad_major;
+    struct class *__aad_class;
+    struct list_head __aad_devlist;
+    struct aad_rb_info *__aad_rb[2];
+    struct aad_rb_info *__write_rb;
+    u8 __curr_rb;
+    struct usb_device *__aad_udev;
+    u8 *transfer_buffer[AAD_AUDIO_BUFS];
+    struct urb *urb[AAD_AUDIO_BUFS];
+    int (*__aad_callback)(void *, unsigned int cmd, void *arg);
+    void *__cb_priv;
+};
+
+#endif
diff --git a/drivers/media/video/empia/em28xx-audio.c b/drivers/media/video/empia/em28xx-audio.c
new file mode 100644
index 0000000..a1d06a7
--- /dev/null
+++ b/drivers/media/video/empia/em28xx-audio.c
@@ -0,0 +1,630 @@
+/*
+ *  Empiatech em28x1 audio extension
+ *
+ *  Copyright (C) 2006 Markus Rechberger <mrechberger@xxxxxxxxxx>
+ *
+ *  This driver is based on my previous au600 usb pstn audio driver
+ *  and inherits all the copyrights
+ *
+ *  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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/kernel.h>
+#include <linux/version.h>
+#include <linux/usb.h>
+#include <linux/init.h>
+#include <linux/sound.h>
+#include <linux/spinlock.h>
+#include <linux/soundcard.h>
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 25)
+#include <sound/driver.h>
+#endif
+#include <linux/slab.h>
+#include <linux/vmalloc.h>
+#include <linux/proc_fs.h>
+#include <linux/moduleparam.h>
+#include <linux/wait.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include <sound/info.h>
+#include <sound/initval.h>
+#include <sound/control.h>
+#include <sound/core.h>
+#include <media/v4l2-common.h>
+#include "em28xx.h"
+#include "xc5000/xc5000_control.h"
+
+static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;
+static int em28xx_cmd(struct em28xx *dev, int cmd,int arg);
+
+
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,16)
+static int snd_pcm_alloc_vmalloc_buffer(snd_pcm_substream_t *subs, size_t size)
+#else
+static int snd_pcm_alloc_vmalloc_buffer(struct snd_pcm_substream *subs, size_t size)
+#endif
+{
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,16)
+	snd_pcm_runtime_t *runtime = subs->runtime;
+#else
+	struct snd_pcm_runtime *runtime = subs->runtime;
+#endif
+	if(runtime->dma_area){
+		if(runtime->dma_bytes > size)
+			return 0;
+		vfree(runtime->dma_area);
+	}
+	runtime->dma_area = vmalloc(size);
+	if(!runtime ->dma_area)
+		return -ENOMEM;
+	runtime->dma_bytes = size;
+	return 0;
+}
+
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,16)
+static snd_pcm_hardware_t snd_em28xx_hw_capture = {
+#else
+static struct snd_pcm_hardware snd_em28xx_hw_capture = {
+#endif
+	.info = SNDRV_PCM_INFO_BLOCK_TRANSFER | 
+		SNDRV_PCM_INFO_MMAP | 
+		SNDRV_PCM_INFO_BATCH |
+		SNDRV_PCM_INFO_INTERLEAVED  | 
+		SNDRV_PCM_INFO_MMAP_VALID,
+	.formats = SNDRV_PCM_FMTBIT_S16_LE,
+	.rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_KNOT,
+	.rate_min = 48000,
+	.rate_max = 48000,
+	.channels_min = 2,
+	.channels_max = 2,
+	.buffer_bytes_max = 1024*1024, 
+	.period_bytes_min = 64, 
+	.period_bytes_max = 512*1024,
+	.periods_min = 2,
+	.periods_max = 1024,
+};
+
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,16)
+static int snd_em28xx_capture_open(snd_pcm_substream_t *substream)
+#else
+static int snd_em28xx_capture_open(struct snd_pcm_substream *substream)
+#endif
+{
+	int ret = 0;
+	int mode;
+	int arg;
+	struct em28xx *dev = snd_pcm_substream_chip(substream);
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,16)
+	snd_pcm_runtime_t *runtime = substream->runtime;
+#else
+	struct snd_pcm_runtime *runtime = substream->runtime;
+#endif
+	printk("opening radio device and trying to acquire exclusive lock\n");
+        switch(dev->mode){
+	case V4L2_TUNER_DIGITAL_TV:
+		/* digital has no support for analog audio */
+		ret = dev->em28xx_acquire(dev, EM28XX_RADIO, 1); 
+		if (ret != 0 ) {
+			printk("device is already in use by DVB-T\n");
+			return -EINVAL;
+		} else {
+			struct v4l2_tuner tuner;
+			struct v4l2_routing arouting;
+			printk("switching device to FM mode\n");
+
+			mode = V4L2_TUNER_RADIO;
+			memset(&tuner, 0x0, sizeof(struct v4l2_tuner));
+			tuner.type = V4L2_TUNER_RADIO;
+
+			dev->mode = mode;
+		
+			arg = EM28XX_REG_ON;
+			dev->em28xx_gpio_control(dev, EM28XX_ANALOG_ON, &arg);
+			dev->em28xx_gpio_control(dev, EM28XX_LED1_ON, &arg);
+			dev->em28xx_gpio_control(dev, EM28XX_TUNER1_ON, &arg);
+			arg = EM28XX_REG_OFF;
+			dev->em28xx_gpio_control(dev, EM28XX_TS1_ON, &arg);
+			mdelay(100);
+
+			/* upload firmware */
+			switch(dev->tuner_type) {
+			case TUNER_XCEIVE_XC3028:
+				{
+					struct xc3028_init_cmd cmd;
+
+					/* this is moreover to switch the decoder to FM */
+					cmd.new_tv_mode_ptr = dev->fmnorm->tv_mode;
+					cmd.new_channel_map_ptr = dev->fmnorm->channelmap;
+					if (dev->tuner)
+						dev->tuner->tuner_cmd(dev->tuner, XC3028_INIT_TUNER, &cmd);
+					break;
+				} 
+			case TUNER_XCEIVE_XC5000:
+				{
+					struct xc_std_conf cmd;
+					/* this is moreover to switch the decoder to FM */
+					if (dev->tuner) {
+						dev->tuner->tuner_cmd(dev->tuner, XC5000_INIT_TUNER, NULL);
+						cmd.index=dev->fmnorm->index;
+						dev->tuner->tuner_cmd(dev->tuner, XC5000_SET_MODE, &cmd);
+					}
+					break;
+				}
+			default:
+				break;
+			}
+
+			dev->em28xx_write_reg_bits(dev, R0F_XCLK_REG, 0x80, 0x80);
+
+			em28xx_i2c_call_clients(dev, VIDIOC_INT_RESET, 0);
+			
+			arouting.input = CX25843_RADIO;
+			em28xx_i2c_call_clients(dev, VIDIOC_INT_S_AUDIO_ROUTING, &arouting);
+
+			printk("retrieved mode from tuner: %d\n",mode);
+		}
+		break;
+
+	case V4L2_TUNER_ANALOG_TV:
+		printk("em28xx-audio: device is currently in analog TV mode\n");
+		/* unmute by default */
+		ret = dev->em28xx_acquire(dev, EM28XX_VIDEO, 1); 
+		if (ret!=0)
+			return -EBUSY;
+
+		dev->em28xx_write_reg_bits(dev, R0F_XCLK_REG, 0x80, 0x80);
+
+		break;
+	case V4L2_TUNER_RADIO:
+	{
+		struct v4l2_routing arouting;
+		/* check current mode and put a hard lock onto it */
+		printk("em28xx-audio: device is currently in analogue FM mode\n");
+		/* unmute by default here */
+		ret = dev->em28xx_acquire(dev, EM28XX_RADIO, 1); 
+
+		dev->mode = V4L2_TUNER_RADIO;
+
+		if ( ret == 0 ) 
+			printk("device is locked in fmradio mode now\n");
+
+		dev->em28xx_write_reg_bits(dev, R0F_XCLK_REG, 0x80, 0x80);
+		arouting.input = CX25843_RADIO;
+		em28xx_i2c_call_clients(dev, VIDIOC_INT_S_AUDIO_ROUTING, &arouting);
+
+		break;
+	}
+	default:
+		printk("em28xx-audio: unhandled mode %d\n", dev->mode);
+		return -EINVAL;
+	}
+	runtime->hw = snd_em28xx_hw_capture;
+	if(dev->alt == 0 && dev->adev->users == 0 ) {
+		int errCode;
+		dev->alt = 7;
+		errCode = usb_set_interface(dev->udev, dev->usb_interface, 7);
+		printk("changing alternate number to 7\n");
+	}
+	dev->adev->users++;
+	snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
+	dev->adev->capture_pcm_substream = substream;
+	runtime->private_data = dev;
+	return 0;
+}
+
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,16)
+static int snd_em28xx_pcm_close(snd_pcm_substream_t *substream)
+#else
+static int snd_em28xx_pcm_close(struct snd_pcm_substream *substream)
+#endif
+{
+	struct em28xx *dev = snd_pcm_substream_chip(substream);
+	int amode = 0;
+	dev->adev->users--;
+
+	/* decrease audio reference */
+	switch(dev->mode) {
+		case V4L2_TUNER_ANALOG_TV:
+			amode = EM28XX_VIDEO;
+			break;
+		case V4L2_TUNER_RADIO:
+			amode = EM28XX_RADIO;
+			break;
+		default:
+			printk("invalid mode: %d\n",dev->mode);
+			return -EINVAL;
+	}
+
+	dev->em28xx_acquire(dev, amode, 0); 
+
+	if(dev->adev->users == 0 && dev->adev->shutdown == 1) {
+		dev->adev->shutdown = 0;
+		em28xx_cmd(dev,EM28XX_CAPTURE_STREAM_EN,0);
+	}
+	wake_up(&dev->adev->open);
+	return 0;
+}
+
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,16)
+static int snd_em28xx_hw_capture_params(snd_pcm_substream_t *substream, snd_pcm_hw_params_t *hw_params)
+#else
+static int snd_em28xx_hw_capture_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *hw_params)
+#endif
+{
+	unsigned int channels, rate, format;
+	struct em28xx *dev = snd_pcm_substream_chip(substream);
+	int ret;
+	ret = snd_pcm_alloc_vmalloc_buffer(substream, params_buffer_bytes(hw_params));
+	dev->adev->hwptr_done_capture = 0;
+
+	format = params_format(hw_params);
+	rate = params_rate(hw_params);
+	channels = params_channels(hw_params);
+	/* TODO: set up em28xx audio chip to deliver the correct audio format, 
+	   xc5000/cx25843 supports stereo
+	   xc3028/em202 supports mono only
+	   */
+	return 0;
+}
+
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,16)
+static int snd_em28xx_hw_capture_free(snd_pcm_substream_t *substream)
+#else
+static int snd_em28xx_hw_capture_free(struct snd_pcm_substream *substream)
+#endif
+{
+	struct em28xx *dev = snd_pcm_substream_chip(substream);
+
+	if(dev->adev->capture_stream==STREAM_ON)
+		em28xx_cmd(dev,EM28XX_CAPTURE_STREAM_EN,0);
+
+	return 0;
+}
+
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,16)
+static int snd_em28xx_prepare(snd_pcm_substream_t *substream)
+#else
+static int snd_em28xx_prepare(struct snd_pcm_substream *substream)
+#endif
+{
+	return 0;
+}
+
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,16)
+static int snd_em28xx_capture_trigger(snd_pcm_substream_t *substream, int cmd)
+#else
+static int snd_em28xx_capture_trigger(struct snd_pcm_substream *substream, int cmd)
+#endif
+{
+	struct em28xx *dev = snd_pcm_substream_chip(substream);
+	switch(cmd){
+		case SNDRV_PCM_TRIGGER_START:
+			em28xx_cmd(dev,EM28XX_CAPTURE_STREAM_EN,1);
+			return 0;
+		case SNDRV_PCM_TRIGGER_STOP:
+			dev->adev->shutdown=1;
+			return 0;
+		default:
+			return -EINVAL;
+	}
+}
+
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19)
+static void em28xx_audio_isocirq(struct urb *urb, struct pt_regs *regs)
+#else
+static void em28xx_audio_isocirq(struct urb *urb)
+#endif
+{
+	struct em28xx *dev = urb->context;
+	struct em28xx_audio *adev = dev->adev;
+	int i;
+	unsigned int oldptr;
+	unsigned long flags;
+	int period_elapsed = 0;
+	int status;
+	unsigned char *cp;
+	unsigned int stride;
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,16)
+	snd_pcm_substream_t *substream;
+	snd_pcm_runtime_t *runtime;
+#else
+	struct snd_pcm_substream *substream;
+	struct snd_pcm_runtime *runtime;
+#endif
+        if (adev->capture_stream == STREAM_INTERRUPT) {
+                adev->capture_stream = STREAM_OFF;
+                wake_up_interruptible(&adev->audio_wait_stream);
+        }
+
+	if ((dev->state & DEV_DISCONNECTED) || 
+			(dev->state & DEV_MISCONFIGURED))                
+		return;
+
+
+	if(dev->adev->capture_pcm_substream){
+		substream=dev->adev->capture_pcm_substream;
+		runtime=substream->runtime;
+
+		stride = runtime->frame_bits >> 3;
+		for(i=0;i<urb->number_of_packets;i++){
+
+			int length=urb->iso_frame_desc[i].actual_length/stride;
+			cp=(unsigned char *) urb->transfer_buffer + urb->iso_frame_desc[i].offset;
+
+			if(!length)
+				continue;
+
+
+			if (urb->iso_frame_desc[i].status) 
+				continue;
+
+			spin_lock_irqsave(&dev->adev->slock, flags);
+			oldptr = dev->adev->hwptr_done_capture;
+			dev->adev->hwptr_done_capture +=length;
+			if(dev->adev->hwptr_done_capture >= runtime->buffer_size)
+				dev->adev->hwptr_done_capture -= runtime->buffer_size;
+
+			dev->adev->capture_transfer_done += length;
+			if(dev->adev->capture_transfer_done >= runtime->period_size){
+				dev->adev->capture_transfer_done -= runtime->period_size;
+				period_elapsed=1;
+			}
+			spin_unlock_irqrestore(&dev->adev->slock, flags);
+
+			if(oldptr + length > runtime->buffer_size){
+				unsigned int cnt = runtime->buffer_size-oldptr;
+				memcpy(runtime->dma_area+oldptr*stride, cp , cnt*stride);
+				memcpy(runtime->dma_area, cp + cnt*stride, length*stride - cnt*stride);
+			} else {
+				memcpy(runtime->dma_area+oldptr*stride, cp, length*stride);
+			}
+		}
+		if(period_elapsed){
+			snd_pcm_period_elapsed(substream);
+		}
+	}
+	urb->status = 0;
+	
+	if(dev->adev->shutdown)
+		return;
+
+	if((status = usb_submit_urb(urb, GFP_ATOMIC)))
+		em28xx_errdev("resubmit of audio urb failed (error=%i)\n", status);
+	return;
+}
+
+static int em28xx_isoc_audio_deinit(struct em28xx *dev)
+{
+	int i;
+	for(i=0;i<EM28XX_AUDIO_BUFS;i++){
+		usb_kill_urb(dev->adev->urb[i]);
+		usb_free_urb(dev->adev->urb[i]);
+		dev->adev->urb[i]=NULL;
+	}
+	return 0;
+}
+
+static int em28xx_init_audio_isoc(struct em28xx *dev)
+{
+	int i;
+	int errCode;
+	const int sb_size=EM28XX_NUM_AUDIO_PACKETS * EM28XX_AUDIO_MAX_PACKET_SIZE;
+
+	for(i=0;i<EM28XX_AUDIO_BUFS;i++){
+		struct urb *urb;
+		int j,k;
+		dev->adev->transfer_buffer[i]=kmalloc(sb_size,GFP_ATOMIC);
+
+		if(!dev->adev->transfer_buffer[i])
+			return -ENOMEM;
+
+		memset(dev->adev->transfer_buffer[i],0x80,sb_size);
+		urb = usb_alloc_urb(EM28XX_NUM_AUDIO_PACKETS,GFP_ATOMIC);
+
+		if(urb){
+			urb->dev=dev->udev;
+			urb->context=dev;
+			urb->pipe=usb_rcvisocpipe(dev->udev,0x83);
+			urb->transfer_flags = URB_ISO_ASAP;
+			urb->transfer_buffer = dev->adev->transfer_buffer[i];
+			urb->interval=1;
+			urb->complete = em28xx_audio_isocirq;
+			urb->number_of_packets = EM28XX_NUM_AUDIO_PACKETS;
+			urb->transfer_buffer_length = sb_size;
+			for(j=k=0; j<EM28XX_NUM_AUDIO_PACKETS;j++,k+=EM28XX_AUDIO_MAX_PACKET_SIZE){
+				urb->iso_frame_desc[j].offset = k;
+				urb->iso_frame_desc[j].length=EM28XX_AUDIO_MAX_PACKET_SIZE;
+			}
+			dev->adev->urb[i]=urb;
+		} else 
+			return -ENOMEM;
+
+	}
+	for(i=0;i<EM28XX_AUDIO_BUFS;i++){
+		errCode = usb_submit_urb(dev->adev->urb[i], GFP_ATOMIC);
+		if (errCode){
+			em28xx_isoc_audio_deinit(dev);
+			return errCode;
+		}
+	}
+	return 0;
+}
+
+
+static int em28xx_cmd(struct em28xx *dev, int cmd,int arg)
+{
+	switch(cmd){
+		case EM28XX_CAPTURE_STREAM_EN:
+			if(dev->adev->capture_stream == STREAM_OFF && arg==1){
+				dev->adev->capture_stream=STREAM_ON;
+				em28xx_init_audio_isoc(dev);
+			} else if (dev->adev->capture_stream==STREAM_ON && arg==0){
+				dev->adev->capture_stream=STREAM_OFF;
+				em28xx_isoc_audio_deinit(dev);
+			} 
+			return 0;
+		default:
+			return -EINVAL;
+	}
+}
+
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,16)
+static snd_pcm_uframes_t snd_em28xx_capture_pointer(snd_pcm_substream_t *substream)
+#else
+static snd_pcm_uframes_t snd_em28xx_capture_pointer(struct snd_pcm_substream *substream)
+#endif
+{
+	struct em28xx *dev;
+	snd_pcm_uframes_t hwptr_done;
+	dev = snd_pcm_substream_chip(substream);
+	hwptr_done = dev->adev->hwptr_done_capture;
+	return hwptr_done;
+}
+
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,16)
+static struct page *snd_pcm_get_vmalloc_page(snd_pcm_substream_t *subs,
+					     unsigned long offset)
+#else
+static struct page *snd_pcm_get_vmalloc_page(struct snd_pcm_substream *subs,
+					     unsigned long offset)
+#endif
+{
+	void *pageptr = subs->runtime->dma_area + offset;
+	return vmalloc_to_page(pageptr);
+}
+
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,16)
+static snd_pcm_ops_t snd_em28xx_pcm_capture = {
+#else
+static struct snd_pcm_ops snd_em28xx_pcm_capture = {
+#endif
+	.open = snd_em28xx_capture_open,
+	.close = snd_em28xx_pcm_close,
+	.ioctl = snd_pcm_lib_ioctl,
+	.hw_params = snd_em28xx_hw_capture_params,
+	.hw_free = snd_em28xx_hw_capture_free,
+	.prepare = snd_em28xx_prepare,
+	.trigger = snd_em28xx_capture_trigger,
+	.pointer = snd_em28xx_capture_pointer,
+	.page = snd_pcm_get_vmalloc_page,
+};
+
+
+static int em28xx_audio_init(struct em28xx *dev)
+{
+	struct em28xx_audio *adev;
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,16)
+	snd_pcm_t *pcm;
+	snd_card_t *card;
+#else
+	struct snd_pcm *pcm;
+	struct snd_card *card;
+#endif
+	static int devnr;
+	int ret;
+	int err;
+	printk("em28xx-audio.c: probing for em28x1 non standard usbaudio\n");
+	printk("em28xx-audio.c: Copyright (C) 2006 Markus Rechberger\n");
+	adev=kzalloc(sizeof(*adev),GFP_KERNEL);
+	if(!adev){
+		printk("em28xx-audio.c: out of memory\n");
+		return -1;
+	}
+	card = snd_card_new(index[devnr], "Em28xx Audio", THIS_MODULE,0);
+	if(card==NULL){
+		kfree(adev);
+		return -ENOMEM;
+	}
+
+	spin_lock_init(&adev->slock);
+	init_waitqueue_head(&adev->audio_wait_stream);
+	init_waitqueue_head(&adev->open);
+	ret=snd_pcm_new(card, "Em28xx Audio", 0, 0, 1, &pcm);
+	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_em28xx_pcm_capture);
+	pcm->info_flags = 0;
+	pcm->private_data = dev;
+	strcpy(pcm->name,"Empia 28xx Capture");
+	strcpy(card->driver, "Empia Em28xx Audio");
+	strcpy(card->shortname, "Em28xx Audio");
+	strcpy(card->longname,"Empia Em28xx Audio");
+
+	if((err = snd_card_register(card))<0){
+		snd_card_free(card);
+		return -ENOMEM;
+	}
+	adev->sndcard=card;
+	adev->udev=dev->udev;
+	dev->adev=adev;
+	return 0;
+}
+
+static int em28xx_audio_fini(struct em28xx *dev)
+{
+	struct em28xx_audio *adev = dev->adev;
+	int ret;
+	printk("audio: deinitializing audio device\n");
+
+	if(dev==NULL) {
+		printk("audio: dev is already null\n");
+		return 0;
+	}
+
+	if(adev){
+		printk("audio: before waitstream\n");
+		if (adev->capture_stream == STREAM_ON) {
+			adev->capture_stream = STREAM_INTERRUPT;
+			ret = wait_event_timeout(adev->audio_wait_stream,
+					(adev->capture_stream == STREAM_OFF) ||
+					(dev->state & DEV_DISCONNECTED),
+					EM28XX_URB_TIMEOUT);
+		}
+		printk("audio: after waitstream\n");
+		printk("audio: waiting for audioclients to release audio node\n");
+
+		if (adev->users>0) 
+			/* we have to strictly wait for this... */
+
+			wait_event(adev->open, (adev->users == 0));
+
+		snd_card_free(dev->adev->sndcard);
+		kfree(dev->adev);
+		dev->adev=NULL;
+	}
+	return 0;
+}
+
+static struct em28xx_ops audio_ops = {
+	.id	= EM28XX_AUDIO,
+	.name	= "Em28xx Audio Extension",
+	.init	= em28xx_audio_init,
+	.fini	= em28xx_audio_fini,
+};
+
+static int __init em28xx_alsa_register(void)
+{
+	return em28xx_register_extension(&audio_ops);
+}
+
+static void __exit em28xx_alsa_unregister(void)
+{
+	em28xx_unregister_extension(&audio_ops);
+}
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Markus Rechberger <mrechberger@xxxxxxxxx>");
+MODULE_DESCRIPTION("Em28xx Audio driver");
+
+module_init(em28xx_alsa_register);
+module_exit(em28xx_alsa_unregister);
diff --git a/drivers/media/video/empia/em28xx-audioep.c b/drivers/media/video/empia/em28xx-audioep.c
new file mode 100644
index 0000000..868e488
--- /dev/null
+++ b/drivers/media/video/empia/em28xx-audioep.c
@@ -0,0 +1,522 @@
+/* Copyright (C) 2008 Empia Technology Inc.
+ * Copyright (C) 2008 Markus Rechberger <mrechberger@xxxxxxxxx>
+ */
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/list.h>
+#include <linux/module.h>
+#include <linux/version.h>
+#include <linux/usb.h>
+#include <linux/sound.h>
+#include <linux/soundcard.h>
+#include <linux/vmalloc.h>
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 25)
+#include <sound/driver.h>
+#endif
+#include <sound/core.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include <sound/info.h>
+#include <sound/initval.h>
+#include <sound/control.h>
+
+
+#include "em28xx.h"
+
+static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;
+
+MODULE_AUTHOR("Markus Rechberger <mrechberger@xxxxxxxxx>");
+MODULE_LICENSE("GPL"); // my appropriate code is dual licensed also BSD
+
+static struct usb_driver em28xx_audio_drv;
+static int em28xx_cmd(struct em28xx_audio *adev, int cmd,int arg);
+
+static struct usb_device_id em28xx_audio_id_table[]={
+        { USB_DEVICE(0x0ccd, 0x0042) }, /* just for testing it will not attach to the real device */
+	{ USB_DEVICE(0xeb1a, 0xe300) },
+	{ USB_DEVICE(0xeb1a, 0xe301) },
+	{ USB_DEVICE(0xeb1a, 0xe305) },
+	{ USB_DEVICE(0xeb1a, 0xe310) },
+	{ USB_DEVICE(0xeb1a, 0xe320) },
+	{ USB_DEVICE(0xeb1a, 0x2861) },
+        { },
+};
+
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,16)
+static snd_pcm_hardware_t snd_em28xx_hw_capture = {
+#else
+static struct snd_pcm_hardware snd_em28xx_hw_capture = {
+#endif
+	.info = SNDRV_PCM_INFO_BLOCK_TRANSFER | 
+		SNDRV_PCM_INFO_MMAP | 
+		SNDRV_PCM_INFO_BATCH |
+		SNDRV_PCM_INFO_INTERLEAVED  | 
+		SNDRV_PCM_INFO_MMAP_VALID,
+	.formats = SNDRV_PCM_FMTBIT_S16_LE,
+	.rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_KNOT,
+	.rate_min = 48000,
+	.rate_max = 48000,
+	.channels_min = 2,
+	.channels_max = 2,
+	.buffer_bytes_max = 1024*1024, 
+	.period_bytes_min = 64, 
+	.period_bytes_max = 512*1024,
+	.periods_min = 2,
+	.periods_max = 1024,
+};
+
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,16)
+static int snd_pcm_alloc_vmalloc_buffer(snd_pcm_substream_t *subs, size_t size)
+#else
+static int snd_pcm_alloc_vmalloc_buffer(struct snd_pcm_substream *subs, size_t size)
+#endif
+{
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,16)
+        snd_pcm_runtime_t *runtime = subs->runtime;
+#else
+        struct snd_pcm_runtime *runtime = subs->runtime;
+#endif
+        if(runtime->dma_area){
+                if(runtime->dma_bytes > size)
+                        return 0;
+                vfree(runtime->dma_area);
+        }
+        runtime->dma_area = vmalloc(size);
+        if(!runtime ->dma_area)
+                return -ENOMEM;
+        runtime->dma_bytes = size;
+        return 0;
+}
+
+
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,16)
+static int snd_em28xx_hw_capture_params(snd_pcm_substream_t *substream, snd_pcm_hw_params_t *hw_params)
+#else
+static int snd_em28xx_hw_capture_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *hw_params)
+#endif
+{
+        unsigned int channels, rate, format;
+        struct em28xx_audio *adev = snd_pcm_substream_chip(substream);
+        int ret;
+        ret = snd_pcm_alloc_vmalloc_buffer(substream, params_buffer_bytes(hw_params));
+        adev->hwptr_done_capture = 0;
+
+        format = params_format(hw_params);
+        rate = params_rate(hw_params);
+        channels = params_channels(hw_params);
+        /* TODO: set up em28xx audio chip to deliver the correct audio format, 
+           xc5000/cx25843 supports stereo
+           xc3028/em202 supports mono only
+           */
+        return 0;
+}
+
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,16)
+static int snd_em28xx_hw_capture_free(snd_pcm_substream_t *substream)
+#else
+static int snd_em28xx_hw_capture_free(struct snd_pcm_substream *substream)
+#endif
+{
+        struct em28xx_audio *adev = snd_pcm_substream_chip(substream);
+
+        if(adev->capture_stream == STREAM_ON)
+                em28xx_cmd(adev, EM28XX_CAPTURE_STREAM_EN, 0);
+
+        return 0;
+}
+
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,16)
+static int snd_em28xx_prepare(snd_pcm_substream_t *substream)
+#else
+static int snd_em28xx_prepare(struct snd_pcm_substream *substream)
+#endif
+{
+        return 0;
+}
+
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,16)
+static int snd_em28xx_capture_trigger(snd_pcm_substream_t *substream, int cmd)
+#else
+static int snd_em28xx_capture_trigger(struct snd_pcm_substream *substream, int cmd)
+#endif
+{
+        struct em28xx_audio *adev = snd_pcm_substream_chip(substream);
+        switch(cmd){
+                case SNDRV_PCM_TRIGGER_START:
+                        em28xx_cmd(adev, EM28XX_CAPTURE_STREAM_EN, 1);
+                        return 0;
+                case SNDRV_PCM_TRIGGER_STOP:
+                        adev->shutdown = 1;
+                        return 0;
+                default:
+                        return -EINVAL;
+        }
+}
+
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19)
+static void em28xx_audio_isocirq(struct urb *urb, struct pt_regs *regs)
+#else
+static void em28xx_audio_isocirq(struct urb *urb)
+#endif
+{
+        struct em28xx_audio *adev = urb->context;
+        int i;
+        unsigned int oldptr;
+        unsigned long flags;
+        int period_elapsed = 0;
+        unsigned char *cp;
+        unsigned int stride;
+
+	int status;
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,16)
+        snd_pcm_substream_t *substream;
+        snd_pcm_runtime_t *runtime;
+#else
+        struct snd_pcm_substream *substream;
+        struct snd_pcm_runtime *runtime;
+#endif
+        if (adev->capture_stream == STREAM_INTERRUPT) {
+                adev->capture_stream = STREAM_OFF;
+                wake_up_interruptible(&adev->audio_wait_stream);
+        }
+        if ((adev->state & DEV_DISCONNECTED) ||
+                        (adev->state & DEV_MISCONFIGURED))
+                return;
+
+
+        if(adev->capture_pcm_substream){
+                substream=adev->capture_pcm_substream;
+                runtime=substream->runtime;
+
+                stride = runtime->frame_bits >> 3;
+                for(i=0;i<urb->number_of_packets;i++){
+
+                        int length=urb->iso_frame_desc[i].actual_length/stride;
+                        cp=(unsigned char *) urb->transfer_buffer + urb->iso_frame_desc[i].offset;
+
+
+                        if(!length)
+                                continue;
+
+
+                        if (urb->iso_frame_desc[i].status)
+                                continue;
+
+                        spin_lock_irqsave(&adev->slock, flags);
+                        oldptr = adev->hwptr_done_capture;
+                        adev->hwptr_done_capture +=length;
+                        if(adev->hwptr_done_capture >= runtime->buffer_size)
+                                adev->hwptr_done_capture -= runtime->buffer_size;
+
+                        adev->capture_transfer_done += length;
+                        if(adev->capture_transfer_done >= runtime->period_size){
+                                adev->capture_transfer_done -= runtime->period_size;
+                                period_elapsed=1;
+                        }
+                        spin_unlock_irqrestore(&adev->slock, flags);
+
+                        if(oldptr + length > runtime->buffer_size){
+                                unsigned int cnt = runtime->buffer_size-oldptr;
+                                memcpy(runtime->dma_area+oldptr*stride, cp , cnt*stride);
+                                memcpy(runtime->dma_area, cp + cnt*stride, length*stride - cnt*stride);
+                        } else {
+                                memcpy(runtime->dma_area+oldptr*stride, cp, length*stride);
+                        }
+                }
+                if(period_elapsed){
+                        snd_pcm_period_elapsed(substream);
+                }
+        }
+        urb->status = 0;
+
+        if(adev->shutdown)
+                return;
+
+        if((status = usb_submit_urb(urb, GFP_ATOMIC)))
+                printk("resubmit of audio urb failed (error=%i)\n", status);
+        return;
+}
+
+
+static int em28xx_isoc_audio_deinit(struct em28xx_audio *adev)
+{
+        int i;
+        for(i=0; i<EM28XX_AUDIO_BUFS; i++){
+                usb_kill_urb(adev->urb[i]);
+                usb_free_urb(adev->urb[i]);
+                adev->urb[i] = NULL;
+        }
+        return 0;
+}
+
+static int em28xx_init_audio_isoc(struct em28xx_audio *adev)
+{
+        int i;
+        int errCode;
+        const int sb_size=EM28XX_NUM_AUDIO_PACKETS * EM28XX_AUDIO_MAX_PACKET_SIZE;
+
+        for(i=0; i<EM28XX_AUDIO_BUFS; i++){
+                struct urb *urb;
+                int j,k;
+                adev->transfer_buffer[i]=kzalloc(sb_size,GFP_ATOMIC);
+
+                if(!adev->transfer_buffer[i])
+                        return -ENOMEM;
+
+                urb = usb_alloc_urb(EM28XX_NUM_AUDIO_PACKETS,GFP_ATOMIC);
+
+                if(urb){
+                        urb->dev = adev->udev;
+                        urb->context = adev;
+                        urb->pipe = usb_rcvisocpipe(adev->udev,0x83);
+                        urb->transfer_flags = URB_ISO_ASAP;
+                        urb->transfer_buffer = adev->transfer_buffer[i];
+                        urb->interval = 1;
+                        urb->complete = em28xx_audio_isocirq;
+                        urb->number_of_packets = EM28XX_NUM_AUDIO_PACKETS;
+                        urb->transfer_buffer_length = sb_size;
+                        for(j=k=0; j<EM28XX_NUM_AUDIO_PACKETS; j++,k+=EM28XX_AUDIO_MAX_PACKET_SIZE){
+                                urb->iso_frame_desc[j].offset = k;
+                                urb->iso_frame_desc[j].length = EM28XX_AUDIO_MAX_PACKET_SIZE;
+                        }
+                        adev->urb[i] = urb;
+                } else
+                        return -ENOMEM;
+
+        }
+        for(i=0; i<EM28XX_AUDIO_BUFS; i++){
+                errCode = usb_submit_urb(adev->urb[i], GFP_ATOMIC);
+                if (errCode){
+                        em28xx_isoc_audio_deinit(adev);
+                        return errCode;
+                }
+        }
+        return 0;
+}
+
+static int em28xx_cmd(struct em28xx_audio *adev, int cmd,int arg)
+{
+        switch(cmd){
+	case EM28XX_CAPTURE_STREAM_EN:
+		if(adev->capture_stream == STREAM_OFF && arg==1){
+			adev->capture_stream = STREAM_ON;
+			em28xx_init_audio_isoc(adev);
+		} else if (adev->capture_stream == STREAM_ON && arg==0){
+			adev->capture_stream = STREAM_OFF;
+			em28xx_isoc_audio_deinit(adev);
+		}
+		return 0;
+	default:
+		return -EINVAL;
+        }
+}
+
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,16)
+static snd_pcm_uframes_t snd_em28xx_capture_pointer(snd_pcm_substream_t *substream)
+#else
+static snd_pcm_uframes_t snd_em28xx_capture_pointer(struct snd_pcm_substream *substream)
+#endif
+{
+        struct em28xx_audio *adev;
+        snd_pcm_uframes_t hwptr_done;
+        adev = snd_pcm_substream_chip(substream);
+        hwptr_done = adev->hwptr_done_capture;
+        return hwptr_done;
+}
+
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,16)
+static struct page *snd_pcm_get_vmalloc_page(snd_pcm_substream_t *subs,
+                                             unsigned long offset)
+#else
+static struct page *snd_pcm_get_vmalloc_page(struct snd_pcm_substream *subs,
+                                             unsigned long offset)
+#endif
+{
+        void *pageptr = subs->runtime->dma_area + offset;
+        return vmalloc_to_page(pageptr);
+}
+
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,16)
+static int snd_em28xx_capture_open(snd_pcm_substream_t *substream)
+#else
+static int snd_em28xx_capture_open(struct snd_pcm_substream *substream)
+#endif
+{
+        struct em28xx_audio *adev = snd_pcm_substream_chip(substream);
+	int errCode;
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,16)
+        snd_pcm_runtime_t *runtime = substream->runtime;
+#else
+        struct snd_pcm_runtime *runtime = substream->runtime;
+#endif
+
+	if(adev->alt == 0 && adev->users == 0 ) 
+                errCode = usb_set_interface(adev->udev, 1, adev->alt_max); /* Todo */
+
+	runtime->hw = snd_em28xx_hw_capture;
+
+        adev->users++;
+        runtime->private_data = adev;
+	snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
+	adev->capture_pcm_substream = substream;
+	return 0;
+
+}
+
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,16)
+static int snd_em28xx_pcm_close(snd_pcm_substream_t *substream)
+#else
+static int snd_em28xx_pcm_close(struct snd_pcm_substream *substream)
+#endif
+{
+        struct em28xx_audio *adev = snd_pcm_substream_chip(substream);
+        adev->users--;
+        if(adev->users == 0 && adev->shutdown == 1) {
+                adev->shutdown = 0;
+                em28xx_cmd(adev, EM28XX_CAPTURE_STREAM_EN, 0);
+        }
+        wake_up(&adev->open);
+        return 0;
+}
+
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,16)
+static snd_pcm_ops_t snd_em28xx_pcm_capture = {
+#else
+static struct snd_pcm_ops snd_em28xx_pcm_capture = {
+#endif
+        .open = snd_em28xx_capture_open,
+        .close = snd_em28xx_pcm_close,
+        .ioctl = snd_pcm_lib_ioctl,
+        .hw_params = snd_em28xx_hw_capture_params,
+        .hw_free = snd_em28xx_hw_capture_free,
+        .prepare = snd_em28xx_prepare,
+        .trigger = snd_em28xx_capture_trigger,
+        .pointer = snd_em28xx_capture_pointer,
+        .page = snd_pcm_get_vmalloc_page,
+};
+
+
+static int em28xx_audio_probe(struct usb_interface *interface, const struct usb_device_id *id)
+{
+	int err;
+	int i;
+	u8 max_alt;
+	u8 if_num;
+	u16 max_pck = 0, cur_pck = 0;
+	struct usb_device *udev;
+	struct em28xx_audio *adev = NULL;
+
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,16)
+        snd_pcm_t *pcm;
+        snd_card_t *card;
+#else
+        struct snd_pcm *pcm;
+        struct snd_card *card;
+#endif
+
+
+	int retval = -ENODEV;
+	u8 i_max = 0;
+        static int devnr;
+        int ret;
+
+
+	struct usb_endpoint_descriptor *endpoint;
+	udev = usb_get_dev(interface_to_usbdev(interface));
+	endpoint = &interface->cur_altsetting->endpoint[0].desc;
+
+	if_num = interface->altsetting[0].desc.bInterfaceNumber;
+	max_alt = interface->num_altsetting;
+
+	if (max_alt == 6 && if_num > 0) {
+		printk("registering em28xx-audioep\n");
+		for (i=0; i<max_alt; i++) {
+			cur_pck=le16_to_cpu(interface->altsetting[i].endpoint[0].desc.wMaxPacketSize);
+			if (cur_pck > max_pck) {
+				i_max = i;
+				max_pck = cur_pck;
+			}
+		}
+		adev = kzalloc(sizeof(struct em28xx_audio), GFP_KERNEL);
+		retval = 0;
+		adev->max_pck = max_pck;
+		adev->alt_max = i_max;
+		adev->udev = udev;
+		
+		printk("em28xx-audioep.c: detected nonstandard usbaudio\n");
+		printk("em28xx-audioep.c: Copyright (C) 2008 Empia Technology Inc.\n");
+		printk("em28xx-audioep.c: Copyright (C) 2008 Markus Rechberger\n");
+		
+
+		card = snd_card_new(index[devnr], "Em28xx Audio2", THIS_MODULE, 0);
+
+		// todo increase devnr .. or better make a bitmap out of it
+
+		if(card == NULL) {
+			kfree(adev);
+			return -ENOMEM;
+		}
+
+		spin_lock_init(&adev->slock);
+		init_waitqueue_head(&adev->audio_wait_stream);
+		init_waitqueue_head(&adev->open);
+		ret = snd_pcm_new(card, "Em28xx Audio2", 0, 0, 1, &pcm);
+		snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_em28xx_pcm_capture);
+		pcm->info_flags = 0;
+		pcm->private_data = adev;
+		strcpy(pcm->name, "Empia em28xx Capture");
+		strcpy(card->driver, "Empia Em28xx Audio 2");
+		strcpy(card->shortname, "Em28xx Audio 2");
+		strcpy(card->longname, "Empia Em28xx Audio 2");
+
+		if ((err = snd_card_register(card)) < 0) {
+			snd_card_free(card);
+			return -ENOMEM;
+		}
+		adev->sndcard = card;
+
+		usb_set_intfdata(interface, adev);
+	}
+	return retval;
+}
+
+static void em28xx_audio_disconnect(struct usb_interface *interface)
+{
+	struct em28xx_audio *adev = usb_get_intfdata(interface);
+	usb_set_intfdata(interface, NULL);
+	if (!adev)
+		return;
+
+	if (adev->users > 0)
+		wait_event(adev->open, (adev->users == 0));
+
+	snd_card_free(adev->sndcard);
+	kfree(adev);
+}
+
+static struct usb_driver em28xx_audio_drv = {
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 15)
+	.owner = THIS_MODULE,
+#endif
+	.name = "em28xx-audioep",
+	.probe = em28xx_audio_probe,
+	.disconnect = em28xx_audio_disconnect,
+	.id_table = em28xx_audio_id_table,
+};
+
+static int __init em28xx_audio_init(void)
+{
+	int result;
+	result = usb_register(&em28xx_audio_drv);
+	if (result)
+		printk("usb_register failed. Error number %d.\n", result);
+	return result;
+}
+
+static void __exit em28xx_audio_exit(void)
+{
+	usb_deregister(&em28xx_audio_drv);
+}
+
+module_init(em28xx_audio_init);
+module_exit(em28xx_audio_exit);
diff --git a/drivers/media/video/empia/em28xx-cards.c b/drivers/media/video/empia/em28xx-cards.c
new file mode 100644
index 0000000..00bea04
--- /dev/null
+++ b/drivers/media/video/empia/em28xx-cards.c
@@ -0,0 +1,3387 @@
+/*
+   em28xx-cards.c - driver for Empia EM2800/EM2820/2840/2880 USB video capture devices
+
+   Copyright (C) 2005 - 2008 Markus Rechberger <mrechberger@xxxxxxxxx>
+		 2005       Mauro Carvalho Chehab <mchehab@xxxxxxxxxxxxx>
+		 2005       Sascha Sommer <saschasommer@xxxxxxxxxx>
+		 2005       Ludovico Cavedon <cavedon@xxxxxxxx>
+
+   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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/delay.h>
+#include <linux/i2c.h>
+#include <linux/usb.h>
+#include <linux/version.h>
+#include <linux/firmware.h>
+#include <media/tuner.h>
+#ifdef EM28XX_TVEEPROM
+#include <media/tveeprom.h>
+#endif
+#include <media/v4l2-common.h>
+#if LINUX_VERSION_CODE <=  KERNEL_VERSION(2, 6, 26)
+#include <media/audiochip.h>
+#else
+#include <media/v4l2-chip-ident.h>
+#endif
+#include "msp3400-driver.h"
+#include <media/saa7115.h>
+#include <media/tvp5150.h>
+
+#include "xc3028/xc3028_firmwares.h"
+#include "xc3028/xc3028l_firmwares.h"
+#include "xc3028/xc3028_channelmaps.h"
+#define XCEIVE_EXTERNAL_FIRMWARE
+#ifdef XCEIVE_EXTERNAL_FIRMWARE
+#include "xc3028/xc3028fw_helper.h"
+#endif
+
+#include "em28xx.h"
+#include "em28xx-keymaps.h"
+
+extern unsigned char *XC5000_firmware_SEQUENCE;
+
+
+
+static const u8 em28xx_terratec_cinergy_200_usb_i2c_devs[]     = {0x4a, 0x60, 0x62, 0x64, 0x86, 0xc0, 0xc2, 0};
+static const u8 em28xx_vgear_pockettv_i2c_devs[]               = {0x4a, 0x60, 0xc6, 0};
+
+/* keep this map private */
+#define EETI_XC3028_DEFAULT_ANALOG { 					\
+	{								\
+		/* analogue TV */					\
+		.name = "PAL-BG", /* AV - tested OK */			\
+		.id = V4L2_STD_PAL_BG, 					\
+		.tv_mode = &XC3028_tv_mode_b_g_pal_nicam_b_mono, 	\
+		.channelmap = &XC3028_channel_map_ccir_analog_air, 	\
+		.vbi_sample_rate = 27000000, 				\
+		.vbi_samples_per_line = 1440, 				\
+		.vbi_start_0 = 5, 					\
+		.vbi_start_1 = 317, 					\
+		.vbi_count_0 = 18, 					\
+		.vbi_count_1 = 18, 					\
+		.vbi_h_start = 0x00, 					\
+		.vbi_v_start = 0x46, 					\
+		.vbi_w = 0xb4, 						\
+		.vbi_h = 18						\
+	}, {								\
+		.name = "PAL-DK", /* AV - tested OK */			\
+		.id = V4L2_STD_PAL_DK, 					\
+		.tv_mode = &XC3028_tv_mode_d_k_pal_nicam_mono, 		\
+		.channelmap = &XC3028_channel_map_ccir_analog_air, 	\
+		.vbi_sample_rate = 27000000, 				\
+		.vbi_samples_per_line = 1440, 				\
+		.vbi_start_0 = 5, 					\
+		.vbi_start_1 = 317, 					\
+		.vbi_count_0 = 18, 					\
+		.vbi_count_1 = 18, 					\
+		.vbi_h_start = 0x00, 					\
+		.vbi_v_start = 0x46, 					\
+		.vbi_w = 0xb4, 						\
+		.vbi_h = 0x12						\
+	}, {								\
+		.name = "PAL-I", /* AV - tested OK */			\
+		.id = V4L2_STD_PAL_I, 					\
+		.tv_mode = &XC3028_tv_mode_i_pal_nicam_mono, 		\
+		.channelmap = &XC3028_channel_map_ccir_analog_air, 	\
+		.vbi_sample_rate = 27000000, 				\
+		.vbi_samples_per_line = 1440, 				\
+		.vbi_start_0 = 5, 					\
+		.vbi_start_1 = 317, 					\
+		.vbi_count_0 = 18, 					\
+		.vbi_count_1 = 18, 					\
+		.vbi_h_start = 0x00, 					\
+		.vbi_v_start = 0x46, 					\
+		.vbi_w = 0xb4, 						\
+		.vbi_h = 0x12						\
+	}, {								\
+		.name = "NTSC-M", /* AV - tested OK */			\
+		.id = V4L2_STD_NTSC_M, 					\
+		.tv_mode = &XC3028_tv_mode_m_n_ntsc_pal_a2_mono,        \
+		.channelmap = &XC3028_channel_map_ccir_analog_air, 	\
+		.vbi_sample_rate = 27000000, 				\
+		.vbi_samples_per_line = 1440, 				\
+		.vbi_start_0 = 8, 					\
+		.vbi_start_1 = 318, 					\
+		.vbi_count_0 = 12, 					\
+		.vbi_count_1 = 12, 					\
+		.vbi_h_start = 0x00, 					\
+		.vbi_v_start = 0x06, 					\
+		.vbi_w = 0xb4, 						\
+		.vbi_h = 0x0c						\
+	}, {								\
+		.name = "SECAM L", /* AV tested ok */			\
+		.id = V4L2_STD_SECAM_L, 				\
+                .tv_mode = &XC3028_tv_mode_l_secam_nicam_am_only,       \
+		.channelmap = &XC3028_channel_map_france_analog_air, 	\
+		.vbi_sample_rate = 27000000, 				\
+		.vbi_samples_per_line = 1440, 				\
+		.vbi_start_0 = 5, 					\
+		.vbi_start_1 = 317, 					\
+		.vbi_count_0 = 18, 					\
+		.vbi_count_1 = 18, 					\
+		.vbi_h_start = 0x00, 					\
+		.vbi_v_start = 0x46, 					\
+		.vbi_w = 0xb4, 						\
+		.vbi_h = 0x12						\
+	}, {								\
+		.name = "SECAM LC", /* AV - not tested */		\
+		.id = V4L2_STD_SECAM_LC, 				\
+		.tv_mode = &XC3028_tv_mode_d_k_secam_a2_dk1_mono, 	\
+		.channelmap = &XC3028_channel_map_ccir_analog_air, 	\
+		.vbi_sample_rate = 27000000, 				\
+		.vbi_samples_per_line = 1440, 				\
+		.vbi_start_0 = 5, 					\
+		.vbi_start_1 = 317, 					\
+		.vbi_count_0 = 18, 					\
+		.vbi_count_1 = 18, 					\
+		.vbi_h_start = 0x00, 					\
+		.vbi_v_start = 0x46, 					\
+		.vbi_w = 0xb4, 						\
+		.vbi_h = 0x12						\
+	}, {								\
+		.name = "SECAM K1", /* AV - not tested */		\
+		.id = V4L2_STD_SECAM_K1, 				\
+		.tv_mode = &XC3028_tv_mode_d_k_secam_a2_dk1_mono, 	\
+		.channelmap = &XC3028_channel_map_ccir_analog_air, 	\
+		.vbi_sample_rate = 27000000, 				\
+		.vbi_samples_per_line = 1440, 				\
+		.vbi_start_0 = 5, 					\
+		.vbi_start_1 = 317, 					\
+		.vbi_count_0 = 18, 					\
+		.vbi_count_1 = 18, 					\
+		.vbi_h_start = 0x00, 					\
+		.vbi_v_start = 0x46, 					\
+		.vbi_w = 0xb4, 						\
+		.vbi_h = 0x12						\
+	}, {								\
+		.name = "PAL-M", /* AV - not tested */			\
+		.id = V4L2_STD_PAL_M, 					\
+		.tv_mode = &XC3028_tv_mode_m_n_ntsc_pal_a2_mono, 	\
+		.channelmap = &XC3028_channel_map_ccir_analog_air, 	\
+		.vbi_sample_rate = 27000000, 				\
+		.vbi_samples_per_line = 1440, 				\
+		.vbi_start_0 = 8, 					\
+		.vbi_start_1 = 318, 					\
+		.vbi_count_0 = 12, 					\
+		.vbi_count_1 = 12, 					\
+		.vbi_h_start = 0x00, 					\
+		.vbi_v_start = 0x06, 					\
+		.vbi_w = 0xb4, 						\
+		.vbi_h = 0x0c						\
+	}								\
+}
+
+/* keep this map private */
+#define EETI_XC3028_DEFAULT_ANALOG_STEREO {				\
+	{								\
+		/* analogue TV */					\
+		.name = "PAL-BG", /* AV - tested OK */			\
+		.id = V4L2_STD_PAL_BG, 					\
+		.tv_mode = &XC3028_tv_mode_b_g_pal_nicam_b,		\
+		.channelmap = &XC3028_channel_map_ccir_analog_air, 	\
+		.vbi_sample_rate = 27000000, 				\
+		.vbi_samples_per_line = 1440, 				\
+		.vbi_start_0 = 5, 					\
+		.vbi_start_1 = 317, 					\
+		.vbi_count_0 = 18, 					\
+		.vbi_count_1 = 18, 					\
+		.vbi_h_start = 0x00, 					\
+		.vbi_v_start = 0x46, 					\
+		.vbi_w = 0xb4, 						\
+		.vbi_h = 18						\
+	}, {								\
+		.name = "PAL-DK", /* AV - tested OK */			\
+		.id = V4L2_STD_PAL_DK, 					\
+		.tv_mode = &XC3028_tv_mode_d_k_pal_nicam, 		\
+		.channelmap = &XC3028_channel_map_ccir_analog_air, 	\
+		.vbi_sample_rate = 27000000, 				\
+		.vbi_samples_per_line = 1440, 				\
+		.vbi_start_0 = 5, 					\
+		.vbi_start_1 = 317, 					\
+		.vbi_count_0 = 18, 					\
+		.vbi_count_1 = 18, 					\
+		.vbi_h_start = 0x00, 					\
+		.vbi_v_start = 0x46, 					\
+		.vbi_w = 0xb4, 						\
+		.vbi_h = 0x12						\
+	}, {								\
+		.name = "PAL-I", /* AV - tested OK */			\
+		.id = V4L2_STD_PAL_I, 					\
+		.tv_mode = &XC3028_tv_mode_i_pal_nicam, 		\
+		.channelmap = &XC3028_channel_map_ccir_analog_air, 	\
+		.vbi_sample_rate = 27000000, 				\
+		.vbi_samples_per_line = 1440, 				\
+		.vbi_start_0 = 5, 					\
+		.vbi_start_1 = 317, 					\
+		.vbi_count_0 = 18, 					\
+		.vbi_count_1 = 18, 					\
+		.vbi_h_start = 0x00, 					\
+		.vbi_v_start = 0x46, 					\
+		.vbi_w = 0xb4, 						\
+		.vbi_h = 0x12						\
+	}, {								\
+		.name = "NTSC-M", /* AV - tested OK */			\
+		.id = V4L2_STD_NTSC_M, 					\
+		.tv_mode = &XC3028_tv_mode_m_n_ntsc_pal_a2_if,		\
+		.channelmap = &XC3028_channel_map_ccir_analog_air, 	\
+		.vbi_sample_rate = 27000000, 				\
+		.vbi_samples_per_line = 1440, 				\
+		.vbi_start_0 = 8, 					\
+		.vbi_start_1 = 318, 					\
+		.vbi_count_0 = 12, 					\
+		.vbi_count_1 = 12, 					\
+		.vbi_h_start = 0x00, 					\
+		.vbi_v_start = 0x06, 					\
+		.vbi_w = 0xb4, 						\
+		.vbi_h = 0x0c						\
+	}, {								\
+		.name = "SECAM L", /* AV - not tested */		\
+		.id = V4L2_STD_SECAM_L, 				\
+		.tv_mode = &XC3028_tv_mode_d_k_secam_a2_dk1,	 	\
+		.channelmap = &XC3028_channel_map_ccir_analog_air, 	\
+		.vbi_sample_rate = 27000000, 				\
+		.vbi_samples_per_line = 1440, 				\
+		.vbi_start_0 = 5, 					\
+		.vbi_start_1 = 317, 					\
+		.vbi_count_0 = 18, 					\
+		.vbi_count_1 = 18, 					\
+		.vbi_h_start = 0x00, 					\
+		.vbi_v_start = 0x46, 					\
+		.vbi_w = 0xb4, 						\
+		.vbi_h = 0x12						\
+	}, {								\
+		.name = "SECAM LC", /* AV - not tested */		\
+		.id = V4L2_STD_SECAM_LC, 				\
+		.tv_mode = &XC3028_tv_mode_d_k_secam_a2_dk1,	 	\
+		.channelmap = &XC3028_channel_map_ccir_analog_air, 	\
+		.vbi_sample_rate = 27000000, 				\
+		.vbi_samples_per_line = 1440, 				\
+		.vbi_start_0 = 5, 					\
+		.vbi_start_1 = 317, 					\
+		.vbi_count_0 = 18, 					\
+		.vbi_count_1 = 18, 					\
+		.vbi_h_start = 0x00, 					\
+		.vbi_v_start = 0x46, 					\
+		.vbi_w = 0xb4, 						\
+		.vbi_h = 0x12						\
+	}, {								\
+		.name = "SECAM K1", /* AV - not tested */		\
+		.id = V4L2_STD_SECAM_K1, 				\
+		.tv_mode = &XC3028_tv_mode_d_k_secam_a2_dk1,	 	\
+		.channelmap = &XC3028_channel_map_ccir_analog_air, 	\
+		.vbi_sample_rate = 27000000, 				\
+		.vbi_samples_per_line = 1440, 				\
+		.vbi_start_0 = 5, 					\
+		.vbi_start_1 = 317, 					\
+		.vbi_count_0 = 18, 					\
+		.vbi_count_1 = 18, 					\
+		.vbi_h_start = 0x00, 					\
+		.vbi_v_start = 0x46, 					\
+		.vbi_w = 0xb4, 						\
+		.vbi_h = 0x12						\
+	}, {								\
+		.name = "PAL-M", /* AV - not tested */			\
+		.id = V4L2_STD_PAL_M, 					\
+		.tv_mode = &XC3028_tv_mode_m_n_ntsc_pal_a2, 		\
+		.channelmap = &XC3028_channel_map_ccir_analog_air, 	\
+		.vbi_sample_rate = 27000000, 				\
+		.vbi_samples_per_line = 1440, 				\
+		.vbi_start_0 = 8, 					\
+		.vbi_start_1 = 318, 					\
+		.vbi_count_0 = 12, 					\
+		.vbi_count_1 = 12, 					\
+		.vbi_h_start = 0x00, 					\
+		.vbi_v_start = 0x06, 					\
+		.vbi_w = 0xb4, 						\
+		.vbi_h = 0x0c						\
+	}								\
+}
+
+#define EETI_XC3028L_DEFAULT_ANALOG {					\
+	{								\
+		/* analogue TV */					\
+		.name = "PAL-BG", /* AV - tested OK */			\
+		.id = V4L2_STD_PAL_BG, 					\
+		.tv_mode = &XC3028L_tv_mode_b_g_pal_nicam_b,		\
+		.channelmap = &XC3028_channel_map_ccir_analog_air, 	\
+		.vbi_sample_rate = 27000000, 				\
+		.vbi_samples_per_line = 1440, 				\
+		.vbi_start_0 = 6, 					\
+		.vbi_start_1 = 317, 					\
+		.vbi_count_0 = 18, 					\
+		.vbi_count_1 = 18, 					\
+		.vbi_h_start = 0x00, 					\
+		.vbi_v_start = 0x46, 					\
+		.vbi_w = 0xb4, 						\
+		.vbi_h = 18						\
+	}, {								\
+		.name = "PAL-DK", /* AV - tested OK */			\
+		.id = V4L2_STD_PAL_DK, 					\
+		.tv_mode = &XC3028L_tv_mode_d_k_pal_nicam, 		\
+		.channelmap = &XC3028_channel_map_ccir_analog_air, 	\
+		.vbi_sample_rate = 27000000, 				\
+		.vbi_samples_per_line = 1440, 				\
+		.vbi_start_0 = 6, 					\
+		.vbi_start_1 = 317, 					\
+		.vbi_count_0 = 18, 					\
+		.vbi_count_1 = 18, 					\
+		.vbi_h_start = 0x00, 					\
+		.vbi_v_start = 0x46, 					\
+		.vbi_w = 0xb4, 						\
+		.vbi_h = 0x12						\
+	}, {								\
+		.name = "PAL-I", /* AV - tested OK */			\
+		.id = V4L2_STD_PAL_I, 					\
+		.tv_mode = &XC3028L_tv_mode_i_pal_nicam, 		\
+		.channelmap = &XC3028_channel_map_ccir_analog_air, 	\
+		.vbi_sample_rate = 27000000, 				\
+		.vbi_samples_per_line = 1440, 				\
+		.vbi_start_0 = 6, 					\
+		.vbi_start_1 = 317, 					\
+		.vbi_count_0 = 18, 					\
+		.vbi_count_1 = 18, 					\
+		.vbi_h_start = 0x00, 					\
+		.vbi_v_start = 0x46, 					\
+		.vbi_w = 0xb4, 						\
+		.vbi_h = 0x12						\
+	}, {								\
+		.name = "NTSC-M", /* AV - tested OK */			\
+		.id = V4L2_STD_NTSC_M, 					\
+		.tv_mode = &XC3028L_tv_mode_m_n_ntsc_pal_a2_if,		\
+		.channelmap = &XC3028_channel_map_ccir_analog_air, 	\
+		.vbi_sample_rate = 27000000, 				\
+		.vbi_samples_per_line = 1440, 				\
+		.vbi_start_0 = 8, 					\
+		.vbi_start_1 = 318, 					\
+		.vbi_count_0 = 12, 					\
+		.vbi_count_1 = 12, 					\
+		.vbi_h_start = 0x00, 					\
+		.vbi_v_start = 0x06, 					\
+		.vbi_w = 0xb4, 						\
+		.vbi_h = 0x0c						\
+	}, {								\
+		.name = "SECAM L", /* AV - not tested */		\
+		.id = V4L2_STD_SECAM_L, 				\
+		.tv_mode = &XC3028L_tv_mode_d_k_secam_a2_dk1,	 	\
+		.channelmap = &XC3028_channel_map_ccir_analog_air, 	\
+		.vbi_sample_rate = 27000000, 				\
+		.vbi_samples_per_line = 1440, 				\
+		.vbi_start_0 = 6, 					\
+		.vbi_start_1 = 317, 					\
+		.vbi_count_0 = 18, 					\
+		.vbi_count_1 = 18, 					\
+		.vbi_h_start = 0x00, 					\
+		.vbi_v_start = 0x46, 					\
+		.vbi_w = 0xb4, 						\
+		.vbi_h = 0x12						\
+	}, {								\
+		.name = "SECAM LC", /* AV - not tested */		\
+		.id = V4L2_STD_SECAM_LC, 				\
+		.tv_mode = &XC3028L_tv_mode_d_k_secam_a2_dk1,	 	\
+		.channelmap = &XC3028_channel_map_ccir_analog_air, 	\
+		.vbi_sample_rate = 27000000, 				\
+		.vbi_samples_per_line = 1440, 				\
+		.vbi_start_0 = 6, 					\
+		.vbi_start_1 = 317, 					\
+		.vbi_count_0 = 18, 					\
+		.vbi_count_1 = 18, 					\
+		.vbi_h_start = 0x00, 					\
+		.vbi_v_start = 0x46, 					\
+		.vbi_w = 0xb4, 						\
+		.vbi_h = 0x12						\
+	}, {								\
+		.name = "SECAM K1", /* AV - not tested */		\
+		.id = V4L2_STD_SECAM_K1, 				\
+		.tv_mode = &XC3028L_tv_mode_d_k_secam_a2_dk1,	 	\
+		.channelmap = &XC3028_channel_map_ccir_analog_air, 	\
+		.vbi_sample_rate = 27000000, 				\
+		.vbi_samples_per_line = 1440, 				\
+		.vbi_start_0 = 6, 					\
+		.vbi_start_1 = 317, 					\
+		.vbi_count_0 = 18, 					\
+		.vbi_count_1 = 18, 					\
+		.vbi_h_start = 0x00, 					\
+		.vbi_v_start = 0x46, 					\
+		.vbi_w = 0xb4, 						\
+		.vbi_h = 0x12						\
+	}, {								\
+		.name = "PAL-M", /* AV - not tested */			\
+		.id = V4L2_STD_PAL_M, 					\
+		.tv_mode = &XC3028L_tv_mode_d_k_secam_a2_dk1,	 	\
+		.channelmap = &XC3028_channel_map_ccir_analog_air, 	\
+		.vbi_sample_rate = 27000000, 				\
+		.vbi_samples_per_line = 1440, 				\
+		.vbi_start_0 = 6, 					\
+		.vbi_start_1 = 317, 					\
+		.vbi_count_0 = 18, 					\
+		.vbi_count_1 = 18, 					\
+		.vbi_h_start = 0x00, 					\
+		.vbi_v_start = 0x46, 					\
+		.vbi_w = 0xb4, 						\
+		.vbi_h = 0x12						\
+	}								\
+}
+
+#define EETI_XC3028L_DEFAULT_DVBT { 					\
+	{								\
+		/* DVB-T */						\
+		.bandwidth = EM28XX_BANDWIDTH_8_MHZ, 			\
+		.tv_mode = &XC3028L_tv_mode_dtv78_zarlink_4_56mhz, 	\
+		.channelmap = &XC3028_channel_map_ccir_digital_air, 	\
+	}, {								\
+		.bandwidth = EM28XX_BANDWIDTH_7_MHZ, 			\
+		.tv_mode = &XC3028L_tv_mode_dtv78_zarlink_4_56mhz, 	\
+		.channelmap = &XC3028_channel_map_ccir_digital_air, 	\
+	}, {								\
+		.bandwidth = EM28XX_BANDWIDTH_6_MHZ, 			\
+		.tv_mode = &XC3028L_tv_mode_dtv78_zarlink_4_56mhz, 	\
+		.channelmap = &XC3028_channel_map_ccir_digital_air, 	\
+	}								\
+}
+
+#define EETI_XC3028L_DEFAULT_QAM { 					\
+	{								\
+		.bandwidth = EM28XX_BANDWIDTH_6_MHZ, 			\
+		.tv_mode = &XC3028L_tv_mode_dtv6_zarlink_qam_4_56mhz, 	\
+		.channelmap = &XC3028_channel_map_ccir_digital_air, 	\
+	}								\
+}
+
+#define EETI_XC3028L_DEFAULT_FM { 					\
+	{								\
+		.tv_mode = &XC3028L_tv_mode_fm_radio_input1, 		\
+		.channelmap = &XC3028_channel_map_ccir_analog_air, 	\
+	}								\
+}
+
+#define EETI_XC3028L_DEFAULT_ATSC {					\
+	{								\
+		/* ATSC */						\
+		.bandwidth = EM28XX_BANDWIDTH_6_MHZ, 			\
+		.tv_mode = &XC3028L_tv_mode_dtv6_atsc_lg_6_0mhz, 	\
+		.channelmap = &XC3028_channel_map_ccir_digital_air	\
+	}								\
+}
+
+#define EETI_XC3028_DEFAULT_QAM { 					\
+	{								\
+		.bandwidth = EM28XX_BANDWIDTH_6_MHZ, 			\
+		.tv_mode = &XC3028_tv_mode_dtv6_zarlink_qam_4_56mhz, 	\
+		.channelmap = &XC3028_channel_map_ccir_digital_air, 	\
+	}								\
+}
+
+#define EETI_XC3028_DEFAULT_DVBT { 					\
+	{								\
+		/* DVB-T */						\
+		.bandwidth = EM28XX_BANDWIDTH_8_MHZ, 			\
+		.tv_mode = &XC3028_tv_mode_dtv78_zarlink_4_56mhz, 	\
+		.channelmap = &XC3028_channel_map_ccir_digital_air, 	\
+	}, {								\
+		.bandwidth = EM28XX_BANDWIDTH_7_MHZ, 			\
+		.tv_mode = &XC3028_tv_mode_dtv78_zarlink_4_56mhz, 	\
+		.channelmap = &XC3028_channel_map_ccir_digital_air, 	\
+	}, {								\
+		.bandwidth = EM28XX_BANDWIDTH_6_MHZ, 			\
+		.tv_mode = &XC3028_tv_mode_dtv78_zarlink_4_56mhz, 	\
+		.channelmap = &XC3028_channel_map_ccir_digital_air, 	\
+	}								\
+}
+
+
+#define EETI_XC3028_DEFAULT_ATSC {					\
+	{								\
+		/* ATSC */						\
+		.bandwidth = EM28XX_BANDWIDTH_6_MHZ, 			\
+		.tv_mode = &XC3028_tv_mode_dtv6_atsc_lg_6_0mhz, 	\
+		.channelmap = &XC3028_channel_map_ccir_digital_air	\
+	}								\
+}
+
+#define EETI_XC3028_DEFAULT_QAM64 {					\
+	{	/* QAM64 */						\
+		.bandwidth = EM28XX_BANDWIDTH_6_MHZ, 			\
+		.tv_mode = &XC3028_tv_mode_dtv6_qam_6_0mhz, 		\
+		.channelmap = &XC3028_channel_map_ccir_digital_air	\
+	}								\
+}
+
+#define EETI_XC3028_DEFAULT_FM { 					\
+	{								\
+		.tv_mode = &XC3028_tv_mode_fm_radio_input1, 		\
+		.channelmap = &XC3028_channel_map_ccir_analog_air, 	\
+	}								\
+}
+
+#define EETI_XC5000_DEFAULT_ANALOG {					\
+	{								\
+		.name = "PAL-BG", 					\
+		.id = V4L2_STD_PAL_BG, 					\
+		.index = 4, 						\
+		.vbi_sample_rate = 27000000, 				\
+		.vbi_samples_per_line = 1440, 				\
+		.vbi_start_0 = 6, 					\
+		.vbi_start_1 = 317, 					\
+		.vbi_count_0 = 17, 					\
+		.vbi_count_1 = 17, 					\
+		.vbi_h_start = 0x00, 					\
+		.vbi_v_start = 0x46, 					\
+		.vbi_w = 0xb4, 						\
+		.vbi_h = 0x11						\
+	}, {								\
+		.name = "PAL-DK", 					\
+		.id = V4L2_STD_PAL_DK, 					\
+		.index = 9, 						\
+		.vbi_sample_rate = 27000000, 				\
+		.vbi_samples_per_line = 1440, 				\
+		.vbi_start_0 = 6, 					\
+		.vbi_start_1 = 317, 					\
+		.vbi_count_0 = 17, 					\
+		.vbi_count_1 = 17, 					\
+		.vbi_h_start = 0x00, 					\
+		.vbi_v_start = 0x46, 					\
+		.vbi_w = 0xb4, 						\
+		.vbi_h = 0x11						\
+	}, {								\
+		.name = "PAL-I", 					\
+		.id = V4L2_STD_PAL_I, 					\
+		.index = 7, 						\
+		.vbi_sample_rate = 27000000, 				\
+		.vbi_samples_per_line = 1440, 				\
+		.vbi_start_0 = 6, 					\
+		.vbi_start_1 = 317, 					\
+		.vbi_count_0 = 17, 					\
+		.vbi_count_1 = 17, 					\
+		.vbi_h_start = 0x00, 					\
+		.vbi_v_start = 0x46, 					\
+		.vbi_w = 0xb4, 						\
+		.vbi_h = 0x11						\
+	}, {								\
+		.name = "NTSC M", 					\
+		.id = V4L2_STD_NTSC_M, 					\
+		.index = 0, 						\
+		.vbi_sample_rate = 27000000, 				\
+		.vbi_samples_per_line = 1440, 				\
+		.vbi_start_0 = 6, 					\
+		.vbi_start_1 = 317, 					\
+		.vbi_count_0 = 12, 					\
+		.vbi_count_1 = 12, 					\
+		.vbi_h_start = 0x00, 					\
+		.vbi_v_start = 0x06, 					\
+		.vbi_w = 0xb4, 						\
+		.vbi_h = 0x0c						\
+	}, {								\
+		.name = "SECAM L", 					\
+		.id = V4L2_STD_SECAM_L, 				\
+		.index = 15, 						\
+		.vbi_sample_rate = 27000000, 				\
+		.vbi_samples_per_line = 1440, 				\
+		.vbi_start_0 = 6, 					\
+		.vbi_start_1 = 317, 					\
+		.vbi_count_0 = 17, 					\
+		.vbi_count_1 = 17, 					\
+		.vbi_h_start = 0x00, 					\
+		.vbi_v_start = 0x46, 					\
+		.vbi_w = 0xb4, 						\
+		.vbi_h = 0x11						\
+	}, {								\
+		.name = "SECAM LC", 					\
+		.id = V4L2_STD_SECAM_LC, 				\
+		.index = 16, 						\
+		.vbi_sample_rate = 27000000, 				\
+		.vbi_samples_per_line = 1440, 				\
+		.vbi_start_0 = 6, 					\
+		.vbi_start_1 = 317, 					\
+		.vbi_count_0 = 17, 					\
+		.vbi_count_1 = 17, 					\
+		.vbi_h_start = 0x00, 					\
+		.vbi_v_start = 0x46, 					\
+		.vbi_w = 0xb4, 						\
+		.vbi_h = 0x11						\
+	}, {								\
+		.name = "SECAM K1", 					\
+		.id = V4L2_STD_SECAM_K1, 				\
+		.index = 15, 						\
+		.vbi_sample_rate = 27000000, 				\
+		.vbi_samples_per_line = 1440, 				\
+		.vbi_start_0 = 6, 					\
+		.vbi_start_1 = 317, 					\
+		.vbi_count_0 = 17, 					\
+		.vbi_count_1 = 17, 					\
+		.vbi_h_start = 0x00, 					\
+		.vbi_v_start = 0x46, 					\
+		.vbi_w = 0xb4, 						\
+		.vbi_h = 0x11						\
+	}, {								\
+		.name = "PAL-M", /* todo, this one needs testing */	\
+		.id = V4L2_STD_PAL_M, 					\
+		.index = 1, 						\
+		.vbi_sample_rate = 27000000, 				\
+		.vbi_samples_per_line = 1440, 				\
+		.vbi_start_0 = 6, 					\
+		.vbi_start_1 = 317, 					\
+		.vbi_count_0 = 17, 					\
+		.vbi_count_1 = 17, 					\
+		.vbi_h_start = 0x00, 					\
+		.vbi_v_start = 0x46, 					\
+		.vbi_w = 0xb4, 						\
+		.vbi_h = 0x11						\
+	}								\
+}
+
+#define EETI_XC5000_DEFAULT_FM {					\
+	{								\
+		.name = "FM Radio", 					\
+		.index = 22, 						\
+	}								\
+}
+
+#define EETI_XC5000_DEFAULT_DVBT {					\
+	{								\
+		.bandwidth = EM28XX_BANDWIDTH_8_MHZ, 			\
+		.index = 18						\
+	}, {								\
+		.bandwidth = EM28XX_BANDWIDTH_7_MHZ, 			\
+		.index = 20						\
+	}, {								\
+		.bandwidth = EM28XX_BANDWIDTH_6_MHZ, 			\
+		.index = 17						\
+	}								\
+}
+
+#define EETI_XC5000_DEFAULT_ATSC {					\
+	{								\
+		.bandwidth = EM28XX_BANDWIDTH_8_MHZ, 			\
+		.index = 0 /* TODO */					\
+	}								\
+}
+
+#define EETI_XC5000_DEFAULT_QAM {					\
+	{								\
+		.bandwidth = EM28XX_BANDWIDTH_8_MHZ, 			\
+		.index = 0 /* TODO */					\
+	}								\
+}
+
+#define EETI_DEFAULT_GPIO {						\
+	.ts1_on     = _BIT_VAL(EM28XX_GPIO0,  0, 0), 			\
+	.a_on       = _BIT_VAL(EM28XX_GPIO1,  0, 0), 			\
+	.xc3028_sec = _BIT_VAL(EM28XX_GPIO2,  1, 0), 			\
+	/* reserved */							\
+	.t1_reset   = _BIT_VAL(EM28XX_GPIO4,  0, 1), 			\
+	/* reserved */							\
+	.t1_on      = _BIT_VAL(EM28XX_GPIO6,  0, 0), 			\
+	.t2_on      = _BIT_VAL(EM28XX_GPIO7,  1, 0), 			\
+									\
+	.l1_on      = _BIT_VAL(EM28XX_GOP2,   1, 0), 			\
+	.d1_reset   = _BIT_VAL(EM28XX_GOP3,   0, 1), 			\
+}
+
+#define EETI_DRX3975D_GPIO {						\
+	.ts1_on     = _BIT_VAL(EM28XX_GPIO0,  0, 0), 			\
+	.a_on       = _BIT_VAL(EM28XX_GPIO1,  0, 0), 			\
+	.xc3028_sec = _BIT_VAL(EM28XX_GPIO2,  1, 0), 			\
+	/* reserved */							\
+	.t1_reset   = _BIT_VAL(EM28XX_GPIO4,  0, 1), 			\
+	/* reserved */							\
+	.t1_on      = _BIT_VAL(EM28XX_GPIO6,  0, 0), 			\
+	.t2_on      = _BIT_VAL(EM28XX_GPIO7,  1, 0), 			\
+									\
+	.l1_on      = _BIT_VAL(EM28XX_GOP2,   1, 0), 			\
+}
+
+struct em28xx_board em28xx_boards[] = {
+	/* FIXME: please verify the supported video standards */
+	[EM2800_BOARD_GENERIC] = {
+		.name         = "Generic EM2800 video grabber",
+	},
+	[EM2820_BOARD_GENERIC] = {
+		.name         = "Generic EM2820 video grabber",
+	},
+	[EM2821_BOARD_GENERIC] = {
+		.name         = "Generic EM2821 video grabber",
+	},
+	[EM2750_BOARD_GENERIC] = {
+		.name         = "Generic EM2750 video grabber",
+	},
+	[EM2860_BOARD_GENERIC] = {
+		.name         = "Generic EM2860 video grabber",
+	},
+	[EM2861_BOARD_GENERIC] = {
+		.name         = "Generic EM2861 video grabber",
+	},
+	[EM2870_BOARD_GENERIC] = {
+		.name         = "Generic EM2870 video grabber",
+	},
+	[EM2881_BOARD_GENERIC] = {
+		.name         = "Generic EM2881 video grabber",
+	},
+	[EM2883_BOARD_GENERIC] = {
+		.name         = "Generic EM2883 video grabber",
+	},
+	[EM2820_BOARD_KWORLD_PVRTV2800RF] = {
+		.name         = "KWorld PVR TV 2800 RF",
+		.vchannels    = 2,
+		.norm         = V4L2_STD_PAL_BG,
+		.tda9887_conf = TDA9887_PRESENT,
+		.has_tuner    = 1,
+		.decoder      = EM28XX_SAA7113,
+		.dev_modes    = EM28XX_VIDEO,
+		.input           = {{
+			.type     = EM28XX_VMUX_COMPOSITE1,
+			.vmux     = SAA7115_COMPOSITE0,
+			.amux     = 1,
+		}, {
+			.type     = EM28XX_VMUX_SVIDEO,
+			.vmux     = SAA7115_SVIDEO3,
+			.amux     = 1,
+		} },
+		.tvnorms	= {{
+				.name = "PAL-BG",
+				.id = V4L2_STD_PAL_BG,
+			}, {
+				.name = "PAL-DK",
+				.id = V4L2_STD_PAL_DK,
+			}, {
+				.name = "PAL-I",
+				.id = V4L2_STD_PAL_I,
+			}, {
+				.name = "PAL-M",
+
+				.id = V4L2_STD_PAL_M,
+		} },
+	},
+	[EM2820_BOARD_TERRATEC_CINERGY_250] = {
+		.name         = "Terratec Cinergy 250 USB",
+		.vchannels    = 3,
+		.norm         = V4L2_STD_PAL_BG,
+		.tuner_type   = TUNER_LG_PAL_NEW_TAPC,
+		.tda9887_conf = TDA9887_PRESENT,
+		.has_tuner    = 1,
+		.decoder      = EM28XX_SAA7113,
+		.dev_modes    = EM28XX_VIDEO,
+		.ir_i2c       = 1,
+		.input          = {{
+			.type     = EM28XX_VMUX_TELEVISION,
+			.vmux     = SAA7115_COMPOSITE2,
+			.amux     = 1,
+			.amix     = EM28XX_MIX_VIDEO,
+		}, {
+			.type     = EM28XX_VMUX_COMPOSITE1,
+			.vmux     = SAA7115_COMPOSITE0,
+			.amux     = 1,
+			.amix     = EM28XX_MIX_LINE_IN,
+		}, {
+			.type     = EM28XX_VMUX_SVIDEO,
+			.vmux     = SAA7115_SVIDEO3,
+			.amux     = 1,
+			.amix     = EM28XX_MIX_LINE_IN,
+		} },
+		.tvnorms	= {
+			{
+				.name = "PAL-BG",
+				.id = V4L2_STD_PAL_BG,
+			}, {
+				.name = "PAL-DK",
+				.id = V4L2_STD_PAL_DK,
+			}, {
+				.name = "PAL-I",
+				.id = V4L2_STD_PAL_I,
+			}, {
+				.name = "PAL-M",
+				.id = V4L2_STD_PAL_M,
+		} },
+	},
+	[EM2820_BOARD_DLINK_USB_TV] = {
+		.name         = "D-Link DUB-T210 TV Tuner",
+		.vchannels    = 3,
+		.norm         = V4L2_STD_PAL_BG,
+		.tuner_type   = TUNER_LG_PAL_NEW_TAPC,
+		.tda9887_conf = TDA9887_PRESENT,
+		.has_tuner    = 1,
+		.decoder      = EM28XX_SAA7113,
+		.dev_modes    = EM28XX_VIDEO,
+		.input          = {{
+			.type     = EM28XX_VMUX_TELEVISION,
+			.vmux     = SAA7115_COMPOSITE2,
+			.amux     = 1,
+		}, {
+			.type     = EM28XX_VMUX_COMPOSITE1,
+			.vmux     = SAA7115_COMPOSITE0,
+			.amux     = 1,
+		}, {
+			.type     = EM28XX_VMUX_SVIDEO,
+			.vmux     = SAA7115_SVIDEO3,
+			.amux     = 1,
+		} },
+		.tvnorms	= {
+			{
+				.name = "PAL-BG",
+				.id = V4L2_STD_PAL_BG,
+			}, {
+				.name = "PAL-DK",
+				.id = V4L2_STD_PAL_DK,
+			}, {
+				.name = "PAL-I",
+				.id = V4L2_STD_PAL_I,
+			}, {
+				.name = "PAL-M",
+				.id = V4L2_STD_PAL_M,
+		} },
+	},
+	[EM2821_BOARD_PROLINK_PLAYTV_USB2] = {
+		.name         = "SIIG AVTuner-PVR/Prolink PlayTV USB 2.0",
+		.vchannels    = 3,
+		.norm         = V4L2_STD_PAL_BG,
+		.tuner_type   = TUNER_LG_PAL_NEW_TAPC, /* unknown? */
+		.tda9887_conf = TDA9887_PRESENT, /* unknown? */
+		.has_tuner    = 1,
+		.decoder      = EM28XX_SAA7113,
+		.dev_modes    = EM28XX_VIDEO,
+		.input          = {{
+			.type     = EM28XX_VMUX_TELEVISION,
+			.vmux     = SAA7115_COMPOSITE2,
+			.amux     = 1,
+			.amix     = EM28XX_MIX_NOTOUCH,
+		}, {
+			.type     = EM28XX_VMUX_COMPOSITE1,
+			.vmux     = SAA7115_COMPOSITE0,
+			.amux     = 2,
+			.amix     = EM28XX_MIX_LINE_IN,
+		}, {
+			.type     = EM28XX_VMUX_SVIDEO,
+			.vmux     = SAA7115_SVIDEO3,
+			.amux     = 1,
+			.amix     = EM28XX_MIX_LINE_IN,
+		}},
+		.tvnorms	= {
+			{
+				.name = "PAL-BG",
+				.id = V4L2_STD_PAL_BG,
+			}, {
+				.name = "PAL-DK",
+				.id = V4L2_STD_PAL_DK,
+			}, {
+				.name = "PAL-I",
+				.id = V4L2_STD_PAL_I,
+			}, {
+				.name = "PAL-M",
+				.id = V4L2_STD_PAL_M,
+		} },
+	},
+	[EM2820_BOARD_HERCULES_SMART_TV_USB2] = {
+		.name         = "Hercules Smart TV USB 2.0",
+		.vchannels    = 3,
+		.norm         = V4L2_STD_PAL_BG,
+		.tuner_type   = TUNER_LG_PAL_NEW_TAPC,
+		.tda9887_conf = TDA9887_PRESENT,
+		.has_tuner    = 1,
+		.decoder      = EM28XX_SAA7113,
+		.dev_modes    = EM28XX_VIDEO,
+		.input          = {{
+			.type     = EM28XX_VMUX_TELEVISION,
+			.vmux     = SAA7115_COMPOSITE2,
+			.amux     = 1,
+		}, {
+			.type     = EM28XX_VMUX_COMPOSITE1,
+			.vmux     = SAA7115_COMPOSITE0,
+			.amux     = 1,
+		}, {
+			.type     = EM28XX_VMUX_SVIDEO,
+			.vmux     = SAA7115_SVIDEO3,
+			.amux     = 1,
+		} },
+		.tvnorms	= {
+			{
+				.name = "PAL-BG",
+				.id = V4L2_STD_PAL_BG,
+			}, {
+				.name = "PAL-DK",
+				.id = V4L2_STD_PAL_DK,
+			}, {
+				.name = "PAL-I",
+				.id = V4L2_STD_PAL_I,
+			}, {
+				.name = "PAL-M",
+				.id = V4L2_STD_PAL_M,
+		} },
+	},
+	[EM2820_BOARD_PINNACLE_USB_2] = {
+		.name         = "Pinnacle PCTV USB 2",
+		.vchannels    = 3,
+		.norm         = V4L2_STD_PAL_BG,
+		.tuner_type   = TUNER_LG_PAL_NEW_TAPC,
+		.tda9887_conf = TDA9887_PRESENT,
+		.has_tuner    = 1,
+		.decoder      = EM28XX_SAA7113,
+		.dev_modes    = EM28XX_VIDEO,
+		.input          = {{
+			.type     = EM28XX_VMUX_TELEVISION,
+			.vmux     = SAA7115_COMPOSITE2,
+			.amux     = 0,
+		}, {
+			.type     = EM28XX_VMUX_COMPOSITE1,
+			.vmux     = SAA7115_COMPOSITE0,
+			.amux     = 1,
+		}, {
+			.type     = EM28XX_VMUX_SVIDEO,
+			.vmux     = SAA7115_SVIDEO3,
+			.amux     = 1,
+		} },
+		.tvnorms	= {
+			{
+				.name = "PAL-BG",
+				.id = V4L2_STD_PAL_BG,
+			}, {
+				.name = "PAL-DK",
+				.id = V4L2_STD_PAL_DK,
+			}, {
+				.name = "PAL-I",
+
+				.id = V4L2_STD_PAL_I,
+			}, {
+				.name = "PAL-M",
+
+				.id = V4L2_STD_PAL_M,
+			}, {
+				.name = "NTSC",
+
+				.id = V4L2_STD_NTSC,
+		} },
+	},
+	[EM2820_BOARD_PINNACLE_USB_2_FM1216ME] = {
+		.name         = "Pinnacle PCTV USB 2 (Philips FM1216ME)",
+		.vchannels    = 3,
+		.norm         = V4L2_STD_PAL_BG,
+		.tuner_type   = TUNER_PHILIPS_FM1216ME_MK3,
+		.tda9887_conf = TDA9887_PRESENT,
+		.has_tuner    = 1,
+		.decoder      = EM28XX_SAA7113,
+		.dev_modes    = EM28XX_VIDEO,
+		.input          = {{
+			.type     = EM28XX_VMUX_TELEVISION,
+			.vmux     = SAA7115_COMPOSITE2,
+			.amux     = 0,
+		}, {
+			.type     = EM28XX_VMUX_COMPOSITE1,
+			.vmux     = SAA7115_COMPOSITE0,
+			.amux     = 1,
+		}, {
+			.type     = EM28XX_VMUX_SVIDEO,
+			.vmux     = SAA7115_SVIDEO3,
+			.amux     = 1,
+		} },
+		.tvnorms        = {
+			{
+				.name = "PAL-BG",
+				.id = V4L2_STD_PAL_BG,
+			}, {
+				.name = "PAL-DK",
+				.id = V4L2_STD_PAL_DK,
+			}, {
+				.name = "PAL-I",
+				.id = V4L2_STD_PAL_I,
+			}, {
+				.name = "PAL-M",
+				.id = V4L2_STD_PAL_M,
+			}, {
+				.name = "NTSC",
+				.id = V4L2_STD_NTSC,
+			}, {
+				.name = "SECAM-DK",
+				.id = V4L2_STD_SECAM_DK,
+			} },
+	},
+	[EM2820_BOARD_HAUPPAUGE_WINTV_USB_2_R2] = {
+		.name         = "Hauppauge WinTV USB 2 (R2)",
+		.vchannels    = 3,
+		.norm         = V4L2_STD_PAL_BG,
+		.tuner_type   = TUNER_ABSENT,
+		.tda9887_conf = TDA9887_PRESENT|TDA9887_PORT1_ACTIVE|TDA9887_PORT2_ACTIVE,
+		.has_tuner    = 1,
+		.decoder      = EM28XX_TVP5150,
+		.has_msp34xx  = 1,
+		.dev_modes    = EM28XX_VIDEO,
+		/*FIXME: S-Video not tested */
+		.input          = {{
+			.type     = EM28XX_VMUX_TELEVISION,
+			.vmux     = TVP5150_COMPOSITE0,
+			.amux     = 6,
+		}, {
+			.type     = EM28XX_VMUX_SVIDEO,
+			.vmux     = TVP5150_SVIDEO,
+			.amux     = 1,
+		} },
+		.tvnorms	= {{
+				.name = "PAL-BG",
+				.id = V4L2_STD_PAL_BG,
+			}, {
+				.name = "NTSC",
+				.id = V4L2_STD_NTSC,
+		} },
+	},
+	[EM2820_BOARD_HAUPPAUGE_WINTV_USB_2] = {
+		.name         = "Hauppauge WinTV USB 2",
+		.vchannels    = 3,
+		.norm         = V4L2_STD_NTSC,
+		.tuner_type   = TUNER_ABSENT,
+		.tda9887_conf = TDA9887_PRESENT|TDA9887_PORT1_ACTIVE|TDA9887_PORT2_ACTIVE,
+		.has_tuner    = 1,
+		.decoder      = EM28XX_TVP5150,
+		.has_msp34xx  = 1,
+		.dev_modes    = EM28XX_VIDEO,
+		/*FIXME: S-Video not tested */
+		.input          = {{
+			.type     = EM28XX_VMUX_TELEVISION,
+			.vmux     = TVP5150_COMPOSITE0,
+			.amux     = 6,
+		}, {
+			.type     = EM28XX_VMUX_SVIDEO,
+			.vmux     = TVP5150_COMPOSITE1,
+			.amux     = 1,
+		} },
+		.tvnorms	= {{
+				.name = "NTSC",
+
+				.id = V4L2_STD_NTSC,
+		} },
+	},
+	[EM2870_BOARD_HAUPPAUGE_WINTV_USB_2_R2] = {
+		.name         = "Hauppauge WinTV USB 2 R2",
+		.vchannels    = 3,
+		.norm         = V4L2_STD_NTSC_M,
+		.tuner_type   = TUNER_XCEIVE_XC3028,
+		.tuner_addr   = 0xc2,
+		.has_tuner    = 1,
+		.has_inttuner = 1,
+		.decoder      = EM28XX_TVP5150,
+		.dev_modes    = EM28XX_VIDEO,
+		.input          = {{
+			.type     = EM28XX_VMUX_TELEVISION,
+			.vmux     = TVP5150_COMPOSITE0,
+			.amux     = 6,
+		}, {
+			.type     = EM28XX_VMUX_COMPOSITE1,
+			.vmux     = TVP5150_COMPOSITE1,
+			.amux     = 1,
+		}, {
+			.type     = EM28XX_VMUX_SVIDEO,
+			.vmux     = TVP5150_SVIDEO,
+			.amux     = 1,
+		} },
+		.manual_gpio	= 1,
+		.gpio_regs 	= EETI_DEFAULT_GPIO,
+		.tvnorms	= EETI_XC3028_DEFAULT_ANALOG,
+		.dvbnorms	= EETI_XC3028_DEFAULT_DVBT,
+	},
+	[EM2821_BOARD_SUPERCOMP_USB_2] = {
+		.name         = "Supercomp USB 2.0 TV",
+		.vchannels    = 3,
+		.norm         = V4L2_STD_PAL_BG,
+		.has_tuner    = 1,
+		.tuner_type   = TUNER_PHILIPS_FM1236_MK3,
+		.tda9887_conf = TDA9887_PRESENT|TDA9887_PORT1_ACTIVE|TDA9887_PORT2_ACTIVE,
+		.decoder      = EM28XX_SAA7113,
+		.dev_modes    = EM28XX_VIDEO,
+		.input          = {{
+			.type     = EM28XX_VMUX_TELEVISION,
+			.vmux     = SAA7115_COMPOSITE2,
+			.amux     = 1,
+		}, {
+			.type     = EM28XX_VMUX_COMPOSITE1,
+			.vmux     = SAA7115_COMPOSITE0,
+			.amux     = 0,
+		}, {
+			.type     = EM28XX_VMUX_SVIDEO,
+			.vmux     = SAA7115_SVIDEO3,
+			.amux     = 1,
+		} },
+		.tvnorms	= {
+			{
+				.name = "PAL-BG",
+				.id = V4L2_STD_PAL_BG,
+			}, {
+				.name = "PAL-DK",
+				.id = V4L2_STD_PAL_DK,
+			}, {
+				.name = "PAL-I",
+				.id = V4L2_STD_PAL_I,
+			}, {
+				.name = "PAL-M",
+				.id = V4L2_STD_PAL_M,
+		} },
+	},
+	[EM2880_BOARD_HAUPPAUGE_WINTV_HVR_900] = {
+		.name         = "Hauppauge WinTV HVR 900",
+		.vchannels    = 3,
+		.norm         = V4L2_STD_PAL_BG,
+		.tuner_type   = TUNER_XCEIVE_XC3028,
+		.tuner_addr   = 0xc2,
+		.has_tuner    = 1,
+		.has_inttuner = 1,
+		.decoder      = EM28XX_TVP5150,
+		.dev_modes    = EM28XX_VIDEO | EM28XX_VBI | EM28XX_DVBT,
+		.input          = {{
+			.type     = EM28XX_VMUX_TELEVISION,
+			.vmux     = TVP5150_COMPOSITE0,
+			.amux     = 0,
+		}, {
+			.type     = EM28XX_VMUX_COMPOSITE1,
+			.vmux     = TVP5150_COMPOSITE1,
+			.amux     = 1,
+		}, {
+			.type     = EM28XX_VMUX_SVIDEO,
+			.vmux     = TVP5150_SVIDEO,
+			.amux     = 1,
+		} },
+		.manual_gpio	= 1,
+		.gpio_regs 	= EETI_DEFAULT_GPIO,
+		.tvnorms	= EETI_XC3028_DEFAULT_ANALOG,
+		.dvbnorms	= EETI_XC3028_DEFAULT_DVBT
+	},
+	[EM2883_BOARD_PINNACLE_PCTV_HD_PRO] = {
+		.name         = "Pinnacle PCTV HD Pro",
+		.vchannels    = 3,
+		.norm         = V4L2_STD_NTSC_M,
+		.tuner_type   = TUNER_XCEIVE_XC3028,
+		.has_tuner    = 1,
+		.has_inttuner = 1,
+		.decoder      = EM28XX_TVP5150,
+		.dev_modes    = EM28XX_VIDEO | EM28XX_AUDIO | EM28XX_VBI | EM28XX_ATSC,
+		.input          = {{
+			.type     = EM28XX_VMUX_TELEVISION,
+			.vmux     = TVP5150_COMPOSITE0,
+			.amux     = 0,
+		}, {
+			.type     = EM28XX_VMUX_COMPOSITE1,
+			.vmux     = TVP5150_COMPOSITE1,
+			.amux     = 1,
+		}, {
+			.type     = EM28XX_VMUX_SVIDEO,
+			.vmux     = TVP5150_SVIDEO,
+			.amux     = 1,
+		} },
+		.manual_gpio	= 1,
+		.gpio_regs 	= EETI_DEFAULT_GPIO,
+		.tvnorms	= EETI_XC3028_DEFAULT_ANALOG,
+		.atscnorms	= EETI_XC3028_DEFAULT_ATSC,
+		.qamnorms	= EETI_XC3028_DEFAULT_QAM,
+	},
+	[EM2883_BOARD_KWORLD_HYBRID_F306] = {
+		.name         = "KWorld PlusTV F306",
+		.em_type      = EM2883,
+		.vchannels    = 3,
+		.norm         = V4L2_STD_NTSC_M,
+		.tuner_type   = TUNER_XCEIVE_XC3028,
+		.has_inttuner = 1,
+		.has_tuner    = 1,
+		.decoder      = EM28XX_TVP5150,
+		.dev_modes    = EM28XX_VIDEO | EM28XX_AUDIO | EM28XX_VBI,
+		.input          = {{
+			.type     = EM28XX_VMUX_TELEVISION,
+			.vmux     = TVP5150_COMPOSITE0,
+			.amux     = 0,
+		}, {
+			.type     = EM28XX_VMUX_COMPOSITE1,
+			.vmux     = TVP5150_COMPOSITE1,
+			.amux     = 1,
+		}, {
+			.type     = EM28XX_VMUX_SVIDEO,
+			.vmux     = TVP5150_SVIDEO,
+			.amux     = 1,
+		} },
+		.manual_gpio	= 1,
+		.gpio_regs 	= EETI_DEFAULT_GPIO,
+		.tvnorms	= EETI_XC3028_DEFAULT_ANALOG,
+	},
+	[EM2888_BOARD_KWORLD_HYBRID_E329] = {
+		.name	      = "KWorld 329u",
+		.em_type      = EM2888,
+		.vchannels    = 3,
+		.norm	      = V4L2_STD_NTSC_M,
+		.tuner_type   = TUNER_XCEIVE_XC3028,
+		.has_inttuner = 1,
+		.has_tuner    = 1,
+		.decoder      = EM28XX_CX25843,
+		.ir_keytab    = ir_codes_em_kworld,
+		.ir_getkey    = em2888_get_key_empia,
+		.dev_modes    = EM28XX_VIDEO | EM28XX_VBI | EM28XX_DVBT | EM28XX_AUDIO | EM28XX_RADIO,
+		.powersaving  = 1,
+		.input          = {{
+			.type     = EM28XX_VMUX_TELEVISION,
+			.vmux     = CX25843_TELEVISION,
+			.amux     = 0,
+		}, {
+			.type     = EM28XX_VMUX_COMPOSITE1,
+			.vmux     = CX25843_COMPOSITE1,
+			.amux     = 4,
+		}, {
+			.type     = EM28XX_VMUX_SVIDEO,
+			.vmux     = CX25843_SVIDEO,
+			.amux     = 5,
+		} },
+		.tvnorms	= EETI_XC3028L_DEFAULT_ANALOG,
+		.dvbnorms	= EETI_XC3028L_DEFAULT_DVBT,
+		.fmnorms	= EETI_XC3028L_DEFAULT_FM,
+	},
+	[EM2888_BOARD_LINCOLN_TV_FM] = {
+		.name	      = "Lincoln TV FM",
+		.em_type      = EM2888,
+		.vchannels    = 3,
+		.norm	      = V4L2_STD_NTSC_M,
+		.tuner_type   = TUNER_XCEIVE_XC3028,
+		.has_inttuner = 1,
+		.has_tuner    = 1,
+		.decoder      = EM28XX_CX25843,
+		.dev_modes    = EM28XX_VIDEO | EM28XX_VBI | EM28XX_AUDIO | EM28XX_RADIO,
+		.powersaving  = 1,
+		.input          = {{
+			.type     = EM28XX_VMUX_TELEVISION,
+			.vmux     = CX25843_TELEVISION,
+			.amux     = 0,
+		}, {
+			.type     = EM28XX_VMUX_COMPOSITE1,
+			.vmux     = CX25843_COMPOSITE1,
+			.amux     = 4,
+		}, {
+			.type     = EM28XX_VMUX_SVIDEO,
+			.vmux     = CX25843_SVIDEO,
+			.amux     = 5,
+		} },
+		.tvnorms	= EETI_XC3028L_DEFAULT_ANALOG,
+		.fmnorms	= EETI_XC3028L_DEFAULT_FM,
+	},
+	[EM2883_BOARD_KWORLD_HYBRID_E323] = {
+		.name	      = "KWorld E323",
+		.vchannels    = 3,
+		.norm	      = V4L2_STD_NTSC_M,
+		.tuner_type   = TUNER_XCEIVE_XC3028,
+		.has_inttuner = 1,
+		.has_tuner    = 1,
+		.decoder      = EM28XX_TVP5150,
+		.dev_modes    = EM28XX_VIDEO | EM28XX_AUDIO | EM28XX_VBI | EM28XX_DVBT,
+		.input        = {{
+			.type     = EM28XX_VMUX_TELEVISION,
+			.vmux     = TVP5150_COMPOSITE0,
+			.amux     = 0,
+		}, {
+			.type     = EM28XX_VMUX_COMPOSITE1,
+			.vmux     = TVP5150_COMPOSITE1,
+			.amux     = 1,
+		}, {
+			.type     = EM28XX_VMUX_SVIDEO,
+			.vmux     = TVP5150_SVIDEO,
+			.amux     = 1,
+		} },
+		.manual_gpio	= 1,
+		.gpio_regs 	= EETI_DEFAULT_GPIO,
+		.tvnorms	= EETI_XC3028_DEFAULT_ANALOG,
+		.dvbnorms	= EETI_XC3028_DEFAULT_DVBT,
+		.fmnorms	= EETI_XC3028_DEFAULT_FM,
+	},
+	[EM2883_BOARD_KWORLD_HYBRID_A316] = {
+		.name         = "KWorld PlusTV HD Hybrid 330",
+		.vchannels    = 3,
+		.norm         = V4L2_STD_NTSC_M,
+		.tuner_type   = TUNER_XCEIVE_XC3028,
+		.has_inttuner = 1,
+		.has_tuner    = 1,
+		.decoder      = EM28XX_TVP5150,
+		.dev_modes    = EM28XX_VIDEO | EM28XX_AUDIO | EM28XX_VBI | EM28XX_DVBT,
+
+		.input          = {{
+			.type     = EM28XX_VMUX_TELEVISION,
+			.vmux     = TVP5150_COMPOSITE0,
+			.amux     = 0,
+		}, {
+			.type     = EM28XX_VMUX_COMPOSITE1,
+			.vmux     = TVP5150_COMPOSITE1,
+			.amux     = 1,
+		}, {
+			.type     = EM28XX_VMUX_SVIDEO,
+			.vmux     = TVP5150_SVIDEO,
+			.amux     = 1,
+		} },
+
+		.manual_gpio	= 1,
+		.gpio_regs 	= EETI_DEFAULT_GPIO,
+		.tvnorms	= EETI_XC3028_DEFAULT_ANALOG,
+		.dvbnorms	= EETI_XC3028_DEFAULT_DVBT,
+	},
+	[EM2883_BOARD_HAUPPAUGE_WINTV_HVR_950] = {
+		.name         = "Hauppauge WinTV HVR 950",
+		.vchannels    = 3,
+		.norm         = V4L2_STD_NTSC_M,
+		.tuner_type   = TUNER_XCEIVE_XC3028,
+		.has_tuner    = 1,
+		.has_inttuner = 1,
+		.decoder      = EM28XX_TVP5150,
+		.dev_modes    = EM28XX_VIDEO | EM28XX_AUDIO | EM28XX_VBI | EM28XX_ATSC,
+		.input          = {{
+			.type     = EM28XX_VMUX_TELEVISION,
+			.vmux     = TVP5150_COMPOSITE0,
+			.amux     = 0,
+		}, {
+			.type     = EM28XX_VMUX_COMPOSITE1,
+			.vmux     = TVP5150_COMPOSITE1,
+			.amux     = 1,
+		}, {
+			.type     = EM28XX_VMUX_SVIDEO,
+			.vmux     = TVP5150_SVIDEO,
+			.amux     = 1,
+		} },
+		.manual_gpio	= 1,
+		.gpio_regs 	= EETI_DEFAULT_GPIO,
+		.tvnorms	= EETI_XC3028_DEFAULT_ANALOG,
+		.atscnorms	= EETI_XC3028_DEFAULT_ATSC,
+		.qamnorms	= EETI_XC3028_DEFAULT_QAM,
+	},
+	[EM2880_BOARD_HAUPPAUGE_WINTV_HVR_900_R2] = {
+		.name         = "Hauppauge WinTV HVR (B2C0)",
+		.vchannels    = 3,
+		.norm         = V4L2_STD_PAL_BG,
+		.has_inttuner = 1,
+		.has_tuner    = 1,
+		.tuner_type   = TUNER_XCEIVE_XC3028,
+		.tuner_addr   = 0xc2,
+		.decoder      = EM28XX_TVP5150,
+		.ir_keytab    = ir_codes_hauppauge_new_u,
+		.ir_getkey    = em2880_get_key_empia,
+		.dev_modes    = EM28XX_VIDEO | EM28XX_AUDIO | EM28XX_VBI | EM28XX_DVBT,
+		.input          = {{
+			.type     = EM28XX_VMUX_TELEVISION,
+			.vmux     = TVP5150_COMPOSITE0,
+			.amux     = 0,
+		}, {
+			.type     = EM28XX_VMUX_COMPOSITE1,
+			.vmux     = TVP5150_COMPOSITE1,
+			.amux     = 1,
+		}, {
+			.type     = EM28XX_VMUX_SVIDEO,
+			.vmux     = TVP5150_SVIDEO,
+			.amux     = 1,
+		} },
+		.manual_gpio	= 1,
+		.gpio_regs 	= EETI_DRX3975D_GPIO,
+		.tvnorms	= EETI_XC3028_DEFAULT_ANALOG,
+		.dvbnorms	= EETI_XC3028_DEFAULT_DVBT,
+	},
+	[EM2860_BOARD_TERRATEC_HYBRID_XS] = {
+		.name         = "Terratec Cinergy A Hybrid XS",
+		.vchannels    = 3,
+		.norm         = V4L2_STD_PAL_BG,
+		.has_tuner    = 1,
+		.has_inttuner = 1,
+		.tuner_type   = TUNER_XCEIVE_XC3028,
+		.decoder      = EM28XX_TVP5150,
+		.ir_keytab    = ir_codes_em_terratec2,
+		.ir_getkey    = em2880_get_key_terratec,
+		.dev_modes    = EM28XX_VIDEO | EM28XX_VBI,
+		.input          = {{
+			.type     = EM28XX_VMUX_TELEVISION,
+			.vmux     = TVP5150_COMPOSITE0,
+			.amux     = 0,
+		}, {
+			.type     = EM28XX_VMUX_COMPOSITE1,
+			.vmux     = TVP5150_COMPOSITE1,
+			.amux     = 1,
+		}, {
+			.type     = EM28XX_VMUX_SVIDEO,
+			.vmux     = TVP5150_SVIDEO,
+			.amux     = 1,
+		} },
+		.manual_gpio	= 1,
+		.gpio_regs 	= EETI_DEFAULT_GPIO,
+		.tvnorms	= EETI_XC3028_DEFAULT_ANALOG,
+	},
+	[EM2880_BOARD_TERRATEC_HYBRID_XS] = {
+		.name         = "Terratec Hybrid XS",
+		.vchannels    = 3,
+		.has_inttuner = 1,
+		.has_tuner    = 1,
+		.norm         = V4L2_STD_PAL_BG,
+		.tuner_type   = TUNER_XCEIVE_XC3028,
+		.decoder      = EM28XX_TVP5150,
+		.ir_keytab    = ir_codes_em_terratec2,
+		.ir_getkey    = em2880_get_key_terratec,
+		.dev_modes    = EM28XX_VIDEO | EM28XX_VBI | EM28XX_DVBT,
+		.powersaving  = 1,
+		.input          = {{
+			.type     = EM28XX_VMUX_TELEVISION,
+			.vmux     = TVP5150_COMPOSITE0,
+			.amux     = 0,
+		}, {
+			.type     = EM28XX_VMUX_COMPOSITE1,
+			.vmux     = TVP5150_COMPOSITE1,
+			.amux     = 1,
+		}, {
+			.type     = EM28XX_VMUX_SVIDEO,
+			.vmux     = TVP5150_SVIDEO,
+			.amux     = 1,
+		} },
+		.manual_gpio	= 1,
+		.gpio_regs 	= EETI_DEFAULT_GPIO,
+		.tvnorms	= EETI_XC3028_DEFAULT_ANALOG,
+		.dvbnorms	= EETI_XC3028_DEFAULT_DVBT,
+	},
+	[EM2861_BOARD_KWORLD_PVRTV_300U] = {
+		.name	      = "KWorld PVRTV 300U",
+		.vchannels    = 3,
+		.norm         = V4L2_STD_NTSC_M,
+		.has_tuner    = 1,
+		.has_inttuner = 1,
+		.tuner_type   = TUNER_XCEIVE_XC3028,
+		.decoder      = EM28XX_TVP5150,
+		.dev_modes    = EM28XX_VIDEO | EM28XX_VBI | EM28XX_AUDIO2,
+		.input          = {{
+			.type     = EM28XX_VMUX_TELEVISION,
+			.vmux     = TVP5150_COMPOSITE0,
+			.amux     = 0,
+		}, {
+			.type     = EM28XX_VMUX_COMPOSITE1,
+			.vmux     = TVP5150_COMPOSITE1,
+			.amux     = 1,
+		}, {
+			.type     = EM28XX_VMUX_SVIDEO,
+			.vmux     = TVP5150_SVIDEO,
+			.amux     = 1,
+		} },
+		.manual_gpio	= 1,
+		.gpio_regs 	= EETI_DEFAULT_GPIO,
+		.tvnorms	= EETI_XC3028_DEFAULT_ANALOG,
+	},
+	[EM2880_BOARD_KWORLD_DVB_310U] = {
+		.name	      = "KWorld DVB-T 310U",
+		.vchannels    = 3,
+		.norm         = V4L2_STD_PAL_BG,
+		.has_tuner    = 1,
+		.has_inttuner = 1,
+		.tuner_type   = TUNER_XCEIVE_XC3028,
+		.decoder      = EM28XX_TVP5150,
+		.dev_modes    = EM28XX_VIDEO | EM28XX_VBI | EM28XX_DVBT,
+		.input          = {{
+			.type     = EM28XX_VMUX_TELEVISION,
+			.vmux     = TVP5150_COMPOSITE0,
+			.amux     = 0,
+		}, {
+			.type     = EM28XX_VMUX_COMPOSITE1,
+			.vmux     = TVP5150_COMPOSITE1,
+			.amux     = 1,
+		}, {
+			.type     = EM28XX_VMUX_SVIDEO,
+			.vmux     = TVP5150_SVIDEO,
+			.amux     = 1,
+		} },
+		.manual_gpio	= 1,
+		.gpio_regs 	= EETI_DEFAULT_GPIO,
+		.tvnorms	= EETI_XC3028_DEFAULT_ANALOG,
+		.dvbnorms	= EETI_XC3028_DEFAULT_DVBT,
+	},
+	[EM2880_BOARD_KWORLD_DVB_305U] = {
+		.name	      = "KWorld DVB-T 305U",
+		.vchannels    = 3,
+		.norm         = V4L2_STD_PAL_BG,
+		.has_tuner    = 1,
+		.has_inttuner = 1,
+		.tuner_type   = TUNER_XCEIVE_XC3028,
+		.decoder      = EM28XX_TVP5150,
+		.dev_modes    = EM28XX_VIDEO | EM28XX_VBI | EM28XX_DVBT,
+		.input          = {{
+			.type     = EM28XX_VMUX_TELEVISION,
+			.vmux     = TVP5150_COMPOSITE0,
+			.amux     = 0,
+		}, {
+			.type     = EM28XX_VMUX_COMPOSITE1,
+			.vmux     = TVP5150_COMPOSITE1,
+			.amux     = 1,
+		}, {
+			.type     = EM28XX_VMUX_SVIDEO,
+			.vmux     = TVP5150_SVIDEO,
+			.amux     = 1,
+		} },
+		.manual_gpio	= 1,
+		.gpio_regs 	= EETI_DEFAULT_GPIO,
+		.tvnorms	= EETI_XC3028_DEFAULT_ANALOG,
+		.dvbnorms	= EETI_XC3028_DEFAULT_DVBT,
+	},
+	[EM2880_BOARD_TERRATEC_HYBRID_XS_FR] = {
+		.name         = "Terratec Hybrid XS Secam",
+		.vchannels    = 3,
+		.norm         = V4L2_STD_SECAM_L,
+		.has_tuner    = 1,
+		.has_inttuner = 1,
+		.has_msp34xx  = 1,
+		.tuner_type   = TUNER_XCEIVE_XC3028,
+		.decoder      = EM28XX_TVP5150,
+		.dev_modes    = EM28XX_VIDEO | EM28XX_VBI | EM28XX_DVBT,
+		.input          = {{
+			.type     = EM28XX_VMUX_TELEVISION,
+			.vmux     = TVP5150_COMPOSITE0,
+			.amux     = 0,
+		}, {
+			.type     = EM28XX_VMUX_COMPOSITE1,
+			.vmux     = TVP5150_COMPOSITE1,
+			.amux     = 1,
+		}, {
+			.type     = EM28XX_VMUX_SVIDEO,
+			.vmux     = TVP5150_SVIDEO,
+			.amux     = 1,
+		} },
+		.manual_gpio	= 1,
+		.gpio_regs 	= EETI_DEFAULT_GPIO,
+		.tvnorms	= EETI_XC3028_DEFAULT_ANALOG,
+		.dvbnorms	= EETI_XC3028_DEFAULT_DVBT,
+	},
+	[EM2882_BOARD_TERRATEC_HYBRID_XS] = {
+		.name         = "Empia Hybrid ATSC (em2882)",
+		.vchannels    = 3,
+		.norm         = V4L2_STD_PAL_BG,
+		.has_tuner    = 1,
+		.has_inttuner = 1,
+		.tuner_type   = TUNER_XCEIVE_XC3028,
+		.decoder      = EM28XX_TVP5150,
+		.ir_keytab    = ir_codes_em_terratec2,
+		.ir_getkey    = em2880_get_key_terratec, 
+		.dev_modes    = EM28XX_VIDEO | EM28XX_VBI | EM28XX_DVBT | EM28XX_AUDIO,
+		.input          = {{
+			.type     = EM28XX_VMUX_TELEVISION,
+			.vmux     = TVP5150_COMPOSITE0,
+			.amux     = 0,
+		}, {
+			.type     = EM28XX_VMUX_COMPOSITE1,
+			.vmux     = TVP5150_COMPOSITE1,
+			.amux     = 1,
+		}, {
+			.type     = EM28XX_VMUX_SVIDEO,
+			.vmux     = TVP5150_SVIDEO,
+			.amux     = 1,
+		} },
+		.manual_gpio	= 1,
+		.gpio_regs 	= EETI_DEFAULT_GPIO,
+		.tvnorms	= EETI_XC3028_DEFAULT_ANALOG,
+		.dvbnorms	= EETI_XC3028_DEFAULT_DVBT,
+	},
+	[EM2883_BOARD_TERRATEC_HYBRID_XS_FM] = {
+		.name         = "Terratec Hybrid XS FM (em2883)",
+		.em_type      = EM2883,
+		.vchannels    = 3,
+		.norm         = V4L2_STD_PAL_BG,
+		.has_radio    = 1,
+		.has_inttuner = 1,
+#if 0
+		.powersaving  = 1,
+#endif
+		.tuner_type   = TUNER_XCEIVE_XC5000,
+		.decoder      = EM28XX_CX25843,
+		.ir_keytab    = ir_codes_em_terratec2,
+		.ir_getkey    = em2880_get_key_terratec,
+		.dev_modes    = EM28XX_VIDEO | EM28XX_VBI | EM28XX_DVBT | EM28XX_AUDIO | EM28XX_RADIO,
+		.input          = {{
+			.type     = EM28XX_VMUX_TELEVISION,
+			.vmux     = CX25843_TELEVISION,
+			.amux     = 0,
+		}, {
+			.type     = EM28XX_VMUX_COMPOSITE1,
+			.vmux     = CX25843_COMPOSITE1,
+			.amux     = 4,
+		}, {
+			.type     = EM28XX_VMUX_SVIDEO,
+			.vmux     = CX25843_SVIDEO,
+			.amux     = 5,
+		} },
+		.tvnorms	= EETI_XC5000_DEFAULT_ANALOG,
+		.dvbnorms	= EETI_XC5000_DEFAULT_DVBT,
+		.fmnorms	= EETI_XC5000_DEFAULT_FM,
+	},
+	[EM2881_BOARD_DNT_DA2_HYBRID] = {
+		.name         = "DNT DA2 Hybrid",
+		.vchannels    = 3,
+		.norm         = V4L2_STD_PAL_BG,
+		.has_tuner    = 1,
+		.has_inttuner = 1,
+		.tuner_type   = TUNER_XCEIVE_XC3028,
+		.decoder      = EM28XX_TVP5150,
+		.dev_modes    = EM28XX_VIDEO | EM28XX_VBI | EM28XX_DVBT,
+		.input          = {{
+			.type     = EM28XX_VMUX_TELEVISION,
+			.vmux     = TVP5150_COMPOSITE0,
+			.amux     = 0,
+		}, {
+			.type     = EM28XX_VMUX_COMPOSITE1,
+			.vmux     = TVP5150_COMPOSITE1,
+			.amux     = 1,
+		}, {
+			.type     = EM28XX_VMUX_SVIDEO,
+			.vmux     = TVP5150_SVIDEO,
+			.amux     = 1,
+		} },
+		.manual_gpio	= 1,
+		.gpio_regs 	= EETI_DEFAULT_GPIO,
+		.tvnorms	= EETI_XC3028_DEFAULT_ANALOG,
+		.dvbnorms	= EETI_XC3028_DEFAULT_DVBT,
+	},
+	[EM2870_BOARD_TERRATEC_XS] = {
+		.name         = "Terratec Cinergy T XS",
+		.has_tuner    = 1,
+		.has_inttuner = 1,
+		.tuner_type   = TUNER_XCEIVE_XC3028,
+		.dev_modes    = EM28XX_DVBT,
+		.manual_gpio	= 1,
+		.gpio_regs 	= EETI_DEFAULT_GPIO,
+		.dvbnorms	= EETI_XC3028_DEFAULT_DVBT,
+	},
+	[EM2870_BOARD_TERRATEC_XS_MT2060] = {
+		.name         = "Terratec Cinergy T XS (MT2060)",
+		.tuner_type   = TUNER_MT2060,
+		.dev_modes    = EM28XX_DVBT,
+#if 0
+		.manual_gpio  = 1,
+		.gpio_regs    = EETI_DEFAULT_GPIO,
+#endif
+	},
+	[EM2870_BOARD_PINNACLE_PCTV_DVB] = {
+		.name         = "Pinnacle PCTV DVB-T",
+		.tuner_type   = TUNER_MT2060,
+		.dev_modes    = EM28XX_DVBT,
+		.ir_keytab    = ir_codes_pinnacle2,
+		.ir_getkey    = em2880_get_key_empia,
+#if 0
+		.manual_gpio  = 1,
+		.gpio_regs    = EETI_DEFAULT_GPIO,
+#endif
+	},
+	[EM2870_BOARD_KWORLD_350U] = {
+		.name         = "KWorld 350 U DVB-T",
+		.has_tuner    = 1,
+		.has_inttuner = 1,
+		.dev_modes    = EM28XX_DVBT,
+		.tuner_type   = TUNER_XCEIVE_XC3028,
+		.manual_gpio	= 1,
+		.gpio_regs 	= EETI_DEFAULT_GPIO,
+		.dvbnorms	= EETI_XC3028_DEFAULT_DVBT,
+	},
+	[EM2870_BOARD_KWORLD_355U] = {
+		.name         = "KWorld 355 U DVB-T",
+		.tuner_type   = TUNER_QT1010,
+		.dev_modes    = EM28XX_DVBT,
+		.manual_gpio  = 1,
+		.gpio_regs 	= EETI_DEFAULT_GPIO,
+	},
+	[EM2870_BOARD_COMPRO_VIDEOMATE] = {
+		.name         = "Compro, VideoMate U3",
+		.tuner_type   = TUNER_MT2060,
+		.dev_modes    = EM28XX_DVBT,
+	},
+	[EM2881_BOARD_PINNACLE_HYBRID_PRO] = {
+		.name         = "Pinnacle Hybrid Pro",
+		.vchannels    = 3,
+		.norm         = V4L2_STD_PAL_BG,
+		.has_tuner    = 1,
+		.has_inttuner = 1,
+		.tuner_type   = TUNER_XCEIVE_XC3028,
+		.decoder      = EM28XX_TVP5150,
+		.ir_keytab    = ir_codes_pinnacle2,
+		.ir_getkey    = em2880_get_key_empia,
+		.dev_modes    = EM28XX_VIDEO | EM28XX_VBI | EM28XX_DVBT,
+		.input          = {{
+			.type     = EM28XX_VMUX_TELEVISION,
+			.vmux     = TVP5150_COMPOSITE0,
+			.amux     = 0,
+		}, {
+			.type     = EM28XX_VMUX_COMPOSITE1,
+			.vmux     = TVP5150_COMPOSITE1,
+			.amux     = 1,
+		}, {
+			.type     = EM28XX_VMUX_SVIDEO,
+			.vmux     = TVP5150_SVIDEO,
+			.amux     = 1,
+		} },
+		.manual_gpio	= 1,
+		.gpio_regs 	= EETI_DEFAULT_GPIO,
+		.tvnorms	= EETI_XC3028_DEFAULT_ANALOG,
+		.dvbnorms	= EETI_XC3028_DEFAULT_DVBT,
+	},
+	[EM2882_BOARD_PINNACLE_HYBRID_PRO] = {
+		.name         = "Pinnacle Hybrid Pro (em2882)",
+		.vchannels    = 3,
+		.norm         = V4L2_STD_PAL_BG,
+		.tuner_type   = TUNER_XCEIVE_XC3028,
+		.tuner_addr   = 0xc2,
+		.has_tuner    = 1,
+		.has_inttuner = 1,
+		.decoder      = EM28XX_TVP5150,
+		.ir_keytab    = ir_codes_em_pinnacle2_usb,
+		.ir_getkey    = em2880_get_key_empia,
+		.dev_modes    = EM28XX_VIDEO | EM28XX_AUDIO | EM28XX_VBI | EM28XX_DVBT,
+		.input          = {{
+			.type     = EM28XX_VMUX_TELEVISION,
+			.vmux     = TVP5150_COMPOSITE0,
+			.amux     = 0,
+		}, {
+			.type     = EM28XX_VMUX_COMPOSITE1,
+			.vmux     = TVP5150_COMPOSITE1,
+			.amux     = 1,
+		}, {
+			.type     = EM28XX_VMUX_SVIDEO,
+			.vmux     = TVP5150_SVIDEO,
+			.amux     = 1,
+		} },
+		.manual_gpio	= 1,
+		.gpio_regs 	= EETI_DRX3975D_GPIO,
+		.tvnorms	= EETI_XC3028_DEFAULT_ANALOG,
+		.dvbnorms	= EETI_XC3028_DEFAULT_DVBT,
+	},
+	/* maybe there's a reason behind it why Terratec sells the Hybrid XS as Prodigy XS with a
+	 * different PID, let's keep it separated for now maybe we'll need it lateron */
+	[EM2880_BOARD_TERRATEC_PRODIGY_XS] = {
+		.name         = "Terratec Prodigy XS",
+		.vchannels    = 3,
+		.norm         = V4L2_STD_PAL_BG,
+		.has_tuner    = 1,
+		.has_inttuner = 1,
+		.tuner_type   = TUNER_XCEIVE_XC3028,
+		.decoder      = EM28XX_TVP5150,
+		.dev_modes    = EM28XX_VIDEO | EM28XX_VBI | EM28XX_DVBT,
+		.input          = {{
+			.type     = EM28XX_VMUX_TELEVISION,
+			.vmux     = TVP5150_COMPOSITE0,
+			.amux     = 0,
+		}, {
+			.type     = EM28XX_VMUX_COMPOSITE1,
+			.vmux     = TVP5150_COMPOSITE1,
+			.amux     = 1,
+		}, {
+			.type     = EM28XX_VMUX_SVIDEO,
+			.vmux     = TVP5150_SVIDEO,
+			.amux     = 1,
+		} },
+		.manual_gpio	= 1,
+		.gpio_regs 	= EETI_DEFAULT_GPIO,
+		.tvnorms	= EETI_XC3028_DEFAULT_ANALOG,
+		.dvbnorms	= EETI_XC3028_DEFAULT_DVBT,
+	},
+	[EM2880_BOARD_MSI_DIGIVOX_AD] = {
+		.name         = "MSI DigiVox A/D",
+		.vchannels    = 3,
+		.norm         = V4L2_STD_PAL_BG,
+		.has_tuner    = 1,
+		.has_inttuner = 1,
+		.tuner_type   = TUNER_XCEIVE_XC3028,
+		.decoder      = EM28XX_TVP5150,
+		.dev_modes    = EM28XX_VIDEO | EM28XX_VBI | EM28XX_DVBT,
+		.input          = {{
+			.type     = EM28XX_VMUX_TELEVISION,
+			.vmux     = TVP5150_COMPOSITE0,
+			.amux     = 0,
+		}, {
+			.type     = EM28XX_VMUX_COMPOSITE1,
+			.vmux     = TVP5150_COMPOSITE1,
+			.amux     = 1,
+		}, {
+			.type     = EM28XX_VMUX_SVIDEO,
+			.vmux     = TVP5150_SVIDEO,
+			.amux     = 1,
+		} },
+		.manual_gpio	= 1,
+		.gpio_regs 	= EETI_DEFAULT_GPIO,
+		.tvnorms	= EETI_XC3028_DEFAULT_ANALOG,
+		.dvbnorms	= EETI_XC3028_DEFAULT_DVBT,
+	},
+	[EM2880_BOARD_MSI_DIGIVOX_AD_II] = {
+		.name         = "MSI DigiVox A/D II",
+		.vchannels    = 3,
+		.norm         = V4L2_STD_PAL_BG,
+		.has_tuner    = 1,
+		.has_inttuner = 1,
+		.tuner_type   = TUNER_XCEIVE_XC3028,
+		.decoder      = EM28XX_TVP5150,
+		.dev_modes    = EM28XX_VIDEO | EM28XX_VBI | EM28XX_DVBT,
+		.input          = {{
+			.type     = EM28XX_VMUX_TELEVISION,
+			.vmux     = TVP5150_COMPOSITE0,
+			.amux     = 0,
+		}, {
+			.type     = EM28XX_VMUX_COMPOSITE1,
+			.vmux     = TVP5150_COMPOSITE1,
+			.amux     = 1,
+		}, {
+			.type     = EM28XX_VMUX_SVIDEO,
+			.vmux     = TVP5150_SVIDEO,
+			.amux     = 1,
+		} },
+		.manual_gpio	= 1,
+		.gpio_regs 	= EETI_DEFAULT_GPIO,
+		.tvnorms	= EETI_XC3028_DEFAULT_ANALOG,
+		.dvbnorms	= EETI_XC3028_DEFAULT_DVBT,
+	},
+	[EM2883_BOARD_ATI_TVWONDER600] = {
+		.name         = "ATI TV Wonder HD 600",
+		.vchannels    = 3,
+		.norm         = V4L2_STD_PAL_BG,
+		.has_tuner    = 1,
+		.has_inttuner = 1,
+		.tuner_type   = TUNER_XCEIVE_XC3028,
+		.decoder      = EM28XX_TVP5150,
+		.dev_modes    = EM28XX_VIDEO | EM28XX_VBI | EM28XX_ATSC | EM28XX_AUDIO,
+		.input          = {{
+			.type     = EM28XX_VMUX_TELEVISION,
+			.vmux     = TVP5150_COMPOSITE0,
+			.amux     = 0,
+		}, {
+			.type     = EM28XX_VMUX_COMPOSITE1,
+			.vmux     = TVP5150_COMPOSITE1,
+			.amux     = 1,
+		}, {
+			.type     = EM28XX_VMUX_SVIDEO,
+			.vmux     = TVP5150_SVIDEO,
+			.amux     = 1,
+		} },
+		.manual_gpio	= 1,
+		.gpio_regs 	= EETI_DEFAULT_GPIO,
+		.tvnorms	= EETI_XC3028L_DEFAULT_ANALOG,
+		.atscnorms	= EETI_XC3028L_DEFAULT_ATSC,
+		.qamnorms	= EETI_XC3028L_DEFAULT_QAM,
+	},
+	[EM2820_BOARD_MSI_VOX_USB_2] = {
+		.name		= "MSI VOX USB 2.0",
+		.vchannels	= 3,
+		.norm		= V4L2_STD_PAL_BG,
+		.tuner_type	= TUNER_LG_PAL_NEW_TAPC,
+		.tda9887_conf	= TDA9887_PRESENT|TDA9887_PORT1_ACTIVE|TDA9887_PORT2_ACTIVE,
+		.has_tuner	= 1,
+		.decoder        = EM28XX_SAA7114,
+		.dev_modes      = EM28XX_VIDEO,
+		.input          = {{
+			.type     = EM28XX_VMUX_TELEVISION,
+			.vmux     = SAA7115_COMPOSITE4,
+			.amux     = 0,
+		}, {
+			.type     = EM28XX_VMUX_COMPOSITE1,
+			.vmux     = SAA7115_COMPOSITE0,
+			.amux     = 1,
+		}, {
+			.type     = EM28XX_VMUX_SVIDEO,
+			.vmux     = SAA7115_SVIDEO3,
+			.amux     = 1,
+		} },
+		.tvnorms	= {
+			{
+				.name = "PAL-BG",
+				.id = V4L2_STD_PAL_BG,
+			}, {
+				.name = "PAL-DK",
+				.id = V4L2_STD_PAL_DK,
+			}, {
+				.name = "PAL-I",
+				.id = V4L2_STD_PAL_I,
+			}, {
+				.name = "PAL-M",
+				.id = V4L2_STD_PAL_M,
+			}, {
+				.name = "NTSC",
+				.id = V4L2_STD_NTSC_M,
+		} },
+	},
+	[EM2800_BOARD_TERRATEC_CINERGY_200] = {
+		.name         = "Terratec Cinergy 200 USB",
+		.em_type      = EM2800,
+		.i2c_devs     = em28xx_terratec_cinergy_200_usb_i2c_devs,
+		.vchannels    = 3,
+		.norm         = V4L2_STD_PAL_BG,
+		.tuner_type   = TUNER_LG_PAL_NEW_TAPC,
+		.tda9887_conf = TDA9887_PRESENT,
+		.has_tuner    = 1,
+		.decoder      = EM28XX_SAA7113,
+		.dev_modes    = EM28XX_VIDEO,
+		.ir_i2c       = 1,
+
+		.input          = {{
+			.type     = EM28XX_VMUX_TELEVISION,
+			.vmux     = SAA7115_COMPOSITE2,
+			.amux     = 0,
+		}, {
+			.type     = EM28XX_VMUX_COMPOSITE1,
+			.vmux     = SAA7115_COMPOSITE0,
+			.amux     = 1,
+		}, {
+			.type     = EM28XX_VMUX_SVIDEO,
+			.vmux     = SAA7115_SVIDEO3,
+			.amux     = 1,
+		} },
+		.tvnorms	= {
+			{
+				.name = "PAL-BG",
+
+				.id = V4L2_STD_PAL_BG,
+			}, {
+				.name = "PAL-DK",
+
+				.id = V4L2_STD_PAL_DK,
+			}, {
+				.name = "PAL-I",
+
+				.id = V4L2_STD_PAL_I,
+			}, {
+				.name = "PAL-M",
+
+				.id = V4L2_STD_PAL_M,
+		} },
+	},
+	[EM2820_BOARD_LEADTEK_WINFAST_USBII_DELUXE] = {
+		.name         = "Leadtek Winfast USB II Deluxe",
+		.em_type      = EM2820,
+		.vchannels    = 3,
+		.norm         = V4L2_STD_PAL_BG,
+		.tuner_type   = TUNER_PHILIPS_FM1216ME_MK3,
+		.tda9887_conf = TDA9887_PRESENT,
+		.has_tuner    = 1,
+		.decoder      = EM28XX_SAA7114,
+		.dev_modes      = EM28XX_VIDEO,
+		.input          = {{
+			.type     = EM28XX_VMUX_TELEVISION,
+			.vmux     = 2,
+			.amux     = 0,
+		}, {
+			.type     = EM28XX_VMUX_COMPOSITE1,
+			.vmux     = 0,
+			.amux     = 1,
+		}, {
+			.type     = EM28XX_VMUX_SVIDEO,
+			.vmux     = 9,
+			.amux     = 1,
+		} },
+		.tvnorms	= {
+			{
+				.name = "PAL-BG",
+				.id = V4L2_STD_PAL_BG,
+			}, {
+				.name = "PAL-DK",
+				.id = V4L2_STD_PAL_DK,
+			}, {
+				.name = "PAL-I",
+				.id = V4L2_STD_PAL_I,
+			}, {
+				.name = "PAL-M",
+				.id = V4L2_STD_PAL_M,
+		} },
+	},
+	[EM2800_BOARD_LEADTEK_WINFAST_USBII] = {
+		.name         = "Leadtek Winfast USB II",
+		.em_type      = EM2800,
+		.vchannels    = 3,
+		.norm         = V4L2_STD_PAL_BG,
+		.tuner_type   = TUNER_LG_PAL_NEW_TAPC,
+		.tda9887_conf = TDA9887_PRESENT,
+		.has_tuner    = 1,
+		.decoder      = EM28XX_SAA7113,
+		.dev_modes      = EM28XX_VIDEO,
+		.input          = {{
+			.type     = EM28XX_VMUX_TELEVISION,
+			.vmux     = SAA7115_COMPOSITE2,
+			.amux     = 0,
+		}, {
+			.type     = EM28XX_VMUX_COMPOSITE1,
+			.vmux     = SAA7115_COMPOSITE0,
+			.amux     = 1,
+		}, {
+			.type     = EM28XX_VMUX_SVIDEO,
+			.vmux     = SAA7115_SVIDEO3,
+			.amux     = 1,
+		} },
+		.tvnorms	= {
+			{
+				.name = "PAL-BG",
+				.id = V4L2_STD_PAL_BG,
+			}, {
+				.name = "PAL-DK",
+				.id = V4L2_STD_PAL_DK,
+			}, {
+				.name = "PAL-I",
+				.id = V4L2_STD_PAL_I,
+			}, {
+				.name = "PAL-M",
+				.id = V4L2_STD_PAL_M,
+		} },
+	},
+	[EM2800_BOARD_KWORLD_USB2800] = {
+		.name         = "KWorld USB2800",
+		.em_type      = EM2800,
+		.vchannels    = 3,
+		.norm         = V4L2_STD_PAL_BG,
+#if defined TUNER_PHILIPS_FCV1236D
+		.tuner_type   = TUNER_PHILIPS_FCV1236D,
+#else
+		.tuner_type   = TUNER_PHILIPS_ATSC,
+#endif
+		.tda9887_conf = TDA9887_PRESENT,
+		.has_tuner    = 1,
+		.decoder      = EM28XX_SAA7113,
+		.dev_modes      = EM28XX_VIDEO,
+		.input          = {{
+			.type     = EM28XX_VMUX_TELEVISION,
+			.vmux     = SAA7115_COMPOSITE2,
+			.amux     = 0,
+		}, {
+			.type     = EM28XX_VMUX_COMPOSITE1,
+			.vmux     = SAA7115_COMPOSITE0,
+			.amux     = 1,
+		}, {
+			.type     = EM28XX_VMUX_SVIDEO,
+			.vmux     = SAA7115_SVIDEO3,
+			.amux     = 1,
+		} },
+		.tvnorms	= {
+			{
+				.name = "PAL-BG",
+				.id = V4L2_STD_PAL_BG,
+			}
+		},
+	},
+	[EM2820_BOARD_PINNACLE_DVC_90] = {
+		.name         = "Pinnacle Dazzle DVC 90",
+		.vchannels    = 3,
+		.norm         = V4L2_STD_PAL_BG,
+		.has_tuner    = 0,
+		.decoder      = EM28XX_SAA7113,
+		.dev_modes      = EM28XX_VIDEO,
+		.input          = {{
+			.type     = EM28XX_VMUX_COMPOSITE1,
+			.vmux     = SAA7115_COMPOSITE0,
+			.amux     = 1,
+		}, {
+			.type     = EM28XX_VMUX_SVIDEO,
+			.vmux     = SAA7115_SVIDEO3,
+			.amux     = 1,
+		} },
+		.tvnorms	= {
+			{
+				.name = "PAL-BG",
+				.id = V4L2_STD_PAL_BG,
+		} },
+	},
+	[EM2820_BOARD_PINNACLE_DVC_100] = {
+		.name         = "Pinnacle Dazzle DVC 100",
+		.vchannels    = 3,
+		.norm         = V4L2_STD_PAL_BG,
+		.has_tuner    = 0,
+		.decoder      = EM28XX_SAA7113,
+		.dev_modes      = EM28XX_VIDEO,
+		.input          = {{
+			.type     = EM28XX_VMUX_COMPOSITE1,
+			.vmux     = SAA7115_COMPOSITE0,
+			.amux     = 1,
+		}, {
+			.type     = EM28XX_VMUX_SVIDEO,
+			.vmux     = SAA7115_SVIDEO3,
+			.amux     = 1,
+		} },
+		.tvnorms	= {
+			{
+				.name = "PAL-BG",
+				.id = V4L2_STD_PAL_BG,
+			}, {
+				.name = "SECAM L",
+				.id = V4L2_STD_SECAM_L,
+			}, {
+				.name = "SECAM LC",
+				.id = V4L2_STD_SECAM_LC,
+			}, {
+				.name = "SECAM K1",
+				.id = V4L2_STD_SECAM_K1,
+		} },
+	},
+	[EM2820_BOARD_VIDEOLOGY_20K14XUSB] = {
+		.name          = "Videology 20K14XUSB USB2.0",
+		.vchannels     = 1,
+		.norm          = V4L2_STD_PAL_BG,
+		.has_tuner     = 0,
+		.ctrl          = em28xx_vy_cctrl,
+		.gctrl         = em28xx_vy_gctrl,
+		.qctrl         = em28xx_vy_qctrl,
+		.dev_modes      = EM28XX_VIDEO,
+		.input         = {{
+			.type     = EM28XX_VMUX_COMPOSITE1,
+			.vmux     = 0,
+			.amux     = 0,
+		} },
+		.tvnorms	= {
+			{
+				.name = "PAL-BG",
+				.id = V4L2_STD_PAL_BG,
+		} },
+	},
+	[EM2821_BOARD_USBGEAR_VD204] = {
+		.name          = "Usbgear VD204v9",
+		.vchannels     = 2,
+		.norm          = V4L2_STD_PAL_BG,
+		.decoder       = EM28XX_SAA7113,
+		.dev_modes      = EM28XX_VIDEO,
+		.input          = {{
+			.type  = EM28XX_VMUX_COMPOSITE1,
+			.vmux  = SAA7115_COMPOSITE0,
+			.amux  = 1,
+		}, {
+			.type  = EM28XX_VMUX_SVIDEO,
+			.vmux  = SAA7115_SVIDEO3,
+			.amux  = 1,
+		} },
+		.tvnorms	= {{
+				.name = "PAL-BG",
+				.id = V4L2_STD_PAL_BG,
+			}, {
+				.name = "PAL-DK",
+				.id = V4L2_STD_PAL_DK,
+			}, {
+				.name = "PAL-I",
+				.id = V4L2_STD_PAL_I,
+			}, {
+				.name = "PAL-M",
+				.id = V4L2_STD_PAL_M,
+		} },
+	},
+	[EM2860_BOARD_TYPHOON_DVD_MAKER] = {
+		.name          = "Typhoon DVD Maker",
+		.vchannels     = 2,
+		.norm          = V4L2_STD_PAL_BG,
+		.decoder       = EM28XX_SAA7113,
+		.dev_modes      = EM28XX_VIDEO,
+		.input          = {{
+			.type  = EM28XX_VMUX_COMPOSITE1,
+			.vmux  = SAA7115_COMPOSITE0,
+			.amux  = 1,
+		}, {
+			.type  = EM28XX_VMUX_SVIDEO,
+			.vmux  = SAA7115_SVIDEO3,
+			.amux  = 1,
+		} },
+		.tvnorms	= {{
+				.name = "PAL-BG",
+				.id = V4L2_STD_PAL_BG,
+			}, {
+				.name = "PAL-DK",
+				.id = V4L2_STD_PAL_DK,
+			}, {
+				.name = "PAL-I",
+				.id = V4L2_STD_PAL_I,
+			}, {
+				.name = "PAL-M",
+				.id = V4L2_STD_PAL_M,
+		} },
+	},
+	[EM2860_BOARD_GADMEI_UTV330] = {
+		.name         = "Gadmei UTV330",
+		.vchannels    = 3,
+		.norm         = V4L2_STD_NTSC_M,
+		.tuner_type   = TUNER_TNF_5335MF,
+		.tda9887_conf = TDA9887_PRESENT,
+		.has_tuner    = 1,
+		.decoder      = EM28XX_SAA7113,
+		.ir_keytab    = ir_codes_em_gadmei_usb,
+		.ir_getkey    = em2880_get_key_empia,
+		.dev_modes    = EM28XX_VIDEO,
+		.input          = {{
+			.type     = EM28XX_VMUX_TELEVISION,
+			.vmux     = SAA7115_COMPOSITE2,
+			.amux     = 0,
+		}, {
+			.type     = EM28XX_VMUX_COMPOSITE1,
+			.vmux     = SAA7115_COMPOSITE0,
+			.amux     = 1,
+		}, {
+			.type     = EM28XX_VMUX_SVIDEO,
+			.vmux     = SAA7115_SVIDEO3,
+			.amux     = 1,
+		} },
+		.tvnorms	= {{
+				.name = "NTSC",
+				.id = V4L2_STD_NTSC_M,
+		}, {
+				.name = "PAL-DK",
+				.id = V4L2_STD_PAL_DK,
+		} },
+	},
+	[EM2820_BOARD_GADMEI_UTV310] = {
+		.name         = "Gadmei UTV310",
+		.vchannels    = 3,
+		.norm         = V4L2_STD_NTSC_M,
+		.tuner_type   = TUNER_TNF_5335MF,
+		.tda9887_conf = TDA9887_PRESENT,
+		.has_tuner    = 1,
+		.decoder      = EM28XX_SAA7113,
+		.dev_modes    = EM28XX_VIDEO,
+		.input          = {{
+			.type     = EM28XX_VMUX_TELEVISION,
+			.vmux     = SAA7115_COMPOSITE1,
+			.amux     = 1,
+		}, {
+			.type     = EM28XX_VMUX_COMPOSITE1,
+			.vmux     = SAA7115_COMPOSITE0,
+			.amux     = 1,
+		}, {
+			.type     = EM28XX_VMUX_SVIDEO,
+			.vmux     = SAA7115_SVIDEO3,
+			.amux     = 1,
+		} },
+		.tvnorms	= {{
+				.name = "NTSC",
+				.id = V4L2_STD_NTSC_M,
+		} },
+	},
+	[EM2800_BOARD_VGEAR_POCKETTV] = {
+		.name         = "V-Gear PocketTV",
+		.em_type      = EM2800,
+		.i2c_devs     = em28xx_vgear_pockettv_i2c_devs,
+		.vchannels    = 3,
+		.norm         = V4L2_STD_PAL_BG,
+		.tuner_type   = TUNER_LG_PAL_NEW_TAPC,
+		.tda9887_conf = TDA9887_PRESENT,
+		.has_tuner    = 1,
+		.decoder      = EM28XX_SAA7113,
+		.dev_modes      = EM28XX_VIDEO,
+		.input          = {{
+			.type     = EM28XX_VMUX_TELEVISION,
+			.vmux     = SAA7115_COMPOSITE2,
+			.amux     = 0,
+		}, {
+			.type     = EM28XX_VMUX_COMPOSITE1,
+			.vmux     = SAA7115_COMPOSITE0,
+			.amux     = 1,
+		}, {
+			.type     = EM28XX_VMUX_SVIDEO,
+			.vmux     = SAA7115_SVIDEO3,
+			.amux     = 1,
+		} },
+		.tvnorms	= {
+			{
+				.name = "PAL-BG",
+				.id = V4L2_STD_PAL_BG,
+			}, {
+				.name = "PAL-DK",
+				.id = V4L2_STD_PAL_DK,
+			}, {
+				.name = "PAL-I",
+				.id = V4L2_STD_PAL_I,
+			}, {
+				.name = "PAL-M",
+				.id = V4L2_STD_PAL_M,
+		} },
+	},
+	[EM2861_BOARD_YAKUMO_MOVIE_MIXER] = {
+		.name          = "Yakumo MovieMixer",
+		.vchannels     = 1,
+		.norm          = V4L2_STD_PAL_BG,
+		.decoder       = EM28XX_TVP5150,
+		.has_tuner     = 0,
+		.dev_modes      = EM28XX_VIDEO,
+		.input          = {{
+			.type     = EM28XX_VMUX_TELEVISION,
+			.vmux     = TVP5150_COMPOSITE0,
+			.amux     = 0,
+		}, {
+			.type     = EM28XX_VMUX_COMPOSITE1,
+			.vmux     = TVP5150_COMPOSITE1,
+			.amux     = 1,
+		}, {
+			.type     = EM28XX_VMUX_SVIDEO,
+			.vmux     = TVP5150_SVIDEO,
+			.amux     = 1,
+		} },
+		.tvnorms	= {
+			{
+				.name = "PAL-BG",
+				.id = V4L2_STD_PAL_BG,
+		} },
+	},
+	[EM2860_BOARD_NETGMBH_CAM] = {
+		.name          = "NetGMBH Cam", /* Beijing Huaqi Information Digital Technology Co., Ltd */
+		.vchannels     = 1,
+		.norm	       = V4L2_STD_PAL_BG,
+		.has_tuner     = 0,
+		.dev_modes      = EM28XX_VIDEO,
+
+		.input         = {{
+			.type     = EM28XX_VMUX_COMPOSITE1,
+			.vmux     = 0,
+			.amux     = 0,
+		} },
+		.tvnorms	= {
+			{
+				.name = "PAL-BG",
+				.id = V4L2_STD_PAL_BG,
+		} },
+	},
+	[EM2750_BOARD_DLCW_130] = {
+		.name          = "Huaqi DLCW-130", /* Beijing Huaqi Information Digital Technology Co., Ltd */
+		.vchannels     = 1,
+		.norm	       = V4L2_STD_PAL_BG,
+		.dev_modes      = EM28XX_VIDEO,
+		.em_type	= EM2751,
+		.input         = {{
+			.type     = EM28XX_VMUX_COMPOSITE1,
+			.vmux     = 0,
+			.amux     = 0,
+		} },
+		.tvnorms	= {
+			{
+				.name = "PAL-BG",
+				.id = V4L2_STD_PAL_BG,
+		} },
+	},
+	[EM2751_BOARD_EMPIA_SAMPLE] = {
+		.name          = "EM2751 Webcam + Audio",
+		.vchannels     = 1,
+		.norm	       = V4L2_STD_PAL_BG,
+		.dev_modes      = EM28XX_VIDEO,
+		.em_type	= EM2751,
+		.input         = {{
+			.type     = EM28XX_VMUX_COMPOSITE1,
+			.vmux     = 0,
+			.amux     = 0,
+		} },
+		.tvnorms	= {
+			{
+				.name = "PAL-BG",
+				.id = V4L2_STD_PAL_BG,
+		} },
+	},
+	[EM2861_BOARD_PLEXTOR_PX_TV100U] = {
+		.name         = "Plextor ConvertX PX-TV100U",
+		.vchannels    = 3,
+		.norm         = V4L2_STD_NTSC_M,
+		.tuner_type   = TUNER_TNF_5335MF,
+		.tda9887_conf = TDA9887_PRESENT,
+		.has_tuner    = 1,
+		.has_msp34xx  = 1,
+		.decoder      = EM28XX_TVP5150,
+		.dev_modes    = EM28XX_VIDEO,  /* EM28XX_AUDIO ? */
+		.input          = {{
+			.type     = EM28XX_VMUX_TELEVISION,
+			.vmux     = TVP5150_COMPOSITE0,
+			.amux     = 1,
+		}, {
+			.type     = EM28XX_VMUX_COMPOSITE1,
+			.vmux     = TVP5150_COMPOSITE1,
+			.amux     = 1,
+		}, {
+			.type     = EM28XX_VMUX_SVIDEO,
+			.vmux     = TVP5150_SVIDEO,
+			.amux     = 1,
+		} },
+		.tvnorms        = {{
+			.name = "NTSC",
+
+			.id = V4L2_STD_NTSC_M,
+		} },
+	},
+	[EM2863_BOARD_EMPIA_GENERIC] = {
+		.name         = "Empia generic",
+		.vchannels    = 3,
+		.norm         = V4L2_STD_NTSC_M,
+		.tuner_type   = TUNER_XCEIVE_XC3028,
+		.has_tuner    = 1,
+		.has_inttuner = 1,
+		.decoder      = EM28XX_CX25843,
+		.dev_modes    = EM28XX_VIDEO | EM28XX_AUDIO | EM28XX_RADIO | EM28XX_VBI,
+		.input          = {{
+			.type     = EM28XX_VMUX_TELEVISION,
+			.vmux     = 1,
+			.amux     = 0,
+		}, {
+			.type     = EM28XX_VMUX_COMPOSITE1,
+			.vmux     = 3,
+			.amux     = 4,
+		}, {
+			.type     = EM28XX_VMUX_SVIDEO,
+			.vmux     = 2,
+			.amux     = 5,
+		} },
+		.tvnorms	= EETI_XC3028_DEFAULT_ANALOG,
+#if 0
+		.dvbnorms	= EETI_XC3028_DEFAULT_DVBT,
+#endif
+
+		.manual_gpio  = 1,
+		.gpio_regs 	= EETI_DEFAULT_GPIO,
+		.tvnorms	= EETI_XC3028_DEFAULT_ANALOG,
+#if 0
+		.dvbnorms	= EETI_XC3028_DEFAULT_DVBT,
+#endif
+	},
+	[EM2883_BOARD_KWORLD_A340] = {
+		.name         = "KWorld ATSC 340",
+		.tuner_type   = TUNER_PHILIPS_TDA18271,
+		.dev_modes    = EM28XX_ATSC,
+	},
+	[EM2875_BOARD_SAMPLE_ISDBT] = {
+		.name         = "Empia ISDB",
+		.em_type      = EM2875,
+		.dev_modes    = EM28XX_ISDB,
+	},
+	[EM2879_BOARD_SAMPLE_DMB] = {
+		.name         = "Empia DMB-T",
+		.tuner_type   = TUNER_ADIMTV102,
+		.dev_modes    = EM28XX_DMB,
+	},
+	[EM2883_BOARD_EMPIA_HYBRID_ATSC] = {
+		.name         = "Empia Hybrid XS ATSC",
+		.vchannels    = 3,
+		.norm         = V4L2_STD_NTSC_M,
+		.tuner_type   = TUNER_XCEIVE_XC5000,
+		.has_tuner    = 1,
+		.has_inttuner = 1,
+#if 0
+		.powersaving  = 1,
+#endif
+		.decoder      = EM28XX_CX25843,
+		.dev_modes    = EM28XX_VIDEO | EM28XX_AUDIO | EM28XX_RADIO | EM28XX_VBI/* | EM28XX_ATSC needs more work*/,
+		.input          = {{
+			.type     = EM28XX_VMUX_TELEVISION,
+			.vmux     = CX25843_TELEVISION,
+			.amux     = 0,
+		}, {
+			.type     = EM28XX_VMUX_COMPOSITE1,
+			.vmux     = CX25843_COMPOSITE1,
+			.amux     = 4,
+		}, {
+			.type     = EM28XX_VMUX_SVIDEO,
+			.vmux     = CX25843_SVIDEO,
+			.amux     = 5,
+		} },
+		.tvnorms	= EETI_XC5000_DEFAULT_ANALOG,
+		.fmnorms	= EETI_XC5000_DEFAULT_FM,
+		.atscnorms	= EETI_XC5000_DEFAULT_ATSC,
+		.qamnorms	= EETI_XC5000_DEFAULT_QAM,
+	},
+	[EM2883_BOARD_EQUINUX_TUBESTICK_ATSC] = {
+		.name         = "Equinux TubeStick Hybrid ATSC",
+		.vchannels    = 3,
+		.norm         = V4L2_STD_NTSC_M,
+		.tuner_type   = TUNER_XCEIVE_XC5000,
+		.has_tuner    = 1,
+		.has_inttuner = 1,
+#if 0
+		.powersaving  = 1,
+#endif
+		.decoder      = EM28XX_CX25843,
+		.dev_modes    = EM28XX_VIDEO | EM28XX_AUDIO | EM28XX_RADIO | EM28XX_VBI/* | EM28XX_ATSC needs more work*/,
+		.input          = {{
+			.type     = EM28XX_VMUX_TELEVISION,
+			.vmux     = CX25843_TELEVISION,
+			.amux     = 0,
+		}, {
+			.type     = EM28XX_VMUX_COMPOSITE1,
+			.vmux     = CX25843_COMPOSITE1,
+			.amux     = 4,
+		}, {
+			.type     = EM28XX_VMUX_SVIDEO,
+			.vmux     = CX25843_SVIDEO,
+			.amux     = 5,
+		} },
+		.tvnorms	= EETI_XC5000_DEFAULT_ANALOG,
+		.fmnorms	= EETI_XC5000_DEFAULT_FM,
+		.atscnorms	= EETI_XC5000_DEFAULT_ATSC,
+		.qamnorms	= EETI_XC5000_DEFAULT_QAM,
+	},
+	[EM2888_BOARD_DVB_TC_HYBRID] = {
+		.name	      = "Pinnacle 510e",
+		.em_type      = EM2888,
+		.vchannels    = 3,
+		.norm	      = V4L2_STD_PAL_BG,
+		.tuner_type   = TUNER_XCEIVE_XC5000,
+		.has_inttuner = 1,
+		.has_tuner    = 1,
+		.decoder      = EM28XX_CX25843,
+		.dev_modes    = EM28XX_VIDEO | EM28XX_VBI | EM28XX_AUDIO | EM28XX_RADIO,
+		.powersaving  = 1,
+		.input          = {{
+			.type     = EM28XX_VMUX_TELEVISION,
+			.vmux     = CX25843_TELEVISION,
+			.amux     = 0,
+		}, {
+			.type     = EM28XX_VMUX_COMPOSITE1,
+			.vmux     = CX25843_COMPOSITE1,
+			.amux     = 4,
+		}, {
+			.type     = EM28XX_VMUX_SVIDEO,
+			.vmux     = CX25843_SVIDEO,
+			.amux     = 5,
+		} },
+		.tvnorms	= EETI_XC5000_DEFAULT_ANALOG,
+		.fmnorms	= EETI_XC5000_DEFAULT_FM,
+	},
+	[EM2888_BOARD_EMPIA_HYBRID] = {
+		.name	      = "Empia Hybrid PCTV",
+		.em_type      = EM2888, /* TODO read this from the chip */
+		.vchannels    = 3,
+		.norm	      = V4L2_STD_NTSC_M,
+		.tuner_type   = TUNER_XCEIVE_XC3028,
+		.has_inttuner = 1,
+		.has_tuner    = 1,
+		.decoder      = EM28XX_CX25843,
+		.dev_modes    = EM28XX_VIDEO | EM28XX_VBI | EM28XX_DVBT | EM28XX_AUDIO | EM28XX_RADIO,
+		.powersaving  = 1,
+		.input          = {{
+			.type     = EM28XX_VMUX_TELEVISION,
+			.vmux     = CX25843_TELEVISION,
+			.amux     = 0,
+		}, {
+			.type     = EM28XX_VMUX_COMPOSITE1,
+			.vmux     = CX25843_COMPOSITE1,
+			.amux     = 4,
+		}, {
+			.type     = EM28XX_VMUX_SVIDEO,
+			.vmux     = CX25843_SVIDEO,
+			.amux     = 5,
+		} },
+		.tvnorms	= EETI_XC3028L_DEFAULT_ANALOG,
+		.dvbnorms	= EETI_XC3028L_DEFAULT_DVBT,
+		.fmnorms	= EETI_XC3028L_DEFAULT_FM,
+	},
+	[EM2860_BOARD_KAIOMY_TVNPC_U2] = {
+		/* TODO radio support */
+		.name	      = "Kaiomy TVnPC U2",
+		.vchannels    = 3,
+		.norm         = V4L2_STD_NTSC_M,
+		.has_tuner    = 1,
+		.has_inttuner = 1,
+		.tuner_type   = TUNER_XCEIVE_XC3028,
+		.decoder      = EM28XX_TVP5150,
+		.ir_keytab    = ir_codes_em_kworld,
+		.ir_getkey    = em2860_get_key_kaiomy,
+		.dev_modes    = EM28XX_VIDEO | EM28XX_VBI | EM28XX_AUDIO2,
+		.input          = {{
+			.type     = EM28XX_VMUX_TELEVISION,
+			.vmux     = TVP5150_COMPOSITE0,
+			.amux     = 0,
+		}, {
+			.type     = EM28XX_VMUX_COMPOSITE1,
+			.vmux     = TVP5150_COMPOSITE1,
+			.amux     = 1,
+		}, {
+			.type     = EM28XX_VMUX_SVIDEO,
+			.vmux     = TVP5150_SVIDEO,
+			.amux     = 1,
+		} },
+		.manual_gpio	= 1,
+		.gpio_regs 	= EETI_DEFAULT_GPIO,
+		.tvnorms	= EETI_XC3028_DEFAULT_ANALOG,
+	},
+	[EM2861_BOARD_POLLIN_USB_R1] = {
+		.name          = "Pollin USB-R1",
+		.vchannels     = 1,
+		.norm          = V4L2_STD_PAL_BG,
+		.decoder       = EM28XX_SAA7113,
+		.has_tuner     = 0,
+		.dev_modes      = EM28XX_VIDEO,
+		.input           = {{
+			.type     = EM28XX_VMUX_COMPOSITE1,
+			.vmux     = SAA7115_COMPOSITE0,
+			.amux     = 1,
+		}},
+		.tvnorms	= {
+			{
+				.name = "PAL-BG",
+				.id = V4L2_STD_PAL_BG,
+			},{
+				.name = "NTSC",
+				.id = V4L2_STD_NTSC,
+		}},
+	},
+	[EM2882_BOARD_LEADTEK_PALMTOP_DTV_200H] = {
+		/* TODO: FM radio support for this Leadtek device */
+		.name         = "Leadtek PalmTop DTV 200H",
+		.vchannels    = 3,
+		.norm         = V4L2_STD_PAL_BG,
+		.has_tuner    = 1,
+		.has_inttuner = 1,
+		.tuner_type   = TUNER_XCEIVE_XC3028,
+		.decoder      = EM28XX_TVP5150,
+		.dev_modes    = EM28XX_VIDEO | EM28XX_VBI | EM28XX_DVBT | EM28XX_AUDIO,
+		.input          = {{
+			.type     = EM28XX_VMUX_TELEVISION,
+			.vmux     = TVP5150_COMPOSITE0,
+			.amux     = 0,
+		}, {
+			.type     = EM28XX_VMUX_COMPOSITE1,
+			.vmux     = TVP5150_COMPOSITE1,
+			.amux     = 1,
+		}, {
+			.type     = EM28XX_VMUX_SVIDEO,
+			.vmux     = TVP5150_SVIDEO,
+			.amux     = 1,
+		} },
+		.manual_gpio	= 1,
+		.gpio_regs 	= EETI_DEFAULT_GPIO,
+		.tvnorms	= EETI_XC3028_DEFAULT_ANALOG,
+		.dvbnorms	= EETI_XC3028_DEFAULT_DVBT,
+	},
+	[EM2820_BOARD_COMPRO_VIDEO_MATE] = {
+		.name         = "Compro VideoMate ForYou/Stereo",
+		.vchannels    = 2,
+		.tuner_type   = TUNER_LG_PAL_NEW_TAPC,
+		.tda9887_conf = TDA9887_PRESENT,
+		.decoder      = EM28XX_TVP5150,
+		.dev_modes    = EM28XX_VIDEO,
+		.input          = { {
+			.type     = EM28XX_VMUX_TELEVISION,
+			.vmux     = TVP5150_COMPOSITE0,
+			.amux     = 1,
+		}, {
+			.type     = EM28XX_VMUX_SVIDEO,
+			.vmux     = TVP5150_SVIDEO,
+			.amux     = 1,
+		} },
+	},
+};
+
+const unsigned int em28xx_bcount = ARRAY_SIZE(em28xx_boards);
+
+/*
+ * seems like it's possible to flash the eeprom, somehow one of my HVR 900 devices suddenly
+ * had the content of a WinTV USB 2 eeprom and thus identified itself as a Wintv USB 2
+ * device which of course didn't work...
+ *
+ */
+
+/* table of devices that work with this driver */
+struct usb_device_id em28xx_id_table [] = {
+	{ USB_DEVICE(0xeb1a, 0x2800), .driver_info = EM2800_BOARD_GENERIC },
+	{ USB_DEVICE(0xeb1a, 0x2820), .driver_info = EM2820_BOARD_GENERIC },
+	{ USB_DEVICE(0xeb1a, 0x2821), .driver_info = EM2821_BOARD_GENERIC },
+	{ USB_DEVICE(0xeb1a, 0x2750), .driver_info = EM2750_BOARD_GENERIC },
+	{ USB_DEVICE(0xeb1a, 0x2860), .driver_info = EM2860_BOARD_GENERIC },
+	{ USB_DEVICE(0xeb1a, 0x2861), .driver_info = EM2861_BOARD_GENERIC },
+	{ USB_DEVICE(0xeb1a, 0x2881), .driver_info = EM2881_BOARD_GENERIC },
+	{ USB_DEVICE(0xeb1a, 0x2870), .driver_info = EM2870_BOARD_GENERIC },
+	{ USB_DEVICE(0xeb1a, 0xe310), .driver_info = EM2880_BOARD_MSI_DIGIVOX_AD },
+	{ USB_DEVICE(0xeb1a, 0xe320), .driver_info = EM2880_BOARD_MSI_DIGIVOX_AD_II },
+	{ USB_DEVICE(0xeb1a, 0xe300), .driver_info = EM2861_BOARD_KWORLD_PVRTV_300U },
+	{ USB_DEVICE(0xeb1a, 0xe350), .driver_info = EM2870_BOARD_KWORLD_350U },
+	{ USB_DEVICE(0xeb1a, 0xe355), .driver_info = EM2870_BOARD_KWORLD_355U },
+	{ USB_DEVICE(0xeb1a, 0xe357), .driver_info = EM2870_BOARD_KWORLD_355U },
+	{ USB_DEVICE(0x1ae7, 0x0380), .driver_info = EM2870_BOARD_KWORLD_355U },
+	{ USB_DEVICE(0x0ccd, 0x0036), .driver_info = EM2820_BOARD_TERRATEC_CINERGY_250 },
+	{ USB_DEVICE(0x2304, 0x0208), .driver_info = EM2820_BOARD_PINNACLE_USB_2 },
+	{ USB_DEVICE(0x2040, 0x4200), .driver_info = EM2820_BOARD_HAUPPAUGE_WINTV_USB_2 },
+	{ USB_DEVICE(0x2040, 0x4201), .driver_info = EM2820_BOARD_HAUPPAUGE_WINTV_USB_2_R2 },
+	{ USB_DEVICE(0x2040, 0x650a), .driver_info = EM2870_BOARD_HAUPPAUGE_WINTV_USB_2_R2 },
+	{ USB_DEVICE(0x2304, 0x0207), .driver_info = EM2820_BOARD_PINNACLE_DVC_90 },
+	{ USB_DEVICE(0x2304, 0x021a), .driver_info = EM2820_BOARD_PINNACLE_DVC_100 },
+	{ USB_DEVICE(0x2040, 0x6500), .driver_info = EM2880_BOARD_HAUPPAUGE_WINTV_HVR_900 },
+	{ USB_DEVICE(0x2040, 0x6502), .driver_info = EM2880_BOARD_HAUPPAUGE_WINTV_HVR_900_R2 },
+	{ USB_DEVICE(0x0ccd, 0x0042), .driver_info = EM2880_BOARD_TERRATEC_HYBRID_XS },
+	{ USB_DEVICE(0x0ccd, 0x004f), .driver_info = EM2860_BOARD_TERRATEC_HYBRID_XS },
+	{ USB_DEVICE(0x0ccd, 0x004c), .driver_info = EM2880_BOARD_TERRATEC_HYBRID_XS_FR },
+	{ USB_DEVICE(0x0ccd, 0x005e), .driver_info = EM2882_BOARD_TERRATEC_HYBRID_XS },
+	{ USB_DEVICE(0x0ccd, 0x0043), .driver_info = EM2870_BOARD_TERRATEC_XS },
+	{ USB_DEVICE(0x0ccd, 0x0047), .driver_info = EM2880_BOARD_TERRATEC_PRODIGY_XS },
+	{ USB_DEVICE(0x185b, 0x2870), .driver_info = EM2870_BOARD_COMPRO_VIDEOMATE },
+	{ USB_DEVICE(0x0413, 0x6023), .driver_info = EM2800_BOARD_LEADTEK_WINFAST_USBII },
+	{ USB_DEVICE(0x2001, 0xf112), .driver_info = EM2820_BOARD_DLINK_USB_TV },
+	{ USB_DEVICE(0xeb1a, 0x2883), .driver_info = EM2883_BOARD_GENERIC },
+	{ USB_DEVICE(0x2040, 0x6513), .driver_info = EM2883_BOARD_HAUPPAUGE_WINTV_HVR_950 },
+	{ USB_DEVICE(0x2040, 0x6517), .driver_info = EM2883_BOARD_HAUPPAUGE_WINTV_HVR_950 },
+	{ USB_DEVICE(0x2040, 0x651b), .driver_info = EM2883_BOARD_HAUPPAUGE_WINTV_HVR_950 },
+	{ USB_DEVICE(0x2040, 0x651f), .driver_info = EM2883_BOARD_HAUPPAUGE_WINTV_HVR_950 },
+	{ USB_DEVICE(0x2304, 0x0227), .driver_info = EM2883_BOARD_PINNACLE_PCTV_HD_PRO },
+	{ USB_DEVICE(0x2304, 0x0226), .driver_info = EM2882_BOARD_PINNACLE_HYBRID_PRO },
+	{ USB_DEVICE(0xeb1a, 0x2751), .driver_info = EM2751_BOARD_EMPIA_SAMPLE },
+	{ USB_DEVICE(0xeb1a, 0xe305), .driver_info = EM2880_BOARD_KWORLD_DVB_305U },
+	{ USB_DEVICE(0xeb1a, 0xa316), .driver_info = EM2883_BOARD_KWORLD_HYBRID_A316 },
+	{ USB_DEVICE(0x093b, 0xa005), .driver_info = EM2861_BOARD_PLEXTOR_PX_TV100U },
+	{ USB_DEVICE(0xeb1a, 0x50a6), .driver_info = EM2860_BOARD_GADMEI_UTV330 },
+	{ USB_DEVICE(0x0ccd, 0x0072), .driver_info = EM2883_BOARD_TERRATEC_HYBRID_XS_FM },
+	{ USB_DEVICE(0x0ccd, 0x0092), .driver_info = EM2883_BOARD_TERRATEC_HYBRID_XS_FM },
+	{ USB_DEVICE(0xeb1a, 0x2863), .driver_info = EM2863_BOARD_EMPIA_GENERIC },
+
+	{ USB_DEVICE(0xeb1a, 0xf306), .driver_info = EM2883_BOARD_KWORLD_HYBRID_F306 },
+	{ USB_DEVICE(0xeb1a, 0xe306), .driver_info = EM2883_BOARD_KWORLD_HYBRID_F306 }, /* development only */
+	{ USB_DEVICE(0x1b80, 0xe329), .driver_info = EM2888_BOARD_KWORLD_HYBRID_E329 },
+	{ USB_DEVICE(0xeb1a, 0x2889), .driver_info = EM2888_BOARD_EMPIA_HYBRID },
+	{ USB_DEVICE(0xeb1a, 0xe323), .driver_info = EM2883_BOARD_KWORLD_HYBRID_E323 },
+	{ USB_DEVICE(0xeb1a, 0xa139), .driver_info = EM2888_BOARD_LINCOLN_TV_FM },
+#if 0
+	{ USB_DEVICE(0x2304, 0x0242), .driver_info = EM2888_BOARD_DVB_TC_HYBRID },
+#endif
+	{ USB_DEVICE(0x0438, 0xb002), .driver_info = EM2883_BOARD_ATI_TVWONDER600 },
+	{ USB_DEVICE(0xeb1a, 0x2875), .driver_info = EM2875_BOARD_SAMPLE_ISDBT },
+	{ USB_DEVICE(0xeb1a, 0x2879), .driver_info = EM2879_BOARD_SAMPLE_DMB   },
+	{ USB_DEVICE(0xeb1a, 0xe301), .driver_info = EM2860_BOARD_KAIOMY_TVNPC_U2 },
+	{ USB_DEVICE(0x0413, 0x6f02), .driver_info = EM2882_BOARD_LEADTEK_PALMTOP_DTV_200H },
+	{ USB_DEVICE(0x185b, 0x2041), .driver_info = EM2820_BOARD_COMPRO_VIDEO_MATE },
+	
+	{ },
+};
+EXPORT_SYMBOL(em28xx_id_table);
+
+/* TODO clean this up */
+int em28xx_card_setup(struct em28xx *dev)
+{
+	int ret = 0;
+
+#ifdef XCEIVE_EXTERNAL_FIRMWARE
+	switch(dev->tuner_type) {
+	case TUNER_XCEIVE_XC3028:
+	{
+		const struct firmware *fw;
+		static unsigned char *xc3028_firmware;
+
+		if (xc3028_firmware==NULL) {
+			ret = request_firmware(&fw, "empia_xc3028.fw", &dev->udev->dev);
+
+			if (ret) {
+				printk(KERN_INFO"Couldn't find empia_xc3028.fw, please run:\n");
+				printk(KERN_INFO"cd /lib/firmware\n");
+				printk(KERN_INFO"sudo wget mcentral.de/empia/empia_xc3028.fw\n");
+				printk(KERN_INFO"and replug your device\n");
+				return -EINVAL;
+			}
+
+			if (fw->size != 120273) {
+				printk(KERN_INFO"Firmware size doesn't match, please be sure\n");
+				printk(KERN_INFO"that you picked the correct firmware\n");
+				printk(KERN_INFO"cd /lib/firmware\n");
+				printk(KERN_INFO"sudo wget mcentral.de/empia/empia_xc3028.fw\n");
+				printk(KERN_INFO"and replug your device\n");
+				return -EINVAL;
+			} else 
+				printk(KERN_INFO"xc3028 firmware successfully loaded to RAM\n");
+
+
+			xc3028_firmware = kzalloc(fw->size, GFP_KERNEL);
+			memcpy(xc3028_firmware, fw->data, fw->size);
+			release_firmware(fw);
+
+			xc3028_set_firmware(xc3028_firmware, 120273);
+		}
+		break;
+	}
+	case TUNER_XCEIVE_XC5000:
+	{
+		const struct firmware *fw;
+
+		if (XC5000_firmware_SEQUENCE == NULL) {
+			ret = request_firmware(&fw, "empia_xc5000.fw", &dev->udev->dev);
+
+			if (ret) {
+				printk(KERN_INFO"Couldn't find empia_xc5000.fw, please run:\n");
+				printk(KERN_INFO"cd /lib/firmware\n");
+				printk(KERN_INFO"sudo wget mcentral.de/empia/empia_xc5000.fw\n");
+				printk(KERN_INFO"and replug your device\n");
+				return -EINVAL;
+			}
+
+			if (fw->size != 12376) {
+				printk(KERN_INFO"Firmware size doesn't match, please be sure\n");
+				printk(KERN_INFO"that you picked the correct firmware\n");
+				printk(KERN_INFO"cd /lib/firmware\n");
+				printk(KERN_INFO"sudo wget mcentral.de/empia/empia_xc5000.fw\n");
+				printk(KERN_INFO"and replug your device\n");
+				return -EINVAL;
+			}
+
+
+			XC5000_firmware_SEQUENCE = kzalloc(fw->size, GFP_KERNEL);
+			memcpy(XC5000_firmware_SEQUENCE, &fw->data[6], fw->size-6);
+			release_firmware(fw);
+
+		}
+		break;
+	}
+	default:
+		break;
+	}
+#endif
+
+	switch (dev->model) {
+	case EM2750_BOARD_DLCW_130:
+	case EM2751_BOARD_EMPIA_SAMPLE:
+	{
+		ret = em28xx_write_regs(dev, R0F_XCLK_REG, "\x0a", 1);
+		if (ret < 0)
+			return ret;
+		break;
+	}
+	case EM2820_BOARD_HAUPPAUGE_WINTV_USB_2:
+	case EM2820_BOARD_HAUPPAUGE_WINTV_USB_2_R2:
+	case EM2870_BOARD_HAUPPAUGE_WINTV_USB_2_R2:
+	{
+		ret = em28xx_write_regs(dev, R0F_XCLK_REG, "\x27", 1);
+		if (ret < 0)
+			return ret;
+		ret = em28xx_write_regs(dev, R06_I2C_CLK_REG, "\x40", 1);
+		if (ret < 0)
+			return ret;
+#ifdef EM28XX_TVEEPROM
+		struct tveeprom tv;
+		request_module("tveeprom");
+#endif
+#ifdef CONFIG_MODULES
+		request_module("ir-kbd-i2c");
+		request_module("msp3400");
+#endif
+		/* Call first TVeeprom */
+
+#ifdef EM28XX_TVEEPROM
+		dev->i2c_client.addr = 0xa0 >> 1;
+		tveeprom_hauppauge_analog(&dev->i2c_client, &tv, dev->eedata);
+
+		dev->tuner_type = tv.tuner_type;
+#if LINUX_VERSION_CODE <=  KERNEL_VERSION(2, 6, 26)
+		if (tv.audio_processor == AUDIO_CHIP_MSP34XX) {
+#else
+		if (tv.audio_processor == V4L2_IDENT_MSPX4XX) {
+#endif
+			dev->i2s_speed = 2048000;
+			dev->has_msp34xx = 1;
+		} else
+			dev->has_msp34xx = 0;
+
+		if (dev->has_msp34xx) {
+			/* Send a reset to other chips via gpio */
+			ret = em28xx_write_regs_req(dev, 0x00, 0x08, "\xf7", 1);
+			if (ret < 0)
+				return ret;
+			udelay(2500);
+			ret = em28xx_write_regs_req(dev, 0x00, 0x08, "\xff", 1);
+			if (ret < 0)
+				return ret;
+			udelay(2500);
+		}
+#endif
+
+		break;
+	}
+	case EM2820_BOARD_KWORLD_PVRTV2800RF:
+	{
+		ret = em28xx_write_regs(dev, R0F_XCLK_REG, "\x27", 1);
+		if (ret < 0)
+			return ret;
+		ret = em28xx_write_regs(dev, R06_I2C_CLK_REG, "\x40", 1);
+		if (ret < 0)
+			return ret;
+		/* GPIO enables sound on KWORLD PVR TV 2800RF */
+		ret = em28xx_write_regs_req(dev, 0x00, 0x08, "\xf9", 1);
+		if (ret < 0)
+			return ret;
+		break;
+	}
+	case EM2880_BOARD_HAUPPAUGE_WINTV_HVR_900:
+	{
+		ret = em28xx_write_regs(dev, R0F_XCLK_REG, "\x27", 1);
+		if (ret < 0)
+			return ret;
+		ret = em28xx_write_regs(dev, R06_I2C_CLK_REG, "\x4c", 1);
+		if (ret < 0)
+			return ret;
+		msleep(10);
+		ret = em28xx_write_regs(dev, 0x08, "\x6d", 1);
+		if (ret < 0)
+			return ret;
+		msleep(10);
+		ret = em28xx_write_regs(dev, 0x08, "\x7d", 1);
+		if (ret < 0)
+			return ret;
+		msleep(10);
+#ifdef CONFIG_MODULES
+		request_module("tveeprom");
+#endif
+		break;
+	}
+	case EM2820_BOARD_MSI_VOX_USB_2:
+	{
+		ret = em28xx_write_regs(dev, R0F_XCLK_REG, "\x27", 1);
+		if (ret < 0)
+			return ret;
+		ret = em28xx_write_regs(dev, R06_I2C_CLK_REG, "\x40", 1);
+		if (ret < 0)
+			return ret;
+		/* enables audio for that device */
+		ret = em28xx_write_regs_req(dev, 0x00, 0x08, "\xfd", 1);
+		if (ret < 0)
+			return ret;
+		break;
+	}
+	case EM2880_BOARD_TERRATEC_HYBRID_XS_FR:
+	{
+		ret = em28xx_write_regs(dev, R0F_XCLK_REG, "\x27", 1);
+		if (ret < 0)
+			return ret;
+		ret = em28xx_write_regs(dev, R06_I2C_CLK_REG, "\x40", 1);
+		if (ret < 0)
+			return ret;
+		ret = em28xx_write_regs(dev, 0x08, "\xfd", 1);
+		if (ret < 0)
+			return ret;
+		msleep(10);
+		ret = em28xx_write_regs(dev, 0x08, "\xff", 1);
+		if (ret < 0)
+			return ret;
+		msleep(10);
+		ret = em28xx_write_regs(dev, 0x08, "\xfe", 1);
+		if (ret < 0)
+			return ret;
+		msleep(10);
+
+		ret = em28xx_write_regs(dev, 0x04, "\x00", 1);
+		if (ret < 0)
+			return ret;
+		msleep(100);
+		ret = em28xx_write_regs(dev, 0x04, "\x08", 1);
+		if (ret < 0)
+			return ret;
+		msleep(100);
+		ret = em28xx_write_regs(dev, 0x08, "\xfe", 1);
+		if (ret < 0)
+			return ret;
+		msleep(100);
+		break;
+	}
+
+	case EM2880_BOARD_TERRATEC_HYBRID_XS:
+	case EM2860_BOARD_TERRATEC_HYBRID_XS:
+	{
+		ret = em28xx_write_regs(dev, R0F_XCLK_REG, "\x97", 1);
+		if (ret < 0)
+			return ret;
+		ret = em28xx_write_regs(dev, R06_I2C_CLK_REG, "\x40", 1);
+		if (ret < 0)
+			return ret;
+		msleep(10);
+		break;
+	}
+	case EM2882_BOARD_TERRATEC_HYBRID_XS:
+	case EM2882_BOARD_LEADTEK_PALMTOP_DTV_200H:
+	{
+		ret = em28xx_write_regs(dev, R0F_XCLK_REG, "\x07", 1);
+		if (ret < 0)
+			return ret;
+		ret = em28xx_write_regs(dev, R06_I2C_CLK_REG, "\x4c", 1);
+		if (ret < 0)
+			return ret;
+		msleep(10);
+		ret = em28xx_write_regs(dev, 0x08, "\x6d", 1);
+		if (ret < 0)
+			return ret;
+		msleep(10);
+		ret = em28xx_write_regs(dev, 0x08, "\x7d", 1);
+		if (ret < 0)
+			return ret;
+		msleep(10);
+		break;
+	}
+	case EM2881_BOARD_DNT_DA2_HYBRID:
+	case EM2861_BOARD_KWORLD_PVRTV_300U:
+	case EM2880_BOARD_KWORLD_DVB_310U:
+	case EM2880_BOARD_KWORLD_DVB_305U:
+	case EM2880_BOARD_MSI_DIGIVOX_AD:
+	case EM2880_BOARD_MSI_DIGIVOX_AD_II:
+	{
+		ret = em28xx_write_regs(dev, R0F_XCLK_REG, "\x27", 1);
+		if (ret < 0)
+			return ret;
+		ret = em28xx_write_regs(dev, R06_I2C_CLK_REG, "\x4c", 1);
+		if (ret < 0)
+			return ret;
+		msleep(10);
+		ret = em28xx_write_regs(dev, 0x08, "\x6d", 1);
+		if (ret < 0)
+			return ret;
+		msleep(10);
+		ret = em28xx_write_regs(dev, 0x08, "\x7d", 1);
+		if (ret < 0)
+			return ret;
+		msleep(10);
+		break;
+	}
+/*		case EM2870_BOARD_COMPRO_VIDEOMATE: TODO */
+	case EM2870_BOARD_PINNACLE_PCTV_DVB:
+	{
+		ret = em28xx_write_regs(dev, R06_I2C_CLK_REG, "\x40", 1);
+		/* this device needs some gpio writes to get the DVB-T demod work */
+		ret = em28xx_write_regs(dev, 0x08, "\xfe", 1);
+		if (ret < 0)
+			return ret;
+		mdelay(70);
+		ret = em28xx_write_regs(dev, 0x08, "\xde", 1);
+		if (ret < 0)
+			return ret;
+		mdelay(70);
+		ret = em28xx_write_regs(dev, 0x08, "\xfe", 1);
+		if (ret < 0)
+			return ret;
+		mdelay(70);
+		ret = em28xx_write_regs(dev, R0F_XCLK_REG, "\x22", 1); /* switch em2880 rc protocol */
+		if (ret < 0)
+			return ret;
+		break;
+	}
+	case EM2870_BOARD_TERRATEC_XS_MT2060:
+	{
+		ret = em28xx_write_regs(dev, R0F_XCLK_REG, "\x27", 1);
+		if (ret < 0)
+			return ret;
+		ret = em28xx_write_regs(dev, R06_I2C_CLK_REG, "\x40", 1);
+		if (ret < 0)
+			return ret;
+		/* this device needs some gpio writes to get the DVB-T demod work */
+		ret = em28xx_write_regs(dev, 0x08, "\xfe", 1);
+		if (ret < 0)
+			return ret;
+		mdelay(70);
+		ret = em28xx_write_regs(dev, 0x08, "\xde", 1);
+		if (ret < 0)
+			return ret;
+		mdelay(70);
+		ret = dev->em28xx_write_regs(dev, 0x08, "\xfe", 1);
+		if (ret < 0)
+			return ret;
+		mdelay(70);
+		break;
+	}
+	case EM2870_BOARD_KWORLD_350U:
+	{
+		ret = em28xx_write_regs(dev, R0F_XCLK_REG, "\x27", 1);
+		if (ret < 0)
+			return ret;
+		ret = em28xx_write_regs(dev, R06_I2C_CLK_REG, "\x40", 1);
+		if (ret < 0)
+			return ret;
+		ret = em28xx_write_regs(dev, 0x08, "\xdf", 1);
+		if (ret < 0)
+			return ret;
+		msleep(10);
+		ret = em28xx_write_regs(dev, 0x08, "\xde", 1);
+		if (ret < 0)
+			return ret;
+		msleep(10);
+		ret = em28xx_write_regs(dev, 0x08, "\xfe", 1);
+		if (ret < 0)
+			return ret;
+		msleep(10);
+		ret = em28xx_write_regs(dev, 0x08, "\x6e", 1);
+		if (ret < 0)
+			return ret;
+		msleep(10);
+		ret = em28xx_write_regs(dev, 0x08, "\x7e", 1);
+		if (ret < 0)
+			return ret;
+		msleep(10);
+		break;
+	}
+	case EM2870_BOARD_KWORLD_355U:
+	case EM2870_BOARD_COMPRO_VIDEOMATE:
+	{
+		ret = em28xx_write_regs(dev, R0F_XCLK_REG, "\x27", 1);
+		if (ret < 0)
+			return ret;
+		ret = em28xx_write_regs(dev, R06_I2C_CLK_REG, "\x40", 1);
+		if (ret < 0)
+			return ret;
+		/* TODO: someone can do some cleanup here... not everything's needed */
+		ret = em28xx_write_regs(dev, 0x04, "\x00", 1);
+		if (ret < 0)
+			return ret;
+		msleep(10);
+		ret = em28xx_write_regs(dev, 0x04, "\x01", 1);
+		if (ret < 0)
+			return ret;
+		msleep(10);
+		ret = em28xx_write_regs(dev, 0x08, "\xfd", 1);
+		if (ret < 0)
+			return ret;
+		mdelay(70);
+		ret = em28xx_write_regs(dev, 0x08, "\xfc", 1);
+		if (ret < 0)
+			return ret;
+		mdelay(70);
+		ret = em28xx_write_regs(dev, 0x08, "\xdc", 1);
+		if (ret < 0)
+			return ret;
+		mdelay(70);
+		ret = em28xx_write_regs(dev, 0x08, "\xfc", 1);
+		if (ret < 0)
+			return ret;
+		mdelay(70);
+		break;
+	}
+
+	case EM2883_BOARD_PINNACLE_PCTV_HD_PRO:
+	case EM2882_BOARD_PINNACLE_HYBRID_PRO:
+	case EM2880_BOARD_HAUPPAUGE_WINTV_HVR_900_R2:
+	case EM2883_BOARD_KWORLD_HYBRID_E323:
+	{
+		ret = em28xx_write_regs(dev, R0F_XCLK_REG, "\x27", 1);
+		if (ret < 0)
+			return ret;
+		ret = em28xx_write_regs(dev, R06_I2C_CLK_REG, "\x40", 1);
+		if (ret < 0)
+			return ret;
+		ret = em28xx_write_regs(dev, 0x08, "\xff", 1);
+		if (ret < 0)
+			return ret;
+		ret = em28xx_write_regs(dev, 0x04, "\x00", 1);
+		if (ret < 0)
+			return ret;
+		msleep(100);
+		ret = em28xx_write_regs(dev, 0x04, "\x08", 1);
+		if (ret < 0)
+			return ret;
+		msleep(100);
+		ret = em28xx_write_regs(dev, 0x08, "\xff", 1);
+		if (ret < 0)
+			return ret;
+		msleep(50);
+		ret = em28xx_write_regs(dev, 0x08, "\x2d", 1);
+		if (ret < 0)
+			return ret;
+		msleep(50);
+		ret = em28xx_write_regs(dev, 0x08, "\x3d", 1);
+		if (ret < 0)
+			return ret;
+
+		/* enable audio 12 mhz i2s*/
+		ret = em28xx_write_regs(dev, 0x0f, "\xa7", 1);
+		if (ret < 0)
+			return ret;
+		msleep(10);
+		break;
+	}
+	case EM2883_BOARD_HAUPPAUGE_WINTV_HVR_950:
+	case EM2883_BOARD_ATI_TVWONDER600:
+	case EM2883_BOARD_KWORLD_HYBRID_A316:
+	{
+		ret = em28xx_write_regs(dev, R0F_XCLK_REG, "\x27", 1);
+		if (ret < 0)
+			return ret;
+		ret = em28xx_write_regs(dev, R06_I2C_CLK_REG, "\x40", 1);
+		if (ret < 0)
+			return ret;
+		ret = em28xx_write_regs(dev, 0x08, "\xff", 1);
+		if (ret < 0)
+			return ret;
+		ret = em28xx_write_regs(dev, 0x04, "\x00", 1);
+		if (ret < 0)
+			return ret;
+		msleep(100);
+		ret = em28xx_write_regs(dev, 0x04, "\x08", 1);
+		if (ret < 0)
+			return ret;
+		msleep(100);
+		ret = em28xx_write_regs(dev, 0x08, "\xff", 1);
+		if (ret < 0)
+			return ret;
+		msleep(50);
+		ret = em28xx_write_regs(dev, 0x08, "\x2d", 1);
+		if (ret < 0)
+			return ret;
+		msleep(50);
+		ret = em28xx_write_regs(dev, 0x08, "\x3d", 1);
+		if (ret < 0)
+			return ret;
+
+		ret = em28xx_write_regs(dev, 0x0f, "\xa7", 1); /* enable audio 12 mhz i2s*/
+		if (ret < 0)
+			return ret;
+		msleep(10);
+		break;
+	}
+	case EM2881_BOARD_PINNACLE_HYBRID_PRO:
+	{
+		ret = em28xx_write_regs(dev, R06_I2C_CLK_REG, "\x4c", 1);
+		if (ret < 0)
+			return ret;
+		msleep(10);
+		ret = em28xx_write_regs(dev, 0x08, "\xfd", 1);
+		if (ret < 0)
+			return ret;
+		msleep(100);
+		ret = em28xx_write_regs(dev, 0x08, "\xfd", 1);
+		if (ret < 0)
+			return ret;
+		msleep(100);
+		ret = em28xx_write_regs(dev, 0x08, "\xff", 1);
+		if (ret < 0)
+			return ret;
+		msleep(5);
+		ret = em28xx_write_regs(dev, R0F_XCLK_REG, "\x27", 1); /* switch em2880 rc protocol */
+		if (ret < 0)
+			return ret;
+#if 0
+
+		ret = dev->em28xx_write_regs(dev, 0x08, "\x6d", 1);
+		if (ret < 0)
+			return ret;
+		msleep(10);
+		ret = dev->em28xx_write_regs(dev, 0x08, "\x7d", 1);
+		if (ret < 0)
+			return ret;
+		msleep(10);
+#endif
+#if 0
+		em2880_ir_attach(dev, ir_codes_pinnacle2, ARRAY_SIZE(ir_codes_pinnacle2), em2880_get_key_empia);
+#endif
+		break;
+	}
+	case EM2820_BOARD_GADMEI_UTV310:
+	{
+		ret = em28xx_write_regs(dev, R0F_XCLK_REG, "\x27", 1);
+		if (ret < 0)
+			return ret;
+		ret = em28xx_write_regs(dev, R06_I2C_CLK_REG, "\x40", 1);
+		if (ret < 0)
+			return ret;
+		/* Turn on analog audio output */
+		ret = em28xx_write_regs_req(dev, 0x00, 0x08, "\xfd", 1);
+		if (ret < 0)
+			return ret;
+		break;
+	}
+	case EM2860_BOARD_GADMEI_UTV330:
+	{
+		/* Turn on IR */
+		ret = em28xx_write_regs(dev, R0F_XCLK_REG, "\x07", 1);
+		if (ret < 0)
+			return ret;
+		ret = em28xx_write_regs(dev, R06_I2C_CLK_REG, "\x40", 1);
+		if (ret < 0)
+			return ret;
+		break;
+	}
+	case EM2861_BOARD_PLEXTOR_PX_TV100U:
+	{
+		ret = em28xx_write_regs(dev, R0F_XCLK_REG, "\x27", 1);
+		if (ret < 0)
+			return ret;
+		ret = em28xx_write_regs(dev, R06_I2C_CLK_REG, "\x40", 1);
+		if (ret < 0)
+			return ret;
+		/* Turn on analog audio output */
+		ret = em28xx_write_regs_req(dev, 0x00, 0x08, "\xfd", 1);
+		if (ret < 0)
+			return ret;
+		break;
+	}
+	case EM2888_BOARD_KWORLD_HYBRID_E329:
+	case EM2888_BOARD_EMPIA_HYBRID:
+	case EM2888_BOARD_LINCOLN_TV_FM:
+	{
+		ret = em28xx_write_regs(dev, 0x80, "\xf0", 1);
+		msleep(100);
+		ret = em28xx_write_regs(dev, 0x80, "\xf4", 1);
+		msleep(50);
+		ret = em28xx_write_regs(dev, 0x80, "\xf6", 1);
+		ret = em28xx_write_regs(dev, 0x80, "\xb6", 1);
+		msleep(100);
+		ret = em28xx_write_regs(dev, 0x80, "\xf6", 1);
+		msleep(100);
+		ret = em28xx_write_regs(dev, 0x80, "\xf5", 1);
+		if (ret < 0)
+			return ret;
+		if (ret < 0)
+			return ret;
+		ret = em28xx_write_regs(dev, R06_I2C_CLK_REG, "\x45", 1);
+		if (ret < 0)
+			return ret;
+		ret = em28xx_write_regs(dev, R0F_XCLK_REG, "\x02", 1);
+		if (ret < 0)
+			return ret;
+		ret = em28xx_write_regs(dev, 0x50, "\x01", 1);
+		if (ret < 0)
+			return ret;
+		break;
+	}
+	case EM2883_BOARD_EMPIA_HYBRID_ATSC:
+	case EM2883_BOARD_EQUINUX_TUBESTICK_ATSC:
+	case EM2883_BOARD_TERRATEC_HYBRID_XS_FM:
+	case EM2863_BOARD_EMPIA_GENERIC:
+	{
+		ret = em28xx_write_regs(dev, R0F_XCLK_REG, "\x97", 1);
+		if (ret < 0)
+			return ret;
+		ret = em28xx_write_regs(dev, R06_I2C_CLK_REG, "\x40", 1);
+		if (ret < 0)
+			return ret;
+		msleep(10);
+		ret = em28xx_write_regs(dev, 0x08, "\x2d", 1);
+		if (ret < 0)
+			return ret;
+		msleep(10);
+#if 0
+		ret = em28xx_write_regs(dev, 0x08, "\x7d", 1);
+		if (ret < 0)
+			return ret;
+		msleep(10);
+#endif
+		break;
+	}
+	case EM2860_BOARD_KAIOMY_TVNPC_U2:
+	{
+		ret = em28xx_write_regs(dev, R0F_XCLK_REG, "\x27", 1);
+		if (ret < 0)
+			return ret;
+		ret = em28xx_write_regs(dev, R06_I2C_CLK_REG, "\x4c", 1);
+		if (ret < 0)
+			return ret;
+		msleep(10);
+		ret = em28xx_write_regs(dev, 0x08, "\x6d", 1);
+		if (ret < 0)
+			return ret;
+		msleep(10);
+		ret = em28xx_write_regs(dev, 0x08, "\x7d", 1);
+		if (ret < 0)
+			return ret;
+		msleep(10);
+		ret = em28xx_write_regs(dev, 0x0f, "\x07", 1);
+		if (ret < 0)
+			return ret;
+		break;
+	}
+	case EM2875_BOARD_SAMPLE_ISDBT:
+	{
+		//            em28xx_write_regs(dev, R06_I2C_CLK_REG, "\x40", 1); // EEPROM access
+		em28xx_write_regs(dev, R06_I2C_CLK_REG, "\x44", 1);
+		em28xx_write_regs(dev, 0x0f, "\x02", 1);
+		em28xx_write_regs(dev, 0x50, "\x0e", 1);
+		em28xx_write_regs(dev, 0x80, "\xf0", 1);
+		break;
+	}
+
+	default:
+		ret = dev->em28xx_write_regs(dev, R0F_XCLK_REG, "\x27", 1);
+		if (ret < 0)
+			return ret;
+		if (dev->em_type != EM2800) {
+			ret = em28xx_write_regs(dev, R06_I2C_CLK_REG, "\x40", 1);
+			if (ret < 0)
+				return ret;
+		}
+	}
+	return 0;
+}
+
+void em28xx_card_disconnect(struct em28xx *dev)
+{
+	if (dev->ir_em2880)
+		em2880_ir_detach(dev);
+}
+
+EXPORT_SYMBOL(em28xx_boards);
+EXPORT_SYMBOL(em28xx_bcount);
+
+MODULE_DEVICE_TABLE (usb, em28xx_id_table);
diff --git a/drivers/media/video/empia/em28xx-core.c b/drivers/media/video/empia/em28xx-core.c
new file mode 100644
index 0000000..48b4b8c
--- /dev/null
+++ b/drivers/media/video/empia/em28xx-core.c
@@ -0,0 +1,1366 @@
+/*
+   em28xx-core.c - driver for Empia EM2800/EM2820/2840/2880 USB video capture devices
+
+   Copyright (C) 2005 Ludovico Cavedon <cavedon@xxxxxxxx>
+		      Markus Rechberger <mrechberger@xxxxxxxxx>
+		      Mauro Carvalho Chehab <mchehab@xxxxxxxxxxxxx>
+		      Sascha Sommer <saschasommer@xxxxxxxxxx>
+
+   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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/init.h>
+#include <linux/list.h>
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/usb.h>
+#include <linux/vmalloc.h>
+
+#include "em28xx.h"
+
+/* #define ENABLE_DEBUG_ISOC_FRAMES */
+
+static unsigned int core_debug;
+module_param(core_debug, int, 0644);
+MODULE_PARM_DESC(core_debug, "enable debug messages [core]");
+
+#define em28xx_coredbg(fmt, arg...) do {\
+	if (core_debug) \
+		printk(KERN_INFO "%s %s :"fmt, \
+			 dev->name, __FUNCTION__ , ##arg); } while (0)
+
+static unsigned int reg_debug;
+module_param(reg_debug, int, 0644);
+MODULE_PARM_DESC(reg_debug, "enable debug messages [URB reg]");
+
+#define em28xx_regdbg(fmt, arg...) do {\
+	if (reg_debug) \
+		printk(KERN_INFO "%s: "fmt, \
+			 dev->name, ##arg); } while (0)
+
+static unsigned int isoc_debug;
+module_param(isoc_debug, int, 0644);
+MODULE_PARM_DESC(isoc_debug, "enable debug messages [isoc transfers]");
+
+#define em28xx_isocdbg(fmt, arg...) do {\
+	if (isoc_debug) \
+		printk(KERN_INFO "%s %s :"fmt, \
+			 dev->name, __FUNCTION__ , ##arg); } while (0)
+
+static int alt = EM28XX_PINOUT;
+module_param(alt, int, 0644);
+MODULE_PARM_DESC(alt, "alternate setting to use for video endpoint");
+
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 15)
+static void *rvmalloc(size_t size)
+{
+	void *mem;
+	unsigned long adr;
+
+	size = PAGE_ALIGN(size);
+
+	mem = vmalloc_32((unsigned long)size);
+	if (!mem)
+		return NULL;
+
+	adr = (unsigned long)mem;
+	while (size > 0) {
+		SetPageReserved(vmalloc_to_page((void *)adr));
+		adr += PAGE_SIZE;
+		size -= PAGE_SIZE;
+	}
+
+	return mem;
+}
+
+static void rvfree(void *mem, size_t size)
+{
+	unsigned long adr;
+
+	if (!mem)
+		return;
+
+	size = PAGE_ALIGN(size);
+
+	adr = (unsigned long)mem;
+	while (size > 0) {
+		ClearPageReserved(vmalloc_to_page((void *)adr));
+		adr += PAGE_SIZE;
+		size -= PAGE_SIZE;
+	}
+
+	vfree(mem);
+}
+#endif
+
+/*
+ * em28xx_request_buffers()
+ * allocate a number of buffers
+ */
+u32 em28xx_request_buffers(struct em28xx *dev, u32 count, int type)
+{
+	size_t size;
+
+	void *buff = NULL;
+	u32 i;
+
+
+	size = PAGE_ALIGN((type == EM28XX_VBI) ?
+			dev->vbi_frame_size : dev->frame_size);
+
+	switch (type) {
+	case EM28XX_VIDEO:
+		if (count > EM28XX_NUM_FRAMES)
+			count = EM28XX_NUM_FRAMES;
+
+		if (dev->num_frames > 0)
+			return -EINVAL;
+
+		dev->num_frames = count;
+		size = PAGE_ALIGN(dev->frame_size);
+		break;
+	case EM28XX_VBI:
+		if (count > EM28XX_NUM_FRAMES) /* FIXME VBI_NUM_FRAMES */
+			count = EM28XX_NUM_FRAMES;
+
+		if (dev->vbi_num_frames > 0)
+			return -EINVAL;
+
+		dev->vbi_num_frames = count;
+		size = PAGE_ALIGN(dev->vbi_frame_size);
+		break;
+	default:
+		printk(KERN_INFO"em28xx-core.c: error wrong buffer request!\n");
+		return -EINVAL;
+	}
+
+	em28xx_coredbg("requested %i buffers with size %zi", count, size);
+
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 15)
+	buff = rvmalloc(count * size);
+#else
+	buff = vmalloc_32(count * size);
+#endif
+	if (buff)
+		memset(buff, 0, count * size);
+	else
+		return -ENOMEM;
+
+	for (i = 0; i < count; i++) {
+		switch (type) {
+		case EM28XX_VBI:
+			dev->vbi_frame[i].bufmem = buff + i * size;
+			dev->vbi_frame[i].buf.index = i;
+			dev->vbi_frame[i].buf.m.offset = i * size;
+			dev->vbi_frame[i].buf.length = dev->vbi_frame_size;
+			dev->vbi_frame[i].buf.type = V4L2_BUF_TYPE_VBI_CAPTURE;
+			dev->vbi_frame[i].buf.sequence = 0;
+
+/* Indicates the field order of the image in the buffer, see Table 3-8>. This
+   field is not used when the buffer contains VBI data. Drivers must set it 
+   when type refers to an input stream, applications when an output stream. 
+ 
+   this probably should be changed since we can have an interlaced field here 
+*/
+			if (dev->vbi_interlaced)
+				dev->vbi_frame[i].buf.field = V4L2_VBI_INTERLACED;
+			else
+				dev->vbi_frame[i].buf.field = V4L2_FIELD_NONE;
+			dev->vbi_frame[i].buf.memory = V4L2_MEMORY_MMAP;
+			dev->vbi_frame[i].buf.flags = 0;
+			break;
+		case EM28XX_VIDEO:
+			dev->frame[i].bufmem = buff + i * size;
+			dev->frame[i].buf.index = i;
+			dev->frame[i].buf.m.offset = i * size;
+			dev->frame[i].buf.length = dev->frame_size;
+			dev->frame[i].buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+			dev->frame[i].buf.sequence = 0;
+			dev->frame[i].buf.field = V4L2_FIELD_INTERLACED; /*_TB;  V4L2_FIELD_NONE; */
+			dev->frame[i].buf.memory = V4L2_MEMORY_MMAP;
+			dev->frame[i].buf.flags = 0;
+			break;
+		default:
+			printk(KERN_INFO"error wrong buffer request!\n");
+			return -EINVAL;
+		}
+
+	}
+	return count;
+}
+
+/*
+ * em28xx_queue_unusedframes()
+ * add all frames that are not currently in use to the inbuffer queue
+ */
+void em28xx_queue_unusedframes(struct em28xx *dev, int type)
+{
+	unsigned long lock_flags;
+	u32 i;
+	switch (type) {
+	case EM28XX_VIDEO:
+		for (i = 0; i < dev->num_frames; i++) {
+			if (dev->frame[i].state == F_UNUSED) {
+				spin_lock_irqsave(&dev->queue_lock, lock_flags);
+				dev->frame[i].state = F_QUEUED;
+				list_add_tail(&dev->frame[i].frame,
+						&dev->inqueue);
+				spin_unlock_irqrestore(&dev->queue_lock,
+						lock_flags);
+			}
+		}
+		break;
+	case EM28XX_VBI:
+		for (i = 0; i < dev->vbi_num_frames; i++) {
+			if (dev->vbi_frame[i].state == F_UNUSED) {
+				spin_lock_irqsave(&dev->vbi_queue_lock,
+						lock_flags);
+				dev->vbi_frame[i].state = F_QUEUED;
+				list_add_tail(&dev->vbi_frame[i].frame,
+						&dev->vbi_inqueue);
+				spin_unlock_irqrestore(&dev->vbi_queue_lock,
+						lock_flags);
+			}
+		}
+		break;
+	}
+}
+
+/*
+ * em28xx_release_buffers()
+ * free frame buffers
+ */
+void em28xx_release_buffers(struct em28xx *dev, int type)
+{
+	if (type == EM28XX_VIDEO && dev->num_frames) {
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 15)
+		rvfree(dev->frame[0].bufmem,
+				dev->num_frames *
+				PAGE_ALIGN(dev->frame[0].buf.length));
+#else
+		vfree(dev->frame[0].bufmem);
+		dev->num_frames = 0;
+#endif
+	} else if (type == EM28XX_VBI && dev->vbi_num_frames) {
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 15)
+		rvfree(dev->vbi_frame[0].bufmem,
+				dev->vbi_num_frames *
+				PAGE_ALIGN(dev->vbi_frame[0].buf.length));
+#else
+		vfree(dev->vbi_frame[0].bufmem);
+		dev->vbi_num_frames = 0;
+#endif
+	}
+}
+
+/*
+ * em28xx_read_reg_req()
+ * reads data from the usb device specifying bRequest
+ */
+int em28xx_read_reg_req_len(struct em28xx *dev, u8 req, u16 reg,
+				   char *buf, int len)
+{
+	int ret, byte;
+
+	if (dev->state & DEV_DISCONNECTED)
+		return -ENODEV;
+
+	ret = usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0), req,
+			      USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+			      0x0000, reg, buf, len, HZ);
+
+	if (reg_debug) {
+		em28xx_regdbg("%s c0 %02x 00 00 %02x 00 %02x 00 <<<",
+				(ret < 0) ? "[NOK]" : "[ OK]", req, reg, len);
+
+		for (byte = 0; byte < len; byte++)
+			printk(" %02x", (unsigned char)buf[byte]);
+		printk("\n");
+	}
+	return ret;
+}
+
+/*
+ * em28xx_read_reg_req()
+ * reads data from the usb device specifying bRequest
+ */
+int em28xx_read_reg_req(struct em28xx *dev, u8 req, u16 reg)
+{
+	u8 val;
+	int ret;
+
+	if (dev->state & DEV_DISCONNECTED)
+		return(-ENODEV);
+
+
+	ret = usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0), req,
+			      USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+			      0x0000, reg, &val, 1, HZ);
+
+	if (reg_debug) {
+		if (ret < 0)
+			em28xx_regdbg("%s c0 %02x 00 00 %02x 00 01 00 <<<\n",
+					(ret < 0) ? "[NOK]" : "[ OK]", req,
+					reg);
+		else
+			em28xx_regdbg("%s c0 %02x 00 00 %02x 00 01 00 <<< "
+				      "%02x\n", (ret < 0) ? "[NOK]" : "[ OK]",
+				      req, reg, (unsigned char)val);
+	}
+
+	if (ret < 0)
+		return ret;
+
+	return val;
+}
+
+int em28xx_read_reg(struct em28xx *dev, u16 reg)
+{
+	return em28xx_read_reg_req(dev, USB_REQ_GET_STATUS, reg);
+}
+
+/*
+ * em28xx_write_regs_req()
+ * sends data to the usb device, specifying bRequest
+ */
+int em28xx_write_regs_req(struct em28xx *dev, u8 req, u16 reg, char *buf,
+				 int len)
+{
+	int ret;
+
+	/*usb_control_msg seems to expect a kmalloced buffer */
+	unsigned char *bufs;
+
+	if (dev->state & DEV_DISCONNECTED)
+		return(-ENODEV);
+
+	bufs = kmalloc(len, GFP_KERNEL);
+
+	if (!bufs)
+		return -ENOMEM;
+	memcpy(bufs, buf, len);
+
+	ret = usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, 0), req,
+			      USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+			      0x0000, reg, bufs, len, HZ);
+	if (reg_debug) {
+		int i;
+		em28xx_regdbg("%s 40 %02x 00 00 %02x 00 %02x 00 >>>",
+				(ret < 0) ? "[NOK]" : "[ OK]", req, reg, len);
+		for (i = 0; i < len; ++i)
+			printk(" %02x", (unsigned char)buf[i]);
+		printk("\n");
+	}
+	kfree(bufs);
+	return ret;
+}
+
+int em28xx_write_regs(struct em28xx *dev, u16 reg, char *buf, int len)
+{
+	return em28xx_write_regs_req(dev, USB_REQ_GET_STATUS, reg, buf, len);
+}
+
+/*
+ * em28xx_write_reg_bits()
+ * sets only some bits (specified by bitmask) of a register, by first reading
+ * the actual value
+ */
+int em28xx_write_reg_bits(struct em28xx *dev, u16 reg, u8 val,
+				 u8 bitmask)
+{
+	int oldval;
+	u8 newval;
+	oldval = em28xx_read_reg(dev, reg);
+	if (oldval < 0)
+		return oldval;
+	newval = (((u8) oldval) & ~bitmask) | (val & bitmask);
+	return em28xx_write_regs(dev, reg, &newval, 1);
+}
+
+/*
+ * em28xx_write_ac97()
+ * write a 16 bit value to the specified AC97 address (LSB first!)
+ */
+int em28xx_write_ac97(struct em28xx *dev, u8 reg, u8 *val)
+{
+	int ret;
+	u8 addr;
+	switch (dev->model) {
+	case EM2881_BOARD_PINNACLE_HYBRID_PRO:
+	case EM2880_BOARD_TERRATEC_HYBRID_XS_FR:
+	case EM2881_BOARD_DNT_DA2_HYBRID:
+		addr = 0x1a;
+		break;
+	default:
+		addr = reg & 0x7f;
+	}
+	
+	ret = em28xx_read_reg(dev, R43_AC97BUSY_REG);
+	if (ret < 0)
+		return ret;
+	else if (((u8) ret) & 0x01) 
+		return 0;
+	
+	ret = em28xx_write_regs(dev, R40_AC97LSB_REG, val, 2);
+	if (ret < 0)
+		return ret;
+
+	ret = em28xx_write_regs(dev, R42_AC97ADDR_REG, &addr, 1);
+	if (ret < 0)
+		return ret;
+
+	return 0;
+}
+
+int em28xx_audio_analog_set(struct em28xx *dev)
+{
+	char s[2] = { 0x00, 0x00 };
+
+	switch (dev->model) {
+	case EM2881_BOARD_PINNACLE_HYBRID_PRO:
+	case EM2880_BOARD_TERRATEC_HYBRID_XS_FR:
+	case EM2881_BOARD_DNT_DA2_HYBRID:
+		s[0] = 0x05;
+		s[1] = 0x05;
+		break;
+	case EM2861_BOARD_PLEXTOR_PX_TV100U:
+	case EM2860_BOARD_GADMEI_UTV330:
+		switch (dev->ctl_ainput) {
+		case 0:
+			s[0] = 0xfd;
+			break;
+		case 1:
+			s[0] = 0xfc;
+			break;
+		default :
+			s[0] = 0xfe;
+			break;
+		}
+		if (dev->mute)
+			s[0] = 0xfe;
+		return em28xx_write_regs(dev, 0x08, s, 1);
+	default:
+		s[0] |= 0x1f - dev->volume;
+		s[1] |= 0x1f - dev->volume;
+	}
+
+	if (dev->mute)
+		s[1] |= 0x80;
+	return em28xx_write_ac97(dev, R02_MASTER_AC97, s);
+}
+
+int em28xx_colorlevels_set_default(struct em28xx *dev)
+{
+	int ret;
+
+	/* contrast */
+	ret = em28xx_write_regs(dev, R20_YGAIN_REG, "\x10", 1);
+	if (ret < 0)
+		return ret;
+
+	/* brightness */
+	ret = em28xx_write_regs(dev, R21_YOFFSET_REG, "\x00", 1);
+	if (ret < 0)
+		return ret;
+
+	/* saturation */
+	ret = em28xx_write_regs(dev, R22_UVGAIN_REG, "\x10", 1);
+	if (ret < 0)
+		return ret;
+
+	ret = em28xx_write_regs(dev, R23_UOFFSET_REG, "\x00", 1);
+	if (ret < 0)
+		return ret;
+
+	ret = em28xx_write_regs(dev, R24_VOFFSET_REG, "\x00", 1);
+	if (ret < 0)
+		return ret;
+
+	ret = em28xx_write_regs(dev, R25_SHARPNESS_REG, "\x00", 1);
+	if (ret < 0)
+		return ret;
+
+	ret = em28xx_write_regs(dev, R14_GAMMA_REG, "\x20", 1);
+	if (ret < 0)
+		return ret;
+
+	ret = em28xx_write_regs(dev, R15_RGAIN_REG, "\x20", 1);
+	if (ret < 0)
+		return ret;
+
+	ret = em28xx_write_regs(dev, R16_GGAIN_REG, "\x20", 1);
+	if (ret < 0)
+		return ret;
+
+	ret = em28xx_write_regs(dev, R17_BGAIN_REG, "\x20", 1);
+	if (ret < 0)
+		return ret;
+
+	ret = em28xx_write_regs(dev, R18_ROFFSET_REG, "\x00", 1);
+	if (ret < 0)
+		return ret;
+
+	ret = em28xx_write_regs(dev, R19_GOFFSET_REG, "\x00", 1);
+	if (ret < 0)
+		return ret;
+
+	ret = em28xx_write_regs(dev, R1A_BOFFSET_REG, "\x00", 1);
+	if (ret < 0)
+		return ret;
+
+	return 0;
+}
+
+int em28xx_capture_start(struct em28xx *dev, int start)
+{
+	int ret;
+	/* FIXME: which is the best order? */
+	/* video registers are sampled by VREF */
+	if ((ret = em28xx_write_reg_bits(dev, R0C_USBSUSP_REG, start ?
+					0x10 : 0x00,
+					  0x10)) < 0)
+		return ret;
+	/* enable video capture */
+	return em28xx_write_regs(dev, R12_VINENABLE_REG, start ?
+			"\x67" : "\x27", 1);
+}
+
+int em28xx_outfmt_set_yuv422(struct em28xx *dev)
+{
+	int ret;
+
+	/* maybe put this configuration into the card configstruct,
+	   it's not entirely clear what values are needed for em2750
+	   boards so this is a hacking place at the moment */
+
+	if (dev->em_type == EM2750 || dev->em_type == EM2751) {
+		ret = em28xx_write_regs(dev, R11_VINCTRL_REG, "\x00", 1);
+		if (ret < 0)
+			return ret;
+
+		ret = em28xx_write_regs(dev, R10_VINMODE_REG, "\x0a", 1);
+		if (ret < 0)
+			return ret;
+	} else {
+		u8 fmt_val;
+
+		fmt_val = ((u8)em28xx_read_reg(dev, R27_OUTFMT_REG) & ~0x1f) | dev->outfmt->config;
+
+		ret = em28xx_write_regs(dev, R27_OUTFMT_REG, &fmt_val, 1);
+		if (ret < 0)
+			return ret;
+
+		ret = em28xx_write_regs(dev, R10_VINMODE_REG, "\x10", 1);
+		if (ret < 0)
+			return ret;
+
+		ret = em28xx_write_regs(dev, R11_VINCTRL_REG, "\x11", 1);
+		if (ret < 0)
+			return ret;
+	}
+	if (dev->dev_modes & EM28XX_VBI)
+		em28xx_set_vbi(dev, 1);
+	return 0;
+}
+
+int em28xx_set_vbi(struct em28xx *dev, int enable)
+{
+	u8 vic;
+	int ret;
+	ret = em28xx_write_regs_req(dev, 0x00, 0x34,
+			&dev->tvnorm->vbi_h_start, 1);
+	if (ret < 0)
+		return ret;
+
+	ret = em28xx_write_regs_req(dev, 0x00, 0x35,
+			&dev->tvnorm->vbi_v_start, 1);
+	if (ret < 0)
+		return ret;
+
+	ret = em28xx_write_regs_req(dev, 0x00, 0x36,
+			&dev->tvnorm->vbi_w, 1);
+	if (ret < 0)
+		return ret;
+
+	ret = em28xx_write_regs_req(dev, 0x00, 0x37,
+			&dev->tvnorm->vbi_h, 1);
+	if (ret < 0)
+		return ret;
+
+	if (enable)
+		vic = em28xx_read_reg(dev, R11_VINCTRL_REG) | 0x48;
+	else
+		vic = em28xx_read_reg(dev, R11_VINCTRL_REG) & ~0x48;
+
+	ret = em28xx_write_regs(dev, R11_VINCTRL_REG, &vic , 1);
+
+	if (ret < 0)
+		return ret;
+
+	return 0;
+}
+
+int em28xx_accumulator_set(struct em28xx *dev, u8 xmin, u8 xmax, u8 ymin,
+				  u8 ymax)
+{
+	int ret;
+	em28xx_coredbg("em28xx Scale: (%d,%d)-(%d,%d)\n", xmin,
+			ymin, xmax, ymax);
+
+	ret = em28xx_write_regs(dev, R28_XMIN_REG, &xmin, 1);
+	if (ret < 0)
+		return ret;
+
+	ret = em28xx_write_regs(dev, R29_XMAX_REG, &xmax, 1);
+	if (ret < 0)
+		return ret;
+
+	ret = em28xx_write_regs(dev, R2A_YMIN_REG, &ymin, 1);
+	if (ret < 0)
+		return ret;
+
+	ret = em28xx_write_regs(dev, R2B_YMAX_REG, &ymax, 1);
+	if (ret < 0)
+		return ret;
+
+	return 0;
+}
+
+int em28xx_capture_area_set(struct em28xx *dev, u8 hstart, u8 vstart,
+				   u16 width, u16 height)
+{
+	int ret;
+	u8 cwidth = width;
+	u8 cheight = height;
+	u8 overflow = (height >> 7 & 0x02) | (width >> 8 & 0x01);
+
+	em28xx_coredbg("em28xx Area Set: (%d,%d)\n",
+			(width | (overflow & 2) << 7),
+			(height | (overflow & 1) << 8));
+
+	ret = em28xx_write_regs(dev, R1C_HSTART_REG, &hstart, 1);
+	if (ret < 0)
+		return ret;
+
+	ret = em28xx_write_regs(dev, R1D_VSTART_REG, &vstart, 1);
+	if (ret < 0)
+		return ret;
+
+	ret = em28xx_write_regs(dev, R1E_CWIDTH_REG, &cwidth, 1);
+	if (ret < 0)
+		return ret;
+
+	ret = em28xx_write_regs(dev, R1F_CHEIGHT_REG, &cheight, 1);
+	if (ret < 0)
+		return ret;
+
+	ret = em28xx_write_regs(dev, R1B_OFLOW_REG, &overflow, 1);
+	if (ret < 0)
+		return ret;
+	return 0;
+}
+
+int em28xx_scaler_set(struct em28xx *dev, u16 h, u16 v)
+{
+	int ret;
+	u8 mode;
+	u8 buf[2];
+	/* the em2800 scaler only supports scaling down to 50% */
+
+	switch (dev->em_type) {
+	case EM2750:
+#if 1 /* TODO: PLEASE VERIFY */
+		mode = (h || v)? 0x30: 0x00;
+		ret = em28xx_write_regs(dev, R30_HSCALELOW_REG, "\x00\x30", 2);
+		if (ret < 0)
+			return ret;
+		ret = em28xx_write_regs(dev, R32_VSCALELOW_REG, "\x00\x30", 2);
+		if (ret < 0)
+			return ret;
+#endif
+		break;
+	case EM2800:
+		mode = (v ? 0x20 : 0x00) | (h ? 0x10 : 0x00);
+		break;
+	default:
+		buf[0] = h;
+		buf[1] = h >> 8;
+		ret = em28xx_write_regs(dev, R30_HSCALELOW_REG, (char *)buf, 2);
+		if (ret < 0)
+			return ret;
+		buf[0] = v;
+		buf[1] = v >> 8;
+		ret = em28xx_write_regs(dev, R32_VSCALELOW_REG, (char *)buf, 2);
+		if (ret < 0)
+			return ret;
+		/* it seems that both H and V scalers must be active to work
+		   correctly */
+		mode = (h || v)? 0x30: 0x00;
+	}
+	ret = em28xx_write_reg_bits(dev, R26_COMPR_REG, mode, 0x30);
+	if (ret < 0)
+		return ret;
+
+	return ret;
+}
+
+/* FIXME: this only function read values from dev */
+int em28xx_resolution_set(struct em28xx *dev)
+{
+	int width, height;
+	width = norm_maxw(dev);
+	height = norm_maxh(dev) >> 1;
+
+	em28xx_outfmt_set_yuv422(dev);
+	em28xx_accumulator_set(dev, 1, (width - 4) >> 2, 1, (height - 4) >> 2);
+	em28xx_capture_area_set(dev, 0, 0, width >> 2, height >> 2);
+	return em28xx_scaler_set(dev, dev->hscale, dev->vscale);
+}
+
+
+/******************* isoc transfer handling ****************************/
+
+#ifdef ENABLE_DEBUG_ISOC_FRAMES
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 19)
+static void em28xx_isoc_dump(struct urb *urb, struct pt_regs *regs)
+#else
+static void em28xx_isoc_dump(struct urb *urb)
+#endif
+{
+	int len = 0;
+	int ntrans = 0;
+	int i;
+
+	printk(KERN_DEBUG "isocIrq: sf=%d np=%d ec=%x\n",
+	       urb->start_frame, urb->number_of_packets,
+	       urb->error_count);
+	for (i = 0; i < urb->number_of_packets; i++) {
+		unsigned char *buf =
+				urb->transfer_buffer +
+				urb->iso_frame_desc[i].offset;
+		int alen = urb->iso_frame_desc[i].actual_length;
+		if (alen > 0) {
+			if (buf[0] == 0x88) {
+				ntrans++;
+				len += alen;
+			} else if (buf[0] == 0x22) {
+				printk(KERN_DEBUG
+						"= l=%d nt=%d bpp=%d\n",
+				len - 4 * ntrans, ntrans,
+				ntrans == 0 ? 0 : len / ntrans);
+				ntrans = 1;
+				len = alen;
+			} else
+				printk(KERN_DEBUG "!\n");
+		}
+		printk(KERN_DEBUG "   n=%d s=%d al=%d %x\n", i,
+		       urb->iso_frame_desc[i].status,
+		       urb->iso_frame_desc[i].actual_length,
+		       (unsigned int)
+				       *((unsigned char *)(urb->transfer_buffer +
+				       urb->iso_frame_desc[i].
+				       offset)));
+	}
+}
+#endif
+
+static int em28xx_isoc_video(struct em28xx *dev, struct em28xx_frame_t **f,
+				struct em28xx_frame_t **vbif,
+				unsigned long *lock_flags, unsigned char buf)
+{
+
+	if (!(buf & 0x01)) {
+		if ((*vbif)) {
+			if ((*vbif)->state == F_GRABBING) {
+				/*previous frame is incomplete */
+				if ((*vbif)->fieldbytesused < dev->vbi_field_size) {
+					(*vbif)->state = F_ERROR;
+				} else {
+					(*vbif)->state = F_DONE;
+					(*vbif)->buf.bytesused = dev->vbi_frame_size;
+				}
+			}
+			if ((*vbif)->state == F_DONE ||
+					(*vbif)->state == F_ERROR) {
+				/* move current frame to outqueue and get next free buffer from inqueue */
+				spin_lock_irqsave(&dev->vbi_queue_lock,
+						*lock_flags);
+				list_move_tail(&(*vbif)->frame,
+						&dev->vbi_outqueue);
+				if (!list_empty(&dev->vbi_inqueue))
+					(*vbif) = list_entry(
+							dev->vbi_inqueue.next,
+							struct em28xx_frame_t,
+							frame);
+				else
+					(*vbif) = NULL;
+				spin_unlock_irqrestore(&dev->vbi_queue_lock,
+						*lock_flags);
+			}
+			if ((*vbif)) {
+				do_gettimeofday(&(*vbif)->buf.timestamp);
+				(*vbif)->buf.sequence = ++dev->vbi_frame_count;
+				(*vbif)->buf.field = V4L2_FIELD_INTERLACED;
+				(*vbif)->state = F_GRABBING;
+				(*vbif)->buf.bytesused = 0;
+				(*vbif)->top_field = 1;
+				(*vbif)->fieldbytesused = 0;
+			}
+		}
+		if ((*f)) {
+			if ((*f)->state == F_GRABBING) {
+				/*previous frame is incomplete */
+				if ((*f)->fieldbytesused < dev->field_size) {
+					(*f)->state = F_ERROR;
+				} else {
+					(*f)->state = F_DONE;
+					(*f)->buf.bytesused = dev->frame_size;
+				}
+			}
+			if ((*f)->state == F_DONE || (*f)->state == F_ERROR) {
+				/* move current frame to outqueue and get next
+				   free buffer from inqueue */
+				spin_lock_irqsave(&dev->queue_lock, *lock_flags);
+				list_move_tail(&(*f)->frame, &dev->outqueue);
+				if (!list_empty(&dev->inqueue)) {
+					(*f) = list_entry(dev->inqueue.next,
+							struct em28xx_frame_t,
+							frame);
+				} else {
+					(*f) = NULL;
+				}
+				spin_unlock_irqrestore(&dev->queue_lock,
+						*lock_flags);
+			}
+			if ((*f)) {
+				do_gettimeofday(&(*f)->buf.timestamp);
+				(*f)->buf.sequence = ++dev->frame_count;
+				(*f)->buf.field = V4L2_FIELD_INTERLACED;
+				(*f)->state = F_GRABBING;
+				(*f)->buf.bytesused = 0;
+				(*f)->top_field = 1;
+				(*f)->fieldbytesused = 0;
+			}
+		}
+	} else {
+		if ((*vbif)) {
+			if ((*vbif)->state == F_QUEUED)
+				(*vbif)->top_field = 0;
+			else if ((*vbif)->state == F_GRABBING) {
+				if (!(*vbif)->top_field)
+					(*vbif)->state = F_ERROR;
+				else if ((*vbif)->fieldbytesused <
+						dev->vbi_field_size - 172)
+					(*vbif)->state = F_ERROR;
+				else {
+					(*vbif)->top_field = 0;
+					(*vbif)->fieldbytesused = 0;
+				}
+			}
+		}
+
+		if ((*f)) {
+			if ((*f)->state == F_GRABBING) {
+				if (!(*f)->top_field)
+					(*f)->state = F_ERROR;
+				else if ((*f)->fieldbytesused <
+						dev->field_size - 172)
+					(*f)->state = F_ERROR;
+				else {
+					(*f)->top_field = 0;
+					(*f)->fieldbytesused = 0;
+				}
+			}
+		}
+	}
+	return 0;
+}
+
+static void em28xx_isoc_video_copy(struct em28xx *dev,
+					  struct em28xx_frame_t **f, unsigned char *buf, int len, int vbioffset)
+{
+	void *fieldstart, *startwrite, *startread;
+	int linesdone, currlinedone, offset, lencopy, remain;
+
+	if (dev->frame_size != (*f)->buf.length)
+		return;
+
+	if (vbioffset > 0) {
+		startread = buf+vbioffset;
+		len -= vbioffset;
+	} else {
+		startread = buf+4;
+		len -= 4;
+	}
+
+	if ((*f)->fieldbytesused + len > dev->field_size)
+		len = dev->field_size - (*f)->fieldbytesused;
+
+	remain = len;
+
+
+	if ((*f)->top_field)
+		fieldstart = (*f)->bufmem;
+	else
+		fieldstart = (*f)->bufmem + dev->bytesperline;
+
+	linesdone = (*f)->fieldbytesused / dev->bytesperline;
+	currlinedone = (*f)->fieldbytesused % dev->bytesperline;
+	offset = linesdone * dev->bytesperline * 2 + currlinedone;
+	startwrite = fieldstart + offset;
+	lencopy = dev->bytesperline - currlinedone;
+	lencopy = lencopy > remain ? remain : lencopy;
+
+	memcpy(startwrite, startread, lencopy);
+	remain -= lencopy;
+
+	while (remain > 0) {
+		startwrite += lencopy + dev->bytesperline;
+		startread += lencopy;
+		if (dev->bytesperline > remain)
+			lencopy = remain;
+		else
+			lencopy = dev->bytesperline;
+
+		memcpy(startwrite, startread, lencopy);
+		remain -= lencopy;
+	}
+
+	(*f)->fieldbytesused += len;
+}
+
+static int em28xx_isoc_vbi_copy(struct em28xx *dev,
+		struct em28xx_frame_t **vbif, unsigned char *buf, int len)
+{
+	void *fieldstart, *startwrite, *startread;
+	int linesdone, currlinedone, offset, lencopy, remain;
+
+	if (((*vbif) && dev->vbi_dropbytes == 0) &&
+		!((*vbif)->top_field == 0 && (*vbif)->state == F_QUEUED)) {
+		if ((*vbif)->fieldbytesused < dev->vbi_field_size) {
+			if ((*vbif)->fieldbytesused + (len-4) >
+					dev->vbi_field_size) {
+				len = dev->vbi_field_size -
+					(*vbif)->fieldbytesused;
+
+				startread = buf+4;
+				remain = len-4;
+
+				if ((*vbif)->top_field)
+					fieldstart = (*vbif)->bufmem;
+				else {
+					if (dev->vbi_interlaced)
+						fieldstart = (*vbif)->bufmem +
+							dev->vbi_bytesperline;
+					else
+						fieldstart = (*vbif)->bufmem +
+							dev->vbi_field_size;
+				}
+
+				linesdone = (*vbif)->fieldbytesused /
+					dev->vbi_bytesperline;
+				currlinedone = (*vbif)->fieldbytesused %
+					dev->vbi_bytesperline;
+
+				if (dev->vbi_interlaced)
+					offset = linesdone * dev->vbi_bytesperline *
+						2 + currlinedone;
+				else
+					offset = linesdone * dev->vbi_bytesperline +
+						currlinedone;
+
+				startwrite = fieldstart + offset;
+				lencopy = dev->vbi_bytesperline - currlinedone;
+				lencopy = lencopy > remain ? remain : lencopy;
+
+				memcpy(startwrite, startread, lencopy);
+				remain -= lencopy;
+
+				while (remain > 0) {
+					startwrite += lencopy;
+					if (dev->vbi_interlaced)
+						startwrite += dev->vbi_bytesperline;
+
+					startread += lencopy;
+					if (dev->vbi_bytesperline > remain)
+						lencopy = remain;
+					else
+						lencopy = dev->vbi_bytesperline;
+
+					memcpy(startwrite, startread, lencopy);
+					remain -= lencopy;
+				}
+				(*vbif)->fieldbytesused = dev->vbi_field_size;
+			} else {
+				if ((*vbif)->top_field)
+					fieldstart = (*vbif)->bufmem;
+				else {
+					if (dev->vbi_interlaced)
+						fieldstart = (*vbif)->bufmem + 
+							dev->vbi_bytesperline;
+					else 
+						fieldstart = (*vbif)->bufmem +
+							dev->vbi_field_size;
+				}
+
+				startread = buf+4;
+				remain = len-4;
+
+				linesdone = (*vbif)->fieldbytesused /
+					dev->vbi_bytesperline;
+				currlinedone = (*vbif)->fieldbytesused %
+					dev->vbi_bytesperline;
+				if (dev->vbi_interlaced)
+					offset = linesdone * dev->vbi_bytesperline *
+						2 + currlinedone;
+				else
+					offset = linesdone * dev->vbi_bytesperline +
+						currlinedone;
+
+				startwrite = fieldstart + offset;
+				lencopy = dev->vbi_bytesperline - currlinedone;
+				lencopy = lencopy > remain ? remain : lencopy;
+
+				memcpy(startwrite, startread, lencopy);
+				remain -= lencopy;
+
+				while (remain > 0) {
+					startwrite += lencopy;
+
+					if (dev->vbi_interlaced)
+						startwrite += dev->vbi_bytesperline;
+
+					startread += lencopy;
+					if (dev->vbi_bytesperline > remain)
+						lencopy = remain;
+					else
+						lencopy = dev->vbi_bytesperline;
+					memcpy(startwrite, startread, lencopy);
+					remain -= lencopy;
+				}
+				(*vbif)->fieldbytesused += (len-4);
+				len -= 4;
+			}
+		} else {
+			len = -4;
+		}
+	} else {
+		if (dev->vbi_dropbytes < dev->vbi_field_size) {
+			if (dev->vbi_dropbytes + (len-4) >
+					dev->vbi_field_size) {
+				len = dev->vbi_field_size - dev->vbi_dropbytes;
+				dev->vbi_dropbytes = dev->vbi_field_size;
+			} else {
+				dev->vbi_dropbytes += (len-4);
+				len -= 4;
+			}
+		} else {
+			len = -4;
+		}
+	}
+	return len;
+}
+
+/*
+ * em28xx_isoIrq()
+ * handles the incoming isoc urbs and fills the frames from our inqueue
+ */
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 19)
+void em28xx_isocIrq(struct urb *urb, struct pt_regs *regs)
+#else
+static void em28xx_isocIrq(struct urb *urb)
+#endif
+{
+	struct em28xx *dev = urb->context;
+	int i, status;
+	struct em28xx_frame_t **f, **vbif;
+	unsigned long lock_flags;
+	int vbioffset = 0;
+
+	if (!dev)
+		return;
+#ifdef ENABLE_DEBUG_ISOC_FRAMES
+	if (isoc_debug > 1)
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 19)
+		em28xx_isoc_dump(urb, regs);
+#else
+		em28xx_isoc_dump(urb);
+#endif
+#endif
+	if (urb->status == -ENOENT)
+		return;
+
+	f = &dev->frame_current;
+	vbif = &dev->vbi_frame_current;
+
+	if (dev->video_stream == STREAM_INTERRUPT) {
+		dev->video_stream = STREAM_OFF;
+		if ((*f))
+			(*f)->state = F_QUEUED;
+		(*f) = NULL;
+
+		em28xx_isocdbg("stream interrupted");
+		wake_up_interruptible(&dev->video_wait_stream);
+	}
+
+	if (dev->vbi_stream == STREAM_INTERRUPT) {
+		dev->vbi_stream = STREAM_OFF;
+		if ((*vbif)) {
+			if ((*vbif)->fieldbytesused)
+				dev->vbi_dropbytes = (*vbif)->fieldbytesused;
+
+			(*vbif)->state = F_QUEUED;
+		}
+		(*vbif) = NULL;
+		wake_up_interruptible(&dev->vbi_wait_stream);
+	}
+
+	if ((dev->state & DEV_DISCONNECTED) || (dev->state & DEV_MISCONFIGURED))
+		return;
+
+	if (dev->video_stream == STREAM_ON || dev->vbi_stream == STREAM_ON) {
+		if (dev->video_stream == STREAM_ON &&
+			!list_empty(&dev->inqueue) &&
+			!(*f))
+
+			(*f) = list_entry(dev->inqueue.next,
+					struct em28xx_frame_t, frame);
+
+		if ((dev->dev_modes & EM28XX_VBI) &&
+			dev->vbi_stream == STREAM_ON &&
+			!list_empty(&dev->vbi_inqueue) &&
+			!(*vbif))
+
+			(*vbif) = list_entry(dev->vbi_inqueue.next,
+					struct em28xx_frame_t, frame);
+
+		for (i = 0; i < urb->number_of_packets; i++) {
+			unsigned char *buf = urb->transfer_buffer +
+					urb->iso_frame_desc[i].offset;
+			int len = urb->iso_frame_desc[i].actual_length;
+
+			if (urb->iso_frame_desc[i].status) {
+				em28xx_isocdbg("data error: [%d] len=%d, "
+						"status=%d", i,
+					urb->iso_frame_desc[i].actual_length,
+					urb->iso_frame_desc[i].status);
+
+				if (urb->iso_frame_desc[i].status != -EPROTO) {
+					em28xx_isocdbg("continue, len=%d\n",
+						urb->iso_frame_desc[i].actual_length);
+					continue;
+				}
+			}
+			if (urb->iso_frame_desc[i].actual_length <= 0) {
+				em28xx_isocdbg("packet %d is empty\n", i);
+				continue;
+			}
+
+			if (urb->iso_frame_desc[i].actual_length >
+						 dev->max_pkt_size) {
+				em28xx_isocdbg("packet bigger than packet "
+					       "size\n");
+				continue;
+			}
+#if 0
+			if (buf[0] != 0x88 && buf[1] != 0x88)
+				printk(KERN_DEBUG"headings: %02x %02x\n",
+						buf[0], buf[1]);
+#endif
+			if (buf[0] == 0x22 && buf[1] == 0x5a) {
+				em28xx_isocdbg("Video frame, length=%i!\n",
+						len);
+				dev->vbi_dropbytes = 0;
+				em28xx_isoc_video(dev, f, vbif, &lock_flags,
+						buf[2]);
+			} else if (buf[0] == 0x33 && buf[1] == 0x95) {
+				dev->vbi_dropbytes = 0;
+				em28xx_isoc_video(dev, f, vbif, &lock_flags,
+						buf[2]);
+			}
+
+			/* actual copying */
+			if (dev->dev_modes & EM28XX_VBI) {
+				vbioffset = em28xx_isoc_vbi_copy(dev, vbif,
+						buf, len) + 4;
+			} else
+				vbioffset = 0;
+
+			if ((*f) && (len - vbioffset > 0) &&
+					(*f)->state == F_GRABBING)
+				em28xx_isoc_video_copy(dev, f, buf, len,
+						vbioffset);
+		}
+	}
+
+	for (i = 0; i < urb->number_of_packets; i++) {
+		urb->iso_frame_desc[i].status = 0;
+		urb->iso_frame_desc[i].actual_length = 0;
+	}
+
+	urb->status = 0;
+	status = usb_submit_urb(urb, GFP_ATOMIC);
+	if (status) {
+		em28xx_errdev("resubmit of urb failed (error=%i)\n", status);
+		dev->state |= DEV_MISCONFIGURED;
+	}
+	wake_up_interruptible(&dev->wait_frame);
+	if (dev->dev_modes & EM28XX_VBI)
+		wake_up_interruptible(&dev->wait_vbi_frame);
+}
+
+/*
+ * em28xx_uninit_isoc()
+ * deallocates the buffers and urbs allocated during em28xx_init_iosc()
+ */
+void em28xx_uninit_isoc(struct em28xx *dev)
+{
+	int i;
+	for (i = 0; i < EM28XX_NUM_BUFS; i++) {
+		if (dev->urb[i]) {
+			usb_kill_urb(dev->urb[i]);
+			if (dev->transfer_buffer[i]) {
+				usb_buffer_free(dev->udev,
+					dev->urb[i]->transfer_buffer_length,
+					dev->transfer_buffer[i],
+					dev->urb[i]->transfer_dma);
+			}
+			usb_free_urb(dev->urb[i]);
+		}
+		dev->urb[i] = NULL;
+		dev->transfer_buffer[i] = NULL;
+	}
+	em28xx_capture_start(dev, 0);
+}
+
+/*
+ * em28xx_init_isoc()
+ * allocates transfer buffers and submits the urbs for isoc transfer
+ */
+int em28xx_init_isoc(struct em28xx *dev)
+{
+	/* change interface to 3 which allowes the biggest packet sizes */
+	int i, errCode;
+	const int sb_size = EM28XX_NUM_PACKETS * dev->max_pkt_size;
+
+	/* reset streaming vars */
+	dev->frame_current = NULL;
+	dev->frame_count = 0;
+
+	dev->vbi_frame_current = NULL;
+	dev->vbi_frame_count = 0;
+
+	/* allocate urbs */
+	for (i = 0; i < EM28XX_NUM_BUFS; i++) {
+		struct urb *urb;
+		int j, k;
+		/* allocate transfer buffer */
+		urb = usb_alloc_urb(EM28XX_NUM_PACKETS, GFP_KERNEL);
+		if (!urb) {
+			em28xx_errdev("cannot alloc urb %i\n", i);
+			em28xx_uninit_isoc(dev);
+			return -ENOMEM;
+		}
+		dev->transfer_buffer[i] = usb_buffer_alloc(dev->udev,
+				sb_size, GFP_KERNEL, &urb->transfer_dma);
+		if (!dev->transfer_buffer[i]) {
+			em28xx_errdev("unable to allocate %i bytes for "
+				      "transfer buffer %i\n", sb_size, i);
+			em28xx_uninit_isoc(dev);
+			return -ENOMEM;
+		}
+		memset(dev->transfer_buffer[i], 0, sb_size);
+		urb->dev = dev->udev;
+		urb->context = dev;
+		urb->pipe = usb_rcvisocpipe(dev->udev, 0x82);
+		urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
+		urb->interval = 1;
+		urb->transfer_buffer = dev->transfer_buffer[i];
+		urb->complete = em28xx_isocIrq;
+		urb->number_of_packets = EM28XX_NUM_PACKETS;
+		urb->transfer_buffer_length = sb_size;
+		for (j = k = 0; j < EM28XX_NUM_PACKETS;
+				j++, k += dev->max_pkt_size) {
+			urb->iso_frame_desc[j].offset = k;
+			urb->iso_frame_desc[j].length =
+				dev->max_pkt_size;
+		}
+		dev->urb[i] = urb;
+	}
+
+	/* submit urbs */
+	for (i = 0; i < EM28XX_NUM_BUFS; i++) {
+		errCode = usb_submit_urb(dev->urb[i], GFP_KERNEL);
+		if (errCode) {
+			em28xx_errdev("submit of urb %i failed (error=%i)\n", i,
+				      errCode);
+			em28xx_uninit_isoc(dev);
+			return errCode;
+		}
+	}
+
+	return 0;
+}
+
+int em28xx_set_alternate(struct em28xx *dev)
+{
+	int errCode, prev_alt = dev->alt;
+	dev->alt = alt;
+	if (dev->alt == 0) {
+		int i;
+#if 1 /* Always try to get the maximum size value */
+		for (i = 0; i < dev->num_alt; i++)
+			if (dev->alt_max_pkt_size[i] >
+					dev->alt_max_pkt_size[dev->alt])
+				dev->alt = i;
+#endif
+#if 0 /* Should be dependent of horizontal size */
+		if (dev->em_type == EM2800) {
+			/* always use the max packet size for em2800
+			   based devices */
+			for (i = 0; i < dev->num_alt; i++)
+				if (dev->alt_max_pkt_size[i] >
+					dev->alt_max_pkt_size[dev->alt])
+					dev->alt = i;
+		} else {
+			/* FIXME: empiric magic number */
+			unsigned int min_pkt_size = dev->field_size / 137;
+			em28xx_coredbg("minimum isoc packet size: %u",
+					min_pkt_size);
+			dev->alt = 7;
+			for (i = 0; i < dev->num_alt; i ++)
+				if (dev->alt_max_pkt_size[i] >= min_pkt_size) {
+					dev->alt = i;
+					break;
+				}
+		}
+#endif
+	}
+
+	if (dev->alt != prev_alt) {
+		dev->max_pkt_size = dev->alt_max_pkt_size[dev->alt];
+		em28xx_coredbg("setting alternate %d with wMaxPacketSize=%u\n", dev->alt,
+		       dev->max_pkt_size);
+
+		errCode = usb_set_interface(dev->udev, dev->usb_interface, dev->alt);
+		if (errCode < 0) {
+			em28xx_errdev("cannot change alternate number to %d "
+					"(error=%i)\n",
+					dev->alt, errCode);
+			return errCode;
+		}
+	}
+	return 0;
+}
diff --git a/drivers/media/video/empia/em28xx-i2c.c b/drivers/media/video/empia/em28xx-i2c.c
new file mode 100644
index 0000000..1278e6e
--- /dev/null
+++ b/drivers/media/video/empia/em28xx-i2c.c
@@ -0,0 +1,983 @@
+/*
+   em28xx-i2c.c - driver for Empia EM2800/EM2820/2840/2880 USB
+   video capture devices
+
+   Copyright (C) 2005 Ludovico Cavedon <cavedon@xxxxxxxx>
+		      Markus Rechberger <mrechberger@xxxxxxxxx>
+		      Mauro Carvalho Chehab <mchehab@xxxxxxxxxxxxx>
+		      Sascha Sommer <saschasommer@xxxxxxxxxx>
+
+   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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/usb.h>
+#include <linux/i2c.h>
+#include <linux/version.h>
+#include <linux/video_decoder.h>
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 27)
+#include <media/audiochip.h>
+#else
+#include <media/v4l2-chip-ident.h>
+#endif
+#ifdef EM28XX_TVEEPROM
+#include <media/tveeprom.h>
+#endif
+
+#include "em28xx.h"
+#include <media/v4l2-common.h>
+#include <media/tuner.h>
+
+#include "dvb_frontend.h"
+
+#include "xc5000/xc5000_control.h"
+
+
+/* ----------------------------------------------------------- */
+
+static unsigned int i2c_scan;
+module_param(i2c_scan, int, 0444);
+MODULE_PARM_DESC(i2c_scan, "scan i2c bus at insmod time");
+
+static unsigned int i2c_debug = 1;
+module_param(i2c_debug, int, 0644);
+MODULE_PARM_DESC(i2c_debug, "enable debug messages [i2c]");
+
+#define dprintk1(lvl, fmt, args...) if (i2c_debug >= lvl) do {\
+			printk(fmt, ##args); } while (0)
+#define dprintk2(lvl, fmt, args...) if (i2c_debug >= lvl) do { \
+			printk(KERN_DEBUG "%s at %s: " fmt, \
+			dev->name, __func__, ##args); } while (0)
+
+/*
+ * em2800_i2c_send_max4()
+ * send up to 4 bytes to the i2c device
+ */
+static int em2800_i2c_send_max4(struct em28xx *dev, unsigned char addr,
+				char *buf, int len)
+{
+	int ret;
+	int write_timeout;
+	unsigned char b2[6];
+	BUG_ON(len < 1 || len > 4);
+	b2[5] = 0x80 + len - 1;
+	b2[4] = addr;
+	b2[3] = buf[0];
+	if (len > 1)
+		b2[2] = buf[1];
+	if (len > 2)
+		b2[1] = buf[2];
+	if (len > 3)
+		b2[0] = buf[3];
+
+	ret = dev->em28xx_write_regs(dev, 4 - len, &b2[4 - len], 2 + len);
+	if (ret < 0) {
+		dprintk1(2, "%s:%u:%s(): FIXME: em28xx_write_regs() failed,"
+			"ret = %i\n", __FILE__, __LINE__, __func__, ret);
+		return ret;
+	}
+	if (ret != 2 + len) {
+		em28xx_warn("writing to i2c device failed (error=%i)\n", ret);
+		return -EIO;
+	}
+	for (write_timeout = EM2800_I2C_WRITE_TIMEOUT; write_timeout > 0;
+	     write_timeout -= 5) {
+		ret = dev->em28xx_read_reg(dev, 0x05);
+		if (ret < 0) {
+			dprintk1(2, "%s:%u:%s(): FIXME: em28xx_read_reg()"
+				"failed, ret = %i\n", __FILE__, __LINE__,
+				__func__, ret);
+			return ret;
+		}
+		if (ret == 0x80 + len - 1)
+			return len;
+		msleep(5);
+	}
+	em28xx_warn("i2c write timed out\n");
+	return -EIO;
+}
+
+int em28xx_gpio_cmd(struct em28xx *dev, unsigned int command, u16 *value,
+		unsigned int *len)
+{
+	struct em28xx_gpio *gpio_map = &em28xx_boards[dev->model].gpio_regs;
+	switch (command) {
+	case EM28XX_ANALOG_ON:
+		*value = gpio_map->a_on;
+		break;
+	case EM28XX_LED1_ON:
+		*value = gpio_map->l1_on;
+		break;
+	case EM28XX_XC3028_SECAM:
+		*value = gpio_map->xc3028_sec;
+		break;
+	case EM28XX_TS1_ON:
+		*value = gpio_map->ts1_on;
+		break;
+	case EM28XX_MODESWITCH:
+		*value = gpio_map->m_switch;
+		break;
+	case EM28XX_DECODER_SLEEP:
+		*value = gpio_map->d_sleep;
+		break;
+	case EM28XX_LED2_ON:
+		*value = gpio_map->l2_on;
+		break;
+	case EM28XX_RF:
+		*value = gpio_map->rf;
+		break;
+	case EM28XX_DVB1_ON:
+		*value = gpio_map->dvbs_lnb;
+		break;
+	case EM28XX_DVB2_ON:
+		*value = gpio_map->dvbs_v;
+		break;
+	case EM28XX_TUNER1_ON:
+		*value = gpio_map->t1_on;
+		break;
+	case EM28XX_DEMOD1_RESET:
+		*value = gpio_map->d1_reset;
+		break;
+	case EM28XX_TUNER1_RESET:
+		*value = gpio_map->t1_reset;
+		break;
+	case EM28XX_DECODER_RESET:
+		*value = gpio_map->dc_reset;
+		break;
+	case EM28XX_DEMOD2_RESET:
+		*value = gpio_map->d2_reset;
+		break;
+	case EM28XX_TUNER2_RESET:
+		*value = gpio_map->t2_reset;
+		break;
+	case EM28XX_TUNER2_ON:
+		*value = gpio_map->t2_on;
+		break;
+	default:
+		break;
+	}
+	return 0;
+}
+
+int em28xx_gpio_control_translate(void *priv, unsigned int command, void *ptr)
+{
+	int cmd;
+	switch (command) {
+	case XC3028_CHIP_RESET:
+		cmd = EM28XX_TUNER1_RESET;
+		break;
+	case XC5000_CHIP_RESET:
+		cmd = EM28XX_TUNER1_RESET;
+		break;
+	default:
+		printk("unknown gpio translate command\n");
+		break;
+	}
+
+	return em28xx_gpio_control(priv, cmd, ptr);
+}
+
+int em28xx_gpio_control(void *priv, unsigned int command, void *ptr)
+{
+	struct em28xx *dev = (struct em28xx *)priv;
+	unsigned int len;
+	u16 gpio_value;
+	u8 buf[2];
+	u8 *index;
+	u8 gpio;
+	int *arg = ptr;
+	u16 gpio_reg;
+	u8 eeprom_offset;
+
+	if (em28xx_boards[dev->model].manual_gpio)
+		em28xx_gpio_cmd(dev, command, &gpio_value, &len);
+	else {
+		switch (dev->em_type) {
+		case EM2888:
+		case EM2889:
+		case EM2875:
+			eeprom_offset = 0xa0;
+			buf[0] = 0;
+			index = &buf[1];
+			len = 2;
+			dev->em28xx_write_regs(dev, 0x06, "\x40", 1);
+			break;
+		case EM2883:
+		default:
+			eeprom_offset = 0x3c;
+			index = &buf[0];
+			len = 1;
+			break;
+		}
+
+		switch (command) {
+		case EM28XX_ANALOG_ON:
+			*index = eeprom_offset + 24;
+			em28xx_write_regs_req(dev, 0x03, 0xa0, buf, len);
+			gpio_value = em28xx_read_reg_req(dev, 0x2, 0xa0);
+			break;
+		case EM28XX_TS1_ON:
+			*index = eeprom_offset + 25;
+			em28xx_write_regs_req(dev, 0x03, 0xa0, buf, len);
+			gpio_value = em28xx_read_reg_req(dev, 0x2, 0xa0);
+			break;
+		case EM28XX_DECODER_SLEEP:
+			*index = eeprom_offset + 20;
+			em28xx_write_regs_req(dev, 0x03, 0xa0, buf, len);
+			gpio_value = em28xx_read_reg_req(dev, 0x2, 0xa0);
+			break;
+		case EM28XX_DEMOD1_RESET:
+			*index = eeprom_offset + 16;
+			em28xx_write_regs_req(dev, 0x03, 0xa0, buf, len);
+			gpio_value = em28xx_read_reg_req(dev, 0x2, 0xa0);
+			break;
+		case EM28XX_TUNER1_RESET:
+			*index = eeprom_offset + 17;
+			em28xx_write_regs_req(dev, 0x03, 0xa0, buf, len);
+			gpio_value = em28xx_read_reg_req(dev, 0x2, 0xa0);
+			break;
+		case EM28XX_TUNER1_ON:
+			*index = eeprom_offset + 23;
+			em28xx_write_regs_req(dev, 0x03, 0xa0, buf, len);
+			gpio_value = em28xx_read_reg_req(dev, 0x2, 0xa0);
+			break;
+		case EM28XX_LED1_ON:
+			printk("reading led\n");
+			*index = eeprom_offset + 22;
+			em28xx_write_regs_req(dev, 0x03, 0xa0, buf, len);
+			gpio_value = em28xx_read_reg_req(dev, 0x2, 0xa0);
+			printk("led returned: %02x\n", gpio_value);
+			break;
+		default:
+			switch (dev->em_type) {
+			case EM2888:
+			case EM2889:
+			case EM2875:
+				dev->em28xx_write_regs(dev, 0x06, "\x45", 1);
+				break;
+			default:
+				break;
+			}
+			return -EINVAL;
+		}
+		switch (dev->em_type) {
+		case EM2888:
+		case EM2875:
+		case EM2889:
+			dev->em28xx_write_regs(dev, 0x06, "\x45", 1);
+			break;
+		case EM2883:
+		default:
+			eeprom_offset = 0x3b;
+			index = &buf[0];
+			len = 1;
+			break;
+		}
+	}
+
+	/* check if gpio register enabled */
+	if (gpio_value & 0x80) {
+		if (((gpio_value >> 6)&1) == 0) {
+			if (arg == NULL) {
+				printk(KERN_INFO"no argument given %02x\n",
+						gpio_value);
+				return -EINVAL;
+			}
+			/* on/off command */
+			switch (dev->em_type) {
+			case EM2888:
+			case EM2889:
+			case EM2875:
+				gpio_reg = 0x80;
+				break;
+			case EM2883:
+			default:
+				gpio_reg = gpio_value&0x10 ? 0x04 : 0x08;
+				break;
+			}
+			gpio = dev->em28xx_read_reg(dev, gpio_reg);
+			gpio &= ~((u8)(1 << (gpio_value&0x7)));
+
+			if (*arg == EM28XX_REG_ON)
+				gpio |= ((gpio_value >> 5)&1) <<
+					(gpio_value&7);
+			else
+				gpio |= (((gpio_value >> 5)&1)^1) <<
+					(gpio_value&7);
+
+			dev->em28xx_write_regs(dev, gpio_reg, &gpio, 1);
+			dprintk1(2, "(1) writing to %02x -> %02x\n", gpio_reg, gpio);
+		} else {
+			switch (dev->em_type) {
+			case EM2889:
+			case EM2888:
+			case EM2875:
+				gpio_reg = 0x80;
+				break;
+			case EM2883:
+			default:
+				gpio_reg = gpio_value&0x10 ? 0x04 : 0x08;
+				break;
+			}
+			gpio = dev->em28xx_read_reg(dev, gpio_reg);
+			gpio &= ~((u8)(1 << (gpio_value&0xf)));
+
+			gpio |= ((gpio_value >> 5)&1) << (gpio_value&7);
+			dev->em28xx_write_regs(dev, gpio_reg, &gpio, 1);
+			dprintk1(2, "(2) writing to %02x -> %02x\n", gpio_reg, gpio);
+			gpio &= ~((u8)(1 << (gpio_value&0xf)));
+			gpio |= (((gpio_value >> 5)&1)^1) << (gpio_value&7);
+			mdelay(100);
+			dev->em28xx_write_regs(dev, gpio_reg, &gpio, 1);
+			mdelay(100);
+			dprintk1(2, "(3) writing to %02x -> %02x\n", gpio_reg, gpio);
+		}
+	} else {
+		printk("register disabled\n");
+	}
+
+	return 0;
+}
+
+static int em2800_i2c_send_bytes(void *data, unsigned char addr, char *buf,
+				 short len)
+{
+	char *bufPtr = buf;
+	int ret;
+	int wrcount = 0;
+	int count;
+	int maxLen = 4;
+	struct em28xx *dev = (struct em28xx *)data;
+	while (len > 0) {
+		count = (len > maxLen) ? maxLen : len;
+		ret = em2800_i2c_send_max4(dev, addr, bufPtr, count);
+		if (ret > 0) {
+			len -= count;
+			bufPtr += count;
+			wrcount += count;
+		} else
+			return (ret < 0) ? ret : -EFAULT;
+	}
+	return wrcount;
+}
+
+/*
+ * em2800_i2c_check_for_device()
+ * check if there is a i2c_device at the supplied address
+ */
+int em2800_i2c_check_for_device(struct em28xx *dev, unsigned char addr)
+{
+	char msg;
+	int ret;
+	int write_timeout;
+	msg = addr;
+	ret = dev->em28xx_write_regs(dev, 0x04, &msg, 1);
+	if (ret < 0) {
+		em28xx_warn("setting i2c device address failed (error=%i)\n",
+			    ret);
+		return ret;
+	}
+	msg = 0x84;
+	ret = dev->em28xx_write_regs(dev, 0x05, &msg, 1);
+	if (ret < 0) {
+		em28xx_warn("preparing i2c read failed (error=%i)\n", ret);
+		return ret;
+	}
+	for (write_timeout = EM2800_I2C_WRITE_TIMEOUT; write_timeout > 0;
+	     write_timeout -= 5) {
+		unsigned int msg;
+		ret = dev->em28xx_read_reg(dev, 0x5);
+		if (ret < 0) {
+			dprintk1(2, "%s:%u:%s(): FIXME: em28xx_read_reg() "
+				"failed, gpval = %i\n", __FILE__, __LINE__,
+				__func__, ret);
+			return ret;
+		}
+		msg = ret;
+		if (msg == 0x94)
+			return -ENODEV;
+		else if (msg == 0x84)
+			return 0;
+		msleep(5);
+	}
+	return -ENODEV;
+}
+
+/*
+ * em2800_i2c_recv_bytes()
+ * read from the i2c device
+ */
+static int em2800_i2c_recv_bytes(struct em28xx *dev, unsigned char addr,
+				 char *buf, int len)
+{
+	int ret;
+	/* check for the device and set i2c read address */
+	ret = em2800_i2c_check_for_device(dev, addr);
+	if (ret) {
+		em28xx_warn
+		    ("preparing read at i2c address 0x%x failed (error=%i)\n",
+		     addr, ret);
+		return ret;
+	}
+	ret = dev->em28xx_read_reg_req_len(dev, 0x0, 0x3, buf, len);
+	if (ret < 0) {
+		em28xx_warn("reading from i2c device at 0x%x failed (error=%i)",
+			    addr, ret);
+		return ret;
+	}
+	return ret;
+}
+
+/*
+ * em28xx_i2c_send_bytes()
+ * untested for more than 4 bytes
+ */
+static int em28xx_i2c_send_bytes(void *data, unsigned char addr, char *buf,
+				 short len, int stop)
+{
+	int wrcount = 0;
+	struct em28xx *dev = (struct em28xx *)data;
+	int i;
+
+	wrcount = dev->em28xx_write_regs_req(dev, stop ? 2 : 3, addr, buf, len);
+	if (wrcount < 0) {
+		dprintk1(2, "%s:%u:%s(): FIXME: em28xx_write_regs_req()"
+			"failed, wrcount = %i\n", __FILE__, __LINE__,
+			__func__, wrcount);
+
+		return wrcount;
+	}
+
+	if (dev->em28xx_read_reg(dev, 0x5) != 0) {
+		printk(KERN_ERR"FIXME:em28xx_i2c_send_bytes(%02x): "
+				"write failed:\n", addr);
+		printk(KERN_ERR"===============================\n");
+		for (i = 0; i < len; i++)
+			printk("%02x ", (unsigned char)buf[i]);
+
+		printk("\n");
+		printk(KERN_ERR"================================\n");
+	}
+
+	return wrcount;
+}
+
+/*
+ * em28xx_i2c_recv_bytes()
+ * read a byte from the i2c device
+ */
+static int em28xx_i2c_recv_bytes(struct em28xx *dev, unsigned char addr,
+				 char *buf, int len)
+{
+	int ret;
+	ret = dev->em28xx_read_reg_req_len(dev, 2, addr, buf, len);
+	if (ret < 0) {
+		em28xx_warn("reading i2c device failed (error=%i)\n", ret);
+		return ret;
+	}
+	if (dev->em28xx_read_reg(dev, 0x5) != 0)
+		return -ENODEV;
+	return ret;
+}
+
+/*
+ * em28xx_i2c_check_for_device()
+ * check if there is a i2c_device at the supplied address
+ */
+static int em28xx_i2c_check_for_device(struct em28xx *dev, unsigned char addr)
+{
+	char msg;
+	int ret;
+	msg = addr;
+
+	ret = dev->em28xx_read_reg_req(dev, 2, addr);
+	if (ret < 0) {
+		em28xx_warn("reading from i2c device failed (error=%i)\n", ret);
+		return ret;
+	}
+	if (dev->em28xx_read_reg(dev, 0x5) != 0)
+		return -ENODEV;
+	return 0;
+}
+
+/*
+ * em28xx_i2c_xfer()
+ * the main i2c transfer function
+ */
+static int em28xx_i2c_xfer(struct i2c_adapter *i2c_adap,
+			   struct i2c_msg msgs[], int num)
+{
+	struct em28xx *dev = i2c_adap->algo_data;
+	int addr, rc, i, byte;
+
+	if (num <= 0)
+		return 0;
+	for (i = 0; i < num; i++) {
+		addr = msgs[i].addr << 1;
+		dprintk2(2, "%s %s addr=%x len=%d:",
+			 (msgs[i].flags & I2C_M_RD) ? "read" : "write",
+			 i == num - 1 ? "stop" : "nonstop", addr, msgs[i].len);
+		/* no len: check only for device presence */
+		if (!msgs[i].len) {
+			if (dev->em_type == EM2800)
+				rc = em2800_i2c_check_for_device(dev, addr);
+			else
+				rc = em28xx_i2c_check_for_device(dev, addr);
+			if (rc < 0) {
+				dprintk2(2, " no device\n");
+				return rc;
+			}
+
+		} else if (msgs[i].flags & I2C_M_RD) {
+			/* read bytes */
+			if (dev->em_type == EM2800)
+				rc = em2800_i2c_recv_bytes(dev, addr,
+							   msgs[i].buf,
+							   msgs[i].len);
+			else
+				rc = em28xx_i2c_recv_bytes(dev, addr,
+							   msgs[i].buf,
+							   msgs[i].len);
+			if (i2c_debug >= 2) {
+				for (byte = 0; byte < msgs[i].len; byte++)
+					printk(KERN_INFO" %02x",
+							msgs[i].buf[byte]);
+			}
+		} else {
+			/* write bytes */
+			if (i2c_debug >= 2) {
+				for (byte = 0; byte < msgs[i].len; byte++)
+					printk(" %02x", msgs[i].buf[byte]);
+			}
+			if (dev->em_type == EM2800)
+				rc = em2800_i2c_send_bytes(dev, addr,
+							   msgs[i].buf,
+							   msgs[i].len);
+			else
+				rc = em28xx_i2c_send_bytes(dev, addr,
+							   msgs[i].buf,
+							   msgs[i].len,
+							   i == num - 1);
+		}
+		if (rc < 0)
+			goto err;
+		if (i2c_debug >= 2)
+			printk("\n");
+	}
+
+	return num;
+err:
+	dprintk2(2, " ERROR: %i\n", rc);
+	return rc;
+}
+
+static int em28xx_i2c_eeprom(struct em28xx *dev, struct i2c_client *client,
+		unsigned char *eedata, int len)
+{
+	unsigned char buf, *p = eedata;
+	struct em28xx_eeprom *em_eeprom = (void *)eedata;
+	int i, err, size = len, block;
+
+	dev->i2c_client.addr = 0xa0 >> 1;
+
+	/* Check if board has eeprom */
+	err = i2c_master_recv(client, &buf, 0);
+	if (err < 0)
+		return -1;
+
+	buf = 0;
+
+	err = i2c_master_send(client, &buf, 1);
+	if (1 != err) {
+		printk(KERN_INFO "%s: Huh, no eeprom present (err=%d)?\n",
+		       dev->name, err);
+		return -1;
+	}
+
+	while (size > 0) {
+		if (size > 16)
+			block = 16;
+		else
+			block = size;
+
+		if (block !=
+		    (err = i2c_master_recv(client, p, block))) {
+			printk(KERN_WARNING
+			       "%s: i2c eeprom read error (err=%d)\n",
+			       dev->name, err);
+			return -1;
+		}
+		size -= block;
+		p += block;
+	}
+	for (i = 0; i < len; i++) {
+		if (0 == (i % 16))
+			printk(KERN_INFO "%s: i2c eeprom %02x:",
+					dev->name, i);
+		printk(" %02x", eedata[i]);
+
+		if (15 == (i % 16))
+			printk("\n");
+	}
+
+	printk(KERN_INFO "EEPROM ID= 0x%08x\n", em_eeprom->id);
+	printk(KERN_INFO "Vendor/Product ID= %04x:%04x\n",
+			em_eeprom->vendor_ID, em_eeprom->product_ID);
+
+	switch (em_eeprom->chip_conf >> 4 & 0x3) {
+	case 0:
+		printk(KERN_INFO "No audio on board.\n");
+		break;
+	case 1:
+		printk(KERN_INFO "AC97 audio (5 sample rates)\n");
+		break;
+	case 2:
+		printk(KERN_INFO "I2S audio, sample rate=32k\n");
+		break;
+	case 3:
+		printk(KERN_INFO "I2S audio, 3 sample rates\n");
+		break;
+	}
+
+	if (em_eeprom->chip_conf & 1 << 3)
+		printk(KERN_INFO "USB Remote wakeup capable\n");
+
+	if (em_eeprom->chip_conf & 1 << 2)
+		printk(KERN_INFO "USB Self power capable\n");
+
+	switch (em_eeprom->chip_conf & 0x3) {
+	case 0:
+		printk(KERN_INFO "500mA max power\n");
+		break;
+	case 1:
+		printk(KERN_INFO "400mA max power\n");
+		break;
+	case 2:
+		printk(KERN_INFO "300mA max power\n");
+		break;
+	case 3:
+		printk(KERN_INFO "200mA max power\n");
+		break;
+	}
+	printk(KERN_INFO "Table at 0x%02x, strings = 0x%04x, 0x%04x, 0x%04x\n",
+				em_eeprom->string_idx_table,
+				em_eeprom->string1,
+				em_eeprom->string2,
+				em_eeprom->string3);
+
+	return 0;
+}
+
+/* ----------------------------------------------------------- */
+
+/*
+ * functionality()
+ */
+static u32 functionality(struct i2c_adapter *adap)
+{
+	return I2C_FUNC_SMBUS_EMUL;
+}
+
+#ifndef I2C_PEC
+static void inc_use(struct i2c_adapter *adap)
+{
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 5, 0)
+	MOD_INC_USE_COUNT;
+#endif
+}
+
+static void dec_use(struct i2c_adapter *adap)
+{
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 5, 0)
+	MOD_DEC_USE_COUNT;
+#endif
+}
+#endif
+
+static int em28xx_set_tuner(int check_eeprom, struct i2c_client *client)
+{
+	struct em28xx *dev = client->adapter->algo_data;
+	struct tuner_setup tun_setup;
+
+	if (dev->has_inttuner == 0 && dev->dev_modes != EM28XX_DVBT) {
+		/* do not set up a tuner if it's a dvb only device */
+		tun_setup.mode_mask = T_ANALOG_TV | T_RADIO;
+		tun_setup.type = dev->tuner_type;
+		tun_setup.addr = dev->tuner_addr;
+		em28xx_i2c_call_clients(dev, TUNER_SET_TYPE_ADDR, &tun_setup);
+	} else {
+		tun_setup.mode_mask = T_UNINITIALIZED;
+		tun_setup.type = TUNER_ABSENT;
+		tun_setup.addr = dev->tuner_addr;
+		em28xx_i2c_call_clients(dev, TUNER_SET_TYPE_ADDR, &tun_setup);
+	}
+
+	return 0;
+}
+
+/*
+ * attach_inform()
+ * gets called when a device attaches to the i2c bus
+ * does some basic configuration
+ */
+static int attach_inform(struct i2c_client *client)
+{
+	struct em28xx *dev = client->adapter->algo_data;
+	int ret;
+
+	if (client->driver->id == I2C_DRIVERID_TUNER && dev->has_inttuner==1) {
+		printk(KERN_INFO"em28xx-i2c: using internal tuner, denying "
+			"request to i2c tuner module.\n");
+		em28xx_set_tuner(-1, client);
+		return 0;
+	}
+
+	switch (client->addr << 1) {
+	case 0x86:
+	case 0x84:
+	case 0x96:
+	case 0x94:
+	{
+#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17)
+#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 25)
+		struct v4l2_priv_tun_config tda9887_cfg;
+#endif
+
+		struct tuner_setup tun_setup;
+
+		tun_setup.mode_mask = T_ANALOG_TV | T_RADIO;
+		tun_setup.type = TUNER_TDA9887;
+		tun_setup.addr = client->addr;
+
+		em28xx_i2c_call_clients(dev, TUNER_SET_TYPE_ADDR, &tun_setup);
+
+#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 25)
+		tda9887_cfg.tuner = TUNER_TDA9887;
+		tda9887_cfg.priv = &dev->tda9887_conf;
+		em28xx_i2c_call_clients(dev, TUNER_SET_CONFIG, &tda9887_cfg);
+#endif
+#endif
+		break;
+	}
+	case 0x42:
+		dprintk1(1, "attach_inform: saa7114 detected.\n");
+		break;
+	case 0x4a:
+		dprintk1(1, "attach_inform: saa7113 detected.\n");
+		break;
+	case 0xa0:
+		dprintk1(1, "attach_inform: eeprom detected.\n");
+		em28xx_i2c_eeprom(dev, client, dev->eedata,
+				sizeof(dev->eedata));
+
+		switch (dev->model) {
+		case EM2820_BOARD_HAUPPAUGE_WINTV_USB_2:
+		case EM2820_BOARD_HAUPPAUGE_WINTV_USB_2_R2:
+		case EM2870_BOARD_HAUPPAUGE_WINTV_USB_2_R2:
+		case EM2880_BOARD_HAUPPAUGE_WINTV_HVR_900:
+		case EM2883_BOARD_HAUPPAUGE_WINTV_HVR_950:
+		case EM2883_BOARD_KWORLD_HYBRID_A316:
+		case EM2880_BOARD_HAUPPAUGE_WINTV_HVR_900_R2:
+		{
+#ifdef EM28XX_TVEEPROM
+			struct tveeprom tv;
+			tveeprom_hauppauge_analog(client, &tv, dev->eedata);
+
+			if (dev->tuner_type == TUNER_ABSENT) {
+				dev->tuner_type = tv.tuner_type;
+				printk(KERN_INFO"setting new tuner type now"
+						"%d!\n", tv.tuner_type);
+				em28xx_set_tuner(-1, client);
+			}
+#if defined V4L2_IDENT_MSPX4XX     /*  XXX  2.6.27  */
+			if (tv.audio_processor == V4L2_IDENT_MSPX4XX) {
+#else
+			if (tv.audio_processor == AUDIO_CHIP_MSP34XX) {
+#endif
+				dev->i2s_speed = 2048000;
+				dev->has_msp34xx = 1;
+			} else
+				dev->has_msp34xx = 0;
+#endif
+
+			if (dev->has_msp34xx) {
+				/* Send a reset to other chips via gpio */
+				ret = em28xx_write_regs_req(dev, 0x00, 0x08,
+						"\xf7", 1);
+				if (ret < 0) {
+					dprintk1(2, "%s:%u:%s(): FIXME: "
+						"em28xx_write_regs_req() "
+						"failed, ret = %i\n", __FILE__,
+						__LINE__, __func__, ret);
+					return ret;
+				}
+				udelay(2500);
+				ret = em28xx_write_regs_req(dev, 0x00, 0x08,
+						"\xff", 1);
+				if (ret < 0) {
+					dprintk1(2, "%s:%u:%s(): FIXME: "
+						"em28xx_write_regs_req() "
+						"failed, ret = %i\n", __FILE__,
+						__LINE__, __func__, ret);
+					return ret;
+				}
+				udelay(2500);
+			}
+		}
+		break;
+	}
+	case 0x60:
+	case 0x8e:
+	{
+		struct IR_i2c *ir = i2c_get_clientdata(client);
+		em28xx_set_ir(dev, ir);
+		break;
+	}
+	case 0x80:
+	case 0x88:
+		dprintk1(1, "attach_inform: msp34xx/cx25843 detected.\n");
+		break;
+	case 0xb8:
+	case 0xba:
+		dprintk1(1, "attach_inform: tvp5150 detected.\n");
+		break;
+	case 0x1e:
+		dprintk1(1, "zl10353 demodulator found!\n");
+		break;
+	default:
+		dprintk1(1, "attach inform (default): "
+			"detected I2C address %x\n", client->addr << 1);
+		dev->tuner_addr = client->addr;
+		em28xx_set_tuner(-1, client);
+	}
+	return 0;
+}
+
+static struct i2c_algorithm em28xx_algo = {
+	.master_xfer   = em28xx_i2c_xfer,
+	.functionality = functionality,
+};
+
+static struct i2c_adapter em28xx_adap_template = {
+#ifdef I2C_PEC
+	.owner = THIS_MODULE,
+#else
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 24)
+	.inc_use = inc_use,
+	.dec_use = dec_use,
+#endif
+#endif
+#ifdef I2C_CLASS_TV_ANALOG
+	.class = I2C_CLASS_TV_ANALOG,
+#endif
+	.name = "em28xx",
+	.id = I2C_HW_B_EM28XX,
+	.algo = &em28xx_algo,
+	.client_register = attach_inform,
+};
+
+static struct i2c_client em28xx_client_template = {
+	.name = "em28xx internal",
+#if LINUX_VERSION_CODE <=  KERNEL_VERSION(2, 6, 15)
+	.flags = I2C_CLIENT_ALLOW_USE,
+#endif
+};
+
+/* ----------------------------------------------------------- */
+
+/*
+ * i2c_devs
+ * incomplete list of known devices
+ */
+static char *i2c_devs[128] = {
+	[0x4a >> 1] = "saa7113h",
+	[0x60 >> 1] = "remote IR sensor",
+	[0x8e >> 1] = "remote IR sensor",
+	[0x86 >> 1] = "tda9887",
+	[0x80 >> 1] = "msp34xx",
+	[0x88 >> 1] = "msp34xx/cx25843",
+	[0xa0 >> 1] = "eeprom",
+	[0xb8 >> 1] = "tvp5150a",
+	[0xba >> 1] = "tvp5150a",
+	[0xc0 >> 1] = "tuner (analog)",
+	[0xc2 >> 1] = "tuner (analog)",
+	[0xc4 >> 1] = "tuner (analog)",
+	[0xc6 >> 1] = "tuner (analog)",
+	[0x1e >> 1] = "zl10353/mt352 dvb-t demodulator",
+};
+
+/*
+ * do_i2c_scan()
+ * check i2c address range for devices
+ */
+static void do_i2c_scan(char *name, struct i2c_client *c)
+{
+	unsigned char buf;
+	int i, rc;
+
+	for (i = 0; i < ARRAY_SIZE(i2c_devs); i++) {
+		c->addr = i;
+		rc = i2c_master_recv(c, &buf, 0);
+		if (rc < 0)
+			continue;
+		printk(KERN_INFO "%s: found i2c device @ 0x%x [%s]\n", name,
+		       i << 1, i2c_devs[i] ? i2c_devs[i] : "???");
+	}
+}
+
+/*
+ * em28xx_i2c_call_clients()
+ * send commands to all attached i2c devices
+ */
+void em28xx_i2c_call_clients(struct em28xx *dev, unsigned int cmd, void *arg)
+{
+	BUG_ON(NULL == dev->i2c_adap.algo_data);
+	i2c_clients_command(&dev->i2c_adap, cmd, arg);
+}
+EXPORT_SYMBOL(em28xx_i2c_call_clients);
+
+/*
+ * em28xx_i2c_register()
+ * register i2c bus
+ */
+int em28xx_i2c_register(struct em28xx *dev)
+{
+	BUG_ON(!dev->em28xx_write_regs || !dev->em28xx_read_reg);
+	BUG_ON(!dev->em28xx_write_regs_req || !dev->em28xx_read_reg_req);
+	dev->i2c_adap = em28xx_adap_template;
+	dev->i2c_adap.dev.parent = &dev->udev->dev;
+	strcpy(dev->i2c_adap.name, dev->name);
+	dev->i2c_adap.algo_data = dev;
+	i2c_add_adapter(&dev->i2c_adap);
+
+	dev->i2c_client = em28xx_client_template;
+	dev->i2c_client.adapter = &dev->i2c_adap;
+
+	if (i2c_scan || dev->dev_modes == 0)
+		do_i2c_scan(dev->name, &dev->i2c_client);
+	return 0;
+}
+
+/*
+ * em28xx_i2c_unregister()
+ * unregister i2c_bus
+ */
+int em28xx_i2c_unregister(struct em28xx *dev)
+{
+	i2c_del_adapter(&dev->i2c_adap);
+	return 0;
+}
+
diff --git a/drivers/media/video/empia/em28xx-input.c b/drivers/media/video/empia/em28xx-input.c
new file mode 100644
index 0000000..a0fcba4
--- /dev/null
+++ b/drivers/media/video/empia/em28xx-input.c
@@ -0,0 +1,536 @@
+/*
+  handle em28xx IR remotes via linux kernel input layer.
+
+   Copyright (C) 2005-2007 Markus Rechberger <mrechberger@xxxxxxxxx>
+		 2005      Mauro Carvalho Chehab <mchehab@xxxxxxxxxxxxx>
+		 2005      Sascha Sommer <saschasommer@xxxxxxxxxx>
+
+
+  There have been many issues with this input handling routines, starting
+  from crashing the box, printing random characters or blocking the
+  keyboard when loading it etc. (those issues were caused because it used
+  the global runqueue with the asynchronous module mechanism).
+
+  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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <linux/sched.h>
+#include <linux/interrupt.h>
+#include <linux/input.h>
+#include <linux/usb.h>
+#include <linux/version.h>
+
+#include "em28xx.h"
+#include "em28xx-keymaps.h"
+
+static unsigned int disable_ir;
+module_param(disable_ir, int, 0444);
+MODULE_PARM_DESC(disable_ir, "disable infrared remote support");
+
+static unsigned int ir_debug;
+module_param(ir_debug, int, 0644);
+MODULE_PARM_DESC(ir_debug, "enable debug messages [IR]");
+
+#define dprintk(fmt, arg...)	if (ir_debug) \
+	printk(KERN_DEBUG"%s/ir: " fmt, ir->c.name , ## arg)
+
+/* ----------------------------------------------------------------------- */
+
+static unsigned int get_timestamp(void)
+{
+	struct timeval tm;
+	do_gettimeofday(&tm);
+	return (unsigned int)(tm.tv_sec*1000 + (tm.tv_usec /1000));
+}
+
+int em2888_get_key_empia(struct em28xx *dev, u32 *ir_key, u32 *keystatus)
+{
+	struct em2880_ir *ir = dev->ir_em2880;
+	u8 buf[5];
+	static u8 dropkey;
+	static u8 repeatdelay;
+	int retval = 0;
+	unsigned int timeoutval;
+
+	/* this algorithm works best with 3-5 ms polling
+	   10ms in userspace */
+
+	msleep(3);
+
+
+	dev->em28xx_read_reg_req_len(dev, 0, 0x50, buf, 5);
+
+	timeoutval = get_timestamp();
+
+	if ((buf[0] != 0x11 || ir->btn != buf[1]) && dev->board->ir_keytab[buf[4]] != 0) {
+		if ((ir->btn != buf[1] && ir->released == 1) || ir->key != buf[4]) {
+
+#if 0
+			if (ir->key != buffer[4] && ir->released == 0) 
+				printk("old key got released\n");
+#endif
+
+			*ir_key = buf[4];
+			ir->released = 0;
+			ir->oldval = timeoutval;
+			ir->key = buf[4];
+			retval = 1;
+			
+			/* volume should be repeated faster than other keys */
+
+			if (ir->key<IR_KEYTAB_SIZE && (
+					dev->board->ir_keytab[ir->key] == KEY_VOLUMEUP ||
+					dev->board->ir_keytab[ir->key] == KEY_VOLUMEDOWN)) {
+				dropkey = 1; 
+				repeatdelay = 10;
+			} else {
+				dropkey = 3; 
+				repeatdelay = 100;
+			}
+		}
+
+		if (timeoutval - ir->oldval > repeatdelay && ir->released == 0) {
+			ir->oldval = timeoutval;
+			*ir_key = ir->key;
+			if (dropkey) {
+				retval = 0;
+				dropkey--;
+			} else
+				retval = 1;
+		}
+		ir->oldtimeoutval = 0;
+	} else {
+		if (timeoutval - ir->oldtimeoutval > 150 && ir->oldtimeoutval > 0 && ir->released == 0) {
+			ir->released = 1;
+			retval = 0;
+		}
+		if (ir->oldtimeoutval == 0)
+			ir->oldtimeoutval = timeoutval;
+		retval = 0;
+	}
+	ir->btn = buf[1];
+	return retval;
+}
+
+/* get_key for terratec's devices */
+
+int em2880_get_key_terratec(struct em28xx *dev, u32 *ir_key, u32 *keystatus)
+{
+	int rc;
+	int irc = 0;
+
+	msleep(50);
+
+	rc = em28xx_read_reg_req(dev, 0x0, 0x45);
+	if (rc < 0)
+		return -1;
+	else
+		irc = rc;
+
+	rc = em28xx_read_reg_req(dev, 0x0, 0x47);
+	if (rc < 0)
+		return -1;
+	else
+		*ir_key = rc;
+
+	dev->ir_em2880->sequence[0] = dev->ir_em2880->sequence[1];
+	dev->ir_em2880->sequence[1] = dev->ir_em2880->sequence[2];
+	dev->ir_em2880->sequence[2] = irc;
+	if (dev->ir_em2880->sequence[0] != dev->ir_em2880->sequence[1] &&
+	    dev->ir_em2880->sequence[1] != dev->ir_em2880->sequence[2])
+		return 1;
+	else
+		return 0;
+}
+
+/* get_key for pinnacle's devices */
+/* TODO: this is just a fast implementation ... */
+
+int em2880_get_key_empia(struct em28xx *dev, u32 *ir_key, u32 *keystatus)
+{
+	char buf[4];
+	int ret;
+
+	msleep(50);
+
+	ret = dev->em28xx_read_reg_req_len(dev, 0x0, 0x45, buf, 4);
+
+	if (ret < 0) {
+		switch (ret) {
+		case -ENODEV:
+			/* Device was disconnected */
+			em28xx_warn("reading key failed "
+				    "(error=%i=-ENODEV)\n", ret);
+			return -1;
+		default:
+			em28xx_warn("reading key failed (error=%i)\n", ret);
+			return -1;
+		}
+	}
+
+	dev->ir_em2880->sequence[0] = dev->ir_em2880->sequence[1];
+	dev->ir_em2880->sequence[1] = dev->ir_em2880->sequence[2];
+	dev->ir_em2880->sequence[2] = buf[0]&1;
+	*ir_key = buf[2];
+	if ((dev->ir_em2880->sequence[0] == 1 &&
+	     dev->ir_em2880->sequence[1] == 0 &&
+	     dev->ir_em2880->sequence[2] == 1) ||
+	    (dev->ir_em2880->sequence[0] == 0 &&
+	     dev->ir_em2880->sequence[1] == 1 &&
+	     dev->ir_em2880->sequence[2] == 0))
+		return 1;
+	else
+		return 0;
+}
+
+static int em2880_ir_key_poll(struct em28xx *dev)
+{
+	struct em2880_ir *ir = dev->ir_em2880;
+	static u32 ir_key, keystatus;
+	u32 keycode;
+	static u32 old_keycode;
+	int rc;
+	rc = ir->get_key(dev, &ir_key, &keystatus);
+	switch (rc) {
+	case 0:
+		if (keystatus == 1) {
+			if (old_keycode == 0)
+				return -EINVAL;
+			input_report_key(ir->input, old_keycode, 0);
+			keystatus = 0;
+		}
+		break;
+	case -1:
+		keystatus = 0;
+		return rc;
+	default:
+		/* keydown */
+		keycode = IR_KEYCODE(ir->keymap, ir_key);
+		if (keycode == 0)
+			return -EINVAL;
+		input_report_key(ir->input, keycode, 1);
+		old_keycode = keycode;
+		keystatus = 1;
+	}
+	return 0;
+
+}
+
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 20)
+static void em2880_ir_timer(unsigned long data)
+{
+      struct em2880_ir *ir = ((struct em28xx *)data)->ir_em2880;
+      schedule_work(&ir->work);
+}
+#endif
+
+
+
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 20)
+static void em28xx_ir_work(void *data)
+{
+	struct em28xx *dev = (struct em28xx *)data;
+	struct em2880_ir *ir = dev->ir_em2880;
+	int rc;
+#else
+static void em28xx_ir_work(struct work_struct *work)
+{
+	struct em2880_ir *ir = container_of(work, struct em2880_ir, work.work);
+	struct em28xx *dev = ir->dev;
+	int rc;
+#endif
+	if (ir->state == EM28XX_REMOTE_POLLING) {
+		rc = em2880_ir_key_poll(dev);
+		if (rc != 0) {
+			ir->state = EM28XX_REMOTE_IDLE;
+			return;
+		}
+		mutex_lock(&ir->state_lock);
+		if (ir->state == EM28XX_REMOTE_POLLING)
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 20)
+			mod_timer(&dev->ir_em2880->timer, jiffies+msecs_to_jiffies(50));
+#else
+			schedule_delayed_work(&dev->ir_em2880->work, msecs_to_jiffies(50));
+#endif
+		mutex_unlock(&ir->state_lock);
+	}
+}
+
+int em2880_ir_detach(struct em28xx *dev)
+{
+#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17)
+	struct em2880_ir *ir = dev->ir_em2880;
+
+	return 0;
+	mutex_lock(&dev->input_lock);
+	if (ir == NULL) {
+		printk(KERN_INFO"em28xx-input.c: ir==NULL, skipping"
+				"em2880_ir_detach()\n");
+		mutex_unlock(&dev->input_lock);
+		return 0;
+	}
+
+	mutex_lock(&ir->state_lock);
+	ir->state = EM28XX_REMOTE_INTERRUPT;
+	mutex_unlock(&ir->state_lock);
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 20)
+	del_timer_sync(&ir->timer);
+#else
+	if (delayed_work_pending(&ir->work))
+		cancel_rearming_delayed_work(&ir->work);
+#endif
+
+	input_unregister_device(ir->input);
+	kfree(dev->ir_em2880);
+	dev->ir_em2880 = NULL;
+	printk(KERN_INFO"em28xx-input.c: remote control handler detached\n");
+	mutex_unlock(&dev->input_lock);
+#endif
+	return 0;
+}
+
+int em2880_ir_attach(struct em28xx *dev)
+{
+#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17)
+	struct em2880_ir *ir;
+	struct input_dev *input_dev;
+	char buf[5];
+	int i;
+
+	/* DISABLED this remote control support is broken by design 
+           upcoming support will be moved to userspace plus interrupt
+           triggering support has to be used here, there are alot problems
+           with polling at a high interval, where I already think the timer
+           API is still not bugfree */
+	return 0;
+
+	mutex_lock(&dev->input_lock);
+	if (dev->ir_em2880) {
+		mutex_unlock(&dev->input_lock);
+		printk(KERN_INFO"RC Handler already registered\n");
+		return 0;
+	}
+	dev->ir_em2880 = kzalloc(sizeof(struct em2880_ir), GFP_KERNEL);
+	ir = dev->ir_em2880;
+	ir->keymap = dev->board->ir_keytab;
+	ir->get_key = dev->board->ir_getkey;
+	ir->dev = dev;
+	mutex_init(&ir->state_lock);
+	init_waitqueue_head(&ir->remote_loop);
+	input_dev = input_allocate_device();
+	ir->input = input_dev;
+	input_dev->id.bustype = BUS_USB;
+	sprintf(ir->name, "em2880/em2870 remote control");
+	sprintf(ir->phys, "USB");
+	input_dev->name = ir->name;
+	input_dev->phys = ir->phys; /* FIXME: this is the wrong entry here,
+				    some applications depend on it */
+	input_dev->keycode = ir->keymap;
+	for (i = 0; i < IR_KEYTAB_SIZE; i++)
+		set_bit(ir->keymap[i], input_dev->keybit);
+
+	input_dev->keycodesize = sizeof(IR_KEYTAB_TYPE);
+	input_dev->keycodemax = IR_KEYTAB_SIZE;
+	input_dev->evbit[0] = BIT(EV_KEY) | BIT(EV_REP);
+
+	input_register_device(ir->input);
+
+	ir->state = EM28XX_REMOTE_POLLING;
+
+	if (dev->board->ir_getkey == em2888_get_key_empia) {
+		dev->em28xx_read_reg_req_len(dev, 0, 0x50, buf, 5);
+		ir->key = buf[4];
+		ir->oldval = get_timestamp();
+		ir->btn = buf[1];
+		ir->released = 1;
+	}
+
+	INIT_DELAYED_WORK(&ir->work, em28xx_ir_work);
+	schedule_delayed_work(&ir->work, msecs_to_jiffies(50));
+	printk(KERN_INFO"em28xx-input.c: remote control handler attached\n");
+	mutex_unlock(&dev->input_lock);
+#endif
+	return 0;
+}
+
+
+static int get_key_terratec(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
+{
+	unsigned char b;
+
+	/* poll IR chip */
+	if (1 != i2c_master_recv(&ir->c, &b, 1)) {
+		dprintk("read error\n");
+		return -EIO;
+	}
+
+	/* it seems that 0xFE indicates that a button is still hold
+	   down, while 0xff indicates that no button is hold
+	   down. 0xfe sequences are sometimes interrupted by 0xFF */
+
+	dprintk("key %02x\n", b);
+
+	if (b == 0xff)
+		return 0;
+
+	if (b == 0xfe)
+		/* keep old data */
+		return 1;
+
+	*ir_key = b;
+	*ir_raw = b;
+	return 1;
+}
+
+
+static int get_key_em_haup(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
+{
+	unsigned char buf[2];
+	unsigned char code;
+
+	/* poll IR chip */
+	if (2 != i2c_master_recv(&ir->c, buf, 2))
+		return -EIO;
+
+	/* Does eliminate repeated parity code */
+	if (buf[1] == 0xff)
+		return 0;
+
+	ir->old = buf[1];
+
+	/* Rearranges bits to the right order */
+	code =   ((buf[0]&0x01)<<5) | /* 0010 0000 */
+		 ((buf[0]&0x02)<<3) | /* 0001 0000 */
+		 ((buf[0]&0x04)<<1) | /* 0000 1000 */
+		 ((buf[0]&0x08)>>1) | /* 0000 0100 */
+		 ((buf[0]&0x10)>>3) | /* 0000 0010 */
+		 ((buf[0]&0x20)>>5);  /* 0000 0001 */
+
+	dprintk("ir hauppauge (em2840): code=0x%02x (rcv=0x%02x)\n",
+			code, buf[0]);
+
+	/* return key */
+	*ir_key = code;
+	*ir_raw = code;
+	return 1;
+}
+
+static int get_key_pinnacle_usb(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
+{
+	unsigned char buf[3];
+
+	/* poll IR chip */
+
+	if (3 != i2c_master_recv(&ir->c, buf, 3)) {
+		dprintk("read error\n");
+		return -EIO;
+	}
+
+	dprintk("key %02x\n", buf[2]&0x3f);
+	if (buf[0] != 0x00) {
+		return 0;
+	}
+
+	*ir_key = buf[2]&0x3f;
+	*ir_raw = buf[2]&0x3f;
+
+	return 1;
+}
+
+int em2860_get_key_kaiomy(struct em28xx *dev, u32 *ir_key, u32 *keystatus)
+{
+	char buf[4];
+	int ret;
+
+	msleep(50);
+
+	ret = dev->em28xx_read_reg_req_len(dev, 0x0, 0x45, buf, 4);
+
+	if (ret < 0) {
+		switch (ret) {
+		case -ENODEV:
+			/* Device was disconnected */
+			em28xx_warn("reading key failed "
+				    "(error=%i=-ENODEV)\n", ret);
+			return -1;
+		default:
+			em28xx_warn("reading key failed (error=%i)\n", ret);
+			return -1;
+		}
+	}
+
+	ret = em28xx_read_reg_req(dev, 0x0, 0x44);
+	if (ret < 0)
+		return -1;
+
+	dev->ir_em2880->sequence[0] = dev->ir_em2880->sequence[1]&0x80;
+	dev->ir_em2880->sequence[1] = buf[0];
+	*ir_key = buf[2];
+	return (buf[0]&0x7f) || (dev->ir_em2880->sequence[0] != dev->ir_em2880->sequence[1]);
+}
+
+
+
+/* ----------------------------------------------------------------------- */
+void em28xx_set_ir(struct em28xx *dev, struct IR_i2c *ir)
+{
+	if (disable_ir) {
+		ir->get_key = NULL;
+		return;
+	}
+
+	/* detect & configure */
+	switch (dev->model) {
+	case EM2800_BOARD_GENERIC:
+		break;
+	case EM2820_BOARD_GENERIC:
+		break;
+	case EM2800_BOARD_TERRATEC_CINERGY_200:
+	case EM2820_BOARD_TERRATEC_CINERGY_250:
+		ir->ir_codes = ir_codes_em_terratec_u;
+		ir->get_key = get_key_terratec;
+		snprintf(ir->c.name, sizeof(ir->c.name),
+				"i2c IR (EM28XX Terratec)");
+		break;
+	case EM2820_BOARD_PINNACLE_USB_2:
+		ir->ir_codes = ir_codes_em_pinnacle_usb;
+		ir->get_key = get_key_pinnacle_usb;
+		snprintf(ir->c.name, sizeof(ir->c.name),
+				"i2c IR (EM28XX Pinnacle PCTV)");
+		break;
+	case EM2820_BOARD_HAUPPAUGE_WINTV_USB_2:
+		ir->ir_codes = ir_codes_hauppauge_new_u;
+		ir->get_key = get_key_em_haup;
+		snprintf(ir->c.name, sizeof(ir->c.name),
+				"i2c IR (EM2840 Hauppauge)");
+		break;
+	case EM2820_BOARD_MSI_VOX_USB_2:
+		break;
+	case EM2800_BOARD_LEADTEK_WINFAST_USBII:
+		break;
+	case EM2800_BOARD_KWORLD_USB2800:
+		break;
+	}
+}
+
+/* ----------------------------------------------------------------------
+ * Local variables:
+ * c-basic-offset: 8
+ * End:
+ */
diff --git a/drivers/media/video/empia/em28xx-keymaps.c b/drivers/media/video/empia/em28xx-keymaps.c
new file mode 100644
index 0000000..5f82f91
--- /dev/null
+++ b/drivers/media/video/empia/em28xx-keymaps.c
@@ -0,0 +1,350 @@
+#include "em28xx-keymaps.h"
+
+IR_KEYTAB_TYPE ir_codes_em_terratec_u[IR_KEYTAB_SIZE] = {
+        [ 0x01 ] = KEY_CHANNEL,
+        [ 0x02 ] = KEY_SELECT,
+        [ 0x03 ] = KEY_MUTE,
+        [ 0x04 ] = KEY_POWER,
+        [ 0x05 ] = KEY_1,
+        [ 0x06 ] = KEY_2,
+        [ 0x07 ] = KEY_3,
+        [ 0x08 ] = KEY_CHANNELUP,
+        [ 0x09 ] = KEY_4,
+        [ 0x0a ] = KEY_5,
+        [ 0x0b ] = KEY_6,
+        [ 0x0c ] = KEY_CHANNELDOWN,
+        [ 0x0d ] = KEY_7,
+        [ 0x0e ] = KEY_8,
+        [ 0x0f ] = KEY_9,
+        [ 0x10 ] = KEY_VOLUMEUP,
+        [ 0x11 ] = KEY_0,
+        [ 0x12 ] = KEY_MENU,
+        [ 0x13 ] = KEY_PRINT,
+        [ 0x14 ] = KEY_VOLUMEDOWN,
+        [ 0x16 ] = KEY_PAUSE,
+        [ 0x18 ] = KEY_RECORD,
+        [ 0x19 ] = KEY_REWIND,
+        [ 0x1a ] = KEY_PLAY,
+        [ 0x1b ] = KEY_FORWARD,
+        [ 0x1c ] = KEY_BACKSPACE,
+        [ 0x1e ] = KEY_STOP,
+        [ 0x40 ] = KEY_ZOOM,
+};
+
+EXPORT_SYMBOL_GPL(ir_codes_em_terratec_u);
+
+IR_KEYTAB_TYPE ir_codes_hauppauge_new_u[IR_KEYTAB_SIZE] = {
+        /* Keys 0 to 9 */
+        [ 0x00 ] = KEY_0,
+        [ 0x01 ] = KEY_1,
+        [ 0x02 ] = KEY_2,
+        [ 0x03 ] = KEY_3,
+        [ 0x04 ] = KEY_4,
+        [ 0x05 ] = KEY_5,
+        [ 0x06 ] = KEY_6,
+        [ 0x07 ] = KEY_7,
+        [ 0x08 ] = KEY_8,
+        [ 0x09 ] = KEY_9,
+
+        [ 0x0a ] = KEY_TEXT,            /* keypad asterisk as well */
+        [ 0x0b ] = KEY_RED,             /* red button */
+        [ 0x0c ] = KEY_RADIO,
+        [ 0x0d ] = KEY_MENU,
+        [ 0x0e ] = KEY_SUBTITLE,        /* also the # key */
+        [ 0x0f ] = KEY_MUTE,
+        [ 0x10 ] = KEY_VOLUMEUP,
+        [ 0x11 ] = KEY_VOLUMEDOWN,
+        [ 0x12 ] = KEY_PREVIOUS,        /* previous channel */
+        [ 0x14 ] = KEY_UP,
+        [ 0x15 ] = KEY_DOWN,
+        [ 0x16 ] = KEY_LEFT,
+        [ 0x17 ] = KEY_RIGHT,
+        [ 0x18 ] = KEY_VIDEO,           /* Videos */
+        [ 0x19 ] = KEY_AUDIO,           /* Music */
+        /* 0x1a: Pictures - presume this means
+           "Multimedia Home Platform" -
+           no "PICTURES" key in input.h
+         */
+        [ 0x1a ] = KEY_MHP,
+
+        [ 0x1b ] = KEY_EPG,             /* Guide */
+        [ 0x1c ] = KEY_TV,
+        [ 0x1e ] = KEY_NEXTSONG,        /* skip >| */
+        [ 0x1f ] = KEY_EXIT,            /* back/exit */
+        [ 0x20 ] = KEY_CHANNELUP,       /* channel / program + */
+        [ 0x21 ] = KEY_CHANNELDOWN,     /* channel / program - */
+        [ 0x22 ] = KEY_CHANNEL,         /* source (old black remote) */
+        [ 0x24 ] = KEY_PREVIOUSSONG,    /* replay |< */
+        [ 0x25 ] = KEY_ENTER,           /* OK */
+        [ 0x26 ] = KEY_SLEEP,           /* minimize (old black remote) */
+        [ 0x29 ] = KEY_BLUE,            /* blue key */
+        [ 0x2e ] = KEY_GREEN,           /* green button */
+        [ 0x30 ] = KEY_PAUSE,           /* pause */
+        [ 0x32 ] = KEY_REWIND,          /* backward << */
+        [ 0x34 ] = KEY_FASTFORWARD,     /* forward >> */
+        [ 0x35 ] = KEY_PLAY,
+        [ 0x36 ] = KEY_STOP,
+        [ 0x37 ] = KEY_RECORD,          /* recording */
+        [ 0x38 ] = KEY_YELLOW,          /* yellow key */
+        [ 0x3b ] = KEY_SELECT,          /* top right button */
+        [ 0x3c ] = KEY_ZOOM,            /* full */
+        [ 0x3d ] = KEY_POWER,           /* system power (green button) */
+};
+
+EXPORT_SYMBOL_GPL(ir_codes_hauppauge_new_u);
+
+
+
+IR_KEYTAB_TYPE ir_codes_pinnacle2[IR_KEYTAB_SIZE] = {
+        /* Keys 0 to 9 */
+        [ 0x15 ] = KEY_0,
+        [ 0x08 ] = KEY_1,
+        [ 0x09 ] = KEY_2,
+        [ 0x0a ] = KEY_3,
+        [ 0x0c ] = KEY_4,
+        [ 0x0d ] = KEY_5,
+        [ 0x0e ] = KEY_6,
+        [ 0x10 ] = KEY_7,
+        [ 0x11 ] = KEY_8,
+        [ 0x12 ] = KEY_9,
+
+        [ 0x03 ] = KEY_POWER,
+
+        [ 0x0b ] = KEY_VOLUMEUP,
+        [ 0x0f ] = KEY_VOLUMEDOWN,
+        [ 0x13 ] = KEY_CHANNELUP,
+        [ 0x17 ] = KEY_CHANNELDOWN,
+        [ 0x14 ] = KEY_INFO,
+
+        [ 0x00 ] = KEY_MUTE,
+
+        [ 0x06 ] = KEY_PLAY,
+        [ 0x04 ] = KEY_REWIND,
+        [ 0x07 ] = KEY_FORWARD,
+        [ 0x06 ] = KEY_PAUSE,
+        [ 0x05 ] = KEY_STOP,
+        [ 0x01 ] = KEY_RECORD,
+        [ 0x02 ] = KEY_ZOOM, /* fullscreen */
+        [ 0x16 ] = KEY_M,
+
+};
+EXPORT_SYMBOL_GPL(ir_codes_pinnacle2);
+
+IR_KEYTAB_TYPE ir_codes_em_gadmei_usb[IR_KEYTAB_SIZE] = {
+        [ 0x00 ] = KEY_1,
+        [ 0x01 ] = KEY_2,
+        [ 0x02 ] = KEY_3,
+        [ 0x03 ] = KEY_4,
+        [ 0x04 ] = KEY_5,
+        [ 0x05 ] = KEY_6,
+        [ 0x06 ] = KEY_7,
+        [ 0x07 ] = KEY_8,
+        [ 0x08 ] = KEY_9,
+        [ 0x09 ] = KEY_0,
+        [ 0x0a ] = KEY_A,
+        [ 0x0b ] = KEY_VIDEO,
+        [ 0x0c ] = KEY_MUTE,
+        [ 0x0d ] = KEY_PLAYPAUSE,
+        [ 0x0e ] = KEY_DVD,
+        [ 0x0f ] = KEY_RADIO,
+        [ 0x10 ] = KEY_VOLUMEUP,
+        [ 0x11 ] = KEY_VOLUMEDOWN,
+        [ 0x12 ] = KEY_CHANNELUP,
+        [ 0x13 ] = KEY_CHANNELDOWN,
+        [ 0x14 ] = KEY_POWER,
+        [ 0x15 ] = KEY_MENU,
+        [ 0x17 ] = KEY_STOP,
+        [ 0x18 ] = KEY_TV,
+        [ 0x1a ] = KEY_RECORD,
+        [ 0x1c ] = KEY_PREVIOUS,
+        [ 0x1e ] = KEY_B,
+        [ 0x1f ] = KEY_C,
+        [ 0x44 ] = KEY_E,
+        [ 0x46 ] = KEY_D,
+        [ 0x4a ] = KEY_ZOOM,
+};
+EXPORT_SYMBOL_GPL(ir_codes_em_gadmei_usb);
+
+IR_KEYTAB_TYPE ir_codes_em_pinnacle2_usb[IR_KEYTAB_SIZE] = {
+        [ 0x00 ] = KEY_MUTE,
+        [ 0x01 ] = KEY_A,
+        [ 0x39 ] = KEY_POWER,
+        [ 0x03 ] = KEY_VOLUMEUP,
+        [ 0x06 ] = KEY_CHANNELUP,
+        [ 0x09 ] = KEY_VOLUMEDOWN,
+        [ 0x0c ] = KEY_CHANNELDOWN,
+        [ 0x0f ] = KEY_1,
+        [ 0x15 ] = KEY_2,
+        [ 0x10 ] = KEY_3,
+        [ 0x18 ] = KEY_4,
+        [ 0x1b ] = KEY_5,
+        [ 0x1e ] = KEY_6,
+        [ 0x11 ] = KEY_7,
+        [ 0x21 ] = KEY_8,
+        [ 0x12 ] = KEY_9,
+        [ 0x24 ] = KEY_ZOOM,
+        [ 0x27 ] = KEY_0,
+        [ 0x2a ] = KEY_T,
+        [ 0x2d ] = KEY_REWIND,
+        [ 0x30 ] = KEY_PLAY,
+        [ 0x33 ] = KEY_FORWARD,
+        [ 0x36 ] = KEY_RECORD,
+        [ 0x3c ] = KEY_STOP,
+        [ 0x3f ] = KEY_INFO,
+};
+EXPORT_SYMBOL_GPL(ir_codes_em_pinnacle2_usb);
+
+IR_KEYTAB_TYPE ir_codes_em_pinnacle_usb[IR_KEYTAB_SIZE] = {
+        [ 0x3a ] = KEY_0,
+        [ 0x31 ] = KEY_1,
+        [ 0x32 ] = KEY_2,
+        [ 0x33 ] = KEY_3,
+        [ 0x34 ] = KEY_4,
+        [ 0x35 ] = KEY_5,
+        [ 0x36 ] = KEY_6,
+        [ 0x37 ] = KEY_7,
+        [ 0x38 ] = KEY_8,
+        [ 0x39 ] = KEY_9,
+
+        [ 0x2f ] = KEY_POWER,
+
+        [ 0x2e ] = KEY_P,
+        [ 0x1f ] = KEY_L,
+        [ 0x2b ] = KEY_I,
+
+        [ 0x2d ] = KEY_ZOOM,
+        [ 0x1e ] = KEY_ZOOM,
+        [ 0x1b ] = KEY_VOLUMEUP,
+        [ 0x0f ] = KEY_VOLUMEDOWN,
+        [ 0x17 ] = KEY_CHANNELUP,
+        [ 0x1c ] = KEY_CHANNELDOWN,
+        [ 0x25 ] = KEY_INFO,
+
+        [ 0x3c ] = KEY_MUTE,
+
+        [ 0x3d ] = KEY_LEFT,
+        [ 0x3b ] = KEY_RIGHT,
+
+        [ 0x3f ] = KEY_UP,
+        [ 0x3e ] = KEY_DOWN,
+        [ 0x1a ] = KEY_PAUSE,
+
+        [ 0x1d ] = KEY_MENU,
+        [ 0x19 ] = KEY_PLAY,
+        [ 0x16 ] = KEY_REWIND,
+        [ 0x13 ] = KEY_FORWARD,
+        [ 0x15 ] = KEY_PAUSE,
+        [ 0x0e ] = KEY_REWIND,
+        [ 0x0d ] = KEY_PLAY,
+        [ 0x0b ] = KEY_STOP,
+        [ 0x07 ] = KEY_FORWARD,
+        [ 0x27 ] = KEY_RECORD,
+        [ 0x26 ] = KEY_TUNER,
+        [ 0x29 ] = KEY_TEXT,
+        [ 0x2a ] = KEY_MEDIA,
+        [ 0x18 ] = KEY_EPG,
+        [ 0x27 ] = KEY_RECORD,
+};
+EXPORT_SYMBOL_GPL(ir_codes_em_pinnacle_usb);
+
+IR_KEYTAB_TYPE ir_codes_em_terratec2[IR_KEYTAB_SIZE] = {
+        [ 0x01 ] = KEY_POWER,
+        [ 0x02 ] = KEY_1,
+        [ 0x03 ] = KEY_2,
+        [ 0x04 ] = KEY_3,
+        [ 0x05 ] = KEY_4,
+        [ 0x06 ] = KEY_5,
+        [ 0x07 ] = KEY_6,
+        [ 0x08 ] = KEY_7,
+        [ 0x09 ] = KEY_8,
+        [ 0x0a ] = KEY_9,
+        [ 0x0b ] = KEY_TUNER,
+        [ 0x0c ] = KEY_0,
+        [ 0x0d ] = KEY_PREVIOUSSONG,
+
+        [ 0x41 ] = KEY_HOME,
+        [ 0x42 ] = KEY_MENU,
+        [ 0x43 ] = KEY_SUBTITLE,
+        [ 0x44 ] = KEY_TEXT,
+        [ 0x45 ] = KEY_DELETE,
+        [ 0x46 ] = KEY_TV,
+        [ 0x47 ] = KEY_DVD,
+        [ 0x49 ] = KEY_VIDEO,
+        [ 0x4a ] = KEY_AUDIO,
+        [ 0x4b ] = KEY_SHUFFLE,
+
+        [ 0x10 ] = KEY_UP,
+        [ 0x11 ] = KEY_LEFT,
+        [ 0x12 ] = KEY_OK,
+        [ 0x13 ] = KEY_RIGHT,
+        [ 0x14 ] = KEY_DOWN,
+
+        [ 0x0f ] = KEY_EPG,
+        [ 0x16 ] = KEY_INFO,
+        [ 0x4d ] = KEY_BACK,
+
+        [ 0x1c ] = KEY_VOLUMEUP,
+        [ 0x4c ] = KEY_PLAY,
+        [ 0x1b ] = KEY_CHANNELUP,
+        [ 0x1e ] = KEY_VOLUMEDOWN,
+        [ 0x1d ] = KEY_MUTE,
+        [ 0x1f ] = KEY_CHANNELDOWN,
+
+        [ 0x17 ] = KEY_RED,
+        [ 0x18 ] = KEY_GREEN,
+        [ 0x19 ] = KEY_YELLOW,
+        [ 0x1a ] = KEY_BLUE,
+
+        [ 0x58 ] = KEY_RECORD,
+        [ 0x48 ] = KEY_STOP,
+        [ 0x40 ] = KEY_PAUSE,
+        [ 0x54 ] = KEY_LAST,
+        [ 0x4e ] = KEY_REWIND,
+        [ 0x4f ] = KEY_FORWARD,
+        [ 0x5c ] = KEY_NEXT,
+};
+EXPORT_SYMBOL_GPL(ir_codes_em_terratec2);
+
+
+IR_KEYTAB_TYPE ir_codes_em_kworld[IR_KEYTAB_SIZE] = {
+        [ 0x43 ] = KEY_POWER,
+	[ 0x03 ] = KEY_POWER2,
+
+        [ 0x04 ] = KEY_1,
+        [ 0x08 ] = KEY_2,
+        [ 0x02 ] = KEY_3,
+        [ 0x0f ] = KEY_4,
+        [ 0x05 ] = KEY_5,
+        [ 0x06 ] = KEY_6,
+        [ 0x0c ] = KEY_7,
+        [ 0x0d ] = KEY_8,
+        [ 0x0a ] = KEY_9,
+        [ 0x11 ] = KEY_0,
+
+        [ 0x09 ] = KEY_CHANNELUP,
+        [ 0x07 ] = KEY_CHANNELDOWN,
+        [ 0x0e ] = KEY_VOLUMEUP,
+        [ 0x13 ] = KEY_VOLUMEDOWN,
+
+        [ 0x01 ] = KEY_TUNER,
+	[ 0x0b ] = KEY_ZOOM,
+
+        [ 0x16 ] = KEY_PLAY,
+        [ 0x17 ] = KEY_MUTE,
+        [ 0x14 ] = KEY_RECORD,
+        [ 0x15 ] = KEY_STOP,
+        
+	[ 0x18 ] = KEY_UP,
+        [ 0x19 ] = KEY_DOWN,
+        [ 0x1a ] = KEY_LEFT,
+        [ 0x1b ] = KEY_RIGHT,
+        
+	[ 0x1c ] = KEY_RED,
+        [ 0x1d ] = KEY_GREEN,
+        [ 0x1e ] = KEY_YELLOW,
+        [ 0x1f ] = KEY_BLUE,
+
+	[ 0x12 ] = KEY_OK,
+	[ 0x10 ] = KEY_HOME
+};
+EXPORT_SYMBOL_GPL(ir_codes_em_kworld);
diff --git a/drivers/media/video/empia/em28xx-keymaps.h b/drivers/media/video/empia/em28xx-keymaps.h
new file mode 100644
index 0000000..1205419
--- /dev/null
+++ b/drivers/media/video/empia/em28xx-keymaps.h
@@ -0,0 +1,21 @@
+#ifndef _EM28XX_KEYMAPS
+#define _EM28XX_KEYMAPS
+#include <linux/input.h>
+#include <linux/workqueue.h>
+
+/* TODO move all that stuff to userspace, fixed keytab definitions in the kernel
+ * are broken by design, there are multiple remotes available with custom return keys
+ * -> raw lirc module is required here */
+
+#define IR_KEYTAB_TYPE  u32 
+#define IR_KEYTAB_SIZE  128  // enougth for rc5, probably need more some day ...
+
+extern IR_KEYTAB_TYPE ir_codes_pinnacle2[IR_KEYTAB_SIZE];
+extern IR_KEYTAB_TYPE ir_codes_em_pinnacle_usb[IR_KEYTAB_SIZE];
+extern IR_KEYTAB_TYPE ir_codes_em_terratec2[IR_KEYTAB_SIZE];
+extern IR_KEYTAB_TYPE ir_codes_em_pinnacle2_usb[IR_KEYTAB_SIZE];
+extern IR_KEYTAB_TYPE ir_codes_em_gadmei_usb[IR_KEYTAB_SIZE];
+extern IR_KEYTAB_TYPE ir_codes_em_terratec_u[IR_KEYTAB_SIZE];
+extern IR_KEYTAB_TYPE ir_codes_hauppauge_new_u[IR_KEYTAB_SIZE];
+extern IR_KEYTAB_TYPE ir_codes_em_kworld[IR_KEYTAB_SIZE];
+#endif
diff --git a/drivers/media/video/empia/em28xx-video.c b/drivers/media/video/empia/em28xx-video.c
new file mode 100644
index 0000000..49db364
--- /dev/null
+++ b/drivers/media/video/empia/em28xx-video.c
@@ -0,0 +1,4244 @@
+/*
+   em28xx-video.c - driver for Empia
+		    EM2800/2820/2840/2870/2880
+		    USB video capture devices
+
+   Copyright (C) 2005 Sascha Sommer <saschasommer@xxxxxxxxxx>
+		 2005-2007 Markus Rechberger <mrechberger@xxxxxxxxx>
+		 2005-2006 Mauro Carvalho Chehab <mchehab@xxxxxxxxxxxxx>
+		 2005 Ludovico Cavedon <cavedon@xxxxxxxx>
+
+   Some parts based on SN9C10x PC Camera Controllers GPL driver made
+   by Luca Risolia <luca.risolia@xxxxxxxxxxxxxxx>
+
+   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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/init.h>
+#include <linux/list.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/bitmap.h>
+#include <linux/usb.h>
+#include <linux/i2c.h>
+#include <linux/version.h>
+#include <linux/video_decoder.h>
+#include "dvb_frontend.h"
+#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 15)
+#include <linux/mutex.h>
+#endif
+
+#include "em28xx.h"
+#include <media/tuner.h>
+#include <media/v4l2-common.h>
+#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 26)
+#include <media/v4l2-ioctl.h>
+#endif
+#include "include/tunerchip.h"
+#include "xc3028/xc3028_control.h"
+#include "xc3028/xc3028_module.h"
+
+#include "xc5000/xc5000_control.h"
+#include "xc5000/xc5000_module.h"
+#include "cx25843/em28xx-cx25843.h"
+
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 5, 0)
+#include "i2c-compat.h"
+#include <linux/moduleparam.h>
+#endif
+
+#define DRIVER_AUTHOR "Ludovico Cavedon <cavedon@xxxxxxxx>, " \
+		      "Markus Rechberger <mrechberger@xxxxxxxxx>, " \
+		      "Mauro Carvalho Chehab <mchehab@xxxxxxxxxxxxx>, " \
+		      "Sascha Sommer <saschasommer@xxxxxxxxxx>"
+
+#define DRIVER_NAME         "em28xx"
+#define DRIVER_DESC         "Empia em28xx based USB video device driver"
+#define EM28XX_VERSION_CODE  KERNEL_VERSION(0, 0, 1)
+
+#define em28xx_videodbg(fmt, arg...) do {\
+	if (video_debug) \
+		printk(KERN_INFO "%s %s :"fmt, \
+			 dev->name, __FUNCTION__ , ##arg); } while (0)
+
+MODULE_AUTHOR(DRIVER_AUTHOR);
+MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_LICENSE("GPL");
+
+unsigned char *XC5000_firmware_SEQUENCE;
+
+LIST_HEAD(em28xx_devlist);
+static LIST_HEAD(em28xx_extension_devlist);
+static DEFINE_MUTEX(em28xx_extension_devlist_lock);
+
+static unsigned int card[]     = {[0 ... (EM28XX_MAXBOARDS - 1)] = UNSET };
+static unsigned int radio_nr[] = {[0 ... (EM28XX_MAXBOARDS - 1)] = UNSET };
+static unsigned int video_nr[] = {[0 ... (EM28XX_MAXBOARDS - 1)] = UNSET };
+static unsigned int vbi_nr[] = {[0 ... (EM28XX_MAXBOARDS - 1)] = UNSET };
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 5, 0)
+MODULE_PARM(card, "1-" __stringify(EM28XX_MAXBOARDS) "i");
+MODULE_PARM(video_nr, "1-" __stringify(EM28XX_MAXBOARDS) "i");
+MODULE_PARM(vbi_nr, "1-" __stringify(EM28XX_MAXBOARDS) "i");
+#else
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 10)
+static int dummy;
+module_param_array(card,  int, dummy, 0444);
+module_param_array(video_nr, int, dummy, 0444);
+module_param_array(vbi_nr, int, dummy, 0444);
+#else
+module_param_array(card,  int, NULL, 0444);
+module_param_array(video_nr, int, NULL, 0444);
+module_param_array(vbi_nr, int, NULL, 0444);
+#endif
+#endif
+MODULE_PARM_DESC(card, "card type");
+MODULE_PARM_DESC(video_nr, "video device numbers");
+MODULE_PARM_DESC(vbi_nr, "vbi device numbers");
+
+static int tuner = -1;
+module_param(tuner, int, 0444);
+MODULE_PARM_DESC(tuner, "tuner type");
+
+static unsigned int video_debug;
+module_param(video_debug, int, 0644);
+MODULE_PARM_DESC(video_debug, "enable debug messages [video]");
+
+static unsigned int device_mode;
+module_param(device_mode, int, 0644);
+MODULE_PARM_DESC(device_mode, "device mode (DVB-T/Analogue TV)");
+
+static unsigned int vbi_mode = 1;
+module_param(vbi_mode, int, 0644);
+MODULE_PARM_DESC(vbi_mode, "VBI mode (0 disabled/1 enabled(default, "
+				"if appropriate))");
+
+static unsigned int vbi_interlaced;
+module_param(vbi_interlaced, int, 0644);
+MODULE_PARM_DESC(vbi_interlaced, "VBI Interlaced (default 0 - off)");
+
+/* Bitmask marking allocated devices from 0 to EM28XX_MAXBOARDS */
+static unsigned long em28xx_devused;
+
+static int em28xx_v4l2_vbi_mmap(struct file *filp, struct vm_area_struct *vma);
+static int em28xx_stream_interrupt(struct em28xx *dev, int type);
+
+struct workqueue_struct *em28xx_wq; /* global workqueue for polling the
+					      remote control and requesting
+					      submodules */
+/* supported controls */
+/* Common to all boards */
+static struct v4l2_queryctrl em28xx_qctrl[] = {
+	{
+		.id = V4L2_CID_AUDIO_VOLUME,
+		.type = V4L2_CTRL_TYPE_INTEGER,
+		.name = "Volume",
+		.minimum = 0x0,
+		.maximum = 0x1f,
+		.step = 0x1,
+		.default_value = 0x1f,
+		.flags = 0,
+	}, {
+		.id = V4L2_CID_AUDIO_MUTE,
+		.type = V4L2_CTRL_TYPE_BOOLEAN,
+		.name = "Mute",
+		.minimum = 0,
+		.maximum = 1,
+		.step = 1,
+		.default_value = 1,
+		.flags = 0,
+	}
+};
+
+/* FIXME: These are specific to saa711x - should be moved to its code */
+static struct v4l2_queryctrl saa711x_qctrl[] = {
+	{
+		.id = V4L2_CID_BRIGHTNESS,
+		.type = V4L2_CTRL_TYPE_INTEGER,
+		.name = "Brightness1",
+		.minimum = -128,
+		.maximum = 127,
+		.step = 1,
+		.default_value = 0,
+		.flags = 0,
+	}, {
+		.id = V4L2_CID_CONTRAST,
+		.type = V4L2_CTRL_TYPE_INTEGER,
+		.name = "Contrast",
+		.minimum = 0x0,
+		.maximum = 0x1f,
+		.step = 0x1,
+		.default_value = 0x10,
+		.flags = 0,
+	}, {
+		.id = V4L2_CID_SATURATION,
+		.type = V4L2_CTRL_TYPE_INTEGER,
+		.name = "Saturation",
+		.minimum = 0x0,
+		.maximum = 0x1f,
+		.step = 0x1,
+		.default_value = 0x10,
+		.flags = 0,
+	}, {
+		.id = V4L2_CID_RED_BALANCE,
+		.type = V4L2_CTRL_TYPE_INTEGER,
+		.name = "Red chroma balance",
+		.minimum = -128,
+		.maximum = 127,
+		.step = 1,
+		.default_value = 0,
+		.flags = 0,
+	}, {
+		.id = V4L2_CID_BLUE_BALANCE,
+		.type = V4L2_CTRL_TYPE_INTEGER,
+		.name = "Blue chroma balance",
+		.minimum = -128,
+		.maximum = 127,
+		.step = 1,
+		.default_value = 0,
+		.flags = 0,
+	}, {
+		.id = V4L2_CID_GAMMA,
+		.type = V4L2_CTRL_TYPE_INTEGER,
+		.name = "Gamma",
+		.minimum = 0x0,
+		.maximum = 0x3f,
+		.step = 0x1,
+		.default_value = 0x20,
+		.flags = 0,
+	}
+#ifdef V4L2_CID_SHARPNESS
+	 , {
+		.id = V4L2_CID_SHARPNESS,
+		.type = V4L2_CTRL_TYPE_INTEGER,
+		.name = "Sharpness",
+		.minimum = 0x0,
+		.maximum = 0xf,
+		.step = 0x1,
+		.default_value = 0x8,
+		.flags = 0,
+	}
+#endif
+};
+
+struct em28xx_output_fmt em28xx_out_fmt[]={
+	{
+		.fmt = {
+			.index = 0,
+			.type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
+			.description = "Y0-U-Y1-V, 16 bpp",
+			.pixelformat = V4L2_PIX_FMT_YUYV,
+		},
+		.config = 0x14
+	}, {
+		.fmt = {
+			.index = 1,
+			.type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
+			.description = "Y1-U-Y0-V, 16 bpp",
+			.pixelformat = V4L2_PIX_FMT_YUY1,
+		},
+		.config = 0x15
+	}, {
+		.fmt = {
+			.index = 2,
+			.type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
+			.description = "YUV411, 12 bpp",
+			.pixelformat = V4L2_PIX_FMT_Y41P
+		},
+		.config = 0x18
+	}, {
+		.fmt = {
+			.index = 3,
+			.type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
+			.description = "YUV211, 8 bpp",
+			.pixelformat = V4L2_PIX_FMT_YUV211
+		},
+		.config = 0x10
+	}, {
+		.fmt = {
+			.index = 4,
+			.type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
+			.description = "RGB, 16 bpp, 6-5-6", /* 16 != 656->17 */
+			.pixelformat = V4L2_PIX_FMT_RGB565   /* 565->16 */
+		},
+		.config = 0x04,
+	}, {
+		.fmt = {
+			.index = 5,
+			.type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
+			.description = "RGB, 8bit RGRG",
+			.pixelformat = 1 /* TODO */
+		},
+		.config = 0x00
+	}, {
+		.fmt = {
+			.index = 6,
+			.type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
+			.description = "RGB, 8bit GRGR",
+			.pixelformat = 2 /* TODO */
+		},
+		.config = 0x01
+	}, {
+		.fmt = {
+			.index = 7,
+			.type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
+			.description = "RGB, 8bit GBGB",
+			.pixelformat = 3 /* TODO */
+		},
+		.config = 0x02
+	}, {
+		.fmt = {
+			.index = 8,
+			.type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
+			.description = "RGB, 8bit BGBG",
+			.pixelformat = 4 /* TODO */
+		},
+		.config = 0x03
+	}
+};
+
+static struct usb_driver em28xx_usb_driver;
+
+static DEFINE_MUTEX(em28xx_sysfs_lock);
+static DECLARE_RWSEM(em28xx_disconnect);
+
+/* ----------------------------------------------------------- */
+/* delayed request_module                                      */
+#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17)
+#if defined(CONFIG_MODULES) && defined(MODULE)
+static void request_module_async(struct work_struct *work)
+{
+	struct em28xx *dev = container_of(work,
+			struct em28xx,
+			request_module_wk.work);
+
+	if ((dev->state & DEV_DISCONNECTED) ||
+		(dev->state & DEV_MISCONFIGURED))
+		goto out;
+
+	if (dev->dev_modes & EM28XX_AUDIO)
+		request_module("em28xx-audio");
+
+	if ((dev->dev_modes & EM28XX_DVBT || dev->dev_modes & EM28XX_ATSC || dev->dev_modes & EM28XX_ISDB))
+		request_module("em28xx-dvb");
+
+	/* unlock all the device nodes here */
+out:
+	dev->em28xx_acquire(dev, EM28XX_LOCK, 0);
+}
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 5, 0)
+static void request_modules(struct em28xx *dev) {
+	dev->em28xx_acquire(dev, EM28XX_LOCK, 0);
+}
+#else
+/* this is a bit fishy here, if we'd directly try to load the module here
+   it would end up in a deadlock since modprobe locks the em28xx module.
+   When loading the em2880-dvb module it also tries to open the em28xx module
+   and it gets stuck and won't return, so a small workaround is to set up
+   a workqueue and run modprobe from another process
+
+   the previous approach used the global workqueue, although this could have
+   locked up the keyboard input system, currently when running
+
+   while :; do modprobe em28xx; rmmod em28xx-dvb; rmmod em28xx-audio; rmmod
+   em28xx; done
+
+   the unloading process might deadlock with the request thread, the requesting-   insmod needs to get killed manually ...(the "bug/feature" is in the
+   linux module code...)
+
+   This whole issue goes back for a very long time already and quite a few
+   people went on this before...
+ */
+
+static void request_modules(struct em28xx *dev)
+{
+       schedule_delayed_work(&dev->request_module_wk, msecs_to_jiffies(50));
+}
+#endif
+#else
+static void request_modules(struct em28xx *dev) {
+	dev->em28xx_acquire(dev, EM28XX_LOCK, 0);
+}
+#endif
+#endif
+
+/*********************  v4l2 interface  ******************************************/
+
+/*
+ * em28xx_config()
+ * inits registers with sane defaults
+ */
+int em28xx_config(struct em28xx *dev)
+{
+	em28xx_audio_usb_mute(dev, EM28XX_MUTED);
+	dev->mute = 1;		/* maybe not the right place... */
+	dev->volume = 0x1f;
+	em28xx_audio_analog_set(dev);
+	em28xx_audio_analog_setup(dev);
+	em28xx_outfmt_set_yuv422(dev);
+	em28xx_colorlevels_set_default(dev);
+	em28xx_compression_disable(dev);
+
+	return 0;
+}
+
+/*
+ * em28xx_config_i2c()
+ * configure i2c attached devices
+ * TODO: add MSI_VOX_USB_2 support again!
+ *
+ */
+void em28xx_config_i2c(struct em28xx *dev)
+{
+	struct v4l2_routing route;
+
+	route.input = INPUT(dev->ctl_input)->vmux;
+	route.output = 0;
+
+	/* configure decoder */
+	em28xx_i2c_call_clients(dev, VIDIOC_INT_RESET, 0);
+	em28xx_i2c_call_clients(dev, VIDIOC_INT_S_VIDEO_ROUTING, &route);
+	em28xx_i2c_call_clients(dev, VIDIOC_STREAMON, NULL);
+
+}
+
+/*
+ * em28xx_empty_framequeues()
+ * prepare queues for incoming and outgoing frames
+ */
+static void em28xx_empty_framequeues(struct em28xx *dev, int type)
+{
+	u32 i;
+	/* FIXME please verify EM28XX_NUM_FRAMES */
+
+	if (type == EM28XX_VBI) {
+		INIT_LIST_HEAD(&dev->vbi_inqueue);
+		INIT_LIST_HEAD(&dev->vbi_outqueue);
+		for (i = 0; i < EM28XX_NUM_FRAMES; i++) {
+			dev->vbi_frame[i].state = F_UNUSED;
+			dev->vbi_frame[i].buf.bytesused = 0;
+		}
+	} else {
+		INIT_LIST_HEAD(&dev->inqueue);
+		INIT_LIST_HEAD(&dev->outqueue);
+		for (i = 0; i < EM28XX_NUM_FRAMES; i++) {
+			dev->frame[i].state = F_UNUSED;
+			dev->frame[i].buf.bytesused = 0;
+		}
+	}
+
+}
+
+static void video_mux(struct em28xx *dev, int index)
+{
+	int input = INPUT(index)->vmux;
+	struct v4l2_routing route;
+	int ainput;
+
+	route.input = INPUT(index)->vmux;
+	route.output = 0;
+
+	dev->ctl_input = index;
+	dev->ctl_ainput = INPUT(index)->amux;
+	dev->ctl_amix = INPUT(index)->amix;
+
+	em28xx_i2c_call_clients(dev, VIDIOC_INT_S_VIDEO_ROUTING, &route);
+
+	em28xx_videodbg("Setting input index = %d, vmux = %d, amux = %d\n",
+			index, input, dev->ctl_ainput);
+
+	if (dev->has_msp34xx) {
+		if (dev->i2s_speed)
+			em28xx_i2c_call_clients(dev, VIDIOC_INT_I2S_CLOCK_FREQ,
+					&dev->i2s_speed);
+		em28xx_i2c_call_clients(dev, VIDIOC_S_AUDIO, &dev->ctl_ainput);
+		ainput = EM28XX_AUDIO_SRC_TUNER;
+		em28xx_audio_source(dev, ainput);
+	} else {
+		switch (dev->model) {
+		case EM2860_BOARD_GADMEI_UTV330:
+		{
+			u8 val;
+			switch (dev->ctl_ainput) {
+				case 0:
+					val = 0xfd;
+					break;
+				case 1:
+					val = 0xfc;
+					break;
+				default :
+					val = 0xfe;
+					break;
+			}
+			if (dev->mute)
+				val = 0xfe;
+
+			em28xx_write_regs(dev, 0x08, &val, 1);
+			break;
+		}
+		default :
+			switch (dev->ctl_ainput) {
+			case 0:
+				ainput = EM28XX_AUDIO_SRC_TUNER;
+				break;
+			default:
+				ainput = EM28XX_AUDIO_SRC_LINE;
+			}
+			em28xx_audio_source(dev, ainput);
+			break;
+		}
+	}
+	em28xx_audio_set_mixer(dev, dev->ctl_amix);
+}
+
+
+static int em28xx_acquire(struct em28xx *dev, int mode, int lock)
+{
+	int ret = 0;
+
+	if (dev->mode_lock && mode != EM28XX_LOCK)
+		return -EBUSY;
+
+	switch (mode) {
+	case EM28XX_LOCK:
+		if (lock)
+			dev->mode_lock = 1;
+		else
+			dev->mode_lock = 0;
+		break;
+	/* radio is allowed if TV and DVB is not in use */
+	case EM28XX_RADIO:
+		if (lock) {
+			if (dev->fe_user || dev->video_user || dev->vbi_user)
+				ret = -EBUSY;
+			else
+				dev->radio_user++;
+		} else
+			dev->radio_user--;
+		break;
+	/* video, vbi and analogue audio are allowed at the same time */
+	case EM28XX_VIDEO:
+		if (lock) {
+			if (dev->fe_user || dev->radio_user)
+				ret = -EBUSY;
+			else
+				dev->video_user++;
+		} else
+			dev->video_user--;
+		break;
+	case EM28XX_VBI:
+		if (lock) {
+			if (dev->fe_user || dev->radio_user)
+				ret = -EBUSY;
+			else
+				dev->vbi_user++;
+		} else
+			dev->vbi_user--;
+		break;
+	case EM28XX_DVBT:
+		if (lock)  {
+			if (dev->radio_user || dev->video_user || dev->vbi_user)
+				ret = -EBUSY;
+			else
+				dev->fe_user++;
+		} else {
+			dev->fe_user--;
+		}
+		break;
+	case EM28XX_ATSC:
+		if (lock) {
+			if (dev->radio_user || dev->video_user || dev->vbi_user)
+				ret = -EBUSY;
+			else
+				dev->fe_user++;
+		} else
+			dev->fe_user--;
+		break;
+	default:
+		ret = -EINVAL;
+	}
+
+	return ret;
+}
+
+/*
+ * em28xx_v4l2_open()
+ * inits the device and starts isoc transfer
+ */
+
+static int em28xx_v4l2_open(struct inode *inode, struct file *filp)
+{
+	int minor = iminor(inode);
+	int errCode = 0;
+	int mode = V4L2_TUNER_ANALOG_TV;
+	int type = 0;
+	int ret;
+	struct em28xx *h, *dev = NULL;
+	struct em28xx_fh *fh;
+	struct list_head *list;
+
+	list_for_each(list, &em28xx_devlist) {
+		h = list_entry(list, struct em28xx, devlist);
+		if (h == NULL) {
+			printk("em28xx-devlist empty\n");
+			return -ENODEV;
+		}
+
+		if (h->vdev &&
+				h->vdev->minor == minor) {
+			dev  = h;
+			type = EM28XX_VIDEO;
+			mode = V4L2_TUNER_ANALOG_TV;
+			break;
+		}
+
+		if ((h->dev_modes & EM28XX_RADIO) &&
+				h->rdev &&
+				h->rdev->minor == minor) {
+			dev = h;
+			type = EM28XX_RADIO;
+			mode = V4L2_TUNER_RADIO;
+			break;
+		}
+
+		if ((h->dev_modes & EM28XX_VBI) &&
+				h->vbi_dev &&
+				h->vbi_dev->minor == minor) {
+			dev  = h;
+			type = EM28XX_VBI;
+			mode = V4L2_TUNER_ANALOG_TV;
+			break;
+		}
+	}
+
+	if (NULL == dev) {
+		printk(KERN_INFO"device struct is not set\n");
+		return -ENODEV;
+	}
+
+	ret = dev->em28xx_acquire(dev, type, 1);
+
+	if (ret != 0)
+		return ret;
+
+	if (dev->has_inttuner) {
+		if (dev->mode != mode) {
+			int arg;
+
+			dev->mode = mode;
+			arg = EM28XX_REG_ON;
+
+			dev->em28xx_gpio_control(dev, EM28XX_ANALOG_ON, &arg);
+			dev->em28xx_gpio_control(dev, EM28XX_LED1_ON, &arg);
+			dev->em28xx_gpio_control(dev, EM28XX_TUNER1_ON, &arg);
+			arg = EM28XX_REG_OFF;
+			dev->em28xx_gpio_control(dev, EM28XX_TS1_ON, &arg);
+			dev->em28xx_gpio_control(dev, EM28XX_DECODER_SLEEP, &arg);
+			mdelay(100);
+
+			em28xx_config(dev);
+			em28xx_config_i2c(dev);
+			if (dev->mode == V4L2_TUNER_ANALOG_TV)
+				em28xx_i2c_call_clients(dev, VIDIOC_S_STD,
+						&dev->tvnorm->id);
+
+			switch (dev->tuner_type) {
+			case TUNER_XCEIVE_XC3028:
+			{
+				struct xc3028_init_cmd cmd;
+
+				if (dev->tuner == NULL) {
+					printk(KERN_INFO"tuner is not "
+							"attached\n");
+					dev->em28xx_acquire(dev, type, 0);
+					return -EINVAL;
+				}
+				switch (dev->mode) {
+				case V4L2_TUNER_RADIO:
+					/* this is moreover to switch the
+					   decoder to FM */
+
+					cmd.new_tv_mode_ptr =
+						dev->fmnorm->tv_mode;
+					cmd.new_channel_map_ptr =
+						dev->fmnorm->channelmap;
+					if (dev->tuner)
+						dev->tuner->tuner_cmd(
+							dev->tuner,
+							XC3028_INIT_TUNER,
+							&cmd);
+					break;
+				case V4L2_TUNER_ANALOG_TV:
+					cmd.new_tv_mode_ptr =
+						dev->tvnorm->tv_mode;
+					cmd.new_channel_map_ptr =
+						dev->tvnorm->channelmap;
+					if (dev->tuner && dev->tuner->tuner_cmd)
+						dev->tuner->tuner_cmd(
+							dev->tuner,
+							XC3028_INIT_TUNER,
+							&cmd);
+					break;
+				}
+				break;
+			}
+			case TUNER_XCEIVE_XC5000:
+			{
+				if (dev->tuner == NULL) {
+					printk("tuner is not attached\n");
+					dev->em28xx_acquire(dev, type, 0);
+					return -EINVAL;
+				}
+
+				if (dev->tuner && dev->tuner->tuner_cmd)
+					dev->tuner->tuner_cmd(dev->tuner,
+							XC5000_INIT_TUNER,
+							NULL);
+				switch (dev->mode) {
+				case V4L2_TUNER_RADIO:
+				{
+					struct xc_std_conf cmd;
+					cmd.index = dev->fmnorm->index;
+					dev->tuner->tuner_cmd(dev->tuner,
+							XC5000_SET_MODE, &cmd);
+					break;
+				}
+				case V4L2_TUNER_ANALOG_TV:
+				{
+					struct xc_std_conf cmd;
+					cmd.index = dev->tvnorm->index;
+					dev->tuner->tuner_cmd(dev->tuner,
+							XC5000_SET_MODE, &cmd);
+					break;
+				}
+				}
+				break;
+			}
+			}
+			if (dev->mode == V4L2_TUNER_RADIO) {
+				struct v4l2_routing arouting;
+				arouting.input = CX25843_RADIO;
+				em28xx_i2c_call_clients(dev,
+						VIDIOC_INT_S_AUDIO_ROUTING,
+						&arouting);
+			}
+
+		}
+	}
+
+	fh = kzalloc(sizeof(struct em28xx_fh), GFP_KERNEL);
+
+	if (!fh) {
+		printk(KERN_INFO"em28xx-video.c: Out of memory\n");
+		dev->em28xx_acquire(dev, type, 0);
+		return -ENOMEM;
+	}
+	fh->type = type;
+	fh->dev = dev;
+	filp->private_data = fh;
+
+	em28xx_videodbg("open minor = %d type = %s users = %d\n",
+				minor, v4l2_type_names[dev->type], dev->users);
+
+	if (!down_read_trylock(&em28xx_disconnect)) {
+		dev->em28xx_acquire(dev, type, 0);
+		return -ERESTARTSYS;
+	}
+
+	dev->users++;
+	if (dev->vbi_user == 1 && fh->type == EM28XX_VBI)
+		dev->vbi_bytesread = 0;
+
+	if ((fh->type == EM28XX_VIDEO || fh->type == EM28XX_VBI) &&
+			dev->users == 1) {
+
+		em28xx_set_alternate(dev);
+
+		dev->width = norm_maxw(dev);
+		dev->height = norm_maxh(dev);
+		dev->frame_size = dev->width * dev->height * 2;
+		dev->vbi_frame_size = 720 * 2 *
+			(dev->tvnorm->vbi_count_0 + dev->tvnorm->vbi_count_1);
+		dev->field_size = dev->frame_size >> 1;
+		dev->vbi_field_size = dev->vbi_frame_size >> 1;
+		dev->bytesperline = dev->width * 2;
+		dev->vbi_bytesperline = dev->width * 2;
+		dev->hscale = 0;
+		dev->vscale = 0;
+		dev->video_bytesread = 0;
+		dev->vbi_bytesread = 0;
+		dev->vbi_dropbytes = 0;
+
+		dev->vbi_frame_current = NULL;
+		dev->frame_current = NULL;
+
+		em28xx_capture_start(dev, 1);
+		em28xx_resolution_set(dev);
+
+		/* start the transfer */
+		errCode = em28xx_init_isoc(dev);
+
+		em28xx_empty_framequeues(dev, EM28XX_VBI);
+		em28xx_empty_framequeues(dev, EM28XX_VIDEO);
+		if (errCode) {
+			dev->users--;
+			goto err;
+		}
+		dev->video_io = IO_NONE;
+		dev->vbi_io = IO_NONE;
+		dev->stream = STREAM_OFF;
+		dev->num_frames = 0;
+		dev->vbi_num_frames = 0;
+		dev->state |= DEV_INITIALIZED;
+		dev->state &= ~DEV_MISCONFIGURED;
+	}
+	up_read(&em28xx_disconnect);
+	return 0;
+err:
+	up_read(&em28xx_disconnect);
+	dev->em28xx_acquire(dev, type, 0);
+	return errCode;
+}
+
+/*
+ * em28xx_realease_resources()
+ * unregisters the v4l2, i2c and usb devices
+ * called when the device gets disconected or at module unload
+*/
+static void em28xx_release_resources(struct em28xx *dev)
+{
+	mutex_lock(&em28xx_sysfs_lock);
+
+	list_del(&dev->devlist);
+	if (dev->dev_modes&EM28XX_VIDEO) {
+		em28xx_info("disconnecting %s\n", dev->vdev->name);
+		em28xx_info("V4L2 VIDEO devices /dev/video%d deregistered\n",
+				dev->vdev->num);
+		video_unregister_device(dev->vdev);
+		if (dev->dev_modes & EM28XX_VBI) {
+			em28xx_info("V4L2 VBI devices /dev/vbi%d "
+				"deregistered\n",
+					dev->vbi_dev->num);
+			video_unregister_device(dev->vbi_dev);
+		}
+	}
+	if (dev->dev_modes & EM28XX_RADIO)
+		video_unregister_device(dev->rdev);
+
+	em28xx_i2c_unregister(dev);
+	usb_put_dev(dev->udev);
+	mutex_unlock(&em28xx_sysfs_lock);
+
+		
+	/* Mark device as unused */
+	em28xx_devused &= ~(1<<dev->devno);
+
+}
+
+/*
+ * em28xx_v4l2_close()
+ * stops streaming and deallocates all resources allocated by the
+ * v4l2 calls and ioctls
+ */
+static int em28xx_v4l2_close(struct inode *inode, struct file *filp)
+{
+	int errCode;
+	struct em28xx_fh *fh;
+	struct em28xx *dev;
+	int ret = 0;
+
+	if (filp->private_data == NULL)
+		return 0;
+
+
+	fh = filp->private_data;
+	dev = fh->dev;
+	em28xx_videodbg("users = %d\n", dev->users);
+
+	if ((dev->vbi_user == 1 || fh->reader == 1) &&
+			fh->type == EM28XX_VBI) {
+		if (dev->vbi_stream == STREAM_ON) {
+			em28xx_videodbg("VIDIOC_STREAMOFF: interrupting "
+					"stream\n");
+			ret = em28xx_stream_interrupt(dev, EM28XX_VBI);
+			em28xx_empty_framequeues(dev, EM28XX_VBI);
+			dev->vbi_stream = STREAM_OFF;
+		}
+		dev->vbi_io = IO_NONE;
+		fh->reader = 0;
+		dev->vbi_reader = 0;
+	}
+	if ((dev->video_user == 1 || fh->reader == 1) &&
+			fh->type == EM28XX_VIDEO) {
+
+		if (dev->video_stream == STREAM_ON) {
+			em28xx_videodbg("VIDIOC_STREAMOFF: interrupting "
+					"stream\n");
+			ret = em28xx_stream_interrupt(dev, EM28XX_VIDEO);
+			em28xx_empty_framequeues(dev, EM28XX_VIDEO);
+			dev->video_stream = STREAM_OFF;
+		}
+		fh->reader = 0;
+		dev->video_reader = 0;
+		dev->video_io = IO_NONE;
+	}
+
+	dev->em28xx_acquire(dev, fh->type, 0);
+
+	/* assume that all handles are closed */
+	if (dev->users == 1) {
+		int gpio_arg;
+		dev->video_reader = 0;
+		dev->vbi_reader = 0;
+
+		em28xx_uninit_isoc(dev);
+		em28xx_release_buffers(dev, EM28XX_VIDEO);
+		em28xx_release_buffers(dev, EM28XX_VBI);
+
+		/* turn off led */
+		gpio_arg = EM28XX_REG_OFF;
+		em28xx_gpio_control(dev, EM28XX_LED1_ON,      &gpio_arg);
+		/* the device is already disconnect, free the remaining
+		   resources */
+		if (dev->state & DEV_DISCONNECTED) {
+			em28xx_release_resources(dev);
+			kfree(dev->alt_max_pkt_size);
+			tuner_chip_detach(dev->tuner);
+			kfree(dev);
+			kfree(fh);
+			return 0;
+		}
+
+		/* set alternate 0 */
+		dev->alt = 0;
+		em28xx_videodbg("setting alternate 0\n");
+		if (dev->adev && dev->adev->users == 0) {
+			dev->alt = 0;
+			em28xx_videodbg("setting alternate 0\n");
+			errCode = usb_set_interface(dev->udev, dev->usb_interface, 0);
+			if (errCode < 0) {
+				em28xx_errdev("cannot change alternate "
+					"number to 0 (error = %i)\n",
+						errCode);
+			}
+		}
+	}
+	kfree(fh);
+	dev->users--;
+	wake_up_interruptible_nr(&dev->open, 1);
+	return ret;
+}
+
+/*
+ * em28xx_v4l2_read()
+ * will allocate buffers when called for the first time
+ */
+static ssize_t
+em28xx_v4l2_read(struct file *filp, char __user *buf, size_t count,
+		 loff_t *f_pos)
+{
+	struct em28xx_frame_t *f, *i;
+	unsigned long lock_flags;
+	int ret = 0;
+	struct em28xx_fh *fh = filp->private_data;
+	struct em28xx *dev = fh->dev;
+
+	/* TODO: either add support for sliced VBI */
+	if (fh->type == V4L2_BUF_TYPE_SLICED_VBI_CAPTURE) {
+		em28xx_videodbg("V4L2_BUF_TYPE_SLICED_VBI_CAPTURE is set\n");
+		if (copy_to_user(buf, "", 1))
+			return -EFAULT;
+		return 1;
+	}
+
+	if (dev->state & DEV_DISCONNECTED) {
+		em28xx_videodbg("device not present\n");
+		return -ENODEV;
+	}
+
+	if (dev->state & DEV_MISCONFIGURED) {
+		em28xx_videodbg("device misconfigured; close and open it "
+				"again\n");
+		return -EIO;
+	}
+
+	if (fh->type == EM28XX_VIDEO && dev->video_reader > 0 &&
+			fh->reader == 0)
+		return -EBUSY;
+
+	if (fh->type == EM28XX_VBI && dev->vbi_reader > 0 && fh->reader == 0)
+		return -EBUSY;
+
+	if (fh->type == EM28XX_VIDEO && dev->video_io == IO_MMAP) {
+		em28xx_videodbg("Video IO method is set to mmap"
+				" the device again to choose the"
+				"read method\n");
+		return -EINVAL;
+	} else {
+		if (fh->type == EM28XX_VIDEO) {
+			dev->video_reader = 1;
+			fh->reader = 1;
+			dev->video_io = IO_READ;
+		}
+	}
+
+	if (fh->type == EM28XX_VBI && dev->vbi_io == IO_MMAP) {
+		em28xx_videodbg("VBI IO method is set to mmap\n");
+		return -EINVAL;
+	} else {
+		if (fh->type == EM28XX_VBI) {
+			dev->vbi_reader = 1;
+			fh->reader = 1;
+			dev->vbi_io = IO_READ;
+		}
+	}
+
+	if (fh->type == EM28XX_VIDEO && dev->video_stream == STREAM_OFF) {
+		if (!em28xx_request_buffers(dev,
+					EM28XX_NUM_READ_FRAMES,
+					EM28XX_VIDEO)) {
+			em28xx_errdev("read failed, not enough memory\n");
+			return -ENOMEM;
+		}
+
+		dev->video_stream = STREAM_ON;
+		em28xx_queue_unusedframes(dev, EM28XX_VIDEO);
+	}
+
+	if (fh->type == EM28XX_VBI && dev->vbi_stream == STREAM_OFF) {
+		if (!em28xx_request_buffers(dev, EM28XX_NUM_READ_FRAMES,
+					EM28XX_VBI)) {
+			em28xx_errdev("read failed not enough memory\n");
+			return -ENOMEM;
+		}
+
+		dev->vbi_stream = STREAM_ON;
+		em28xx_queue_unusedframes(dev, EM28XX_VBI);
+	}
+
+
+
+	if (!count)
+		return 0;
+
+	if (fh->type == EM28XX_VIDEO) {
+		if (list_empty(&dev->outqueue)) {
+			if (filp->f_flags & O_NONBLOCK)
+				return -EAGAIN;
+
+			ret = wait_event_interruptible
+				(dev->wait_frame,
+				 (!list_empty(&dev->outqueue)) ||
+				 (dev->state & DEV_DISCONNECTED));
+			if (ret)
+				return ret;
+
+			if (dev->state & DEV_DISCONNECTED)
+				return -ENODEV;
+
+			dev->video_bytesread = 0;
+		}
+
+		f = list_entry(dev->outqueue.prev, struct em28xx_frame_t,
+				frame);
+
+
+		em28xx_queue_unusedframes(dev, EM28XX_VIDEO);
+
+		if (count > f->buf.length)
+			count = f->buf.length;
+
+		if ((dev->video_bytesread+count) > dev->frame_size)
+			count = dev->frame_size - dev->video_bytesread;
+
+		if (copy_to_user(buf, f->bufmem + dev->video_bytesread, count))
+			return -EFAULT;
+
+		dev->video_bytesread += count;
+
+		if (dev->video_bytesread == dev->frame_size) {
+			spin_lock_irqsave(&dev->queue_lock, lock_flags);
+			list_for_each_entry(i, &dev->outqueue, frame)
+				i->state = F_UNUSED;
+			INIT_LIST_HEAD(&dev->outqueue);
+			spin_unlock_irqrestore(&dev->queue_lock, lock_flags);
+			em28xx_queue_unusedframes(dev, EM28XX_VIDEO);
+			dev->video_bytesread = 0;
+		}
+
+		*f_pos += count;
+	} else if (fh->type == EM28XX_VBI) {
+
+		if (list_empty(&dev->vbi_outqueue)) {
+			if (filp->f_flags & O_NONBLOCK)
+				return -EAGAIN;
+
+			if (dev->vbi_num_frames == 0) {
+				em28xx_request_buffers(dev,
+						EM28XX_NUM_READ_FRAMES,
+						EM28XX_VBI);
+				em28xx_queue_unusedframes(dev, EM28XX_VBI);
+			}
+
+			ret = wait_event_interruptible
+				(dev->wait_vbi_frame,
+				 (!list_empty(&dev->vbi_outqueue)) ||
+				 (dev->state & DEV_DISCONNECTED));
+
+			if (ret)
+				return ret;
+
+			if (dev->state & DEV_DISCONNECTED)
+				return -ENODEV;
+
+			dev->vbi_bytesread = 0;
+		}
+
+		f = list_entry(dev->vbi_outqueue.prev, struct em28xx_frame_t,
+				frame);
+		em28xx_queue_unusedframes(dev, EM28XX_VBI);
+
+		if (count > f->buf.length)
+			count = f->buf.length;
+
+		if ((dev->vbi_bytesread + count) > dev->vbi_frame_size)
+			count = dev->vbi_frame_size-dev->vbi_bytesread;
+
+		if (copy_to_user(buf, f->bufmem+dev->vbi_bytesread, count))
+			return -EFAULT;
+
+		dev->vbi_bytesread += count;
+		if (dev->vbi_bytesread == dev->vbi_frame_size) {
+			spin_lock_irqsave(&dev->vbi_queue_lock, lock_flags);
+			list_for_each_entry(i, &dev->vbi_outqueue, frame)
+				i->state = F_UNUSED;
+			INIT_LIST_HEAD(&dev->vbi_outqueue);
+			spin_unlock_irqrestore(&dev->vbi_queue_lock,
+					lock_flags);
+			em28xx_queue_unusedframes(dev, EM28XX_VBI);
+			dev->vbi_bytesread = 0;
+		}
+
+		*f_pos += count;
+	}
+
+	return count;
+}
+
+/*
+ * em28xx_v4l2_poll()
+ * will allocate buffers when called for the first time
+ */
+static unsigned int em28xx_v4l2_poll(struct file *filp, poll_table * wait)
+{
+	unsigned int mask = 0;
+	struct em28xx_fh *fh = filp->private_data;
+	struct em28xx *dev = fh->dev;
+
+	if (dev->state & DEV_DISCONNECTED)
+		em28xx_videodbg("device not present\n");
+	else if (dev->state & DEV_MISCONFIGURED)
+		em28xx_videodbg("device is misconfigured; close and open it "
+				"again\n");
+	else if (fh->type == EM28XX_VBI) {
+		if (fh->reader == 0 && dev->vbi_io != IO_NONE)
+			return -EINVAL;
+
+		if (dev->vbi_num_frames == 0 && dev->vbi_reader == 0) {
+			em28xx_empty_framequeues(dev, EM28XX_VBI);
+			if (!em28xx_request_buffers(dev,
+						EM28XX_NUM_READ_FRAMES,
+						EM28XX_VBI))
+				return -ENOMEM;
+		}
+
+		if (dev->vbi_io == IO_NONE && dev->vbi_reader == 0) {
+			em28xx_queue_unusedframes(dev, EM28XX_VBI);
+			dev->vbi_io = IO_READ;
+			dev->vbi_stream = STREAM_ON;
+			dev->vbi_reader = 1;
+			fh->reader = 1;
+		}
+
+		poll_wait(filp, &dev->wait_vbi_frame, wait);
+		if (!list_empty(&dev->vbi_outqueue))
+			mask |= POLLIN | POLLRDNORM;
+		return mask;
+	} else if (fh->type == EM28XX_VIDEO) {
+
+		if (dev->num_frames == 0 && dev->reader == 0) {
+			em28xx_empty_framequeues(dev, EM28XX_VIDEO);
+			if (!em28xx_request_buffers(dev, EM28XX_NUM_READ_FRAMES,
+						EM28XX_VIDEO))
+				return -ENOMEM;
+		}
+
+		if (dev->video_io == IO_NONE && dev->reader == 0) {
+			em28xx_queue_unusedframes(dev, EM28XX_VIDEO);
+			dev->video_io = IO_READ;
+			dev->video_stream = STREAM_ON;
+			dev->reader = 1;
+			fh->reader = 1;
+		}
+
+		poll_wait(filp, &dev->wait_frame, wait);
+		if (!list_empty(&dev->outqueue))
+			mask |= POLLIN | POLLRDNORM;
+		return mask;
+	}
+
+	return POLLERR;
+}
+
+/*
+ * em28xx_vm_open()
+ */
+static void em28xx_vm_open(struct vm_area_struct *vma)
+{
+	struct em28xx_frame_t *f = vma->vm_private_data;
+	f->vma_use_count++;
+}
+
+/*
+ * em28xx_vm_close()
+ */
+static void em28xx_vm_close(struct vm_area_struct *vma)
+{
+	/* NOTE: buffers are not freed here */
+	struct em28xx_frame_t *f = vma->vm_private_data;
+	f->vma_use_count--;
+}
+
+static struct vm_operations_struct em28xx_vm_ops = {
+	.open = em28xx_vm_open,
+	.close = em28xx_vm_close,
+};
+
+/*
+ * em28xx_v4l2_mmap()
+ */
+static int em28xx_v4l2_mmap(struct file *filp, struct vm_area_struct *vma)
+{
+	unsigned long size = vma->vm_end - vma->vm_start,
+	    start = vma->vm_start;
+	void *pos;
+	u32 i;
+
+	struct em28xx_fh *fh = filp->private_data;
+	struct em28xx *dev = fh->dev;
+
+	if (fh->type == EM28XX_VBI)
+		return em28xx_v4l2_vbi_mmap(filp, vma);
+
+	if (fh->type != EM28XX_VIDEO)
+		return -EINVAL;
+
+
+	if (dev->video_reader > 0 && fh->reader == 0)
+		return -EBUSY;
+	else {
+		dev->video_reader = 1;
+		fh->reader = 1;
+	}
+
+	if (dev->state & DEV_DISCONNECTED) {
+		em28xx_videodbg("mmap: device not present\n");
+		return -ENODEV;
+	}
+
+	if (dev->state & DEV_MISCONFIGURED) {
+		em28xx_videodbg("mmap: Device is misconfigured; close and "
+						"open it again\n");
+		return -EIO;
+	}
+
+	if (dev->video_io != IO_MMAP || !(vma->vm_flags & VM_WRITE) /*||
+	    size != PAGE_ALIGN(dev->frame[0].buf.length) */) {
+		return -EINVAL;
+	}
+
+	for (i = 0; i < dev->num_frames; i++)
+		if ((dev->frame[i].buf.m.offset >> PAGE_SHIFT) == vma->vm_pgoff)
+			break;
+
+	if (i == dev->num_frames) {
+		em28xx_videodbg("mmap: user supplied mapping address is out "
+				"of range\n");
+		return -EINVAL;
+	}
+
+	/* VM_IO is eventually going to replace PageReserved altogether */
+	vma->vm_flags |= VM_IO;
+	vma->vm_flags |= VM_RESERVED;	/* avoid to swap out this VMA */
+
+	pos = dev->frame[i].bufmem;
+	if (pos == 0) {
+		em28xx_videodbg("em28xx-video.c: exception pos is 0\n");
+		return -EINVAL;
+	}
+	if (dev->frame[0].buf.length == 0)
+
+		return -EINVAL;
+
+	if (dev->frame[i].buf.length == 0)
+		return -EINVAL;
+
+	while (size > 0) {	/* size is page-aligned */
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 15)
+		unsigned long page = vmalloc_to_pfn(pos);
+		if (remap_pfn_range(vma, start, page, PAGE_SIZE,
+				    vma->vm_page_prot)) {
+			em28xx_videodbg("mmap: rename page map failed\n");
+#else
+		if (vm_insert_page(vma, start, vmalloc_to_page(pos))) {
+			em28xx_videodbg("mmap: vm_insert_page failed\n");
+#endif
+			return -EAGAIN;
+		}
+		start += PAGE_SIZE;
+		pos += PAGE_SIZE;
+		size -= PAGE_SIZE;
+	}
+
+	vma->vm_ops = &em28xx_vm_ops;
+	vma->vm_private_data = &dev->frame[i];
+
+	em28xx_vm_open(vma);
+	return 0;
+}
+
+static int em28xx_v4l2_vbi_mmap(struct file *filp, struct vm_area_struct *vma)
+{
+	unsigned long size = vma->vm_end - vma->vm_start,
+	    start = vma->vm_start;
+	void *pos;
+	u32 i;
+
+	struct em28xx_fh *fh = filp->private_data;
+	struct em28xx *dev = fh->dev;
+
+	if (fh->type != EM28XX_VBI)
+		return -EINVAL;
+
+	if (dev->vbi_reader > 0 && fh->reader == 0) {
+		return -EBUSY;
+	} else {
+		dev->vbi_reader = 1;
+		fh->reader = 1;
+	}
+
+	if (dev->state & DEV_DISCONNECTED) {
+		em28xx_videodbg("mmap: device not present\n");
+		return -ENODEV;
+	}
+
+	if (dev->state & DEV_MISCONFIGURED) {
+		em28xx_videodbg("mmap: Device is misconfigured; close and "
+						"open it again\n");
+		return -EIO;
+	}
+
+	if (dev->vbi_io != IO_MMAP || !(vma->vm_flags & VM_WRITE) /*||
+	    size != PAGE_ALIGN(dev->frame[0].buf.length) */) {
+		return -EINVAL;
+	}
+
+	for (i = 0; i < dev->vbi_num_frames; i++) {
+		if ((dev->vbi_frame[i].buf.m.offset >> PAGE_SHIFT) ==
+				vma->vm_pgoff)
+			break;
+	}
+	if (i == dev->vbi_num_frames) {
+		em28xx_videodbg("mmap: user supplied mapping address is out "
+				"of range\n");
+		return -EINVAL;
+	}
+
+	/* VM_IO is eventually going to replace PageReserved altogether */
+	vma->vm_flags |= VM_IO;
+	vma->vm_flags |= VM_RESERVED;	/* avoid to swap out this VMA */
+
+	pos = dev->vbi_frame[i].bufmem;
+	if (pos == 0)
+		return -EINVAL;
+
+	if (dev->vbi_frame[0].buf.length == 0)
+		return -EINVAL;
+
+	if (dev->vbi_frame[i].buf.length == 0)
+		return -EINVAL;
+
+	while (size > 0) {	/* size is page-aligned */
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 15)
+		unsigned long page = vmalloc_to_pfn(pos);
+		if (remap_pfn_range(vma, start, page, PAGE_SIZE,
+				    vma->vm_page_prot)) {
+			em28xx_videodbg("mmap: rename page map failed\n");
+#else
+		if (vm_insert_page(vma, start, vmalloc_to_page(pos))) {
+			em28xx_videodbg("mmap: vm_insert_page failed\n");
+#endif
+			return -EAGAIN;
+		}
+		start += PAGE_SIZE;
+		pos += PAGE_SIZE;
+		size -= PAGE_SIZE;
+	}
+
+	vma->vm_ops = &em28xx_vm_ops;
+	vma->vm_private_data = &dev->vbi_frame[i];
+
+	em28xx_vm_open(vma);
+	return 0;
+}
+
+/*
+ * em28xx_get_ctrl()
+ * return the current saturation, brightness or contrast, mute state
+ */
+static int em28xx_get_ctrl(struct em28xx *dev, struct v4l2_control *ctrl)
+{
+	switch (ctrl->id) {
+	case V4L2_CID_AUDIO_MUTE:
+		ctrl->value = dev->mute;
+		return 0;
+	case V4L2_CID_AUDIO_VOLUME:
+		ctrl->value = dev->volume;
+		return 0;
+	default:
+		return -EINVAL;
+	}
+}
+
+/*FIXME: should be moved to saa711x */
+static int saa711x_get_ctrl(struct em28xx *dev, struct v4l2_control *ctrl)
+{
+	s32 tmp;
+	switch (ctrl->id) {
+	case V4L2_CID_BRIGHTNESS:
+		tmp = em28xx_brightness_get(dev);
+		if (tmp < 0)
+			return -EIO;
+		/* FIXME: cleaner way to extend sign? */
+		ctrl->value = (s32) ((s8) tmp);
+		return 0;
+	case V4L2_CID_CONTRAST:
+		ctrl->value = em28xx_contrast_get(dev);
+		if (ctrl->value < 0)
+			return -EIO;
+		return 0;
+	case V4L2_CID_SATURATION:
+		ctrl->value = em28xx_saturation_get(dev);
+		if (ctrl->value < 0)
+			return -EIO;
+		return 0;
+	case V4L2_CID_RED_BALANCE:
+		tmp = em28xx_v_balance_get(dev);
+		if (tmp < 0)
+			return -EIO;
+		/* FIXME: clenaer way to extend sign? */
+		ctrl->value = (s32) ((s8) tmp);
+		return 0;
+	case V4L2_CID_BLUE_BALANCE:
+		tmp = em28xx_u_balance_get(dev);
+		if (tmp < 0)
+			return -EIO;
+		/* FIXME: clenaer way to extend sign? */
+		ctrl->value = (s32) ((s8) tmp);
+		return 0;
+	case V4L2_CID_GAMMA:
+		ctrl->value = em28xx_gamma_get(dev);
+		if (ctrl->value < 0)
+			return -EIO;
+		return 0;
+	default:
+		return -EINVAL;
+	}
+}
+
+/*
+ * em28xx_set_ctrl()
+ * mute or set new saturation, brightness or contrast
+ */
+static int em28xx_set_ctrl(struct em28xx *dev, const struct v4l2_control *ctrl)
+{
+	switch (ctrl->id) {
+	case V4L2_CID_AUDIO_MUTE:
+		if (ctrl->value != dev->mute) {
+			dev->mute = ctrl->value;
+			em28xx_audio_usb_mute(dev, ctrl->value);
+			return em28xx_audio_analog_set(dev);
+		}
+		return 0;
+	case V4L2_CID_AUDIO_VOLUME:
+		dev->volume = ctrl->value;
+		return em28xx_audio_analog_set(dev);
+	default:
+		return -EINVAL;
+	}
+}
+
+/*FIXME: should be moved to saa711x */
+static int saa711x_set_ctrl(struct em28xx *dev, const struct v4l2_control *ctrl)
+{
+	switch (ctrl->id) {
+	case V4L2_CID_BRIGHTNESS:
+		return em28xx_brightness_set(dev, ctrl->value);
+	case V4L2_CID_CONTRAST:
+		return em28xx_contrast_set(dev, ctrl->value);
+	case V4L2_CID_SATURATION:
+		return em28xx_saturation_set(dev, ctrl->value);
+	case V4L2_CID_RED_BALANCE:
+		return em28xx_v_balance_set(dev, ctrl->value);
+	case V4L2_CID_BLUE_BALANCE:
+		return em28xx_u_balance_set(dev, ctrl->value);
+	case V4L2_CID_GAMMA:
+		return em28xx_gamma_set(dev, ctrl->value);
+	default:
+		return -EINVAL;
+	}
+}
+
+/*
+ * em28xx_stream_interrupt()
+ * stops streaming
+ */
+static int em28xx_stream_interrupt(struct em28xx *dev, int type)
+{
+	int ret = 0;
+
+	/* stop reading from the device */
+	switch (type) {
+	case EM28XX_VBI:
+		dev->vbi_stream = STREAM_INTERRUPT;
+		ret = wait_event_timeout(dev->vbi_wait_stream,
+				(dev->vbi_stream == STREAM_OFF) ||
+				(dev->state & DEV_DISCONNECTED),
+				EM28XX_URB_TIMEOUT);
+
+		if (dev->state & DEV_DISCONNECTED)
+			return -ENODEV;
+		else if (ret) {
+			dev->state |= DEV_MISCONFIGURED;
+			em28xx_videodbg("device is misconfigured; close and "
+					"open /dev/video%d again\n",
+					dev->vdev->num);
+		}
+		break;
+	case EM28XX_VIDEO:
+		dev->video_stream = STREAM_INTERRUPT;
+		ret = wait_event_timeout(dev->video_wait_stream,
+					 (dev->video_stream == STREAM_OFF) ||
+					 (dev->state & DEV_DISCONNECTED),
+					 EM28XX_URB_TIMEOUT);
+		if (dev->state & DEV_DISCONNECTED)
+			return -ENODEV;
+		else if (ret) {
+			dev->state |= DEV_MISCONFIGURED;
+			em28xx_videodbg("device is misconfigured; close and "
+				"open /dev/video%d again\n",
+					dev->vdev->num);
+			return ret;
+		}
+		break;
+	}
+	return 0;
+}
+
+static int em28xx_set_norm(struct em28xx *dev, int width, int height)
+{
+	unsigned int hscale, vscale;
+	unsigned int maxh, maxw;
+
+	maxw = norm_maxw(dev);
+	maxh = norm_maxh(dev);
+
+	/* width must even because of the YUYV format */
+	/* height must be even because of interlacing */
+	height &= 0xfffe;
+	width &= 0xfffe;
+
+	if (height < 32)
+		height = 32;
+	if (height > maxh)
+		height = maxh;
+	if (width < 48)
+		width = 48;
+	if (width > maxw)
+		width = maxw;
+
+	hscale = (((unsigned long)maxw) << 12) / width - 4096L;
+
+	if (hscale >= 0x4000)
+		hscale = 0x3fff;
+	width = (((unsigned long)maxw) << 12) / (hscale + 4096L);
+
+	vscale = (((unsigned long)maxh) << 12) / height - 4096L;
+
+	if (vscale >= 0x4000)
+		vscale = 0x3fff;
+
+	height = (((unsigned long)maxh) << 12) / (vscale + 4096L);
+
+	/* set new image size */
+	dev->width = width;
+	dev->height = height;
+	dev->frame_size = dev->width * dev->height * 2;
+	dev->field_size = dev->frame_size >> 1;
+	dev->bytesperline = dev->width * 2;
+	dev->hscale = hscale;
+	dev->vscale = vscale;
+
+	em28xx_resolution_set(dev);
+
+	return 0;
+}
+
+static int em28xx_get_fmt(struct em28xx *dev, struct v4l2_format *format)
+{
+	em28xx_videodbg("VIDIOC_G_FMT: type = %s\n",
+		(format->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) ?
+		"V4L2_BUF_TYPE_VIDEO_CAPTURE" :
+		(format->type == V4L2_BUF_TYPE_VBI_CAPTURE) ?
+		"V4L2_BUF_TYPE_VBI_CAPTURE" :
+		(format->type == V4L2_CAP_SLICED_VBI_CAPTURE) ?
+		"V4L2_BUF_TYPE_SLICED_VBI_CAPTURE " :
+		"not supported");
+
+	switch (format->type) {
+	case V4L2_BUF_TYPE_VIDEO_CAPTURE:
+	{
+		format->fmt.pix.width = dev->width;
+		format->fmt.pix.height = dev->height;
+		format->fmt.pix.pixelformat = dev->outfmt->fmt.pixelformat;
+	//	V4L2_PIX_FMT_YUYV;
+		format->fmt.pix.bytesperline = dev->bytesperline;
+		format->fmt.pix.sizeimage = dev->frame_size;
+		format->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
+		format->fmt.pix.field = V4L2_FIELD_INTERLACED;
+#if 0
+		format->fmt.pix.field = V4L2_FIELD_INTERLACED_TB;
+#endif
+
+		em28xx_videodbg("VIDIOC_G_FMT: %dx%d\n", dev->width,
+			dev->height);
+		break;
+	}
+
+	case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
+	{
+		format->fmt.sliced.service_set = 0;
+		em28xx_i2c_call_clients(dev, VIDIOC_G_FMT, format);
+		if (format->fmt.sliced.service_set == 0)
+			return -EINVAL;
+		break;
+	}
+	case V4L2_BUF_TYPE_VBI_CAPTURE:
+	{
+		format->type = V4L2_BUF_TYPE_VBI_CAPTURE;
+
+		switch (dev->tvnorm->id) {
+		case V4L2_STD_NTSC_M:
+			format->fmt.vbi.sampling_rate =
+				dev->tvnorm->vbi_sample_rate;
+			break;
+		case V4L2_STD_PAL:
+		default:
+			format->fmt.vbi.sampling_rate =
+				dev->tvnorm->vbi_sample_rate;
+		}
+
+		format->fmt.vbi.samples_per_line =
+			dev->tvnorm->vbi_samples_per_line;
+		format->fmt.vbi.sample_format = V4L2_PIX_FMT_GREY;
+		format->fmt.vbi.offset = dev->tvnorm->vbi_offset;
+		format->fmt.vbi.start[0] = dev->tvnorm->vbi_start_0;
+		format->fmt.vbi.count[0] = dev->tvnorm->vbi_count_0;
+		format->fmt.vbi.start[1] = dev->tvnorm->vbi_start_1;
+		format->fmt.vbi.count[1] = dev->tvnorm->vbi_count_1;
+		if (dev->vbi_interlaced)
+			format->fmt.vbi.flags = V4L2_VBI_INTERLACED;
+		else 
+			format->fmt.vbi.flags = 0;
+		return 0;
+	}
+	default:
+		return -EINVAL;
+	}
+	return 0;
+}
+
+static int em28xx_set_fmt(struct em28xx *dev, unsigned int cmd, struct v4l2_format *format)
+{
+	u32 i;
+	int ret = 0;
+	int width = format->fmt.pix.width;
+	int height = format->fmt.pix.height;
+	unsigned int hscale, vscale;
+	unsigned int maxh, maxw;
+
+	maxw = norm_maxw(dev);
+	maxh = norm_maxh(dev);
+
+	em28xx_videodbg("%s: type = %s\n",
+			cmd == VIDIOC_TRY_FMT ?
+			"VIDIOC_TRY_FMT" : "VIDIOC_S_FMT",
+			format->type == V4L2_BUF_TYPE_VIDEO_CAPTURE ?
+			"V4L2_BUF_TYPE_VIDEO_CAPTURE" :
+			format->type == V4L2_BUF_TYPE_VBI_CAPTURE ?
+			"V4L2_BUF_TYPE_VBI_CAPTURE " :
+			"not supported");
+
+	if (format->type == V4L2_BUF_TYPE_SLICED_VBI_CAPTURE) {
+		em28xx_i2c_call_clients(dev, VIDIOC_G_FMT, format);
+
+		if (format->fmt.sliced.service_set == 0)
+			return -EINVAL;
+
+		return 0;
+	}
+	if (format->type == V4L2_BUF_TYPE_VBI_CAPTURE &&
+			dev->dev_modes&EM28XX_VBI) {
+		em28xx_i2c_call_clients(dev, VIDIOC_S_FMT, format);
+		format->type = V4L2_BUF_TYPE_VBI_CAPTURE;
+		switch (dev->tvnorm->id) {
+		case V4L2_STD_NTSC_M:
+			format->fmt.vbi.sampling_rate =
+				dev->tvnorm->vbi_sample_rate;
+			break;
+		case V4L2_STD_PAL:
+		default:
+			format->fmt.vbi.sampling_rate =
+				dev->tvnorm->vbi_sample_rate;
+		}
+		format->fmt.vbi.samples_per_line =
+			dev->tvnorm->vbi_samples_per_line;
+		format->fmt.vbi.sample_format = V4L2_PIX_FMT_GREY;
+		format->fmt.vbi.offset = dev->tvnorm->vbi_offset;
+
+		if (dev->vbi_interlaced)
+			format->fmt.vbi.flags = V4L2_VBI_INTERLACED;
+		else 
+			format->fmt.vbi.flags = 0;
+
+		format->fmt.vbi.start[0] = dev->tvnorm->vbi_start_0;
+		format->fmt.vbi.start[1] = dev->tvnorm->vbi_start_1;
+		format->fmt.vbi.count[0] = dev->tvnorm->vbi_count_0;
+		format->fmt.vbi.count[1] = dev->tvnorm->vbi_count_1;
+		dev->vbi_frame_size = 720 * 2 *
+			(dev->tvnorm->vbi_count_0 + dev->tvnorm->vbi_count_1);
+		dev->vbi_field_size = dev->vbi_frame_size >> 1;
+
+		return 0;
+	}
+
+	if (format->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
+		return -EINVAL;
+
+	em28xx_videodbg("%s: requested %dx%d\n",
+		cmd == VIDIOC_TRY_FMT ?
+		"VIDIOC_TRY_FMT" : "VIDIOC_S_FMT",
+		format->fmt.pix.width, format->fmt.pix.height);
+
+	/* FIXME: Move some code away from here */
+	/* width must even because of the YUYV format */
+	/* height must be even because of interlacing */
+	height &= 0xfffe;
+	width &= 0xfffe;
+
+	if (height < 32)
+		height = 32;
+	if (height > maxh)
+		height = maxh;
+	if (width < 48)
+		width = 48;
+	if (width > maxw)
+		width = maxw;
+
+	if (dev->em_type == EM2800) {
+		/* the em2800 can only scale down to 50% */
+		if (height % (maxh / 2))
+			height = maxh;
+		if (width % (maxw / 2))
+			width = maxw;
+		/* according to empiatech support */
+		/* the MaxPacketSize is to small to support */
+		/* framesizes larger than 640x480 @ 30 fps */
+		/* or 640x576 @ 25 fps. As this would cut */
+		/* of a part of the image we prefer */
+		/* 360x576 or 360x480 for now */
+		if (width == maxw && height == maxh)
+			width /= 2;
+	}
+
+	hscale = (((unsigned long)maxw) << 12) / width - 4096L;
+	if (hscale >= 0x4000)
+		hscale = 0x3fff;
+
+	width = (((unsigned long)maxw) << 12) / (hscale + 4096L);
+
+	vscale = (((unsigned long)maxh) << 12) / height - 4096L;
+	if (vscale >= 0x4000)
+		vscale = 0x3fff;
+
+	height = (((unsigned long)maxh) << 12) / (vscale + 4096L);
+
+	format->fmt.pix.width = width;
+	format->fmt.pix.height = height;
+
+	dev->outfmt = &em28xx_out_fmt[0];
+
+	for (i = 0; i < ARRAY_SIZE(em28xx_out_fmt); i++) {
+		if (em28xx_out_fmt[i].fmt.pixelformat == format->fmt.pix.pixelformat) {
+			dev->outfmt = &em28xx_out_fmt[i];
+			break;
+		}
+	}
+		
+	format->fmt.pix.pixelformat = dev->outfmt->fmt.pixelformat;
+	format->fmt.pix.bytesperline = width * 2;
+	format->fmt.pix.sizeimage = width * 2 * height;
+	format->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
+	format->fmt.pix.field = V4L2_FIELD_INTERLACED;
+
+#if 0
+	/* available since what kernel version ? */
+	format->fmt.pix.field = V4L2_FIELD_INTERLACED_TB;
+#endif
+
+	em28xx_videodbg("%s: returned %dx%d (%d, %d)\n",
+		cmd == VIDIOC_TRY_FMT ?
+		"VIDIOC_TRY_FMT" :"VIDIOC_S_FMT",
+		format->fmt.pix.width, format->fmt.pix.height, hscale, vscale);
+
+	if (cmd == VIDIOC_TRY_FMT) {
+		return 0;
+	}
+
+	for (i = 0; i < dev->num_frames; i++)
+		if (dev->frame[i].vma_use_count) {
+			em28xx_videodbg("VIDIOC_S_FMT failed. "
+				"Unmap the buffers first.\n");
+			return -EINVAL;
+		}
+
+	/* stop io in case it is already in progress */
+
+	/* set new image size */
+	dev->width = width;
+	dev->height = height;
+	dev->frame_size = dev->width * dev->height * 2;
+	dev->field_size = dev->frame_size >> 1;
+	dev->bytesperline = dev->width * 2;
+	dev->hscale = hscale;
+	dev->vscale = vscale;
+	dev->vbi_frame_size = 720 * 2 *
+		(dev->tvnorm->vbi_count_0 + dev->tvnorm->vbi_count_1);
+	dev->vbi_field_size = dev->vbi_frame_size >> 1;
+
+	if (dev->video_stream == STREAM_ON) {
+		em28xx_videodbg("VIDIOC_SET_FMT: interupting video stream\n");
+		ret = em28xx_stream_interrupt(dev, EM28XX_VIDEO);
+		if (ret)
+			return ret;
+	}
+	if (dev->vbi_stream == STREAM_ON) {
+		em28xx_videodbg("VIDIOC_SET_FMT: interupting vbi stream\n");
+		ret = em28xx_stream_interrupt(dev, EM28XX_VBI);
+		if (ret)
+			return ret;
+	}
+
+	em28xx_release_buffers(dev, EM28XX_VIDEO);
+	em28xx_release_buffers(dev, EM28XX_VBI);
+	dev->video_io = IO_NONE;
+	dev->vbi_io = IO_NONE;
+	em28xx_uninit_isoc(dev);
+	em28xx_set_alternate(dev);
+	em28xx_capture_start(dev, 1);
+	em28xx_resolution_set(dev);
+	em28xx_init_isoc(dev);
+	return 0;
+}
+
+/*
+ * em28xx_v4l2_do_ioctl()
+ * This function is _not_ called directly, but from
+ * em28xx_v4l2_ioctl. Userspace
+ * copying is done already, arg is a kernel pointer.
+ */
+static int em28xx_do_ioctl(struct inode *inode, struct file *filp,
+			   struct em28xx *dev, unsigned int cmd, void *arg,
+			   v4l2_kioctl driver_ioctl)
+{
+	int ret;
+	struct em28xx_fh *fh = filp->private_data;
+
+	switch (cmd) {
+		/* ---------- tv norms ---------- */
+	case VIDIOC_ENUMSTD:
+	{
+		struct v4l2_standard *e = arg;
+		unsigned int i;
+
+		i = e->index;
+		if (i >= MAX_EM28XX_TVNORMS || dev->board->tvnorms[i].id == 0)
+			return -EINVAL;
+
+		ret = v4l2_video_std_construct(e,
+				dev->board->tvnorms[e->index].id,
+				dev->board->tvnorms[e->index].name);
+
+		e->index = i;
+		if (ret < 0)
+			return ret;
+		return 0;
+	}
+	case VIDIOC_G_STD:
+	{
+		v4l2_std_id *id = arg;
+		*id = dev->tvnorm->id;
+		return 0;
+	}
+	case VIDIOC_S_STD:
+	{
+		v4l2_std_id *id = arg;
+		unsigned int i;
+		int switch_std = 0;
+
+		for (i = 0; i < MAX_EM28XX_TVNORMS &&
+				dev->board->tvnorms[i].id; i++)
+			if (dev->board->tvnorms[i].id == *id)
+				break;
+
+		if (i == MAX_EM28XX_TVNORMS || dev->board->tvnorms[i].id == 0)
+			for (i = 0; i < MAX_EM28XX_TVNORMS &&
+					dev->board->tvnorms[i].id; i++)
+				if ((*id & dev->board->tvnorms[i].id) &&
+						dev->board->tvnorms[i].id != 0)
+					break;
+
+		if (i == MAX_EM28XX_TVNORMS || dev->board->tvnorms[i].id == 0)
+			return -EINVAL;
+
+		if (((dev->tvnorm->id & V4L2_STD_SECAM) &&
+			(dev->board->tvnorms[i].id & V4L2_STD_SECAM) == 0) ||
+		   (((dev->tvnorm->id & V4L2_STD_SECAM) == 0) &&
+		    (dev->board->tvnorms[i].id & V4L2_STD_SECAM))) {
+			switch_std = 1;
+		}
+
+		if (((dev->tvnorm->id & V4L2_STD_625_50) &&
+		    ((dev->board->tvnorms[i].id & V4L2_STD_625_50) == 0)) ||
+		      (((dev->tvnorm->id & V4L2_STD_625_50) == 0) &&
+		      (dev->board->tvnorms[i].id & V4L2_STD_625_50))) {
+			if (dev->vbi_stream == STREAM_ON ||
+			    dev->video_stream == STREAM_ON) {
+				printk(KERN_INFO"em28xx: don't switch the standard "
+						"while the device is capturing");
+				return -EBUSY;
+			}
+			dev->vbi_frame_size = 720 * 2 *
+				(dev->board->tvnorms[i].vbi_count_0 + dev->board->tvnorms[i].vbi_count_1);
+			dev->vbi_field_size = dev->vbi_frame_size >> 1;
+		}
+
+		dev->tvnorm = &dev->board->tvnorms[i];
+
+		if (dev->dev_modes & EM28XX_VBI)
+			em28xx_set_vbi(dev, 1);
+
+		em28xx_set_norm(dev, dev->width, dev->height);
+
+		if (dev->has_inttuner) {
+			switch (dev->tuner_type) {
+			case TUNER_XCEIVE_XC3028:
+			{
+				struct xc3028_init_cmd cmd;
+				int gpio_arg;
+				cmd.new_tv_mode_ptr = dev->tvnorm->tv_mode;
+				cmd.new_channel_map_ptr =
+					dev->tvnorm->channelmap;
+
+				if (switch_std) {
+					if (*id & V4L2_STD_SECAM)
+						gpio_arg = EM28XX_REG_ON;
+					else
+						gpio_arg = EM28XX_REG_OFF;
+
+					em28xx_gpio_control(dev,
+							EM28XX_XC3028_SECAM,
+							&gpio_arg);
+				}
+
+				if (dev->tuner && dev->tuner->tuner_cmd)
+					dev->tuner->tuner_cmd(dev->tuner,
+							XC3028_INIT_TUNER,
+							&cmd);
+				break;
+			}
+			case TUNER_XCEIVE_XC5000:
+			{
+				struct xc_std_conf cmd;
+				cmd.index = dev->tvnorm->index;
+				dev->tuner->tuner_cmd(dev->tuner,
+						XC5000_SET_MODE,
+						&cmd);
+				break;
+			}
+			default:
+				break;
+			}
+		}
+
+		em28xx_i2c_call_clients(dev, VIDIOC_S_STD,
+				&dev->tvnorm->id);
+
+		return 0;
+	}
+
+	/* ------ input switching ---------- */
+	case VIDIOC_ENUMINPUT:
+	{
+		struct v4l2_input *i = arg;
+		unsigned int n;
+		static const char *iname[] = {
+			[EM28XX_VMUX_COMPOSITE1] = "Composite1",
+			[EM28XX_VMUX_COMPOSITE2] = "Composite2",
+			[EM28XX_VMUX_COMPOSITE3] = "Composite3",
+			[EM28XX_VMUX_COMPOSITE4] = "Composite4",
+			[EM28XX_VMUX_SVIDEO] = "S-Video",
+			[EM28XX_VMUX_TELEVISION] = "Television",
+			[EM28XX_VMUX_CABLE] = "Cable TV",
+			[EM28XX_VMUX_DVB] = "DVB",
+			[EM28XX_VMUX_DEBUG] = "for debug only",
+		};
+
+		n = i->index;
+		if (n >= MAX_EM28XX_INPUT)
+			return -EINVAL;
+		if (0 == INPUT(n)->type)
+			return -EINVAL;
+		memset(i, 0, sizeof(*i));
+		i->index = n;
+		i->type = V4L2_INPUT_TYPE_CAMERA;
+		strcpy(i->name, iname[INPUT(n)->type]);
+		if ((EM28XX_VMUX_TELEVISION == INPUT(n)->type) ||
+			(EM28XX_VMUX_CABLE == INPUT(n)->type))
+			i->type = V4L2_INPUT_TYPE_TUNER;
+		for (n = 0; dev->board->tvnorms[n].id; n++)
+			i->std |= dev->board->tvnorms[n].id;
+		return 0;
+	}
+	case VIDIOC_G_INPUT:
+	{
+		int *i = arg;
+		*i = dev->ctl_input;
+
+		return 0;
+	}
+	case VIDIOC_S_INPUT:
+	{
+		int *index = arg;
+
+		if (*index >= MAX_EM28XX_INPUT)
+			return -EINVAL;
+
+		if (0 == INPUT(*index)->type)
+			return -EINVAL;
+
+		video_mux(dev, *index);
+
+		return 0;
+	}
+	case VIDIOC_G_AUDIO:
+	{
+		struct v4l2_audio *a = arg;
+		unsigned int index = a->index;
+
+		if (a->index > 1)
+			return -EINVAL;
+		memset(a, 0, sizeof(*a));
+		index = dev->ctl_ainput;
+
+		if (index == 0)
+			strcpy(a->name, "Television");
+		else
+			strcpy(a->name, "Line In");
+
+		a->capability = V4L2_AUDCAP_STEREO;
+		a->index = index;
+		return 0;
+	}
+	case VIDIOC_S_AUDIO:
+	{
+		struct v4l2_audio *a = arg;
+
+		if (a->index != dev->ctl_ainput)
+			return -EINVAL;
+
+		return 0;
+	}
+
+	/* --- controls ---------------------------------------------- */
+	case VIDIOC_QUERYCTRL:
+	{
+		struct v4l2_queryctrl *qc = arg;
+		int i, id = qc->id;
+		int retval;
+		if (fh->type == EM28XX_RADIO)
+			return -EINVAL;
+
+		memset(qc, 0, sizeof(*qc));
+		qc->id = id;
+
+		if (!dev->has_msp34xx) {
+			for (i = 0; i < ARRAY_SIZE(em28xx_qctrl); i++) {
+				if (qc->id && qc->id == em28xx_qctrl[i].id) {
+					memcpy(qc, &(em28xx_qctrl[i]),
+					sizeof(*qc));
+					return 0;
+				}
+			}
+		}
+		if (dev->em28xx_qctrl) {
+			retval = dev->em28xx_qctrl(arg);
+			if (retval == 0)
+				return 0;
+		}
+
+		em28xx_i2c_call_clients(dev, cmd, qc);
+
+		if (qc->type)
+			return 0;
+		else
+			return -EINVAL;
+		break;
+	}
+	case VIDIOC_G_CTRL:
+	{
+		struct v4l2_control *ctrl = arg;
+		int retval = -EINVAL;
+		if (fh->type == EM28XX_RADIO)
+			return -EINVAL;
+
+		if (!dev->has_msp34xx)
+			retval = em28xx_get_ctrl(dev, ctrl);
+		if (retval == -EINVAL) {
+			if (dev->decoder == EM28XX_TVP5150) {
+				em28xx_i2c_call_clients(dev, cmd, arg);
+				return 0;
+			}
+
+			return saa711x_get_ctrl(dev, ctrl);
+		} else if (dev->em28xx_gctrl)
+			return dev->em28xx_ctrl(dev, arg);
+		else
+			return retval;
+	}
+	case VIDIOC_S_CTRL:
+	{
+		struct v4l2_control *ctrl = arg;
+		u8 i;
+		if (fh->type == EM28XX_RADIO)
+			return -EINVAL;
+
+		if (!dev->has_msp34xx) {
+			for (i = 0; i < ARRAY_SIZE(em28xx_qctrl); i++) {
+				if (ctrl->id == em28xx_qctrl[i].id) {
+					if (ctrl->value <
+					em28xx_qctrl[i].minimum
+					|| ctrl->value >
+					em28xx_qctrl[i].maximum)
+						return -ERANGE;
+					return em28xx_set_ctrl(dev, ctrl);
+				}
+			}
+		}
+
+		if (dev->decoder == EM28XX_TVP5150) {
+			em28xx_i2c_call_clients(dev, cmd, arg);
+			return 0;
+		} else if (!dev->has_msp34xx) {
+			for (i = 0; i < ARRAY_SIZE(em28xx_qctrl); i++) {
+				if (ctrl->id == em28xx_qctrl[i].id) {
+					if (ctrl->value <
+					em28xx_qctrl[i].minimum
+					|| ctrl->value >
+					em28xx_qctrl[i].maximum)
+						return -ERANGE;
+					return em28xx_set_ctrl(dev, ctrl);
+				}
+			}
+			for (i = 0; i < ARRAY_SIZE(saa711x_qctrl); i++) {
+				if (ctrl->id == saa711x_qctrl[i].id) {
+					if (ctrl->value <
+					saa711x_qctrl[i].minimum
+					|| ctrl->value >
+					saa711x_qctrl[i].maximum)
+						return -ERANGE;
+					return saa711x_set_ctrl(dev, ctrl);
+				}
+			}
+		}
+
+		return -EINVAL;
+	}
+	/* --- tuner ioctls ------------------------------------------ */
+	case VIDIOC_G_TUNER:
+	{
+		struct v4l2_tuner *t = arg;
+		static unsigned int tv_range[2] = { 44, 958 };
+		unsigned short int lock_status = 0;
+
+		if (0 != t->index)
+			return -EINVAL;
+
+		switch (fh->type) {
+		case EM28XX_RADIO:
+			t->type = V4L2_TUNER_RADIO;
+			/* em2882 + cx2584x + xc5000 uses the videodecoder
+			   for radio detection */
+			em28xx_i2c_call_clients(dev, cmd, t);
+			break;
+		case EM28XX_VBI:
+		case EM28XX_VIDEO:
+			memset(t, 0, sizeof(*t));
+			strcpy(t->name, "Tuner");
+			t->type = V4L2_TUNER_ANALOG_TV;
+			t->capability |= V4L2_TUNER_CAP_NORM;
+			t->rangelow = tv_range[0] * 16;
+			t->rangehigh = tv_range[1] * 16;
+
+			if (dev->tuner && dev->tuner->get_lock_status) {
+				dev->tuner->get_lock_status(dev->tuner, &lock_status);
+				if (lock_status == 1)
+					t->signal = 0xffff;
+			} else
+				em28xx_i2c_call_clients(dev, cmd, t);
+
+			em28xx_videodbg("VIDIO_G_TUNER: signal = %x, afc = %x\n", t->signal,
+					t->afc);
+		}
+		return 0;
+	}
+	case VIDIOC_S_TUNER:
+	{
+		struct v4l2_tuner *t = arg;
+
+		if (0 != t->index)
+			return -EINVAL;
+		/* there are only a very few devices with more than one tuner
+		   available, this can be updated to work correctly later */
+		return 0;
+	}
+	case VIDIOC_G_FREQUENCY:
+	{
+		struct v4l2_frequency *f = arg;
+
+		memset(f, 0, sizeof(*f));
+		switch (fh->type) {
+		case EM28XX_RADIO:
+			f->type = V4L2_TUNER_RADIO;
+			f->frequency = dev->rctl_freq;
+			break;
+		case EM28XX_VIDEO:
+		case EM28XX_VBI:
+			f->type = V4L2_TUNER_ANALOG_TV;
+			f->frequency = dev->vctl_freq;
+			break;
+		}
+		return 0;
+	}
+	case VIDIOC_S_FREQUENCY:
+	{
+		struct v4l2_frequency *f = arg;
+
+		if (0 != f->tuner)
+			return -EINVAL;
+
+		if ((fh->type == EM28XX_RADIO && f->type != V4L2_TUNER_RADIO) ||
+			(fh->type == EM28XX_VIDEO && f->type != V4L2_TUNER_ANALOG_TV))
+			return -EINVAL;
+
+		switch (fh->type) {
+		case EM28XX_RADIO:
+			dev->rctl_freq = f->frequency;
+			break;
+		case EM28XX_VIDEO:
+		case EM28XX_VBI:
+			dev->vctl_freq = f->frequency;
+			break;
+		}
+
+		if (dev->tuner) {
+			switch (fh->type) {
+			case EM28XX_VBI:
+			case EM28XX_VIDEO:
+				dev->tuner->set_frequency(dev->tuner, (unsigned long)f->frequency*1000/16*1000);
+				break;
+			case EM28XX_RADIO:
+				dev->tuner->set_frequency(dev->tuner, (unsigned long)f->frequency/16*1000);
+				break;
+			}
+		} else
+			em28xx_i2c_call_clients(dev, VIDIOC_S_FREQUENCY, f);
+
+		return 0;
+	}
+#if 0				/* ioctl is optional */
+	case VIDIOC_G_PARM:
+	{
+		struct v4l2_captureparm *parm = arg;
+		memset(parm, 0, sizeof(*parm));
+		return 0;
+	}
+#endif
+	case VIDIOC_CROPCAP:
+	{
+		struct v4l2_cropcap *cc = arg;
+
+		if (cc->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
+			return -EINVAL;
+		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;	/* 4:3 FIXME: remove magic numbers */
+		cc->pixelaspect.denominator = 59;
+		return 0;
+	}
+	case VIDIOC_STREAMON:
+	{
+		int *type = arg;
+		if (fh->type == EM28XX_VBI) {
+			dev->vbi_stream = STREAM_ON;
+			return 0;
+		}
+
+		if (*type != V4L2_BUF_TYPE_VIDEO_CAPTURE
+			|| dev->video_io != IO_MMAP)
+			return -EINVAL;
+#if 0
+		if (list_empty(&dev->inqueue))
+			return -EINVAL;
+#endif
+
+		dev->video_stream = STREAM_ON;
+
+		em28xx_videodbg("VIDIOC_STREAMON: starting stream\n");
+
+		return 0;
+
+	}
+	case VIDIOC_STREAMOFF:
+	{
+		int *type = arg;
+		int ret;
+
+		if (fh->type == EM28XX_VBI) {
+			dev->vbi_reader = 0;
+			fh->reader = 0;
+			if (dev->vbi_stream == STREAM_ON) {
+				em28xx_videodbg("VIDIOC_STREAMOFF: interrupting stream\n");
+				ret = em28xx_stream_interrupt(dev, EM28XX_VBI);
+				if (ret)
+					return ret;
+			}
+			em28xx_empty_framequeues(dev, EM28XX_VBI);
+			dev->vbi_stream = STREAM_OFF;
+			return 0;
+		}
+
+		if (*type != V4L2_BUF_TYPE_VIDEO_CAPTURE
+			|| dev->video_io != IO_MMAP)
+			return -EINVAL;
+
+		if (dev->video_stream == STREAM_ON) {
+			em28xx_videodbg("VIDIOC_STREAMOFF: interrupting stream\n");
+			ret = em28xx_stream_interrupt(dev, EM28XX_VIDEO);
+			if (ret)
+				return ret;
+		}
+		dev->video_reader = 0;
+		dev->video_stream = STREAM_OFF;
+		fh->reader = 0;
+		em28xx_empty_framequeues(dev, EM28XX_VIDEO);
+
+		return 0;
+	}
+	default:
+		return v4l_compat_translate_ioctl(inode, filp, cmd, arg,
+						  driver_ioctl);
+	}
+	return 0;
+}
+
+/*
+ * em28xx_v4l2_do_ioctl()
+ * This function is _not_ called directly, but from
+ * em28xx_v4l2_ioctl. Userspace
+ * copying is done already, arg is a kernel pointer.
+ */
+static int em28xx_video_do_ioctl(struct inode *inode, struct file *filp,
+				 unsigned int cmd, void *arg)
+{
+	struct em28xx_fh *fh = filp->private_data;
+	struct em28xx *dev = fh->dev;
+
+	if (!dev)
+		return -ENODEV;
+
+	if (video_debug > 1)
+		v4l_print_ioctl(dev->name, cmd);
+
+	switch (cmd) {
+
+		/* --- capabilities ------------------------------------------ */
+	case VIDIOC_QUERYCAP:
+		{
+		struct v4l2_capability *cap = arg;
+
+		memset(cap, 0, sizeof(*cap));
+		strlcpy(cap->driver, "em28xx", sizeof(cap->driver));
+		strlcpy(cap->card, em28xx_boards[dev->model].name,
+			sizeof(cap->card));
+		strlcpy(cap->bus_info, dev->udev->dev.bus_id,
+			sizeof(cap->bus_info));
+		cap->version = EM28XX_VERSION_CODE;
+		cap->capabilities =
+#if 0
+				V4L2_CAP_SLICED_VBI_CAPTURE |
+#endif
+				V4L2_CAP_VIDEO_CAPTURE |
+				V4L2_CAP_AUDIO |
+				V4L2_CAP_READWRITE | V4L2_CAP_STREAMING;
+		if (dev->has_tuner)
+			cap->capabilities |= V4L2_CAP_TUNER;
+		if (dev->dev_modes & EM28XX_RADIO)
+			cap->capabilities |= V4L2_CAP_TUNER;
+		if (dev->dev_modes & EM28XX_VBI)
+			cap->capabilities |= V4L2_CAP_VBI_CAPTURE;
+		return 0;
+	}
+	/* --- capture ioctls ---------------------------------------- */
+	case VIDIOC_ENUM_FMT:
+	{
+		struct v4l2_fmtdesc *fmtd = arg;
+		int index = fmtd->index;
+
+		if (fmtd->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
+			return -EINVAL;
+
+		if (index >= ARRAY_SIZE(em28xx_out_fmt))
+			return -EINVAL;
+
+		memset(fmtd, 0, sizeof(*fmtd));
+		fmtd->index = index;
+		fmtd->type = em28xx_out_fmt[index].fmt.type;
+		strcpy(fmtd->description, em28xx_out_fmt[index].fmt.description);
+		fmtd->pixelformat = em28xx_out_fmt[index].fmt.pixelformat;
+		return 0;
+	}
+	case VIDIOC_G_FMT:
+		return em28xx_get_fmt(dev, (struct v4l2_format *) arg);
+
+	case VIDIOC_TRY_FMT:
+	case VIDIOC_S_FMT:
+	{
+		struct v4l2_format *fmt = arg;
+		if ((dev->video_reader == 1 && fh->reader == 0) ||
+		   (dev->vbi_reader == 1 && fh->reader == 0)) {
+
+			/* this is something to struggle around however you need it
+			   mplayer tries to set 640x480 and ongoing formats till
+			   it hits 720x576 if requested, if the first try will fail
+			   the ongoing tries will also fail and mplayer will not
+			   work with the em28xx driver
+
+			   the enabled code is mplayer aware, commented out code
+			   would be a small workaround not perfect either but
+			   slightly better.
+			 */
+			if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
+				fmt->fmt.pix.height = dev->height;
+				fmt->fmt.pix.width = dev->width;
+				return 0;
+#if 0
+				if (dev->width == (fmt->fmt.pix.width & 0xfffe) &&
+						dev->height == (fmt->fmt.pix.height & 0xfffe)) {
+					fmt->fmt.pix.height &= 0xfffe;
+					fmt->fmt.pix.width &= 0xfffe;
+					printk(KERN_INFO"everything ok not changing anything and returning 0\n");
+					return 0;
+				}
+#endif
+			}
+			printk("em28xx-video.c: device is currently busy!\n");
+			return -EBUSY;
+		}
+		return em28xx_set_fmt(dev, cmd, (struct v4l2_format *)arg);
+	}
+
+	/* obsolete v4l1 implementation, but it's still used by some applications -
+	 * it should be implemented but we don't support it
+	 */
+
+	case VIDIOCGMBUF:
+	{
+		struct video_mbuf *mbuf = arg;
+		int i;
+
+		int gbuffers = EM28XX_NUM_READ_FRAMES;
+		int gbufsize = PAGE_ALIGN(dev->frame_size); /* max resolution of em28xx based devices */
+
+		if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
+			return -EINVAL;
+		}
+
+		if (dev->video_io != IO_NONE) {
+			em28xx_videodbg("method is set to read;"
+				" close and open the device again to"
+				" choose the mmap I/O method\n");
+			printk(KERN_INFO"VIDEO_IO is busy\n");
+			return -EBUSY;
+		}
+
+		memset(mbuf, 0, sizeof(*mbuf));
+		mbuf->frames = gbuffers;
+
+		mbuf->size = gbufsize * gbuffers;
+		for (i = 0; i < gbuffers; i++) {
+			mbuf->offsets[i] = i*gbufsize;
+		}
+
+		/* FIXME: setting resolution using the v4l1 PICT command */
+
+		em28xx_empty_framequeues(dev, EM28XX_VIDEO);
+		em28xx_release_buffers(dev, EM28XX_VIDEO);
+
+		if (!em28xx_request_buffers(dev, EM28XX_NUM_READ_FRAMES, EM28XX_VIDEO)) {
+			printk(KERN_INFO"em28xx-video.c: unable to map"
+					" buffers\n");
+			return -ENOMEM;
+		}
+
+		dev->video_stream = STREAM_ON;
+		em28xx_empty_framequeues(dev, EM28XX_VIDEO);
+		dev->frame_current = NULL;
+		dev->video_io = IO_MMAP;
+		return 0;
+	}
+	case VIDIOCMCAPTURE:
+	{
+		struct video_mmap *vm = arg;
+		unsigned long lock_flags;
+
+		if (vm->format != VIDEO_PALETTE_YUV422)
+			return -EINVAL;
+
+		if (dev->frame[vm->frame].state != F_UNUSED) {
+			return -EAGAIN;
+		}
+
+		dev->frame[vm->frame].state = F_QUEUED;
+
+		spin_lock_irqsave(&dev->queue_lock, lock_flags);
+		list_add_tail(&dev->frame[vm->frame].frame, &dev->inqueue);
+		spin_unlock_irqrestore(&dev->queue_lock, lock_flags);
+		return 0;
+	}
+	case VIDIOCSYNC:
+	{
+		/* int *frame = arg; FIXME - argument not used?*/
+		struct em28xx_frame_t *f;
+		unsigned long lock_flags;
+		int ret = 0;
+
+		if (list_empty(&dev->outqueue)) {
+			if (dev->video_stream == STREAM_OFF) {
+				return -EINVAL;
+			}
+			if (filp->f_flags & O_NONBLOCK) {
+				return -EAGAIN;
+			}
+			ret = wait_event_interruptible(
+					dev->wait_frame,
+					(!list_empty(&dev->outqueue)) ||
+					(dev->state&DEV_DISCONNECTED));
+			if (ret) {
+				return ret;
+			}
+			if (dev->state & DEV_DISCONNECTED) {
+				return -ENODEV;
+			}
+		}
+
+		spin_lock_irqsave(&dev->queue_lock, lock_flags);
+		f = list_entry(dev->outqueue.next, struct em28xx_frame_t, frame);
+		list_del(dev->outqueue.next);
+		spin_unlock_irqrestore(&dev->queue_lock, lock_flags);
+		f->state = F_UNUSED;
+		return 0;
+	}
+
+	/* end v4l1 compat code */
+
+	case VIDIOC_REQBUFS:
+	{
+		struct v4l2_requestbuffers *rb = arg;
+		u32 i;
+		int ret;
+
+		if (rb->type == V4L2_BUF_TYPE_VBI_CAPTURE &&
+				rb->memory == V4L2_MEMORY_MMAP) {
+			if (dev->vbi_reader == 1 && fh->reader == 0)
+				return -EBUSY;
+
+			if (dev->vbi_io == IO_READ) {
+				printk("method is set to read;"
+				       " close and open the device again to"
+				       " choose the mmap I/O method\n");
+				return -EBUSY;
+			}
+			em28xx_empty_framequeues(dev, EM28XX_VBI);
+
+			if (dev->vbi_stream == STREAM_ON) {
+				em28xx_videodbg("VIDIOC_REQBUFS: interrupting stream\n");
+				ret = em28xx_stream_interrupt(dev, EM28XX_VBI);
+				if (ret) {
+					printk(KERN_INFO"em28xx-video.c: VIDIOC_REQBUFS 4\n");
+					return ret;
+				}
+			}
+
+			em28xx_release_buffers(dev, EM28XX_VBI);
+
+			if (rb->count)
+				rb->count = em28xx_request_buffers(dev, rb->count, EM28XX_VBI);
+
+			dev->vbi_frame_current = NULL;
+
+			dev->vbi_stream = STREAM_ON;
+			em28xx_videodbg("VIDIOC_REQBUFS: setting io method to mmap: num bufs %i\n",
+					rb->count);
+
+			dev->vbi_io = rb->count ? IO_MMAP : IO_NONE;
+			fh->reader = 1;
+			dev->vbi_reader = 1;
+			return 0;
+		}
+
+		if (rb->type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
+			rb->memory != V4L2_MEMORY_MMAP) {
+			return -EINVAL;
+		}
+
+		if (dev->video_io == IO_READ) {
+			em28xx_videodbg("method is set to read;"
+				" close and open the device again to"
+				" choose the mmap I/O method\n");
+			printk(KERN_INFO"em28xx-video.c: VIDIOC_REQBUFS 2\n");
+			return -EBUSY;
+		}
+
+		for (i = 0; i < dev->num_frames; i++)
+			if (dev->frame[i].vma_use_count) {
+				em28xx_videodbg("VIDIOC_REQBUFS failed; previous buffers are still mapped\n");
+				printk(KERN_INFO"em28xx-video.c: VIDIOC_REQBUFS 3\n");
+				return -EINVAL;
+			}
+
+		if (dev->video_stream == STREAM_ON) {
+			em28xx_videodbg("VIDIOC_REQBUFS: interrupting stream\n");
+			ret = em28xx_stream_interrupt(dev, EM28XX_VIDEO);
+			if (ret) {
+				printk(KERN_INFO"em28xx-video.c: VIDIOC_REQBUFS 4\n");
+				return ret;
+			}
+		}
+
+		em28xx_empty_framequeues(dev, EM28XX_VIDEO);
+
+		em28xx_release_buffers(dev, EM28XX_VIDEO);
+		if (rb->count)
+			rb->count =
+				em28xx_request_buffers(dev, rb->count, EM28XX_VIDEO);
+
+		dev->frame_current = NULL;
+
+		dev->video_stream = STREAM_ON;
+		em28xx_videodbg("VIDIOC_REQBUFS: setting io method to mmap: num bufs %i\n",
+				rb->count);
+		dev->video_io = rb->count ? IO_MMAP : IO_NONE;
+		return 0;
+	}
+	case VIDIOC_QUERYBUF:
+	{
+		struct v4l2_buffer *b = arg;
+
+		if (b->type == V4L2_BUF_TYPE_VBI_CAPTURE &&
+				b->index < dev->vbi_num_frames &&
+				dev->vbi_io == IO_MMAP) {
+			memcpy(b, &dev->vbi_frame[b->index].buf, sizeof(*b));
+
+			if (dev->vbi_frame[b->index].vma_use_count)
+				b->flags |= V4L2_BUF_FLAG_MAPPED;
+
+			if (dev->frame[b->index].state == F_DONE)
+				b->flags |= V4L2_BUF_FLAG_DONE;
+			else if (dev->frame[b->index].state != F_UNUSED)
+				b->flags |= V4L2_BUF_FLAG_QUEUED;
+
+			return 0;
+		}
+
+		if (b->type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
+			b->index >= dev->num_frames || dev->video_io != IO_MMAP)
+			return -EINVAL;
+
+		memcpy(b, &dev->frame[b->index].buf, sizeof(*b));
+
+		if (dev->frame[b->index].vma_use_count)
+			b->flags |= V4L2_BUF_FLAG_MAPPED;
+
+		if (dev->frame[b->index].state == F_DONE)
+			b->flags |= V4L2_BUF_FLAG_DONE;
+		else if (dev->frame[b->index].state != F_UNUSED)
+			b->flags |= V4L2_BUF_FLAG_QUEUED;
+
+		return 0;
+	}
+	case VIDIOC_QBUF:
+	{
+		struct v4l2_buffer *b = arg;
+		unsigned long lock_flags;
+
+		if (b->type == V4L2_BUF_TYPE_VBI_CAPTURE &&
+				b->index < dev->vbi_num_frames &&
+				dev->vbi_io == IO_MMAP) {
+			if (dev->vbi_frame[b->index].state != F_UNUSED)
+				return -EAGAIN;
+
+			dev->vbi_frame[b->index].state = F_QUEUED;
+
+			spin_lock_irqsave(&dev->queue_lock, lock_flags);
+			list_add_tail(&dev->vbi_frame[b->index].frame,
+					&dev->vbi_inqueue);
+			spin_unlock_irqrestore(&dev->queue_lock, lock_flags);
+			return 0;
+		}
+
+		if (b->type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
+			b->index >= dev->num_frames || dev->video_io != IO_MMAP) {
+			return -EINVAL;
+		}
+
+		if (dev->frame[b->index].state != F_UNUSED)
+			return -EAGAIN;
+
+		dev->frame[b->index].state = F_QUEUED;
+
+		/* add frame to fifo */
+		spin_lock_irqsave(&dev->queue_lock, lock_flags);
+		list_add_tail(&dev->frame[b->index].frame,
+				&dev->inqueue);
+		spin_unlock_irqrestore(&dev->queue_lock, lock_flags);
+
+		return 0;
+	}
+	case VIDIOC_DQBUF:
+	{
+		struct v4l2_buffer *b = arg;
+		struct em28xx_frame_t *f;
+		unsigned long lock_flags;
+		int ret = 0;
+
+		if (b->type == V4L2_BUF_TYPE_VBI_CAPTURE &&
+				b->index < dev->vbi_num_frames &&
+				dev->vbi_io == IO_MMAP) {
+			if (list_empty(&dev->vbi_outqueue)) {
+				if (dev->vbi_stream == STREAM_OFF)
+					return -EINVAL;
+				if (filp->f_flags & O_NONBLOCK)
+					return -EAGAIN;
+				ret = wait_event_interruptible(dev->wait_vbi_frame, (!list_empty(&dev->vbi_outqueue)) ||
+						(dev->state & DEV_DISCONNECTED));
+
+				if (ret)
+					return ret;
+
+				if (dev->state & DEV_DISCONNECTED)
+					return -ENODEV;
+			}
+
+			spin_lock_irqsave(&dev->queue_lock, lock_flags);
+			f = list_entry(dev->vbi_outqueue.next,
+					struct em28xx_frame_t, frame);
+			list_del(dev->vbi_outqueue.next);
+			spin_unlock_irqrestore(&dev->queue_lock, lock_flags);
+
+			f->state = F_UNUSED;
+			memcpy(b, &f->buf, sizeof(*b));
+
+			if (f->vma_use_count)
+				b->flags |= V4L2_BUF_FLAG_MAPPED;
+
+			return 0;
+		}
+
+		if (b->type != V4L2_BUF_TYPE_VIDEO_CAPTURE
+			|| dev->video_io != IO_MMAP)
+			return -EINVAL;
+
+		if (list_empty(&dev->outqueue)) {
+			if (dev->video_stream == STREAM_OFF)
+				return -EINVAL;
+			if (filp->f_flags & O_NONBLOCK)
+				return -EAGAIN;
+			ret = wait_event_interruptible
+				(dev->wait_frame,
+				(!list_empty(&dev->outqueue)) ||
+				(dev->state & DEV_DISCONNECTED));
+			if (ret)
+				return ret;
+			if (dev->state & DEV_DISCONNECTED)
+				return -ENODEV;
+		}
+
+		spin_lock_irqsave(&dev->queue_lock, lock_flags);
+		f = list_entry(dev->outqueue.next,
+				struct em28xx_frame_t, frame);
+		list_del(dev->outqueue.next);
+		spin_unlock_irqrestore(&dev->queue_lock, lock_flags);
+
+		f->state = F_UNUSED;
+		memcpy(b, &f->buf, sizeof(*b));
+
+		if (f->vma_use_count)
+			b->flags |= V4L2_BUF_FLAG_MAPPED;
+
+		return 0;
+	}
+	default:
+		return em28xx_do_ioctl(inode, filp, dev, cmd, arg,
+				       em28xx_video_do_ioctl);
+	}
+	return 0;
+}
+
+/*
+ * em28xx_v4l2_ioctl()
+ * handle v4l2 ioctl the main action happens in em28xx_v4l2_do_ioctl()
+ */
+static int em28xx_v4l2_ioctl(struct inode *inode, struct file *filp,
+			     unsigned int cmd, unsigned long arg)
+{
+	int ret = 0;
+	struct em28xx_fh *fh = filp->private_data;
+	struct em28xx *dev = fh->dev;
+
+
+	if (dev->state & DEV_DISCONNECTED) {
+		em28xx_errdev("v4l2 ioctl: device not present\n");
+		return -ENODEV;
+	}
+
+	if (dev->state & DEV_MISCONFIGURED) {
+		em28xx_errdev
+		    ("v4l2 ioctl: device is misconfigured; close and open it again\n");
+		return -EIO;
+	}
+
+	ret = video_usercopy(inode, filp, cmd, arg, em28xx_video_do_ioctl);
+
+	return ret;
+}
+
+static struct file_operations em28xx_v4l_fops = {
+	.owner = THIS_MODULE,
+	.open = em28xx_v4l2_open,
+	.release = em28xx_v4l2_close,
+	.ioctl = em28xx_v4l2_ioctl,
+	.read = em28xx_v4l2_read,
+	.poll = em28xx_v4l2_poll,
+	.mmap = em28xx_v4l2_mmap,
+	.llseek = no_llseek,
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 11)
+#if 0
+	.compat_ioctl   = v4l_compat_ioctl32,
+#endif
+#endif
+
+};
+
+int em28xx_aad_control(void *priv, unsigned int command, void *ptr) {
+    struct em28xx *dev = (struct em28xx*)priv;
+    int ret = 0;
+    switch(command) {
+    case EM28XX_ENABLE_AUDIO:
+        ret = dev->em28xx_write_reg_bits(dev, R0F_XCLK_REG, 0x80, 0x80);
+	if(dev->alt == 0 ) {
+		int errCode;
+		dev->alt = 7;
+		errCode = usb_set_interface(dev->udev, dev->usb_interface, 7);
+		printk("changing alternate number to 7\n");
+	}
+        break;
+    case EM28XX_DISABLE_AUDIO:
+        if(dev->alt != 0) {
+            int errCode;
+            dev->alt = 0;
+            errCode = usb_set_interface(dev->udev, dev->usb_interface, 0);
+            printk("changing alternate number to 0\n");
+        }
+        break;
+    default:
+        break;
+    }
+    return ret;
+}
+
+/******************************** usb interface *****************************************/
+
+/*
+ * em28xx_init_dev()
+ * allocates and inits the device structs, registers i2c bus and v4l device
+ */
+static int em28xx_init_dev(struct em28xx **devhandle, struct usb_device *udev,
+			   int minor, int model)
+{
+	struct em28xx *dev = *devhandle;
+	int retval = -ENOMEM;
+	int errCode, i;
+	unsigned int maxh, maxw;
+	int ret;
+	int gpio_arg;
+	struct list_head *pos = NULL;
+	struct em28xx_ops *ops = NULL;
+	u8 value;
+
+	dev->model = model;
+	dev->dvb_dev = NULL;
+	init_waitqueue_head(&dev->open);
+
+	mutex_init(&dev->input_lock);
+
+	dev->em_type = em28xx_boards[model].em_type;
+	dev->has_tuner = em28xx_boards[model].has_tuner;
+	dev->has_inttuner = em28xx_boards[model].has_inttuner;
+	dev->powersaving = em28xx_boards[model].powersaving;
+	dev->has_msp34xx = em28xx_boards[model].has_msp34xx;
+	dev->tda9887_conf = em28xx_boards[model].tda9887_conf;
+	dev->decoder = em28xx_boards[model].decoder;
+	dev->em28xx_ctrl = em28xx_boards[model].ctrl;
+	dev->em28xx_qctrl = em28xx_boards[model].qctrl;
+	dev->em28xx_gctrl = em28xx_boards[model].gctrl;
+	dev->dev_modes = em28xx_boards[model].dev_modes;
+	dev->board = &em28xx_boards[model];
+	dev->outfmt = &em28xx_out_fmt[0]; /* default to YUYV */
+
+#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17)
+	INIT_DELAYED_WORK(&dev->request_module_wk, request_module_async);
+#endif
+	dev->tvnorm = &em28xx_boards[model].tvnorms[0];
+	dev->dvbnorm = &em28xx_boards[model].dvbnorms[0];
+	dev->fmnorm = &em28xx_boards[model].fmnorms[0];
+	dev->qamnorm = &em28xx_boards[model].qamnorms[0];
+	dev->atscnorm = &em28xx_boards[model].atscnorms[0];
+
+	dev->vbi_interlaced = vbi_interlaced;
+
+	dev->em28xx_gpio_control = em28xx_gpio_control;
+	dev->manual_gpio = em28xx_boards[model].manual_gpio;
+        dev->em28xx_aad_control = em28xx_aad_control;
+
+	/* check if gpio config is stored onboard */
+	dev->qamnorm = &em28xx_boards[model].qamnorms[0];
+	dev->atscnorm = &em28xx_boards[model].atscnorms[0];
+
+	em28xx_write_regs_req(dev, 0x02, 0xa0, "\x23", 1);
+	ret = dev->em28xx_read_reg(dev, 0x05);
+
+	if (ret == 0) {
+		value = em28xx_read_reg_req(dev, 0x2, 0xa0);
+		/* keep it overridable */
+		if (dev->manual_gpio == 0)
+			dev->manual_gpio = (em28xx_read_reg_req(dev, 0x2, 0xa0)>>3)&1;
+	}
+
+
+	if (dev->udev == NULL)
+		dev->udev = udev;
+
+	if (dev->dev_modes == EM28XX_DVBT || dev->dev_modes == EM28XX_ATSC)
+		dev->device_mode = 1;
+	else
+		dev->device_mode = device_mode;
+
+	if (vbi_mode == 0)
+		dev->dev_modes &= ~EM28XX_VBI;
+
+	if (dev->dev_modes & EM28XX_VBI)
+		em28xx_set_vbi(dev, 1);
+
+	if (tuner >= 0)
+		dev->tuner_type = tuner;
+	else
+		dev->tuner_type = em28xx_boards[model].tuner_type;
+
+	/* Do board specific init and eeprom reading */
+	ret = em28xx_card_setup(dev);
+
+	if (ret)
+		return ret;
+
+	gpio_arg = EM28XX_REG_OFF;
+	em28xx_gpio_control(dev, EM28XX_LED1_ON,      &gpio_arg);
+	em28xx_gpio_control(dev, EM28XX_TS1_ON,       &gpio_arg);
+	em28xx_gpio_control(dev, EM28XX_ANALOG_ON,    &gpio_arg);
+	em28xx_gpio_control(dev, EM28XX_XC3028_SECAM, &gpio_arg);
+	em28xx_gpio_control(dev, EM28XX_TUNER2_ON,    &gpio_arg);
+	em28xx_gpio_control(dev, EM28XX_DECODER_SLEEP, &gpio_arg);
+	mdelay(100);
+	gpio_arg = EM28XX_REG_ON;
+	em28xx_gpio_control(dev, EM28XX_ANALOG_ON,    &gpio_arg);
+	em28xx_gpio_control(dev, EM28XX_TUNER1_ON,    &gpio_arg);
+	mdelay(100);
+
+	em28xx_gpio_control(dev, EM28XX_DECODER_RESET, NULL);
+
+#ifdef CONFIG_MODULES
+	/* request some modules */
+	if (dev->has_tuner && dev->has_inttuner == 0)
+		request_module("tuner");
+	if (dev->decoder == EM28XX_SAA7113 || dev->decoder == EM28XX_SAA7114)
+		request_module("saa7115");
+	if (dev->decoder == EM28XX_TVP5150)
+		request_module("tvp5150");
+	if (dev->tda9887_conf)
+		request_module("tda9887");
+	if (dev->decoder == EM28XX_CX25843)
+		request_module("em28xx-cx25843");
+#endif
+	spin_lock_init(&dev->queue_lock);
+	spin_lock_init(&dev->vbi_queue_lock);
+	init_waitqueue_head(&dev->wait_frame);
+	init_waitqueue_head(&dev->wait_vbi_frame);
+	init_waitqueue_head(&dev->video_wait_stream);
+	init_waitqueue_head(&dev->vbi_wait_stream);
+
+	if (ret < 0) {
+		printk("%s:%u:%s(): em28xx_card_setup() failed, ret = %i\n", __FILE__, __LINE__, __FUNCTION__, ret);
+		return ret;
+	}
+
+	em28xx_i2c_register(dev);
+
+	em28xx_config_i2c(dev);
+
+	if (dev->has_inttuner) {
+		switch (dev->tuner_type) {
+		case TUNER_XCEIVE_XC3028:
+		{
+			struct xc3028_config config;
+			memset(&config, 0x0, sizeof(struct xc3028_config));
+			config.new_tv_mode_ptr = em28xx_boards[model].tvnorms[0].tv_mode;
+			config.new_channel_map_ptr = em28xx_boards[model].tvnorms[0].channelmap;
+			config.callback = em28xx_gpio_control_translate;
+			config.dev = dev;
+			config.adap = &dev->i2c_adap;
+			config.i2c_address = 0xc2>>1;
+#if 0
+			em28xx_gpio_control(dev, EM28XX_XC3028_SECAM, arg);
+#endif
+			dev->tuner = tuner_chip_attach(xc3028_tuner_attach, &config);
+			break;
+		}
+		case TUNER_XCEIVE_XC5000:
+		{
+			struct xc5000_config config;
+			printk("trying to attach xc5000\n");
+			memset(&config, 0x0, sizeof(struct xc5000_config));
+			config.callback = em28xx_gpio_control_translate;
+			config.dev = dev;
+			config.adap = &dev->i2c_adap;
+			config.i2c_address = 0xc2>>1;
+			dev->tuner = tuner_chip_attach(xc5000_tuner_attach, &config, XC5000_firmware_SEQUENCE);
+			break;
+		}
+		}
+
+		/* configure the device */
+
+		if (dev->tuner == NULL)
+			printk(KERN_INFO"unable to attach tuner\n");
+		else
+			printk(KERN_INFO"successfully attached tuner\n");
+	}
+
+	dev->em28xx_acquire = em28xx_acquire;
+
+	dev->em28xx_acquire(dev, EM28XX_LOCK, 1);
+
+	list_add_tail(&dev->devlist, &em28xx_devlist);
+
+	if (dev->dev_modes&EM28XX_RADIO) {
+		dev->rdev = video_device_alloc();
+		memset(dev->rdev, 0x0, sizeof(struct video_device));
+
+		if (NULL == dev->rdev) {
+			list_del(&dev->devlist);
+			kfree(dev);
+			return -ENOMEM;
+		}
+
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 27)
+		dev->rdev->type = VID_TYPE_TUNER;
+		dev->rdev->dev = &dev->udev->dev;
+#else
+		dev->rdev->vfl_type = VID_TYPE_TUNER;
+		dev->rdev->parent = &dev->udev->dev;
+#endif
+		dev->rdev->fops = &em28xx_v4l_fops;
+		dev->rdev->minor = -1;
+		dev->rdev->release = video_device_release;
+		snprintf(dev->rdev->name, sizeof(dev->rdev->name), "%s#%d %s",
+				"em28xx", dev->devno, "radio");
+
+		if (video_register_device(dev->rdev, VFL_TYPE_RADIO,
+					radio_nr[dev->devno]) < 0) {
+			printk(KERN_INFO"unable to register radio device\n");
+			list_del(&dev->devlist);
+			kfree(dev);
+			return -ENODEV;
+		}
+		printk(KERN_INFO"radio device registered as /dev/radio%d\n",
+					dev->rdev->minor & 0x1f);
+	}
+
+	if (dev->dev_modes&EM28XX_VIDEO) {
+
+		dev->video_inputs = em28xx_boards[model].vchannels;
+
+		dev->tvnorm = &em28xx_boards[model].tvnorms[0];	/* set default norm */
+		for (i = 0; em28xx_boards[model].tvnorms[i].id; i++)
+			if (em28xx_boards[model].norm == em28xx_boards[model].tvnorms[i].id) {
+				dev->tvnorm = &em28xx_boards[model].tvnorms[i];	/* set default norm */
+				break;
+			}
+
+		em28xx_videodbg("tvnorm = %s\n", dev->tvnorm->name);
+
+		maxw = norm_maxw(dev);
+		maxh = norm_maxh(dev);
+
+		/* set default image size */
+		dev->width = maxw;
+		dev->height = maxh;
+		dev->interlaced = EM28XX_INTERLACED_DEFAULT;
+		dev->field_size = dev->width * dev->height;
+		dev->frame_size =
+			dev->interlaced ? dev->field_size << 1 : dev->field_size;
+		dev->bytesperline = dev->width * 2;
+		dev->hscale = 0;
+		dev->vscale = 0;
+		dev->ctl_input = 2;
+
+		if (dev->dev_modes&EM28XX_VIDEO) {
+			errCode = em28xx_config(dev); /* TODO: check for errorvalue */
+			if (errCode) {
+				em28xx_errdev("error configuring device\n");
+				em28xx_devused &= ~(1<<dev->devno);
+				list_del(&dev->devlist);
+				kfree(dev);
+				return -ENOMEM;
+			}
+		}
+
+#ifdef CONFIG_MODULES
+		/* FIXME: is this module really required? some devices just spit errors
+			  when using that modules */
+		if (dev->has_msp34xx)
+			request_module("msp3400");
+#endif
+
+		/* allocate and fill v4l2 device struct */
+		dev->vdev = video_device_alloc();
+		if (NULL == dev->vdev) {
+			em28xx_errdev("cannot allocate video_device.\n");
+			em28xx_devused &= ~(1<<dev->devno);
+			list_del(&dev->devlist);
+			kfree(dev);
+			return -ENOMEM;
+		}
+		memset(dev->vdev, 0x0, sizeof(struct video_device));
+
+
+		/* Fills CAPTURE device info */
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 27)
+		dev->vdev->type = VID_TYPE_CAPTURE;
+		if (dev->has_tuner)
+			dev->vdev->type |= VID_TYPE_TUNER;
+		dev->vdev->dev = &dev->udev->dev;
+#else
+		dev->vdev->vfl_type = VID_TYPE_CAPTURE;
+		if (dev->has_tuner)
+			dev->vdev->vfl_type |= VID_TYPE_TUNER;
+		dev->vdev->parent = &dev->udev->dev;
+#endif
+		dev->vdev->fops = &em28xx_v4l_fops;
+		dev->vdev->minor = -1;
+		dev->vdev->release = video_device_release;
+		snprintf(dev->vdev->name, sizeof(dev->vbi_dev->name), "%s#%d %s",
+				"em28xx", dev->devno, "video");
+
+		/* register v4l2 device */
+		if ((retval = video_register_device(dev->vdev, VFL_TYPE_GRABBER,
+						video_nr[dev->devno]))) {
+			em28xx_errdev("unable to register video device (error = %i).\n",
+					retval);
+			list_del(&dev->devlist);
+			video_device_release(dev->vdev);
+			em28xx_devused &= ~(1<<dev->devno);
+			kfree(dev);
+			return -ENODEV;
+		}
+		if (dev->dev_modes&EM28XX_VBI) {
+
+			dev->vbi_dev = video_device_alloc();
+			if (NULL == dev->vbi_dev) {
+				em28xx_errdev("cannot allocate video_device.\n");
+				em28xx_devused &= ~(1<<dev->devno);
+				list_del(&dev->devlist);
+				video_device_release(dev->vdev);
+				kfree(dev);
+				return -ENOMEM;
+			}
+			memset(dev->vbi_dev, 0x0, sizeof(struct video_device));
+
+			/* Fills VBI device info */
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 27)
+			dev->vbi_dev->type = VFL_TYPE_VBI;
+			dev->vbi_dev->dev = &dev->udev->dev;
+#else
+			dev->vbi_dev->vfl_type = VFL_TYPE_VBI;
+			dev->vbi_dev->parent = &dev->udev->dev;
+#endif
+			dev->vbi_dev->fops = &em28xx_v4l_fops;
+			dev->vbi_dev->minor = -1;
+			dev->vbi_dev->release = video_device_release;
+			snprintf(dev->vbi_dev->name, sizeof(dev->vbi_dev->name), "%s#%d %s",
+					"em28xx", dev->devno, "vbi");
+
+			if (video_register_device(dev->vbi_dev, VFL_TYPE_VBI,
+						vbi_nr[dev->devno]) < 0) {
+				printk(KERN_INFO"unable to register vbi device\n");
+				list_del(&dev->devlist);
+				video_device_release(dev->vbi_dev);
+				video_device_release(dev->vdev);
+				em28xx_devused &= ~(1<<dev->devno);
+				kfree(dev);
+				return -ENODEV;
+			}
+			em28xx_info("V4L2 VBI device registered as /dev/vbi%d\n",
+					dev->vbi_dev->num);
+		}
+		video_mux(dev, 0);
+		em28xx_info("V4L2 device registered as /dev/video%d\n",
+				dev->vdev->num);
+	}
+
+	/* when reattaching the device reinitialize the attached submodules */
+	mutex_lock(&em28xx_extension_devlist_lock);
+	if (!list_empty(&em28xx_extension_devlist)) {
+		list_for_each(pos, &em28xx_extension_devlist) {
+			ops = list_entry(pos, struct em28xx_ops, next);
+			if (ops->id & dev->dev_modes)
+				ops->init(dev);
+		}
+	}
+	mutex_unlock(&em28xx_extension_devlist_lock);
+
+#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17)
+	request_modules(dev);
+#else
+	dev->em28xx_acquire(dev, EM28XX_LOCK, 0);
+#endif
+	if (dev->board->ir_i2c == 0 &&
+			dev->board->ir_keytab &&
+			dev->board->ir_getkey) 
+		em2880_ir_attach(dev);
+
+	return 0;
+}
+
+/*
+ * em28xx_generic_probe()
+ * probes generic em28xx devices
+ * TODO: add em2800 based card detection (cinergy 200)
+ *
+ */
+
+struct drequest_t {
+	int brequest;
+	int index;
+	char *buffer;
+	int retval;
+	int blen;
+	int msecs;
+};
+
+static int em28xx_generic_probe(int *model, struct usb_device *udev,
+		struct em28xx *dev)
+{
+	int i;
+	char buffer = -1;
+	char *sendbuf;
+	int ret;
+	int rv = 0;
+	switch ((*model)) {
+		case EM2870_BOARD_TERRATEC_XS:
+		{
+			sendbuf = kmalloc(1, GFP_KERNEL);
+			memcpy(sendbuf, "\x00", 1);
+			ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x02,
+					USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+					0x0000, 0x00c0, sendbuf, 1, HZ);
+			kfree(sendbuf);
+			ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 0x02,
+					USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+					0x0000, 0x00c0, &buffer, 1, HZ);
+			if (buffer == 0x63) {
+				(*model) = EM2870_BOARD_TERRATEC_XS_MT2060;
+				printk(KERN_INFO"em28xx-video.c: New Terratec XS Detected\n");
+			}
+		}
+		return 0;
+		case EM2800_BOARD_LEADTEK_WINFAST_USBII:
+		{
+			/* seems like leadtek didn't change the product id for em2820/em2800 based
+			   devices */
+			ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 0x00,
+					USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+					0x0000, 0x000a, &buffer, 1, HZ);
+			switch (buffer) {
+			case 0x12:
+				printk("EM2820 based device detected\n");
+				(*model) = EM2820_BOARD_LEADTEK_WINFAST_USBII_DELUXE;
+				return 0;
+			}
+		}
+		case EM2800_BOARD_GENERIC:
+		{
+			u8 i2c_devs[128];
+			int nr_i2c_devs = 0;
+			printk(KERN_INFO"em28xx: generic EM2800 board trying to guess card by i2c addresses\n");
+			/* do a i2c scan */
+			for (i = 0; i < 128; i++) {
+				if (!em2800_i2c_check_for_device(dev, i<<1))
+					i2c_devs[nr_i2c_devs++] = i<<1;
+			}
+			/* something went wrong */
+			if (!nr_i2c_devs)
+				break;
+			/* now loop through all em2800 cards */
+			for (i = 0; i < em28xx_bcount; i++) {
+				/* if the card definition contains a list of i2c devices */
+				if (em28xx_boards[i].em_type == EM2800 &&
+						em28xx_boards[i].i2c_devs) {
+					int x;
+					/* compare the list to the scan results */
+					for (x = 0; x < nr_i2c_devs &&
+						em28xx_boards[i].i2c_devs[x];
+						x++) {
+						if (i2c_devs[x] !=
+						   em28xx_boards[i].i2c_devs[x])
+							break;
+					}
+					if (x == nr_i2c_devs  && !em28xx_boards[i].i2c_devs[x]) {
+						(*model) = i;
+						return 0;
+					}
+				}
+			}
+		}
+		break;
+		case EM2861_BOARD_GENERIC:
+		{
+			struct drequest_t yakumo[] = {
+				{0x03, 0xb8, "\x00", 0x00, 1, 0}
+				/* this is the only i2c port which is
+				   available */
+			};
+			for (i = 0, rv = 0; i < ARRAY_SIZE(yakumo); i++) {
+				sendbuf = kmalloc(yakumo[i].blen, GFP_KERNEL);
+				memcpy(sendbuf, yakumo[i].buffer, yakumo[i].blen);
+				ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), yakumo[i].brequest,
+						USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+						0x0000, yakumo[i].index, sendbuf, yakumo[i].blen, HZ);
+				kfree(sendbuf);
+				if (yakumo[i].msecs)
+					msleep(yakumo[i].msecs);
+				ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 0x00,
+						USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+						0x0000, 0x05, &buffer, 1, HZ);
+				if (buffer != yakumo[i].retval) {
+					rv = 1;
+					break;
+				}
+			}
+			if (rv == 0) {
+				(*model) = EM2861_BOARD_YAKUMO_MOVIE_MIXER;
+				return 0;
+			}
+
+		}
+		break;
+		case EM2820_BOARD_GENERIC:
+		{
+			struct drequest_t videology[] = { /* todo videology
+							     has a device
+							     identifier
+							     somewhere in the
+							     eeprom */
+				{0x03, 0xa2, "\x00", 0x00, 1, 0},
+				{0x03, 0xa0, "\x00", 0x00, 1, 0},
+				{0x03, 0x68, "\x00", 0x00, 1, 0},
+				{0x03, 0xa4, "\x00", 0x00, 1, 0},
+				{0x03, 0xa6, "\x00", 0x00, 1, 0},
+				{0x03, 0x66, "\x00", 0x10, 1, 0},
+				{0x03, 0x86, "\x00", 0x10, 1, 0},
+				{0x03, 0xc0, "\x00", 0x10, 1, 0},
+				{0x03, 0xc2, "\x00", 0x10, 1, 0},
+			};
+
+			struct drequest_t hercules_stv[] = {
+				{0x03, 0x42, "\x00", 0x10, 1, 0},
+				{0x03, 0x4a, "\x00", 0x00, 1, 0},
+				{0x03, 0x60, "\x00", 0x00, 1, 0},
+				{0x03, 0x66, "\x00", 0x10, 1, 0},
+				{0x03, 0x68, "\x00", 0x10, 1, 0},
+				{0x03, 0x86, "\x00", 0x10, 1, 0},
+				{0x03, 0xa0, "\x00", 0x00, 1, 0},
+				{0x03, 0xa2, "\x00", 0x10, 1, 0},
+				{0x03, 0xc0, "\x00", 0x10, 1, 0},
+				{0x03, 0xc2, "\x00", 0x10, 1, 0},
+				{0x03, 0xc6, "\x00", 0x00, 1, 0},
+			};
+
+			struct drequest_t gadmei_utv_310[] = {
+				{0x03, 0x42, "\x00", 0x10, 1, 0},
+				{0x03, 0x4a, "\x00", 0x00, 1, 0},
+				{0x03, 0x60, "\x00", 0x10, 1, 0},
+				{0x03, 0x66, "\x00", 0x10, 1, 0},
+				{0x03, 0x68, "\x00", 0x10, 1, 0},
+				{0x03, 0x86, "\x00", 0x10, 1, 0},
+				{0x03, 0xa0, "\x00", 0x10, 1, 0},
+				{0x03, 0xa2, "\x00", 0x10, 1, 0},
+				{0x03, 0xc0, "\x00", 0x10, 1, 0},
+				{0x03, 0xc2, "\x00", 0x10, 1, 0},
+			};
+
+			struct drequest_t msi_vox[] = {
+				{0x03, 0x42, "\x00", 0x00, 1, 0},
+				{0x03, 0x4a, "\x00", 0x10, 1, 0},
+				{0x03, 0x86, "\x00", 0x00, 1, 0},
+				{0x03, 0xa0, "\x00", 0x10, 1, 0},
+				{0x03, 0xa2, "\x00", 0x10, 1, 0},
+				{0x03, 0xc0, "\x00", 0x00, 1, 0},
+				{0x03, 0xc2, "\x00", 0x00, 1, 0},
+			};
+			struct drequest_t msi_vox_ntsc[] = {
+				{0x03, 0x42, "\x00", 0x00, 1, 0},
+/*					{0x03, 0x66, "\x00", 0x00, 1, 0}, */
+/*					{0x03, 0x68, "\x00", 0x00, 1, 0}, */
+				{0x03, 0xa0, "\x00", 0x10, 1, 0},
+				{0x03, 0xa2, "\x00", 0x10, 1, 0},
+				{0x03, 0xc0, "\x00", 0x00, 1, 0},
+				{0x03, 0xc2, "\x00", 0x00, 1, 0},
+			};
+
+
+			for (i = 0, rv = 0; i < ARRAY_SIZE(videology); i++) {
+				/* usb_control_msg() expects kmalloced memory, otherwise the host controller will die */
+				sendbuf = kmalloc(videology[i].blen, GFP_KERNEL);
+				memcpy(sendbuf, videology[i].buffer, videology[i].blen);
+				ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), videology[i].brequest,
+						USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+						0x0000, videology[i].index, sendbuf, videology[i].blen, HZ);
+				kfree(sendbuf);
+				if (videology[i].msecs)
+					msleep(videology[i].msecs);
+				ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 0x00,
+						USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+						0x0000, 0x05, &buffer, 1, HZ);
+				if (buffer != videology[i].retval) {
+					rv = 1;
+					break;
+				}
+			}
+			if (rv == 0) {
+				(*model) = EM2820_BOARD_VIDEOLOGY_20K14XUSB;
+				return 0;
+			}
+
+
+			for (i = 0, rv = 0; i < ARRAY_SIZE(msi_vox); i++) {
+				sendbuf = kmalloc(msi_vox[i].blen, GFP_KERNEL);
+				memcpy(sendbuf, msi_vox[i].buffer, msi_vox[i].blen);
+				ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), msi_vox[i].brequest,
+						USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+						0x0000, msi_vox[i].index, sendbuf, msi_vox[i].blen, HZ);
+				kfree(sendbuf);
+				if (msi_vox[i].msecs)
+					msleep(msi_vox[i].msecs);
+				ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 0x00,
+						USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+						0x0000, 0x05, &buffer, 1, HZ);
+				if (buffer != msi_vox[i].retval) {
+					rv = 1;
+					break;
+				}
+			}
+			if (rv == 0) {
+				(*model) = EM2820_BOARD_MSI_VOX_USB_2;
+				return 0;
+			}
+
+			for (i = 0, rv = 0; i < ARRAY_SIZE(hercules_stv); i++) {
+				sendbuf = kmalloc(hercules_stv[i].blen, GFP_KERNEL);
+				memcpy(sendbuf, hercules_stv[i].buffer, hercules_stv[i].blen);
+				ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), hercules_stv[i].brequest,
+						USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+						0x0000, hercules_stv[i].index, sendbuf, hercules_stv[i].blen, HZ);
+				kfree(sendbuf);
+				if (hercules_stv[i].msecs)
+					msleep(hercules_stv[i].msecs);
+				ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 0x00,
+						USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+						0x0000, 0x05, &buffer, 1, HZ);
+				if (buffer != hercules_stv[i].retval) {
+					rv = 1;
+					break;
+				}
+			}
+			if (rv == 0) {
+				(*model) = EM2820_BOARD_HERCULES_SMART_TV_USB2;
+				return 0;
+			}
+
+			for (i = 0, rv = 0; i < ARRAY_SIZE(gadmei_utv_310); i++) {
+				sendbuf = kmalloc(gadmei_utv_310[i].blen, GFP_KERNEL);
+				memcpy(sendbuf, gadmei_utv_310[i].buffer, gadmei_utv_310[i].blen);
+				ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), gadmei_utv_310[i].brequest,
+						USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+						0x0000, gadmei_utv_310[i].index, sendbuf, gadmei_utv_310[i].blen, HZ);
+				kfree(sendbuf);
+				if (gadmei_utv_310[i].msecs)
+					msleep(gadmei_utv_310[i].msecs);
+				ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 0x00,
+						USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+						0x0000, 0x05, &buffer, 1, HZ);
+				if (buffer != gadmei_utv_310[i].retval) {
+					rv = 1;
+					break;
+				}
+			}
+			if (rv == 0) {
+				(*model) = EM2820_BOARD_GADMEI_UTV310;
+				return 0;
+			}
+			for (i = 0, rv = 0; i < ARRAY_SIZE(msi_vox_ntsc); i++) {
+				sendbuf = kmalloc(msi_vox_ntsc[i].blen, GFP_KERNEL);
+				memcpy(sendbuf, msi_vox_ntsc[i].buffer, msi_vox_ntsc[i].blen);
+				ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), msi_vox_ntsc[i].brequest,
+						USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+						0x0000, msi_vox_ntsc[i].index, sendbuf, msi_vox_ntsc[i].blen, HZ);
+				kfree(sendbuf);
+				if (msi_vox_ntsc[i].msecs)
+					msleep(msi_vox_ntsc[i].msecs);
+				ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 0x00,
+						USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+						0x0000, 0x05, &buffer, 1, HZ);
+				if (buffer != msi_vox_ntsc[i].retval) {
+					rv = 1;
+					break;
+				}
+			}
+			if (rv == 0) {
+				(*model) = EM2820_BOARD_MSI_VOX_USB_2;
+				return 0;
+			}
+		}
+		break;
+		case EM2750_BOARD_GENERIC:
+		{
+			/* TODO */
+			(*model) = EM2750_BOARD_DLCW_130;
+			return 0;
+		}
+		break;
+		case EM2860_BOARD_GENERIC:
+		{
+			struct drequest_t gadmei_utv_330[] = {
+				{0x03, 0x42, "\x00", 0x10, 1, 0},
+				{0x03, 0x4a, "\x00", 0x00, 1, 0},
+				{0x03, 0x60, "\x00", 0x10, 1, 0},
+				{0x03, 0x66, "\x00", 0x10, 1, 0},
+				{0x03, 0x68, "\x00", 0x10, 1, 0},
+				{0x03, 0x86, "\x00", 0x10, 1, 0},
+				{0x03, 0xa0, "\x00", 0x00, 1, 0},
+				{0x03, 0xa2, "\x00", 0x10, 1, 0},
+				{0x03, 0xc0, "\x00", 0x00, 1, 0},
+				{0x03, 0xc2, "\x00", 0x10, 1, 0},
+			};
+			struct drequest_t netgmbh_cam[] = {
+#if 0
+				{0x02, 0x48, "\x00", 0x00, 1, 0},
+#endif
+				{0x03, 0x5a, "\x00", 0x00, 1, 0},
+			};
+
+			struct drequest_t typhoon_dvdmaker[] = {
+				{0x03, 0x4a, "\x00", 0x00, 1, 0},
+			};
+
+			for (i = 0, rv = 0; i < ARRAY_SIZE(gadmei_utv_330);
+					i++) {
+				sendbuf = kmalloc(gadmei_utv_330[i].blen, GFP_KERNEL);
+				memcpy(sendbuf, gadmei_utv_330[i].buffer, gadmei_utv_330[i].blen);
+				ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), gadmei_utv_330[i].brequest,
+						USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+						0x0000, gadmei_utv_330[i].index, sendbuf, gadmei_utv_330[i].blen, HZ);
+				kfree(sendbuf);
+				if (gadmei_utv_330[i].msecs)
+					msleep(gadmei_utv_330[i].msecs);
+				ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 0x00,
+						USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+						0x0000, 0x05, &buffer, 1, HZ);
+				if (buffer != gadmei_utv_330[i].retval) {
+					rv = 1;
+					break;
+				}
+			}
+			if (rv == 0) {
+				(*model) = EM2860_BOARD_GADMEI_UTV330;
+				return 0;
+			}
+			for (i = 0, rv = 0; i < ARRAY_SIZE(netgmbh_cam); i++) {
+				sendbuf = kmalloc(netgmbh_cam[i].blen, GFP_KERNEL);
+				memcpy(sendbuf, netgmbh_cam[i].buffer, netgmbh_cam[i].blen);
+				ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), netgmbh_cam[i].brequest,
+						USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+						0x0000, netgmbh_cam[i].index, sendbuf, netgmbh_cam[i].blen, HZ);
+				kfree(sendbuf);
+				if (netgmbh_cam[i].msecs)
+					msleep(netgmbh_cam[i].msecs);
+				ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 0x00,
+						USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+						0x0000, 0x05, &buffer, 1, HZ);
+				if (buffer != netgmbh_cam[i].retval) {
+					rv = 1;
+					break;
+				}
+			}
+			if (rv == 0) {
+				(*model) = EM2860_BOARD_NETGMBH_CAM;
+				return 0;
+			}
+
+
+			for (i = 0, rv = 0; i < ARRAY_SIZE(typhoon_dvdmaker); i++) {
+				sendbuf = kmalloc(typhoon_dvdmaker[i].blen, GFP_KERNEL);
+				memcpy(sendbuf, typhoon_dvdmaker[i].buffer, typhoon_dvdmaker[i].blen);
+				ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), typhoon_dvdmaker[i].brequest,
+						USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+						0x0000, typhoon_dvdmaker[i].index, sendbuf, typhoon_dvdmaker[i].blen, HZ);
+				kfree(sendbuf);
+				if (typhoon_dvdmaker[i].msecs)
+					msleep(typhoon_dvdmaker[i].msecs);
+				ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 0x00,
+						USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+						0x0000, 0x05, &buffer, 1, HZ);
+				if (buffer != typhoon_dvdmaker[i].retval) {
+					rv = 1;
+					break;
+				}
+			}
+			if (rv == 0) {
+				(*model) = EM2860_BOARD_TYPHOON_DVD_MAKER;
+				return 0;
+			}
+		}
+		break;
+		case EM2821_BOARD_GENERIC:
+			{
+				struct drequest_t usbgear[] = {
+					{0x03, 0xa2, "\x00", 0x10, 1, 0},
+					{0x03, 0xa0, "\x00", 0x10, 1, 0},
+					{0x03, 0x68, "\x00", 0x10, 1, 0},
+					{0x03, 0x4a, "\x00", 0x00, 1, 0},
+					{0x03, 0x66, "\x00", 0x10, 1, 0},
+					{0x03, 0x68, "\x00", 0x10, 1, 0},
+					{0x03, 0x86, "\x00", 0x10, 1, 0},
+					{0x03, 0xc0, "\x00", 0x10, 1, 0},
+					{0x03, 0xc2, "\x00", 0x10, 1, 0},
+				};
+				struct drequest_t siig_prolink[] = {
+					{0x03, 0x4a, "\x00", 0x00, 1, 0},
+					{0x03, 0x60, "\x00", 0x00, 1, 0},
+					{0x03, 0xa0, "\x00", 0x00, 1, 0},
+					{0x03, 0xc6, "\x00", 0x00, 1, 0},
+				};
+				struct drequest_t supercomp[] = {
+					{0x03, 0x4a, "\x00", 0x00, 1, 0},
+#if 0
+					{0x03, 0x60, "\x00", 0x00, 1, 0},
+#endif
+					{0x03, 0xc2, "\x00", 0x00, 1, 0},
+					{0x03, 0xc6, "\x00", 0x00, 1, 0},
+				};
+
+				for (i = 0, rv = 0; i < ARRAY_SIZE(usbgear); i++) {
+					sendbuf = kmalloc(usbgear[i].blen, GFP_KERNEL);
+					memcpy(sendbuf, usbgear[i].buffer, usbgear[i].blen);
+					ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), usbgear[i].brequest,
+							USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+							0x0000, usbgear[i].index, sendbuf, usbgear[i].blen, HZ);
+					kfree(sendbuf);
+					if (usbgear[i].msecs)
+						msleep(usbgear[i].msecs);
+					ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 0x00,
+							USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+							0x0000, 0x05, &buffer, 1, HZ);
+					if (buffer != usbgear[i].retval) {
+						rv = 1;
+						break;
+					}
+				}
+				if (rv == 0) {
+					(*model) = EM2821_BOARD_USBGEAR_VD204;
+					return 0;
+				}
+
+				for (i = 0, rv = 0; i < ARRAY_SIZE(siig_prolink); i++) {
+					sendbuf = kmalloc(siig_prolink[i].blen, GFP_KERNEL);
+					memcpy(sendbuf, siig_prolink[i].buffer, siig_prolink[i].blen);
+					ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), siig_prolink[i].brequest,
+							USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+							0x0000, siig_prolink[i].index, sendbuf, siig_prolink[i].blen, HZ);
+					kfree(sendbuf);
+					if (siig_prolink[i].msecs)
+						msleep(siig_prolink[i].msecs);
+					ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 0x00,
+							USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+							0x0000, 0x05, &buffer, 1, HZ);
+					if (buffer != siig_prolink[i].retval) {
+						rv = 1;
+						break;
+					}
+				}
+				if (rv == 0) {
+					(*model) = EM2821_BOARD_PROLINK_PLAYTV_USB2;
+					return 0;
+				}
+				for (i = 0, rv = 0; i < ARRAY_SIZE(supercomp); i++) {
+					sendbuf = kmalloc(supercomp[i].blen, GFP_KERNEL);
+					memcpy(sendbuf, supercomp[i].buffer, supercomp[i].blen);
+					ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), supercomp[i].brequest,
+							USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+							0x0000, supercomp[i].index, sendbuf, supercomp[i].blen, HZ);
+					kfree(sendbuf);
+					if (supercomp[i].msecs)
+						msleep(supercomp[i].msecs);
+					ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 0x00,
+							USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+							0x0000, 0x05, &buffer, 1, HZ);
+					if (buffer != supercomp[i].retval) {
+						rv = 1;
+						break;
+					}
+				}
+				if (rv == 0) {
+					(*model) = EM2821_BOARD_SUPERCOMP_USB_2;
+					return 0;
+				}
+			}
+			break;
+		case EM2870_BOARD_GENERIC:
+		{
+			struct drequest_t pinnacle_pctv[] = {
+				/* {0x03, 0xb8, "\x00", 0x00, 1, 0}, tvp5150 -- it's possible that this IC isn't reachable*/
+				{0x03, 0xa0, "\x00", 0x00, 1, 0}, /* eeprom */
+				{0x03, 0xc0, "\x00", 0x00, 1, 0}, /* mt2060 */
+			};
+			for (i = 0, rv = 0; i < ARRAY_SIZE(pinnacle_pctv);
+					i++) {
+				sendbuf = kmalloc(pinnacle_pctv[i].blen, GFP_KERNEL);
+				memcpy(sendbuf, pinnacle_pctv[i].buffer, pinnacle_pctv[i].blen);
+				ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), pinnacle_pctv[i].brequest,
+						USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+						0x0000, pinnacle_pctv[i].index, sendbuf, pinnacle_pctv[i].blen, HZ);
+				kfree(sendbuf);
+				if (pinnacle_pctv[i].msecs)
+					msleep(pinnacle_pctv[i].msecs);
+				ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 0x00,
+						USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+						0x0000, 0x05, &buffer, 1, HZ);
+				if (buffer != pinnacle_pctv[i].retval) {
+					rv = 1;
+					break;
+				}
+			}
+			if (rv == 0) {
+				(*model) = EM2870_BOARD_PINNACLE_PCTV_DVB;
+				return 0;
+			}
+		}
+		break;
+		/* no other card has been available yet with that IC,
+		   so we assume HVR_950 by default */
+		case EM2883_BOARD_GENERIC:
+		{
+			(*model) = EM2883_BOARD_EMPIA_HYBRID_ATSC;
+			return 0;
+		}
+		break;
+		case EM2881_BOARD_GENERIC:
+		{
+			struct drequest_t dnt_hybrid[] = {
+				{0x03, 0xa0, "\x15", 0x56, 1, 0},
+#if 0
+				{0x03, 0xc2, "\x00", 0x00, 1, 0},
+				{0x00, 0x04, "\x08", 0x00, 1, 20},
+				{0x00, 0x08, "\x6f", 0x00, 1, 20},
+				{0x00, 0x08, "\x7f", 0x00, 1, 20},
+				{0x03, 0xb8, "\x00", 0x00, 1, 0},
+				{0x00, 0x04, "\x0c", 0x00, 1, 20},
+				{0x00, 0x08, "\x6e", 0x00, 1, 20},
+				{0x00, 0x08, "\x7e", 0x00, 1, 20},
+				{0x03, 0x1e, "\x00", 0x00, 1, 0},
+#endif
+			};
+			struct drequest_t pinnacle_hybrid_pro[] = {
+				{0x03, 0xa0, "\x15", 0x57, 1, 0},
+#if 0
+				{0x03, 0xc2, "\x00", 0x00, 1, 0},
+				{0x00, 0x04, "\x08", 0x00, 1, 20},
+				{0x00, 0x08, "\x6f", 0x00, 1, 20},
+				{0x00, 0x08, "\x7f", 0x00, 1, 20},
+				{0x03, 0xb8, "\x00", 0x00, 1, 0},
+				{0x00, 0x04, "\x0c", 0x00, 1, 20},
+				{0x00, 0x08, "\x6e", 0x00, 1, 20},
+				{0x00, 0x08, "\x7e", 0x00, 1, 20},
+				{0x03, 0x1e, "\x00", 0x00, 1, 0},
+#endif
+			};
+			for (i = 0, rv = 0; i < ARRAY_SIZE(pinnacle_hybrid_pro); i++)
+			{
+				sendbuf = kmalloc(pinnacle_hybrid_pro[i].blen, GFP_KERNEL);
+				memcpy(sendbuf, pinnacle_hybrid_pro[i].buffer, pinnacle_hybrid_pro[i].blen);
+				ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), pinnacle_hybrid_pro[i].brequest,
+						USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+						0x0000, pinnacle_hybrid_pro[i].index, sendbuf, pinnacle_hybrid_pro[i].blen, HZ);
+				kfree(sendbuf);
+				if (pinnacle_hybrid_pro[i].msecs)
+					msleep(pinnacle_hybrid_pro[i].msecs);
+				ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 0x00,
+						USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+						0x0000, 0x05, &buffer, 1, HZ);
+				if (pinnacle_hybrid_pro[i].index == 0xa0)
+					ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 0x02,
+							USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+							0x0000, pinnacle_hybrid_pro[i].index, &buffer, 1, HZ);
+
+				if (buffer != pinnacle_hybrid_pro[i].retval) {
+					printk("FAILED: 0x%02x 0x%02x\n", pinnacle_hybrid_pro[i].index, buffer);
+					rv = 1;
+					break;
+				}
+			}
+			if (rv == 0) {
+				(*model) = EM2881_BOARD_PINNACLE_HYBRID_PRO;
+				return 0;
+			}
+			for (i = 0, rv = 0; i < ARRAY_SIZE(dnt_hybrid); i++)
+			{
+				sendbuf = kmalloc(dnt_hybrid[i].blen, GFP_KERNEL);
+				memcpy(sendbuf, dnt_hybrid[i].buffer, dnt_hybrid[i].blen);
+				ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), dnt_hybrid[i].brequest,
+						USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+						0x0000, dnt_hybrid[i].index, sendbuf, dnt_hybrid[i].blen, HZ);
+				kfree(sendbuf);
+				if (dnt_hybrid[i].msecs)
+					msleep(dnt_hybrid[i].msecs);
+				ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 0x00,
+						USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+						0x0000, 0x05, &buffer, 1, HZ);
+				if (dnt_hybrid[i].index == 0xa0)
+					ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 0x02,
+							USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+							0x0000, pinnacle_hybrid_pro[i].index, &buffer, 1, HZ);
+				if (buffer != dnt_hybrid[i].retval) {
+					rv = 1;
+					break;
+				}
+			}
+			if (rv == 0) {
+				(*model) = EM2881_BOARD_DNT_DA2_HYBRID;
+				return 0;
+			}
+			}
+			break;
+		default:
+			return 0;
+	}
+
+	em28xx_errdev("Your board has no eeprom inside it and thus can't\n"
+			"%s: be autodetected.  Please pass card = <n> insmod option to\n"
+			"%s: workaround that.  Redirect complaints to the vendor of\n"
+			"%s: the TV card. Generic type will be used.\n"
+			"%s: Best regards, \n"
+			"%s:         -- tux\n",
+			dev->name, dev->name, dev->name, dev->name, dev->name);
+	em28xx_errdev("%s: Here is a list of valid choices for the card = <n> insmod option:\n",
+			dev->name);
+	for (i = 0; i < em28xx_bcount; i++) {
+		em28xx_errdev("    card = %d -> %s\n", i,
+				em28xx_boards[i].name);
+	}
+	return 0;
+}
+
+/*
+ * em28xx_usb_probe()
+ * checks for supported devices
+ */
+
+static int em28xx_usb_probe(struct usb_interface *interface,
+			    const struct usb_device_id *id)
+{
+	const struct usb_endpoint_descriptor *endpoint;
+	struct usb_device *udev;
+	struct usb_interface *uif;
+	struct em28xx *dev = NULL;
+	int retval = -ENODEV;
+	int model, i, nr, ifnum, is_em2875 = 0;
+
+	udev = usb_get_dev(interface_to_usbdev(interface));
+
+	if (udev == NULL) {
+		printk("something's weird here udev returned 0!\n");
+		return -EINVAL;
+	}
+
+	ifnum = interface->altsetting[0].desc.bInterfaceNumber;
+
+	/* Check to see next free device and mark as used */
+	nr = find_first_zero_bit(&em28xx_devused, EM28XX_MAXBOARDS);
+	em28xx_devused |= 1<<nr;
+
+	/* Don't register audio interfaces */
+	if (interface->altsetting[0].desc.bInterfaceClass == USB_CLASS_AUDIO) {
+		printk(KERN_INFO "audio device (%04x:%04x): interface %i, class %i\n",
+				udev->descriptor.idVendor, udev->descriptor.idProduct,
+				ifnum,
+				interface->altsetting[0].desc.bInterfaceClass);
+
+		em28xx_devused &= ~(1<<nr);
+		return -ENODEV;
+	}
+
+	printk(KERN_INFO "em28xx: new video device (%04x:%04x): interface %i, class %i\n",
+			udev->descriptor.idVendor, udev->descriptor.idProduct,
+			ifnum,
+			interface->altsetting[0].desc.bInterfaceClass);
+
+
+	/* check if the device has the iso in endpoint at the correct place */
+
+        endpoint = &interface->cur_altsetting->endpoint[0].desc;
+	if ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) ==
+			USB_ENDPOINT_XFER_ISOC &&
+		(interface->altsetting[1].endpoint[0].desc.wMaxPacketSize == 940)) {
+		printk(KERN_INFO "em28xx: DTV Device detected\n");
+		is_em2875 = 1;
+	} else {
+		endpoint = &interface->cur_altsetting->endpoint[1].desc;
+		if ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) !=
+				USB_ENDPOINT_XFER_ISOC) {
+			em28xx_err("em28xx: probing error: endpoint is non-ISO endpoint!\n");
+			em28xx_devused &= ~(1<<nr);
+			return -ENODEV;
+		}
+		if ((endpoint->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_OUT) {
+			em28xx_err("em28xx: probing error: endpoint is ISO OUT endpoint!\n");
+			em28xx_devused &= ~(1<<nr);
+			return -ENODEV;
+		}
+	}
+
+	switch (udev->speed) {
+	case USB_SPEED_HIGH:
+		printk(KERN_INFO"em28xx: device is attached to a USB 2.0 bus\n");
+		break;
+	case USB_SPEED_FULL:
+		printk(KERN_INFO"em28xx: setting up device on a USB 1.1 bus\n");
+		/* passthrough */
+	default:
+		printk(KERN_INFO"em28xx: your device won't work properly when\n");
+		printk(KERN_INFO"em28xx: not attached to a USB 2.0 highspeed bus\n");
+		printk(KERN_INFO"em28xx: more information:\n");
+		printk(KERN_INFO"em28xx: http://mcentral.de/wiki/index.php5/Talk:Em2880\n";);
+	}
+
+	model = id->driver_info;
+
+	if (nr >= EM28XX_MAXBOARDS) {
+		printk(DRIVER_NAME ": Supports only %i em28xx boards.\n", EM28XX_MAXBOARDS);
+		em28xx_devused &= ~(1<<nr);
+		return -ENOMEM;
+	}
+
+	/* allocate memory for our device state and initialize it */
+	dev = kzalloc(sizeof(struct em28xx), GFP_KERNEL);
+	if (dev == NULL) {
+		em28xx_err(DRIVER_NAME ": out of memory!\n");
+		em28xx_devused &= ~(1<<nr);
+		return -ENOMEM;
+	}
+
+	snprintf(dev->name, 28, "em28xx #%d", nr);
+	dev->devno = nr;
+
+	dev->udev = udev;
+
+	dev->em28xx_write_regs = em28xx_write_regs;
+	dev->em28xx_read_reg = em28xx_read_reg;
+	dev->em28xx_read_reg_req_len = em28xx_read_reg_req_len;
+	dev->em28xx_write_regs_req = em28xx_write_regs_req;
+	dev->em28xx_read_reg_req = em28xx_read_reg_req;
+	dev->em28xx_write_reg_bits = em28xx_write_reg_bits;	
+	dev->usb_interface = ifnum;
+
+	/* compute alternate max packet sizes */
+	uif = udev->actconfig->interface[ifnum];
+
+	dev->num_alt = uif->num_altsetting;
+	dev->uif = uif;
+
+	em28xx_info("Alternate settings: %i\n", dev->num_alt);
+	dev->alt_max_pkt_size = kmalloc((dev->num_alt+1)*sizeof(int),
+			GFP_KERNEL);
+	if (dev->alt_max_pkt_size == NULL) {
+		em28xx_errdev("out of memory!\n");
+		em28xx_devused &= ~(1<<nr);
+		return -ENOMEM;
+	}
+
+	for (i = 0; i < dev->num_alt ; i++) {
+		u16 tmp = le16_to_cpu(uif->altsetting[i].endpoint[is_em2875?0:1].desc.
+							wMaxPacketSize);
+
+		dev->alt_max_pkt_size[i] =
+		    (tmp & 0x07ff) * (((tmp & 0x1800) >> 11) + 1);
+		em28xx_info("Alternate setting %i, max size= %i\n", i,
+							dev->alt_max_pkt_size[i]);
+	}
+
+	if ((card[nr] >= 0) && (card[nr] < em28xx_bcount))
+		model = card[nr];
+
+	em28xx_generic_probe(&model, udev, dev);
+
+	/* allocate device struct */
+	retval = em28xx_init_dev(&dev, udev, nr, model);
+	if (retval)
+		return retval;
+
+	em28xx_info("Found %s\n", em28xx_boards[model].name);
+
+	/* save our data pointer in this interface device */
+	usb_set_intfdata(interface, dev);
+	return 0;
+}
+
+/*
+ * em28xx_usb_disconnect()
+ * called when the device gets diconencted
+ * video device will be unregistered on v4l2_close in case it is still open
+ */
+static void em28xx_usb_disconnect(struct usb_interface *interface)
+{
+	struct em28xx *dev = usb_get_intfdata(interface);
+	struct list_head *pos;
+	struct em28xx_ops *ops = 0;
+
+	/* might be racy */
+	dev->state |= DEV_DISCONNECTED;
+
+	usb_set_intfdata(interface, NULL);
+
+	/* TODO: kernel versions <=2.6.21 */
+#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17)
+	if (delayed_work_pending(&dev->request_module_wk))
+		cancel_rearming_delayed_work(&dev->request_module_wk);
+#endif
+
+	if (!dev)
+		return;
+
+	down_write(&em28xx_disconnect);
+
+	em28xx_card_disconnect(dev);
+
+	mutex_lock(&em28xx_extension_devlist_lock);
+	if (!list_empty(&em28xx_extension_devlist)) {
+		list_for_each(pos, &em28xx_extension_devlist) {
+			ops = list_entry(pos, struct em28xx_ops, next);
+			ops->fini(dev);
+		}
+	}
+	mutex_unlock(&em28xx_extension_devlist_lock);
+
+	wake_up_interruptible_all(&dev->open);
+
+	if (dev->users) {
+		dev->state |= DEV_MISCONFIGURED;
+		em28xx_uninit_isoc(dev);
+		wake_up_interruptible(&dev->wait_frame);
+		wake_up_interruptible(&dev->video_wait_stream);
+		if (dev->dev_modes&EM28XX_VBI) {
+			wake_up_interruptible(&dev->wait_vbi_frame);
+			wake_up_interruptible(&dev->vbi_wait_stream);
+		}
+	} else {
+		em28xx_release_resources(dev);
+		kfree(dev->alt_max_pkt_size);
+		tuner_chip_detach(dev->tuner);
+		kfree(dev);
+	}
+
+	up_write(&em28xx_disconnect);
+}
+
+static struct usb_driver em28xx_usb_driver = {
+#if LINUX_VERSION_CODE <=  KERNEL_VERSION(2, 6, 15)
+	.owner = THIS_MODULE,
+#endif
+	.name = "em28xx",
+	.probe = em28xx_usb_probe,
+	.disconnect = em28xx_usb_disconnect,
+	.id_table = em28xx_id_table,
+};
+
+int em28xx_register_extension(struct em28xx_ops *ops)
+{
+	struct em28xx *dev = NULL;
+	struct list_head *list;
+
+	mutex_lock(&em28xx_extension_devlist_lock);
+	list_add_tail(&ops->next, &em28xx_extension_devlist);
+	
+	/* TODO: defer the work put the module request into a linked list
+	   lock the device when the corresponding node got closed and load
+	   the module:
+	 
+	    problem here to consider is if module autoloading is not enabled
+	    to make it more safe it would be good to lock the driver and unlock
+	    it when the corresponding extension got unlocked
+
+	    better ideas are welcome of course
+	 
+	 */
+
+	list_for_each(list, &em28xx_devlist) {
+		dev = list_entry(list, struct em28xx, devlist);
+		if (dev &&
+		    (dev->state & DEV_DISCONNECTED) == 0 &&
+		    (dev->state & DEV_MISCONFIGURED) == 0 &&
+		    dev->radio_user == 0 &&
+		    dev->video_user == 0 &&
+		    dev->vbi_user == 0 && 
+		    dev->fe_user == 0 &&
+		    dev->dev_modes & ops->id) {
+			dev->em28xx_acquire(dev, EM28XX_LOCK, 1);
+
+			ops->init(dev);
+			printk("Em28xx: Initialized (%s) extension\n",ops->name);
+
+			dev->em28xx_acquire(dev, EM28XX_LOCK, 0);
+		}
+	}
+
+	mutex_unlock(&em28xx_extension_devlist_lock);
+	return 0;
+}
+
+void em28xx_unregister_extension(struct em28xx_ops *ops)
+{
+	struct em28xx *dev = NULL;
+	struct list_head *list;
+
+	mutex_lock(&em28xx_extension_devlist_lock);
+	list_for_each(list, &em28xx_devlist) {
+		dev = list_entry(list, struct em28xx, devlist);
+		if (dev)
+			ops->fini(dev);
+	}
+	printk(KERN_INFO"Em28xx: Removed (%s) extension\n", ops->name);
+	list_del(&ops->next);
+	mutex_unlock(&em28xx_extension_devlist_lock);
+}
+
+
+static int __init em28xx_module_init(void)
+{
+	int result;
+
+	printk(KERN_INFO DRIVER_NAME " v4l2 driver version %d.%d.%d loaded\n",
+	       (EM28XX_VERSION_CODE >> 16) & 0xff,
+	       (EM28XX_VERSION_CODE >> 8) & 0xff, EM28XX_VERSION_CODE & 0xff);
+#ifdef SNAPSHOT
+	printk(KERN_INFO DRIVER_NAME " snapshot date %04d-%02d-%02d\n",
+	       SNAPSHOT / 10000, (SNAPSHOT / 100) % 100, SNAPSHOT % 100);
+#endif
+
+	em28xx_wq = create_singlethread_workqueue("em28xx-worker");
+	if (em28xx_wq == NULL)
+		return -ENOMEM;
+
+	/* register this driver with the USB subsystem */
+	result = usb_register(&em28xx_usb_driver);
+	if (result)
+		em28xx_err(DRIVER_NAME
+			   " usb_register failed. Error number %d.\n", result);
+
+	return result;
+}
+
+static void __exit em28xx_module_exit(void)
+{
+	/* deregister this driver with the USB subsystem */
+	usb_deregister(&em28xx_usb_driver);
+	destroy_workqueue(em28xx_wq);
+}
+
+module_init(em28xx_module_init);
+module_exit(em28xx_module_exit);
+EXPORT_SYMBOL(em28xx_register_extension);
+EXPORT_SYMBOL(em28xx_unregister_extension);
+
diff --git a/drivers/media/video/empia/em28xx-webcam.c b/drivers/media/video/empia/em28xx-webcam.c
new file mode 100644
index 0000000..228c04e
--- /dev/null
+++ b/drivers/media/video/empia/em28xx-webcam.c
@@ -0,0 +1,375 @@
+/*
+   em28xx-vy.c - driver for em28xx based webcams
+
+   Copyright (C) 2006 Markus Rechberger <mrechberger@xxxxxxxxx>
+
+   I got a few specs but none of them were clear enough to get anything
+   work. Finally I end up with writing usbreplay and stepping through
+   the sniffed logfiles...
+
+   all this is quite device specific (em2820 specific) so I decided to
+   not write an I2C client no other device will behave like this one
+
+   Thanks to Walter Grom from MT (www.mt.com) for implementing
+   the reversed specs
+
+   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., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/delay.h>
+#include <linux/i2c.h>
+#include <linux/usb.h>
+#include <linux/version.h>
+#include <media/v4l2-common.h>
+
+#include "em28xx.h"
+
+#define VY_FEATURE_REGISTER_1       0x02 /* Gain control en, gain control
+					    values */
+#define VY_FEATURE_REGISTER_2       0x04 /* WBM, Shutter, Mirror */
+#define VY_FEATURE_REGISTER_3       0x7c /* edge enhance */
+#define VY_FEATURE_REGISTER_4       0x7b /* edge enhance en */
+#define VY_FEATURE_REGISTER_5       0x7e /* edge enhance again? */
+#define VY_FEATURE_REGISTER_6       0x13 /* BLC ?? */
+#define VY_FEATURE_REGISTER_7	    0x1d /* gain control values */
+#define VY_FEATURE_REGISTER_8	    0x42 /* RGain */
+#define VY_FEATURE_REGISTER_9       0x43 /* BGain */
+
+#define V4L2_VY_WBM_MASK                 0x03
+#define V4L2_VY_SHUTTER_MASK             0x78
+#define V4L2_VY_MIRROR_MASK              0x80
+#define V4L2_VY_GAIN_CONTROL_EN_MASK     0x02
+#define V4L2_VY_GAIN_CONTROL_MASK        0xfe
+#define V4L2_VY_EDGE_ENHANCE_EN_MASK     0x03
+#define V4L2_VY_EDGE_ENHANCE_MASK        0x1f
+#define V4L2_VY_BLC_MASK                 0x00 /* FIXME */
+#define V4L2_VY_RGAIN_MASK               0xFF
+#define V4L2_VY_BGAIN_MASK               0xFF
+
+/* videology specific data */
+struct v4l2_queryctrl em28xx_vy_ctrl[] = {
+	{
+		.id = V4L2_VY_WBM,
+		.type = V4L2_CTRL_TYPE_INTEGER,
+		.name = "whiteblc",
+		.minimum = 0x0,
+		.maximum = 0x3,
+		.step = 0x1,
+		.default_value = 0x0,
+		.flags = 0,
+	}, {
+		.id = V4L2_VY_SHUTTER,
+		.type = V4L2_CTRL_TYPE_INTEGER,
+		.name = "shuttermode",
+		.minimum = 0x0,
+		.maximum = 0xf,
+		.step = 1,
+		.default_value = 0xf,
+		.flags = 0,
+	}, {
+		.id = V4L2_VY_MIRROR,
+		.type = V4L2_CTRL_TYPE_BOOLEAN,
+		.name = "mirror",
+		.minimum = 0x0,
+		.maximum = 0x1,
+		.step = 1,
+		.default_value = 0x0,
+		.flags = 0,
+	}, {
+		.id = V4L2_VY_GAIN_CONTROL_EN,
+		.type = V4L2_CTRL_TYPE_BOOLEAN,
+		.name = "gain_en",
+		.minimum = 0x0,
+		.maximum = 0x1,
+		.step = 1,
+		.default_value = 0x0,
+		.flags = 0,
+	}, {
+		.id = V4L2_VY_GAIN_CONTROL,
+		.type = V4L2_CTRL_TYPE_INTEGER,
+		.name = "gainctrl",
+		.minimum = 0x0,
+		.maximum = 0x7f,
+		.step = 1,
+		.default_value = 0x0,
+		.flags = 0,
+	}, {
+		.id = V4L2_VY_EDGE_ENHANCE_EN,
+		.type = V4L2_CTRL_TYPE_BOOLEAN,
+		.name = "edge_en",
+		.minimum = 0x0,
+		.maximum = 0x1,
+		.step = 1,
+		.default_value = 0x0,
+		.flags = 0,
+	}, {
+		.id = V4L2_VY_EDGE_ENHANCE,
+		.type = V4L2_CTRL_TYPE_INTEGER,
+		.name = "edgectrl",
+		.minimum = 0x0,
+		.maximum = 0x1f,
+		.step = 1,
+		.default_value = 0x0,
+		.flags = 0,
+	}, {
+		.id = V4L2_VY_BLC, /* wonder what this really is? */
+		.type = V4L2_CTRL_TYPE_INTEGER,
+		.name = "blc",
+		.minimum = 0x0,
+		.maximum = 0x40,
+		.step = 1,
+		.default_value = 0x0,
+		.flags = 0,
+	}, {
+		.id = V4L2_VY_RGAIN,
+		.type = V4L2_CTRL_TYPE_INTEGER,
+		.name = "rgain",
+		.minimum = 0x0,
+		.maximum = 0xff,
+		.step = 1,
+		.default_value = 0x3b,
+		.flags = 0,
+	}, {
+		.id = V4L2_VY_BGAIN,
+		.type = V4L2_CTRL_TYPE_INTEGER,
+		.name = "bgain",
+		.minimum = 0x0,
+		.maximum = 0xff,
+		.step = 1,
+		.default_value = 0x74,
+		.flags = 0,
+	}
+};
+
+
+static int em28xx_vy_readmap(struct em28xx *dev, u8 reg, int mask)
+{
+	int value;
+
+	em28xx_write_regs_req(dev, 0x02, 0xa2, &reg, 1);
+	value = em28xx_read_reg_req(dev, 0x2, 0xa2);
+	value &= mask;
+	return value;
+}
+
+
+/* --------------------------------------------- */
+int em28xx_vy_write(struct em28xx *dev, u8 reg_index, u8 value, u8 mask)
+{
+	u8 msg[2];
+	u8 val;
+	u8 oldval;
+	u8 state = 1; /* 1 == OK */
+
+	/* write index of desired register to adress 0xa2 */
+	em28xx_write_regs_req(dev, 0x02, 0xa2, &reg_index, 1);
+	/* read old register value from eeprom */
+	oldval = em28xx_read_reg_req(dev, 0x2, 0xa2);
+	/* write again index of desired register to adress 0xa2 */
+	em28xx_write_regs_req(dev, 0x02, 0xa2, &reg_index, 1);
+
+	/* calculate new register value */
+	msg[0] = reg_index;
+	msg[1] = (oldval & ~mask)|(value&mask);
+	/* write new register value to eeprom */
+	dev->em28xx_write_regs_req(dev, 0x02, 0xa0, msg, 2);
+
+	/* instruct microcontroller to write values into the eeprom */
+	msg[0] = 0x11;
+	msg[1] = reg_index;
+	dev->em28xx_write_regs_req(dev, 0x02, 0x68, msg, 2);
+	dev->em28xx_write_regs_req(dev, 0x03, 0x68, "\x00", 1);
+	val = em28xx_read_reg_req(dev, 0x2, 0x68);
+	if (val == 0x05)
+		; /* everything's fine */
+	else
+		state = 0;
+
+	/* write new register value to eeprom again */
+	msg[0] = reg_index;
+	msg[1] = (oldval & ~mask)|(value&mask);
+	dev->em28xx_write_regs_req(dev, 0x02, 0xa2, msg, 2);
+
+	/* instruct microcontroller for verification */
+	msg[0] = 0x21;
+	msg[1] = reg_index;
+	em28xx_write_regs_req(dev, 0x02, 0x68, msg, 2);
+	em28xx_write_regs_req(dev, 0x03, 0x68, "\x00", 1);
+	val = em28xx_read_reg_req(dev, 0x2, 0x68);
+	if (val == 0x05)
+		; /* everything's fine */
+	else
+		state = 0;
+
+	if (state == 0)
+		return oldval;  /* error */
+	else
+		return value;
+}
+
+/* embedded QUERYCTRL */
+int em28xx_vy_qctrl(struct v4l2_queryctrl *qctrl)
+{
+	struct v4l2_queryctrl *qc = qctrl;
+	int i;
+	for (i = 0; i < ARRAY_SIZE(em28xx_vy_ctrl); i++) {
+		if (qc->id && qc->id == em28xx_vy_ctrl[i].id) {
+			memcpy(qc, &(em28xx_vy_ctrl[i]),
+					sizeof(*qc));
+			return 0;
+		}
+	}
+	return -EINVAL; /* no ctrl found here */
+}
+
+/* VIDIOC_G_CTRL */
+int em28xx_vy_gctrl(struct em28xx *dev, struct v4l2_control *ctrl)
+{
+	switch (ctrl->id) {
+	case V4L2_VY_WBM:
+		ctrl->value = em28xx_vy_readmap(dev,
+				VY_FEATURE_REGISTER_2,
+				V4L2_VY_WBM_MASK);
+		break;
+	case V4L2_VY_SHUTTER:
+		ctrl->value = (em28xx_vy_readmap(dev,
+					VY_FEATURE_REGISTER_2,
+					V4L2_VY_SHUTTER_MASK)) >> 3;
+		break;
+	case V4L2_VY_MIRROR:
+		ctrl->value = (em28xx_vy_readmap(dev,
+					VY_FEATURE_REGISTER_2,
+					V4L2_VY_MIRROR_MASK)) >> 7;
+		break;
+	case V4L2_VY_GAIN_CONTROL_EN:
+		ctrl->value = (em28xx_vy_readmap(dev,
+					VY_FEATURE_REGISTER_1,
+					V4L2_VY_GAIN_CONTROL_EN_MASK)) >> 1;
+		break;
+	case V4L2_VY_GAIN_CONTROL:
+		ctrl->value = (em28xx_vy_readmap(dev,
+					VY_FEATURE_REGISTER_7,
+					V4L2_VY_GAIN_CONTROL_MASK)) >> 1;
+		break;
+	case V4L2_VY_EDGE_ENHANCE_EN:
+		ctrl->value = (em28xx_vy_readmap(dev,
+					VY_FEATURE_REGISTER_4,
+					V4L2_VY_EDGE_ENHANCE_EN_MASK) & 0x01) ?
+					0 : 1;
+		break;
+	case V4L2_VY_EDGE_ENHANCE:
+		ctrl->value = em28xx_vy_readmap(dev, VY_FEATURE_REGISTER_3,
+					       V4L2_VY_EDGE_ENHANCE_MASK);
+		break;
+	case V4L2_VY_BLC:
+#if 0
+		ctrl->value = em28xx_vy_readmap(dev, VY_FEATURE_REGISTER_6,
+				V4L2_VY_BLC_MASK);
+#endif
+		printk(KERN_INFO"em28xx-vy.c V4L2_VY_BLC: not implemented\n");
+		break;
+	case V4L2_VY_RGAIN:
+		ctrl->value = em28xx_vy_readmap(dev, VY_FEATURE_REGISTER_8,
+					       V4L2_VY_RGAIN_MASK);
+		break;
+	case V4L2_VY_BGAIN:
+		ctrl->value = em28xx_vy_readmap(dev, VY_FEATURE_REGISTER_9,
+					       V4L2_VY_BGAIN_MASK);
+		break;
+	default:
+		printk(KERN_INFO"em28xx-vy.c: unknown command!\n");
+		return -EINVAL;
+	}
+	return 0;
+}
+
+/* VIDIOC_S_CTRL */
+int em28xx_vy_cctrl(struct em28xx *dev, struct v4l2_control *ctrl)
+{
+	int i;
+
+	for (i = 0; i < ARRAY_SIZE(em28xx_vy_ctrl); i++) {
+		if (ctrl->id == em28xx_vy_ctrl[i].id) {
+			if (em28xx_vy_ctrl[i].minimum >= ctrl->value &&
+					em28xx_vy_ctrl[i].maximum <=
+					ctrl->value) {
+				printk(KERN_INFO"em28xx-vy.c: value out of "
+						"range\n");
+				return -EINVAL;
+			}
+		}
+	}
+
+	switch (ctrl->id) {
+	case V4L2_VY_WBM:
+		em28xx_vy_write(dev, (u8)VY_FEATURE_REGISTER_2,
+				(u8)ctrl->value, V4L2_VY_WBM_MASK);
+		break;
+	case V4L2_VY_SHUTTER:
+		em28xx_vy_write(dev, (u8)VY_FEATURE_REGISTER_2,
+				(u8)(ctrl->value)<<3,
+				V4L2_VY_SHUTTER_MASK);
+		break;
+	case V4L2_VY_MIRROR:
+		em28xx_vy_write(dev, (u8)VY_FEATURE_REGISTER_2,
+				(u8)(ctrl->value)<<7,
+				V4L2_VY_MIRROR_MASK);
+		break;
+	case V4L2_VY_GAIN_CONTROL_EN:
+		em28xx_vy_write(dev, (u8)VY_FEATURE_REGISTER_1,
+				(u8)(ctrl->value)<<1,
+				V4L2_VY_GAIN_CONTROL_EN_MASK);
+		break;
+	case V4L2_VY_GAIN_CONTROL:
+		em28xx_vy_write(dev, (u8)VY_FEATURE_REGISTER_7,
+				(u8)(ctrl->value)<<1,
+				V4L2_VY_GAIN_CONTROL_MASK);
+		break;
+	case V4L2_VY_EDGE_ENHANCE_EN:
+		em28xx_vy_write(dev, (u8)VY_FEATURE_REGISTER_4,
+				(u8)(~(((ctrl->value)<<1) | (ctrl->value))),
+				V4L2_VY_EDGE_ENHANCE_EN_MASK);
+		break;
+	case V4L2_VY_EDGE_ENHANCE:
+		em28xx_vy_write(dev, (u8)VY_FEATURE_REGISTER_3,
+				(u8)(ctrl->value),
+				V4L2_VY_EDGE_ENHANCE_MASK);
+		em28xx_vy_write(dev, (u8)VY_FEATURE_REGISTER_5,
+				(u8)(ctrl->value),
+				V4L2_VY_EDGE_ENHANCE_MASK);
+		break;
+	case V4L2_VY_RGAIN:
+		em28xx_vy_write(dev, (u8)VY_FEATURE_REGISTER_8,
+				(u8)(ctrl->value),
+				V4L2_VY_RGAIN_MASK);
+		break;
+	case V4L2_VY_BGAIN:
+		em28xx_vy_write(dev, (u8)VY_FEATURE_REGISTER_9,
+				(u8)(ctrl->value),
+				V4L2_VY_BGAIN_MASK);
+		break;
+	case V4L2_VY_BLC:
+		printk(KERN_INFO"em28xx-vy.c V4l2_VY_BLC not implemented\n");
+		break;
+	default:
+		printk(KERN_INFO"em28xx-vy.c: unknown command!\n");
+	}
+	return 0;
+}
+
+
diff --git a/drivers/media/video/empia/em28xx.h b/drivers/media/video/empia/em28xx.h
new file mode 100644
index 0000000..069dd5a
--- /dev/null
+++ b/drivers/media/video/empia/em28xx.h
@@ -0,0 +1,1153 @@
+/*
+   em28xx.h - driver for Empia EM2800/EM2820/2840/2880 USB video capture devices
+
+   Copyright (C) 2005 Markus Rechberger <mrechberger@xxxxxxxxx>
+		      Ludovico Cavedon <cavedon@xxxxxxxx>
+		      Mauro Carvalho Chehab <mchehab@xxxxxxxxxxxxx>
+
+   Based on the em2800 driver from Sascha Sommer <saschasommer@xxxxxxxxxx>
+
+   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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef _EM28XX_H
+#define _EM28XX_H
+
+#include <linux/version.h>
+#include <linux/videodev.h>
+#include <linux/i2c.h>
+#include <linux/dvb/frontend.h>
+#include "dmxdev.h"
+#include "dvb_demux.h"
+#include "dvb_net.h"
+#include "dvb_frontend.h"
+#include <linux/soundcard.h>
+
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 25)
+#include <sound/driver.h>
+#endif
+#include <sound/core.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include "xc3028/xc3028_control.h"
+#include "cx25843/em28xx-cx25843.h"
+#include "media/tuner.h"
+#include "em28xx-aad.h"
+
+#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 15)
+#include <linux/mutex.h>
+#endif
+#include <media/ir-kbd-i2c.h>
+
+/* Boards supported by driver */
+
+#define EM2800_BOARD_GENERIC			  0
+#define EM2820_BOARD_GENERIC			  1
+#define EM2821_BOARD_GENERIC                      2
+#define EM2870_BOARD_GENERIC                      3
+#define EM2881_BOARD_GENERIC                      4
+#define EM2860_BOARD_GENERIC 			  5
+#define EM2861_BOARD_GENERIC 			  6
+#define EM2820_BOARD_TERRATEC_CINERGY_250	  7
+#define EM2820_BOARD_PINNACLE_USB_2		  8
+#define EM2820_BOARD_HAUPPAUGE_WINTV_USB_2        9
+#define EM2820_BOARD_MSI_VOX_USB_2                10
+#define EM2800_BOARD_TERRATEC_CINERGY_200         11
+#define EM2800_BOARD_LEADTEK_WINFAST_USBII        12
+#define EM2800_BOARD_KWORLD_USB2800               13
+#define EM2820_BOARD_PINNACLE_DVC_90		  14
+#define EM2880_BOARD_HAUPPAUGE_WINTV_HVR_900	  15
+#define EM2880_BOARD_TERRATEC_HYBRID_XS		  16
+#define EM2880_BOARD_TERRATEC_HYBRID_XS_FR	  17
+#define EM2820_BOARD_KWORLD_PVRTV2800RF		  18
+#define EM2880_BOARD_TERRATEC_PRODIGY_XS	  19
+#define EM2820_BOARD_VIDEOLOGY_20K14XUSB	  20
+#define EM2821_BOARD_USBGEAR_VD204                21
+#define EM2870_BOARD_TERRATEC_XS                  22
+#define EM2870_BOARD_PINNACLE_PCTV_DVB            23
+#define EM2881_BOARD_DNT_DA2_HYBRID               24
+#define EM2881_BOARD_PINNACLE_HYBRID_PRO          25
+#define EM2820_BOARD_HERCULES_SMART_TV_USB2	  26
+#define EM2870_BOARD_COMPRO_VIDEOMATE             27
+#define EM2880_BOARD_KWORLD_DVB_310U              28
+#define EM2821_BOARD_PROLINK_PLAYTV_USB2          29
+#define EM2870_BOARD_TERRATEC_XS_MT2060           30
+#define EM2880_BOARD_MSI_DIGIVOX_AD               31
+#define EM2820_BOARD_DLINK_USB_TV                 32
+#define EM2820_BOARD_GADMEI_UTV310                33
+#define EM2870_BOARD_KWORLD_355U		  34
+#define EM2821_BOARD_SUPERCOMP_USB_2              35
+#define EM2880_BOARD_HAUPPAUGE_WINTV_HVR_900_R2	  36
+#define EM2860_BOARD_GADMEI_UTV330		  37
+#define EM2800_BOARD_VGEAR_POCKETTV               38
+#define EM2870_BOARD_KWORLD_350U		  39
+#define EM2882_BOARD_TERRATEC_HYBRID_XS		  40
+#define EM2820_BOARD_PINNACLE_DVC_100		  41
+#define EM2861_BOARD_YAKUMO_MOVIE_MIXER           43
+#define EM2750_BOARD_DLCW_130                     44
+#define EM2750_BOARD_GENERIC			  42
+#define EM2883_BOARD_GENERIC                      45
+#define EM2883_BOARD_HAUPPAUGE_WINTV_HVR_950      46
+#define EM2883_BOARD_PINNACLE_PCTV_HD_PRO	  47
+#define EM2882_BOARD_PINNACLE_HYBRID_PRO          48
+#define EM2820_BOARD_HAUPPAUGE_WINTV_USB_2_R2     49
+#define EM2860_BOARD_NETGMBH_CAM		  50
+#define EM2820_BOARD_LEADTEK_WINFAST_USBII_DELUXE 51
+#define EM2880_BOARD_MSI_DIGIVOX_AD_II            52
+#define EM2860_BOARD_TYPHOON_DVD_MAKER            53
+#define EM2820_BOARD_PINNACLE_USB_2_FM1216ME      54
+#define EM2751_BOARD_EMPIA_SAMPLE		  55
+#define EM2880_BOARD_KWORLD_DVB_305U              56
+#define EM2861_BOARD_KWORLD_PVRTV_300U 		  57
+#define EM2883_BOARD_KWORLD_HYBRID_A316 	  58
+#define EM2860_BOARD_TERRATEC_HYBRID_XS		  59
+#define EM2861_BOARD_PLEXTOR_PX_TV100U            60
+#define EM2883_BOARD_TERRATEC_HYBRID_XS_FM        61
+#define EM2870_BOARD_HAUPPAUGE_WINTV_USB_2_R2     62
+#define EM2883_BOARD_EMPIA_HYBRID_ATSC            63
+#define EM2863_BOARD_EMPIA_GENERIC                64
+#define EM2883_BOARD_KWORLD_HYBRID_F306		  65
+#define EM2888_BOARD_KWORLD_HYBRID_E329		  66
+#define EM2883_BOARD_KWORLD_HYBRID_E323		  67
+#define EM2883_BOARD_KWORLD_A340		  68
+#define EM2888_BOARD_LINCOLN_TV_FM		  69
+#define EM2888_BOARD_DVB_TC_HYBRID		  70
+#define EM2888_BOARD_EMPIA_HYBRID                 71
+#define EM2883_BOARD_ATI_TVWONDER600		  72
+#define EM2875_BOARD_SAMPLE_ISDBT                 73
+#define EM2879_BOARD_SAMPLE_DMB                   74
+#define EM2860_BOARD_KAIOMY_TVNPC_U2              75
+#define EM2861_BOARD_POLLIN_USB_R1                76
+#define EM2883_BOARD_EQUINUX_TUBESTICK_ATSC       77
+#define EM2882_BOARD_LEADTEK_PALMTOP_DTV_200H     78
+#define EM2820_BOARD_COMPRO_VIDEO_MATE            79
+
+#ifndef TUNER_XCEIVE_XC5000
+#define TUNER_XCEIVE_XC5000 10000
+#endif
+
+#ifndef TUNER_XCEIVE_XC3028
+#define TUNER_XCEIVE_XC3028 10001
+#endif
+
+#ifndef TUNER_MT2060
+#define TUNER_MT2060 10002
+#endif
+
+#ifndef TUNER_QT1010
+#define TUNER_QT1010 10003
+#endif
+
+#ifndef TUNER_PHILIPS_TDA18271
+#define TUNER_PHILIPS_TDA18271 10004
+#endif
+
+#ifndef TUNER_ADIMTV102
+#define TUNER_ADIMTV102 10005
+#endif
+
+
+#define UNSET -1
+
+/* maximum number of em28xx boards */
+/* TODO: we should distinct here between
+   * DVB-T
+   * analogue only
+   * hybrid devices
+   1 analogue tuner requires up to 170 mbit
+   2 analogue tuners will work in alt 3 mode, but the default
+     is alt 7 at the moment (it's possible to override
+     with the module parameter alt=3), though it should be
+     implemented properly.
+     2 devices take up to 340 mbit which should work.
+     (3 tuners would be 510 mbit which is too much for
+     one usb controller)
+
+   DVB-T tuner only take around 15 mbit, so we should be able
+   to support more than the limit below.
+
+   I think a controller based bandwidth table would do here
+   and guarantee that the initialized devices will work
+*/
+#define EM28XX_MAXBOARDS 3 /* FIXME: should be bigger */
+
+/* maximum number of frames that can be queued */
+#define EM28XX_NUM_FRAMES 5
+/* number of frames that get used for v4l2_read() */
+#define EM28XX_NUM_READ_FRAMES 2
+
+/* number of buffers for isoc transfers */
+#define EM28XX_NUM_BUFS 5
+#define EM2880_DVB_NUM_BUFS 5
+#define EM28XX_AUDIO_BUFS 3
+#define EM28XX_NUM_AUDIO_PACKETS 64
+#define EM28XX_AUDIO_MAX_PACKET_SIZE 196 /* static value */
+
+
+/* number of packets for each buffer
+   windows requests only 40 packets .. so we better do the same
+   this is what I found out for all alternate numbers there!
+ */
+#define EM28XX_NUM_PACKETS 64
+
+/* default alternate; 0 means choose the best */
+#define EM28XX_PINOUT 0
+
+#define EM28XX_INTERLACED_DEFAULT 1
+
+/*
+#define (use usbview if you want to get the other alternate number infos)
+#define
+#define alternate number 2
+#define 			Endpoint Address: 82
+			Direction: in
+			Attribute: 1
+			Type: Isoc
+			Max Packet Size: 1448
+			Interval: 125us
+
+  alternate number 7
+
+			Endpoint Address: 82
+			Direction: in
+			Attribute: 1
+			Type: Isoc
+			Max Packet Size: 3072
+			Interval: 125us
+*/
+
+/* time to wait when stopping the isoc transfer */
+#define EM28XX_URB_TIMEOUT \
+	msecs_to_jiffies(EM28XX_NUM_BUFS * EM28XX_NUM_PACKETS)
+
+/* time in msecs to wait for i2c writes to finish */
+#define EM2800_I2C_WRITE_TIMEOUT 20
+
+enum em28xx_fe_bandwidth {
+	EM28XX_BANDWIDTH_8_MHZ,
+	EM28XX_BANDWIDTH_7_MHZ,
+	EM28XX_BANDWIDTH_6_MHZ,
+	EM28XX_BANDWIDTH_AUTO
+};
+
+extern struct list_head em28xx_devlist;
+
+/* the various frame states */
+enum em28xx_frame_state {
+	F_UNUSED = 0,
+	F_QUEUED,
+	F_GRABBING,
+	F_DONE,
+	F_ERROR,
+};
+
+/* stream states */
+enum em28xx_stream_state {
+	STREAM_OFF,
+	STREAM_ON,
+	STREAM_INTERRUPT,
+};
+
+/* frames */
+struct em28xx_frame_t {
+	void *bufmem;
+	struct v4l2_buffer buf;
+	enum em28xx_frame_state state;
+	struct list_head frame;
+	unsigned long vma_use_count;
+	int top_field;
+	int fieldbytesused;
+};
+
+/* io methods */
+enum em28xx_io_method {
+	IO_NONE,
+	IO_READ,
+	IO_MMAP,
+};
+
+/* Colorspace Output */
+
+/* To be discussed */
+
+#ifndef V4L2_PIX_FMT_YUV211
+#define V4L2_PIX_FMT_YUV211	v4l2_fourcc('Y','2','1','1')
+#endif
+
+#ifndef V4L2_PIX_FMT_YUY1
+#define V4L2_PIX_FMT_YUY1	v4l2_fourcc('Y','U','Y','1')
+#endif
+
+#ifndef V4L2_PIX_FMT_Y21P
+#define V4L2_PIX_FMT_Y21P	v4l2_fourcc('Y','2','1','P')
+#endif
+
+struct em28xx_output_fmt {
+	struct v4l2_fmtdesc fmt;
+	u8 config;
+};
+
+/* inputs */
+
+#define MAX_EM28XX_INPUT 4
+#define MAX_EM28XX_TVNORMS 10
+#define MAX_EM28XX_DVBNORMS 5
+#define MAX_EM28XX_FMNORMS 2
+#define MAX_EM28XX_ATSCNORMS 2
+#define MAX_EM28XX_QAMNORMS 2
+
+enum enum28xx_itype {
+	EM28XX_VMUX_COMPOSITE1 = 1,
+	EM28XX_VMUX_COMPOSITE2,
+	EM28XX_VMUX_COMPOSITE3,
+	EM28XX_VMUX_COMPOSITE4,
+	EM28XX_VMUX_SVIDEO,
+	EM28XX_VMUX_TELEVISION,
+	EM28XX_VMUX_CABLE,
+	EM28XX_VMUX_DVB,
+	EM28XX_VMUX_DEBUG,
+	EM28XX_AMUX_RADIO,
+};
+
+enum enum28xx_mixchannel {
+	EM28XX_MIX_NOTOUCH = 0,
+	EM28XX_MIX_LINE_IN = 1,
+	EM28XX_MIX_VIDEO = 2,
+};
+
+struct em28xx_input {
+	enum enum28xx_itype type;
+	unsigned int vmux;
+	unsigned int amux;
+	enum enum28xx_mixchannel amix;
+};
+
+#define INPUT(nr) (&em28xx_boards[dev->model].input[nr])
+
+enum em28xx_decoder {
+	EM28XX_TVP5150,
+	EM28XX_SAA7113,
+	EM28XX_SAA7114,
+	EM28XX_CX25843,
+};
+
+struct em28xx;
+
+/* 0x0 - undef */
+enum empia_type {
+	EM2800 = 1,
+	EM2820,
+	EM2840,
+	EM2750,
+	EM2751,
+	EM2860,
+	EM2875,
+	EM2880,
+	EM2881,
+	EM2882,
+	EM2883,
+	EM2888,
+	EM2889
+};
+
+#define EM28XX_VIDEO    0x01
+#define EM28XX_DVBT     0x02
+#define EM28XX_DVBC     0x04
+#define EM28XX_ATSC     0x08
+#define EM28XX_DMB      0x10
+#define EM28XX_ISDB     0x20
+#define EM28XX_VBI      0x40
+#define EM28XX_REMOTE   0x80
+#define EM28XX_AUDIO    0x100 /* vendor specific audiodriver */
+#define EM28XX_AUDIO2   0x200 /* vendor specific audiodriver, different interface number */
+#define EM28XX_RADIO    0x400
+#define EM28XX_LOCK	0x800
+
+#define EM28XX_CAPTURE_STREAM_EN 1
+
+/* used by the audio driver */
+#define EM28XX_ENABLE_AUDIO 1
+#define EM28XX_DISABLE_AUDIO 2
+
+/* tvnorms */
+struct em28xx_tvnorm {
+	char *name;
+	XC3028_TV_MODE *tv_mode;
+	XC3028_CHANNEL_MAP *channelmap;
+	int index; /* xc5000 configuration */
+
+	/* digital tv */
+	enum em28xx_fe_bandwidth bandwidth;
+	/* analog tv */
+	v4l2_std_id id;
+	u32 vbi_sample_rate;
+	u16 vbi_samples_per_line;
+	u16 vbi_lines;
+	u16 vbi_offset;
+	u16 vbi_start_0;
+	u16 vbi_start_1;
+	u8 vbi_count_0;
+	u8 vbi_count_1;
+
+	u8 vbi_h_start;
+	u8 vbi_v_start;
+	u8 vbi_w;
+	u8 vbi_h;
+};
+
+/* gpio definitions */
+#define EM28XX_GPIO_EN 0x1
+
+#define EM28XX_GOP0    0x10
+#define EM28XX_GOP1    0x11
+#define EM28XX_GOP2    0x12
+#define EM28XX_GOP3    0x13
+
+#define EM28XX_GPIO0   0x0
+#define EM28XX_GPIO1   0x1
+#define EM28XX_GPIO2   0x2
+#define EM28XX_GPIO3   0x3
+#define EM28XX_GPIO4   0x4
+#define EM28XX_GPIO5   0x5
+#define EM28XX_GPIO6   0x6
+#define EM28XX_GPIO7   0x7
+
+/* helpers */
+#define _BIT_VAL(reg, val, reset) (reg  | 0x80 | (reset?1<<6:0) | (val<<5))
+
+/* internal gpio controls */
+#define EM28XX_TS1_ON         1
+#define EM28XX_ANALOG_ON      2
+#define EM28XX_LED1_ON        3
+#define EM28XX_XC3028_SECAM   4
+#define EM28XX_MODESWITCH     5
+#define EM28XX_DECODER_SLEEP  6
+#define EM28XX_LED2_ON        7
+#define EM28XX_RF             8
+#define EM28XX_DVB1_ON        9
+#define EM28XX_DVB2_ON        10
+#define EM28XX_TUNER1_ON      11
+#define EM28XX_TUNER2_ON      12
+#define EM28XX_DEMOD1_RESET   13
+#define EM28XX_TUNER1_RESET   14
+#define EM28XX_DECODER_RESET  15
+#define EM28XX_DEMOD2_RESET   16
+#define EM28XX_TUNER2_RESET   17
+#define EM28XX_I2C_BUS        18
+
+/* internal gpio control arguments */
+#define EM28XX_REG_ON       1 
+#define EM28XX_REG_OFF      2
+
+struct em28xx_gpio {
+	u16 d1_reset;
+	u16 d2_reset;
+	u16 t1_reset;
+	u16 t2_reset;
+	u16 dc_reset;
+	u16 a_on;
+	u16 l1_on;
+	u16 l2_on;
+	u16 xc3028_sec;
+	u16 m_switch;
+	u16 d_sleep;
+	u16 ts1_on;
+	u16 ts2_on;
+	u16 t1_on;
+	u16 t2_on;
+	u16 rf;
+	u16 dvbs_lnb;
+	u16 dvbs_v;
+};
+
+struct em28xx_board {
+	char *name;
+	int vchannels;
+	v4l2_std_id norm;
+	int tuner_type;
+	int tuner_addr;
+
+	/* i2c flags */
+	unsigned int em_type;
+	/* null terminated list of used i2c addresses */
+	/* used to autodetect some em2800 devices without eeprom */
+	const u8 *i2c_devs;
+	u8 tda9887_conf;
+
+	u8 has_tuner:1;
+	u8 has_inttuner:1;
+	u8 has_msp34xx:1;
+	u8 has_radio:1;
+	u8 powersaving:1;
+
+	u8 manual_gpio:1;
+	u8 ir_i2c:1; /* remote is i2c based */
+
+	struct em28xx_gpio gpio_regs;
+
+	u16 dev_modes;
+
+	enum em28xx_decoder decoder;
+
+	struct em28xx_tvnorm  tvnorms[MAX_EM28XX_TVNORMS];
+	struct em28xx_tvnorm  dvbnorms[MAX_EM28XX_DVBNORMS];
+	struct em28xx_tvnorm  fmnorms[MAX_EM28XX_FMNORMS];
+	struct em28xx_tvnorm  atscnorms[MAX_EM28XX_ATSCNORMS];
+	struct em28xx_tvnorm  qamnorms[MAX_EM28XX_QAMNORMS];
+
+	int (*ctrl)(struct em28xx *dev, struct v4l2_control *ctrl);
+	int (*gctrl)(struct em28xx *dev, struct v4l2_control *ctrl);
+	int (*qctrl)(struct v4l2_queryctrl *qctrl);
+
+	IR_KEYTAB_TYPE *ir_keytab;
+	int (*ir_getkey)(struct em28xx *dev, u32 *ir_key, u32 *keystatus);
+
+	struct em28xx_input       input[MAX_EM28XX_INPUT];
+};
+
+struct em28xx_eeprom {
+	u32 id;			/* 0x9567eb1a */
+	u16 vendor_ID;
+	u16 product_ID;
+
+	u16 chip_conf;
+
+	u16 board_conf;
+
+	u16 string1, string2, string3;
+
+	u8 string_idx_table;
+};
+
+/* device states */
+enum em28xx_dev_state {
+	DEV_INITIALIZED = 0x01,
+	DEV_DISCONNECTED = 0x02,
+	DEV_MISCONFIGURED = 0x04,
+};
+
+
+/* digital main device struct */
+
+enum mtype {
+	EM28XX_ZL10353,
+	EM28XX_MT352,
+	EM28XX_DRX3975D,
+	EM28XX_LGDT330X,
+};
+
+struct em2880_dvb {
+	char *name;
+	struct dvb_demux demux;
+#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 15)
+	struct mutex sem;
+#else
+	struct semaphore sem;
+#endif
+	int streaming;
+	enum mtype mod_type;
+	struct dvb_adapter adapter;
+	struct dvb_frontend        *frontend;
+	struct dvb_device *fedev;
+	struct dmxdev dmxdev;
+	struct em28xx *em28xx_dev; /* please get rid of it lateron */
+	struct dvb_net dvbnet;
+	struct usb_device *udev;	/* the usb device */
+	char *transfer_buffer[EM2880_DVB_NUM_BUFS];     /* transfer buffers for isoc transfer */
+	struct urb *urb[EM2880_DVB_NUM_BUFS];   /* urb for isoc transfers */
+	int (*demod_init)(struct dvb_frontend *fe);
+	int bw_index; /* bandwidth index */
+	int (*init_override)(struct dvb_frontend *fe);
+	u16 dtv_packetsize; 
+};
+
+struct em28xx_audio {
+	char name[50];
+	char *transfer_buffer[EM28XX_AUDIO_BUFS];
+	struct urb *urb[EM28XX_AUDIO_BUFS];
+	struct usb_device *udev;
+	unsigned int capture_transfer_done;
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 16)
+	snd_pcm_substream_t        *capture_pcm_substream;
+#else
+	struct snd_pcm_substream   *capture_pcm_substream;
+#endif
+
+	unsigned int hwptr_done_capture;
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 16)
+	snd_card_t                 *sndcard;
+#else
+	struct snd_card            *sndcard;
+#endif
+
+	int users;
+	unsigned int shutdown:1;
+	spinlock_t slock; /* for protecting the alsa buffer */
+	enum em28xx_stream_state capture_stream;
+	wait_queue_head_t audio_wait_stream, open;
+	u16 max_pck;
+	u8 alt_max;
+	/* states */
+	enum em28xx_dev_state state;
+	u8 alt;		/* alternate */
+	struct usb_interface usb_dev;
+};
+
+
+struct em2880_ir {
+	u8      old;
+	u8      sequence[4];
+	IR_KEYTAB_TYPE		*keymap;
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20)
+	struct work_struct work;
+#else
+	struct delayed_work work;
+#endif
+
+	struct input_dev	*input;
+	struct em28xx		*dev;
+	int                     keypressed;
+	struct timer_list       timer;
+	u32                     keycode;
+
+	u32			oldval;
+	u32			oldtimeoutval;
+	u32			key;
+	u8			btn;
+
+	u8                      name[50];
+	u8			phys[50];
+	u8			released:1;
+	u8			state;
+	struct mutex state_lock;
+#define EM28XX_REMOTE_IDLE      0
+#define EM28XX_REMOTE_POLLING   1
+#define EM28XX_REMOTE_INTERRUPT 2
+	int (*get_key)(struct em28xx *dev, u32 *ir_key, u32 *keystatus);
+	wait_queue_head_t	remote_loop;
+};
+
+struct em28xx_fh {
+	struct em28xx *dev;
+	unsigned int reader:1;
+	int type;
+};
+
+
+/* main device struct */
+struct em28xx {
+	/* generic device properties */
+	char name[30];		/* name (including minor) of the device */
+	int model;		/* index in the device_data struct */
+	int devno;		/* marks the number of this device */
+	unsigned int em_type;
+	u8 video_inputs;	/* number of video inputs */
+	struct list_head	devlist;
+	u8 has_tuner:1;
+	u8 has_inttuner:1;
+	u8 has_msp34xx:1;
+	u8 has_tda9887:1;
+	u8 has_vbi:1;
+	u8 device_mode:1; /* EM28XX_VIDEO | EM28XX_DVB  */
+	u16 dev_modes;
+	u8 manual_gpio:1;
+	u8 powersaving:1;
+
+	u8 modules_requested;
+#define EM28XX_MODULES_REQUESTED 0
+#define EM28XX_MODULES_PENDING   1
+	wait_queue_head_t mod_request;
+
+	void (*request_modules)(struct em28xx *dev);
+
+	u8 vbi_interlaced:1;
+
+	u8 vbi_frame_done:1;
+
+	u8 usb_interface;
+
+	u8 audio_user;
+	u8 video_user;
+	u8 radio_user;
+	u8 fe_user;
+	u8 vbi_user;
+	u8 mode_lock;
+
+
+	int mode;
+
+#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17)
+	struct delayed_work request_module_wk;
+#endif
+
+	struct em28xx_board *board;
+	struct usb_interface *uif;
+	struct em28xx_output_fmt *outfmt;
+
+	u32 i2s_speed;		/* I2S speed for audio digital stream */
+
+	enum em28xx_decoder decoder;
+
+	int tuner_type;		/* type of the tuner */
+	u8 tuner_addr;		/* tuner address */
+	int tda9887_conf;
+
+	struct tuner_module *tuner;
+	/* i2c i/o */
+	struct i2c_adapter i2c_adap;
+	struct i2c_client i2c_client;
+
+	/* dvb */
+	struct em2880_dvb *dvb_dev;
+	struct em28xx_audio *adev;
+	struct em2880_ir *ir_em2880;
+
+	/* video for linux */
+	u8 users;		/* user count for exclusive use */
+
+	struct video_device *rdev;	/* video for linux device struct */
+	struct video_device *vdev;	/* video for linux device struct */
+	struct video_device *vbi_dev;
+
+	struct em28xx_tvnorm *tvnorm;	/* selected tv norm */
+	struct em28xx_tvnorm *dvbnorm;
+	struct em28xx_tvnorm *atscnorm;
+	struct em28xx_tvnorm *qamnorm;
+	struct em28xx_tvnorm *fmnorm;
+	unsigned int tv_std;
+
+	unsigned long rctl_freq;		/* selected radio frequency */
+	unsigned long vctl_freq;		/* selected video frequency */
+	unsigned long dctl_freq;		/* selected dvb-t/atsc frequency */
+	u8 ctl_input;	/* selected input */
+	u8 ctl_ainput;	/* selected audio input */
+	enum enum28xx_mixchannel ctl_amix;	/* slected audio mixer channel */
+	u8 mute;
+	int volume;
+	/* frame properties */
+	struct em28xx_frame_t frame[EM28XX_NUM_FRAMES];	/* list of frames */
+	struct em28xx_frame_t vbi_frame[EM28XX_NUM_FRAMES];	/* list of frames */
+	u8 num_frames;		/* number of frames currently in use */
+	u8 vbi_num_frames;
+	u32 frame_count;	/* total number of transfered frames */
+	u32 vbi_frame_count;	/* total number of transfered frames */
+	struct em28xx_frame_t *frame_current;	/* the frame that is being filled */
+	struct em28xx_frame_t *vbi_frame_current;	/* the frame that is being filled */
+	u16 width;		/* current frame width */
+	u16 height;		/* current frame height */
+	u32 frame_size;		/* current frame size */
+	u32 field_size;		/* current field size */
+	u16 vbi_frame_size;
+	u16 vbi_field_size;
+	u16 bytesperline;
+	u16 vbi_bytesperline;
+	u16 hscale;		/* horizontal scale factor (see datasheet) */
+	u16 vscale;		/* vertical scale factor (see datasheet) */
+	u8 interlaced:1;	/* 1=interlace fileds, 0=just top fileds */
+	int type;
+
+	u8 reader:1;
+	u8 vbi_reader:1;
+	u8 video_reader:1;
+
+	/* states */
+	enum em28xx_dev_state state;
+
+	enum em28xx_stream_state stream;
+	enum em28xx_stream_state video_stream;
+	enum em28xx_stream_state vbi_stream;
+
+	enum em28xx_io_method io;
+
+	enum em28xx_io_method video_io;
+	enum em28xx_io_method vbi_io;
+
+	/* locks */
+#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 15)
+	struct mutex lock, fileop_lock, vbi_fileop_lock, input_lock;
+#else
+	struct semaphore lock, fileop_lock, vbi_fileop_lock, input_lock;
+#endif
+	spinlock_t queue_lock;
+	spinlock_t vbi_queue_lock;
+
+	struct list_head inqueue, outqueue, vbi_inqueue, vbi_outqueue;
+	wait_queue_head_t open, wait_frame, wait_vbi_frame, vbi_wait_stream;
+	wait_queue_head_t video_wait_stream;
+	u32 video_bytesread;
+	u16 vbi_bytesread;
+	u16 vbi_dropbytes;
+
+	unsigned char eedata[256];
+
+	/* usb transfer */
+	struct usb_device *udev;	/* the usb device */
+	u8 alt;		/* alternate */
+	u16 max_pkt_size;	/* max packet size of isoc transaction */
+	u8 num_alt;		/* Number of alternative settings */
+	unsigned int *alt_max_pkt_size;	/* array of wMaxPacketSize */
+	struct urb *urb[EM28XX_NUM_BUFS];	/* urb for isoc transfers */
+	char *transfer_buffer[EM28XX_NUM_BUFS];	/* transfer buffers for isoc transfer */
+
+	/* helper funcs that call usb_control_msg */
+
+	int (*em28xx_acquire)(struct em28xx *dev, int mode, int lock);
+	int (*em28xx_callback)(void *priv, int ptr, int mode);
+
+	int (*em28xx_write_regs) (struct em28xx *dev, u16 reg, char *buf,
+				  int len);
+	int (*em28xx_read_reg) (struct em28xx *dev, u16 reg);
+	int (*em28xx_read_reg_req_len) (struct em28xx *dev, u8 req, u16 reg,
+					char *buf, int len);
+	int (*em28xx_write_regs_req) (struct em28xx *dev, u8 req, u16 reg,
+				      char *buf, int len);
+	int (*em28xx_read_reg_req) (struct em28xx *dev, u8 req, u16 reg);
+	int (*em28xx_write_reg_bits)(struct em28xx *dev, u16 reg, u8 val,
+			u8 bitmask);
+
+	int (*em28xx_ctrl)(struct em28xx *dev, struct v4l2_control *ctrl);
+	int (*em28xx_gctrl)(struct em28xx *dev, struct v4l2_control *ctrl);
+	int (*em28xx_qctrl)(struct v4l2_queryctrl *qctrl);
+
+	int (*em28xx_gpio_control)(void *priv, unsigned int command, void *ptr);
+        int (*em28xx_aad_control)(void *priv, unsigned int command, void *ptr);
+
+        struct em28xx_aad_info *aad;
+
+};
+
+struct em28xx_ops {
+	struct list_head next;
+	char *name;
+	int id;
+	int (*init)(struct em28xx *);
+	int (*fini)(struct em28xx *);
+};
+
+/* Provided by em28xx-i2c.c */
+int em2800_i2c_check_for_device(struct em28xx *dev, unsigned char addr);
+void em28xx_i2c_call_clients(struct em28xx *dev, unsigned int cmd, void *arg);
+int em28xx_i2c_register(struct em28xx *dev);
+int em28xx_i2c_unregister(struct em28xx *dev);
+
+/* Provided by em28xx-input.c */
+
+void em28xx_set_ir(struct em28xx *dev, struct IR_i2c *ir);
+
+/* Provided by em28xx-core.c */
+
+u32 em28xx_request_buffers(struct em28xx *dev, u32 count, int type);
+void em28xx_queue_unusedframes(struct em28xx *dev, int type);
+void em28xx_release_buffers(struct em28xx *dev, int type);
+
+int em28xx_read_reg_req_len(struct em28xx *dev, u8 req, u16 reg,
+			    char *buf, int len);
+int em28xx_read_reg_req(struct em28xx *dev, u8 req, u16 reg);
+int em28xx_read_reg(struct em28xx *dev, u16 reg);
+int em28xx_write_regs_req(struct em28xx *dev, u8 req, u16 reg, char *buf,
+			  int len);
+int em28xx_write_regs(struct em28xx *dev, u16 reg, char *buf, int len);
+int em28xx_write_reg_bits(struct em28xx *dev, u16 reg, u8 val,
+			  u8 bitmask);
+int em28xx_write_ac97(struct em28xx *dev, u8 reg, u8 *val);
+int em28xx_audio_analog_set(struct em28xx *dev);
+int em28xx_colorlevels_set_default(struct em28xx *dev);
+int em28xx_capture_start(struct em28xx *dev, int start);
+int em28xx_outfmt_set_yuv422(struct em28xx *dev);
+int em28xx_accumulator_set(struct em28xx *dev, u8 xmin, u8 xmax, u8 ymin,
+			   u8 ymax);
+int em28xx_capture_area_set(struct em28xx *dev, u8 hstart, u8 vstart,
+			    u16 width, u16 height);
+int em28xx_scaler_set(struct em28xx *dev, u16 h, u16 v);
+int em28xx_resolution_set(struct em28xx *dev);
+int em28xx_init_isoc(struct em28xx *dev);
+void em28xx_uninit_isoc(struct em28xx *dev);
+int em28xx_set_alternate(struct em28xx *dev);
+int em28xx_register_extension(struct em28xx_ops *dev);
+void em28xx_unregister_extension(struct em28xx_ops *dev);
+int em2880_ir_detach(struct em28xx *dev);
+int em2880_ir_attach(struct em28xx *dev);
+int em2880_get_key_terratec(struct em28xx *dev, u32 *ir_key, u32 *keystatus);
+int em2880_get_key_empia(struct em28xx *dev, u32 *ir_key, u32 *keystatus);
+int em2888_get_key_empia(struct em28xx *dev, u32 *ir_key, u32 *keystatus);
+int em2860_get_key_kaiomy(struct em28xx *dev, u32 *ir_key, u32 *keystatus);
+int em28xx_set_vbi(struct em28xx *dev, int enable);
+
+
+extern struct workqueue_struct *em28xx_wq;
+
+
+/* Provided by em28xx-cards.c */
+extern int em2800_variant_detect(struct usb_device* udev, int model);
+extern int em28xx_card_setup(struct em28xx *dev);
+extern void em28xx_card_disconnect(struct em28xx *dev);
+extern struct em28xx_board em28xx_boards[];
+extern struct usb_device_id em28xx_id_table[];
+extern const unsigned int em28xx_bcount;
+extern int em28xx_gpio_control(void *priv, unsigned int command, void *ptr);
+extern int em28xx_gpio_control_translate(void *priv, unsigned int command, void *ptr);
+extern int em28xx_qt1010_reset_control(void *priv, int command, void *ptr);
+
+/* Videology specific functions */
+
+/* white balance mode */
+#define V4L2_VY_WBM                 (V4L2_CID_PRIVATE_BASE+0)
+/* shutter speed */
+#define V4L2_VY_SHUTTER             (V4L2_CID_PRIVATE_BASE+1)
+/* mirror mode */
+#define V4L2_VY_MIRROR              (V4L2_CID_PRIVATE_BASE+2)
+/* gain control on/off */
+#define V4L2_VY_GAIN_CONTROL_EN     (V4L2_CID_PRIVATE_BASE+3)
+/* gain control values 0x00 - 0x7f */
+#define V4L2_VY_GAIN_CONTROL        (V4L2_CID_PRIVATE_BASE+4)
+/* enable edge enhance */
+#define V4L2_VY_EDGE_ENHANCE_EN     (V4L2_CID_PRIVATE_BASE+5)
+/* edge enhance values 0x00 - 0x1f */
+#define V4L2_VY_EDGE_ENHANCE        (V4L2_CID_PRIVATE_BASE+6)
+/* BLC (???) values 0x00 (off) - 0x40 */
+#define V4L2_VY_BLC                 (V4L2_CID_PRIVATE_BASE+7)
+/* RGain value    0x00-0xff */
+#define V4L2_VY_RGAIN               (V4L2_CID_PRIVATE_BASE+8)
+/* BGain value    0x00-0xff */
+#define V4L2_VY_BGAIN               (V4L2_CID_PRIVATE_BASE+9)
+
+
+int em28xx_vy_cctrl(struct em28xx *dev, struct v4l2_control *ctrl);
+int em28xx_vy_gctrl(struct em28xx *dev, struct v4l2_control *ctrl);
+int em28xx_vy_qctrl(struct v4l2_queryctrl *qctrl);
+
+/* em28xx registers */
+#define R06_I2C_CLK_REG         0x06
+#define R0A_CHIPID_REG		0x0a
+#define R0C_USBSUSP_REG		0x0c
+
+#define R0E_AUDIOSRC_REG	0x0e
+#define R0F_XCLK_REG  		0x0f
+
+#define R10_VINMODE_REG        	0x10
+#define R11_VINCTRL_REG        	0x11
+#define R12_VINENABLE_REG      	0x12
+
+#define R14_GAMMA_REG  		0x14
+#define R15_RGAIN_REG  		0x15
+#define R16_GGAIN_REG  		0x16
+#define R17_BGAIN_REG  		0x17
+#define R18_ROFFSET_REG        	0x18
+#define R19_GOFFSET_REG        	0x19
+#define R1A_BOFFSET_REG        	0x1a
+
+#define R1B_OFLOW_REG  		0x1b
+#define R1C_HSTART_REG 		0x1c
+#define R1D_VSTART_REG 		0x1d
+#define R1E_CWIDTH_REG 		0x1e
+#define R1F_CHEIGHT_REG        	0x1f
+
+#define R20_YGAIN_REG  		0x20
+#define R21_YOFFSET_REG        	0x21
+#define R22_UVGAIN_REG 		0x22
+#define R23_UOFFSET_REG        	0x23
+#define R24_VOFFSET_REG        	0x24
+#define R25_SHARPNESS_REG      	0x25
+
+#define R26_COMPR_REG  		0x26
+#define R27_OUTFMT_REG 		0x27
+
+#define R28_XMIN_REG   		0x28
+#define R29_XMAX_REG   		0x29
+#define R2A_YMIN_REG   		0x2a
+#define R2B_YMAX_REG   		0x2b
+
+#define R30_HSCALELOW_REG      	0x30
+#define R31_HSCALEHIGH_REG     	0x31
+#define R32_VSCALELOW_REG      	0x32
+#define R33_VSCALEHIGH_REG     	0x33
+
+#define R40_AC97LSB_REG        	0x40
+#define R41_AC97MSB_REG        	0x41
+#define R42_AC97ADDR_REG       	0x42
+#define R43_AC97BUSY_REG       	0x43
+
+/* em202 registers */
+#define R02_MASTER_AC97     	0x02
+#define R10_LINE_IN_AC97        0x10
+#define R14_VIDEO_AC97 		0x14
+
+/* em2800 registers */
+#define EM2800_AUDIOSRC_REG 	0x08
+
+/* register settings */
+#define EM2800_AUDIO_SRC_TUNER  0x0d
+#define EM2800_AUDIO_SRC_LINE   0x0c
+#define EM28XX_AUDIO_SRC_TUNER	0xc0
+#define EM28XX_AUDIO_SRC_LINE	0x80
+
+/* printk macros */
+
+#define em28xx_err(fmt, arg...) do {\
+	printk(KERN_ERR fmt , ##arg); } while (0)
+
+#define em28xx_errdev(fmt, arg...) do {\
+	printk(KERN_ERR "%s: "fmt,\
+			dev->name , ##arg); } while (0)
+
+#define em28xx_info(fmt, arg...) do {\
+	printk(KERN_INFO "%s: "fmt,\
+			dev->name , ##arg); } while (0)
+#define em28xx_warn(fmt, arg...) do {\
+	printk(KERN_WARNING "%s: "fmt,\
+			dev->name , ##arg); } while (0)
+
+void em28xx_config_i2c(struct em28xx *dev);
+int em28xx_config(struct em28xx *dev);
+
+static inline int em28xx_audio_source(struct em28xx *dev, int input)
+{
+	if (dev->em_type == EM2800) {
+		u8 tmp = EM2800_AUDIO_SRC_TUNER;
+		if (input == EM28XX_AUDIO_SRC_LINE)
+			tmp = EM2800_AUDIO_SRC_LINE;
+		em28xx_write_regs(dev, EM2800_AUDIOSRC_REG, &tmp, 1);
+	}
+	return em28xx_write_reg_bits(dev, R0E_AUDIOSRC_REG, input, 0xc0);
+}
+
+/* FIXME: return something sane here */
+
+#define EM28XX_MUTED   1
+#define EM28XX_UNMUTED 0
+
+static inline int em28xx_audio_usb_mute(struct em28xx *dev, int mute)
+{
+	switch (dev->em_type) {
+	case EM2750:
+		em28xx_write_regs(dev, R0F_XCLK_REG, "\x0a", 1);
+		break;
+	default:
+		em28xx_write_reg_bits(dev, R0F_XCLK_REG, mute ? 0x00 : 0x80, 0x80);
+	}
+	return 0;
+}
+
+static inline int em28xx_audio_analog_setup(struct em28xx *dev)
+{
+	/* unmute video mixer with default volume level */
+	return em28xx_write_ac97(dev, R14_VIDEO_AC97, "\x08\x08");
+}
+
+static inline int em28xx_audio_set_mixer(struct em28xx *dev, enum  enum28xx_mixchannel chan)
+{
+	int ret = 0;
+
+	if (chan == EM28XX_MIX_NOTOUCH)
+		return ret;
+	if ((ret = em28xx_write_ac97(dev, R10_LINE_IN_AC97,
+					chan == EM28XX_MIX_LINE_IN ?
+					"\x08\x08" : "\x08\x88")))
+		return ret;
+	if ((ret = em28xx_write_ac97(dev, R14_VIDEO_AC97, chan == EM28XX_MIX_VIDEO ?
+					"\x08\x08":"\x08\x88")))
+		return ret;
+	return ret;
+}
+
+static inline int em28xx_compression_disable(struct em28xx *dev)
+{
+	/* side effect of disabling scaler and mixer */
+	return em28xx_write_regs(dev, R26_COMPR_REG, "\x00", 1);
+}
+
+static inline int em28xx_contrast_get(struct em28xx *dev)
+{
+	return em28xx_read_reg(dev, R20_YGAIN_REG) & 0x1f;
+}
+
+static inline int em28xx_brightness_get(struct em28xx *dev)
+{
+	return em28xx_read_reg(dev, R21_YOFFSET_REG);
+}
+
+static inline int em28xx_saturation_get(struct em28xx *dev)
+{
+	return em28xx_read_reg(dev, R22_UVGAIN_REG) & 0x1f;
+}
+
+static inline int em28xx_u_balance_get(struct em28xx *dev)
+{
+	return em28xx_read_reg(dev, R23_UOFFSET_REG);
+}
+
+static inline int em28xx_v_balance_get(struct em28xx *dev)
+{
+	return em28xx_read_reg(dev, R24_VOFFSET_REG);
+}
+
+static inline int em28xx_gamma_get(struct em28xx *dev)
+{
+	return em28xx_read_reg(dev, R14_GAMMA_REG) & 0x3f;
+}
+
+static inline int em28xx_contrast_set(struct em28xx *dev, s32 val)
+{
+	u8 tmp = (u8) val;
+	return em28xx_write_regs(dev, R20_YGAIN_REG, &tmp, 1);
+}
+
+static inline int em28xx_brightness_set(struct em28xx *dev, s32 val)
+{
+	u8 tmp = (u8) val;
+	return em28xx_write_regs(dev, R21_YOFFSET_REG, &tmp, 1);
+}
+
+static inline int em28xx_saturation_set(struct em28xx *dev, s32 val)
+{
+	u8 tmp = (u8) val;
+	return em28xx_write_regs(dev, R22_UVGAIN_REG, &tmp, 1);
+}
+
+static inline int em28xx_u_balance_set(struct em28xx *dev, s32 val)
+{
+	u8 tmp = (u8) val;
+	return em28xx_write_regs(dev, R23_UOFFSET_REG, &tmp, 1);
+}
+
+static inline int em28xx_v_balance_set(struct em28xx *dev, s32 val)
+{
+	u8 tmp = (u8) val;
+	return em28xx_write_regs(dev, R24_VOFFSET_REG, &tmp, 1);
+}
+
+static inline int em28xx_gamma_set(struct em28xx *dev, s32 val)
+{
+	u8 tmp = (u8) val;
+	return em28xx_write_regs(dev, R14_GAMMA_REG, &tmp, 1);
+}
+
+/*FIXME: especially em2800 devices have a too small framebuffer
+  for 720/YUY2 frames */
+static inline unsigned int norm_maxw(struct em28xx *dev)
+{
+	switch (dev->model) {
+		default: return 720;
+	}
+}
+
+static inline unsigned int norm_maxh(struct em28xx *dev)
+{
+	switch (dev->model) {
+		default: return (dev->tvnorm->id & V4L2_STD_625_50) ? 576 : 480;
+	}
+}
+
+#endif