[media] tw68: refactor and cleanup the tw68 driver

Refactor and clean up the tw68 driver. It's now using the proper
V4L2 core frameworks.

Tested with my Techwell tw6805a and tw6816 grabber boards.

Signed-off-by: Hans Verkuil <hans.verkuil@cisco.com>
Signed-off-by: Mauro Carvalho Chehab <m.chehab@samsung.com>

12 files changed, 556 insertions, 3404 deletions

diff --git a/drivers/media/pci/tw68/Kconfig b/drivers/media/pci/tw68/Kconfig
new file mode 100644
index 000000000000..5425ba1e320d
--- /dev/null
+++ b/drivers/media/pci/tw68/Kconfig
@@ -0,0 +1,10 @@
+config VIDEO_TW68
+	tristate "Techwell tw68x Video For Linux"
+	depends on VIDEO_DEV && PCI && VIDEO_V4L2
+	select I2C_ALGOBIT
+	select VIDEOBUF2_DMA_SG
+	---help---
+	  Support for Techwell tw68xx based frame grabber boards.
+
+	  To compile this driver as a module, choose M here: the
+	  module will be called tw68.
diff --git a/drivers/media/pci/tw68/Makefile b/drivers/media/pci/tw68/Makefile
new file mode 100644
index 000000000000..3d02f28b14fb
--- /dev/null
+++ b/drivers/media/pci/tw68/Makefile
@@ -0,0 +1,3 @@
+tw68-objs := tw68-core.o tw68-video.o tw68-risc.o
+
+obj-$(CONFIG_VIDEO_TW68) += tw68.o
diff --git a/drivers/media/pci/tw68/tw68-cards.c b/drivers/media/pci/tw68/tw68-cards.c
deleted file mode 100644
index 62aec4faa0d1..000000000000
--- a/drivers/media/pci/tw68/tw68-cards.c
+++ /dev/null
@@ -1,172 +0,0 @@
-/*
- *  device driver for Techwell 68xx based cards
- *
- *  Much of this code is derived from the cx88 and sa7134 drivers, which
- *  were in turn derived from the bt87x driver.  The original work was by
- *  Gerd Knorr; more recently the code was enhanced by Mauro Carvalho Chehab,
- *  Hans Verkuil, Andy Walls and many others.  Their work is gratefully
- *  acknowledged.  Full credit goes to them - any problems within this code
- *  are mine.
- *
- *  Copyright (C) 2009  William M. Brack <wbrack@mmm.com.hk>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License along
- *  with this program; if not, write to the Free Software Foundation, Inc.,
- *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
- */
-
-#include <linux/init.h>
-#include <linux/module.h>
-#include <linux/i2c.h>		/* must appear before i2c-algo-bit.h */
-#include <linux/i2c-algo-bit.h>
-
-#include <media/v4l2-common.h>
-#include <media/tveeprom.h>
-
-#include "tw68.h"
-#include "tw68-reg.h"
-
-/* commly used strings */
-#if 0
-static char name_mute[]    = "mute";
-static char name_radio[]   = "Radio";
-static char name_tv[]      = "Television";
-static char name_tv_mono[] = "TV (mono only)";
-static char name_svideo[]  = "S-Video";
-static char name_comp[]    = "Composite";
-#endif
-static char name_comp1[]   = "Composite1";
-static char name_comp2[]   = "Composite2";
-static char name_comp3[]   = "Composite3";
-static char name_comp4[]   = "Composite4";
-
-/* ------------------------------------------------------------------ */
-/* board config info                                                  */
-
-/* If radio_type !=UNSET, radio_addr should be specified
- */
-
-struct tw68_board tw68_boards[] = {
-	[TW68_BOARD_UNKNOWN] = {
-		.name		= "GENERIC",
-		.tuner_type	= TUNER_ABSENT,
-		.radio_type     = UNSET,
-		.tuner_addr	= ADDR_UNSET,
-		.radio_addr	= ADDR_UNSET,
-
-		.inputs         = {
-			{
-				.name = name_comp1,
-				.vmux = 0,
-			}, {
-				.name = name_comp2,
-				.vmux = 1,
-			}, {
-				.name = name_comp3,
-				.vmux = 2,
-			}, {
-				.name = name_comp4,
-				.vmux = 3,
-			}, {	/* Must have a NULL entry at end of list */
-				.name = NULL,
-				.vmux = 0,
-			}
-		},
-	},
-};
-
-const unsigned int tw68_bcount = ARRAY_SIZE(tw68_boards);
-
-/*
- * Please add any new PCI IDs to: http://pci-ids.ucw.cz.  This keeps
- * the PCI ID database up to date.  Note that the entries must be
- * added under vendor 0x1797 (Techwell Inc.) as subsystem IDs.
- */
-struct pci_device_id tw68_pci_tbl[] = {
-	{
-		.vendor		= PCI_VENDOR_ID_TECHWELL,
-		.device		= PCI_DEVICE_ID_6800,
-		.subvendor	= PCI_ANY_ID,
-		.subdevice	= PCI_ANY_ID,
-		.driver_data	= TW68_BOARD_UNKNOWN,
-	}, {
-		.vendor		= PCI_VENDOR_ID_TECHWELL,
-		.device		= PCI_DEVICE_ID_6801,
-		.subvendor	= PCI_ANY_ID,
-		.subdevice	= PCI_ANY_ID,
-		.driver_data	= TW68_BOARD_UNKNOWN,
-	}, {
-		.vendor		= PCI_VENDOR_ID_TECHWELL,
-		.device		= PCI_DEVICE_ID_6804,
-		.subvendor	= PCI_ANY_ID,
-		.subdevice	= PCI_ANY_ID,
-		.driver_data	= TW68_BOARD_UNKNOWN,
-	}, {
-		.vendor		= PCI_VENDOR_ID_TECHWELL,
-		.device		= PCI_DEVICE_ID_6816_1,
-		.subvendor	= PCI_ANY_ID,
-		.subdevice	= PCI_ANY_ID,
-		.driver_data	= TW68_BOARD_UNKNOWN,
-	}, {
-		.vendor		= PCI_VENDOR_ID_TECHWELL,
-		.device		= PCI_DEVICE_ID_6816_2,
-		.subvendor	= PCI_ANY_ID,
-		.subdevice	= PCI_ANY_ID,
-		.driver_data	= TW68_BOARD_UNKNOWN,
-	}, {
-		.vendor		= PCI_VENDOR_ID_TECHWELL,
-		.device		= PCI_DEVICE_ID_6816_3,
-		.subvendor	= PCI_ANY_ID,
-		.subdevice	= PCI_ANY_ID,
-		.driver_data	= TW68_BOARD_UNKNOWN,
-	}, {
-		.vendor		= PCI_VENDOR_ID_TECHWELL,
-		.device		= PCI_DEVICE_ID_6816_4,
-		.subvendor	= PCI_ANY_ID,
-		.subdevice	= PCI_ANY_ID,
-		.driver_data	= TW68_BOARD_UNKNOWN,
-	}, {
-		/* end of list */
-	}
-};
-MODULE_DEVICE_TABLE(pci, tw68_pci_tbl);
-
-/* ------------------------------------------------------------ */
-/* stuff done before i2c enabled */
-int tw68_board_init1(struct tw68_dev *dev)
-{
-	/* Clear GPIO outputs */
-	tw_writel(TW68_GPOE, 0);
-	/* Remainder of setup according to board ID */
-	switch (dev->board) {
-	case TW68_BOARD_UNKNOWN:
-		printk(KERN_INFO "%s: Unable to determine board type, "
-				"using generic values\n", dev->name);
-		break;
-	}
-	dev->input = dev->hw_input = &card_in(dev,0);
-	return 0;
-}
-
-int tw68_tuner_setup(struct tw68_dev *dev)
-{
-	return 0;
-}
-
-/* stuff which needs working i2c */
-int tw68_board_init2(struct tw68_dev *dev)
-{
-	return 0;
-}
-
-
diff --git a/drivers/media/pci/tw68/tw68-core.c b/drivers/media/pci/tw68/tw68-core.c
index 2c5d7a5f3f8e..baf93af1d764 100644
--- a/drivers/media/pci/tw68/tw68-core.c
+++ b/drivers/media/pci/tw68/tw68-core.c
@@ -9,7 +9,11 @@
  *  acknowledged.  Full credit goes to them - any problems within this code
  *  are mine.
  *
- *  Copyright (C) 2009  William M. Brack <wbrack@mmm.com.hk>
+ *  Copyright (C) 2009  William M. Brack
+ *
+ *  Refactored and updated to the latest v4l core frameworks:
+ *
+ *  Copyright (C) 2014 Hans Verkuil <hverkuil@xs4all.nl>
  *
  *  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
@@ -20,10 +24,6 @@
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License along
- *  with this program; if not, write to the Free Software Foundation, Inc.,
- *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  */
 
 #include <linux/init.h>
@@ -44,320 +44,44 @@
 #include "tw68-reg.h"
 
 MODULE_DESCRIPTION("v4l2 driver module for tw6800 based video capture cards");
-MODULE_AUTHOR("William M. Brack <wbrack@mmm.com.hk>");
+MODULE_AUTHOR("William M. Brack");
+MODULE_AUTHOR("Hans Verkuil <hverkuil@xs4all.nl>");
 MODULE_LICENSE("GPL");
 
-static unsigned int core_debug;
-module_param(core_debug, int, 0644);
-MODULE_PARM_DESC(core_debug, "enable debug messages [core]");
-
-static unsigned int gpio_tracking;
-module_param(gpio_tracking, int, 0644);
-MODULE_PARM_DESC(gpio_tracking, "enable debug messages [gpio]");
-
-static unsigned int alsa = 1;
-module_param(alsa, int, 0644);
-MODULE_PARM_DESC(alsa, "enable/disable ALSA DMA sound [dmasound]");
-
 static unsigned int latency = UNSET;
 module_param(latency, int, 0444);
 MODULE_PARM_DESC(latency, "pci latency timer");
 
-static unsigned int nocomb;
-module_param(nocomb, int, 0644);
-MODULE_PARM_DESC(nocomb, "disable comb filter");
-
 static unsigned int video_nr[] = {[0 ... (TW68_MAXBOARDS - 1)] = UNSET };
-static unsigned int vbi_nr[]   = {[0 ... (TW68_MAXBOARDS - 1)] = UNSET };
-static unsigned int radio_nr[] = {[0 ... (TW68_MAXBOARDS - 1)] = UNSET };
-static unsigned int tuner[]    = {[0 ... (TW68_MAXBOARDS - 1)] = UNSET };
-static unsigned int card[]     = {[0 ... (TW68_MAXBOARDS - 1)] = UNSET };
-
 module_param_array(video_nr, int, NULL, 0444);
-module_param_array(vbi_nr,   int, NULL, 0444);
-module_param_array(radio_nr, int, NULL, 0444);
-module_param_array(tuner,    int, NULL, 0444);
-module_param_array(card,     int, NULL, 0444);
-
 MODULE_PARM_DESC(video_nr, "video device number");
-MODULE_PARM_DESC(vbi_nr,   "vbi device number");
-MODULE_PARM_DESC(radio_nr, "radio device number");
-MODULE_PARM_DESC(tuner,    "tuner type");
-MODULE_PARM_DESC(card,     "card type");
-
-LIST_HEAD(tw68_devlist);
-EXPORT_SYMBOL(tw68_devlist);
-DEFINE_MUTEX(tw68_devlist_lock);
-EXPORT_SYMBOL(tw68_devlist_lock);
-static LIST_HEAD(mops_list);
-static unsigned int tw68_devcount;      /* curr tot num of devices present */
 
-int (*tw68_dmasound_init)(struct tw68_dev *dev);
-EXPORT_SYMBOL(tw68_dmasound_init);
-int (*tw68_dmasound_exit)(struct tw68_dev *dev);
-EXPORT_SYMBOL(tw68_dmasound_exit);
+static unsigned int card[] = {[0 ... (TW68_MAXBOARDS - 1)] = UNSET };
+module_param_array(card, int, NULL, 0444);
+MODULE_PARM_DESC(card, "card type");
 
-#define dprintk(level, fmt, arg...)      if (core_debug & (level)) \
-	printk(KERN_DEBUG "%s: " fmt, dev->name , ## arg)
+static atomic_t tw68_instance = ATOMIC_INIT(0);
 
 /* ------------------------------------------------------------------ */
 
-void tw68_dma_free(struct videobuf_queue *q, struct tw68_buf *buf)
-{
-	struct videobuf_dmabuf *dma = videobuf_to_dma(&buf->vb);
-	
-	if (core_debug & DBG_FLOW)
-		printk(KERN_DEBUG "%s: called\n", __func__);
-	BUG_ON(in_interrupt());
-
-#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,36)
-	videobuf_waiton(&buf->vb, 0, 0);
-#else
-	videobuf_waiton(q, &buf->vb, 0, 0);
-#endif
-#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,35)	
-	videobuf_dma_unmap(q, dma);
-#else
-	videobuf_dma_unmap(q->dev, dma);
-#endif
-	videobuf_dma_free(dma);
-	/* if no risc area allocated, btcx_riscmem_free just returns */
-	btcx_riscmem_free(to_pci_dev(q->dev), &buf->risc);
-	buf->vb.state = VIDEOBUF_NEEDS_INIT;
-}
-
-/* ------------------------------------------------------------------ */
-/* ------------- placeholders for later development ----------------- */
-
-static int tw68_input_init1(struct tw68_dev *dev)
-{
-	return 0;
-}
-
-static void tw68_input_fini(struct tw68_dev *dev)
-{
-	return;
-}
-
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,38)
-static void tw68_ir_start(struct tw68_dev *dev, struct card_ir *ir)
-{
-	return;
-}
-
-static void tw68_ir_stop(struct tw68_dev *dev)
-{
-	return;
-}
-#endif
-
-/* ------------------------------------------------------------------ */
 /*
- * Buffer handling routines
- *
- * These routines are "generic", i.e. are intended to be used by more
- * than one module, e.g. the video and the transport stream modules.
- * To accomplish this generality, callbacks are used whenever some
- * module-specific test or action is required.
+ * Please add any new PCI IDs to: http://pci-ids.ucw.cz.  This keeps
+ * the PCI ID database up to date.  Note that the entries must be
+ * added under vendor 0x1797 (Techwell Inc.) as subsystem IDs.
  */
-
-/* resends a current buffer in queue after resume */
-int tw68_buffer_requeue(struct tw68_dev *dev,
-				  struct tw68_dmaqueue *q)
-{
-	struct tw68_buf *buf, *prev;
-
-	dprintk(DBG_FLOW | DBG_TESTING, "%s: called\n", __func__);
-	if (!list_empty(&q->active)) {
-		buf = list_entry(q->active.next, struct tw68_buf, vb.queue);
-		dprintk(DBG_BUFF, "%s: [%p/%d] restart dma\n", __func__,
-			buf, buf->vb.i);
-		q->start_dma(dev, q, buf);
-		mod_timer(&q->timeout, jiffies + BUFFER_TIMEOUT);
-		return 0;
-	}
-
-	prev = NULL;
-	for (;;) {
-		if (list_empty(&q->queued))
-			return 0;
-		buf = list_entry(q->queued.next, struct tw68_buf, vb.queue);
-		/* if nothing precedes this one */
-		if (NULL == prev) {
-			list_move_tail(&buf->vb.queue, &q->active);
-			q->start_dma(dev, q, buf);
-			buf->activate(dev, buf, NULL);
-			dprintk(DBG_BUFF, "%s: [%p/%d] first active\n",
-				__func__, buf, buf->vb.i);
-
-		} else if (q->buf_compat(prev, buf) &&
-			   (prev->fmt == buf->fmt)) {
-			list_move_tail(&buf->vb.queue, &q->active);
-			buf->activate(dev, buf, NULL);
-			prev->risc.jmp[1] = cpu_to_le32(buf->risc.dma);
-			dprintk(DBG_BUFF, "%s: [%p/%d] move to active\n",
-				__func__, buf, buf->vb.i);
-		} else {
-			dprintk(DBG_BUFF, "%s: no action taken\n", __func__);
-			return 0;
-		}
-		prev = buf;
-	}
-}
-
-/* nr of (tw68-)pages for the given buffer size */
-static int tw68_buffer_pages(int size)
-{
-	size  = PAGE_ALIGN(size);
-	size += PAGE_SIZE; /* for non-page-aligned buffers */
-	size /= 4096;
-	return size;
-}
-
-/* calc max # of buffers from size (must not exceed the 4MB virtual
- * address space per DMA channel) */
-int tw68_buffer_count(unsigned int size, unsigned int count)
-{
-	unsigned int maxcount;
-
-	maxcount = 1024 / tw68_buffer_pages(size);
-	if (count > maxcount)
-		count = maxcount;
-	return count;
-}
-
-/*
- * tw68_wakeup
- *
- * Called when the driver completes filling a buffer, and tasks waiting
- * for the data need to be awakened.
- */
-void tw68_wakeup(struct tw68_dmaqueue *q, unsigned int *fc)
-{
-	struct tw68_dev *dev = q->dev;
-	struct tw68_buf *buf;
-
-	dprintk(DBG_FLOW, "%s: called\n", __func__);
-	if (list_empty(&q->active)) {
-		dprintk(DBG_BUFF | DBG_TESTING, "%s: active list empty",
-			__func__);
-		del_timer(&q->timeout);
-		return;
-	}
-	buf = list_entry(q->active.next, struct tw68_buf, vb.queue);
-	do_gettimeofday(&buf->vb.ts);
-	buf->vb.field_count = (*fc)++;
-	dprintk(DBG_BUFF | DBG_TESTING, "%s: [%p/%d] field_count=%d\n",
-		__func__, buf, buf->vb.i, *fc);
-	buf->vb.state = VIDEOBUF_DONE;
-	list_del(&buf->vb.queue);
-	wake_up(&buf->vb.done);
-	mod_timer(&q->timeout, jiffies + BUFFER_TIMEOUT);
-}
-
-/*
- * tw68_buffer_queue
- *
- * Add specified buffer to specified queue
- */
-void tw68_buffer_queue(struct tw68_dev *dev,
-			 struct tw68_dmaqueue *q,
-			 struct tw68_buf *buf)
-{
-	struct tw68_buf    *prev;
-
-	dprintk(DBG_FLOW, "%s: called\n", __func__);
-	assert_spin_locked(&dev->slock);
-	dprintk(DBG_BUFF, "%s: queuing buffer %p\n", __func__, buf);
-
-	/* append a 'JUMP to stopper' to the buffer risc program */
-	buf->risc.jmp[0] = cpu_to_le32(RISC_JUMP | RISC_INT_BIT);
-	buf->risc.jmp[1] = cpu_to_le32(q->stopper.dma);
-
-	/* if this buffer is not "compatible" (in dimensions and format)
-	 * with the currently active chain of buffers, we must change
-	 * settings before filling it; if a previous buffer has already
-	 * been determined to require changes, this buffer must follow
-	 * it.  To do this, we maintain a "queued" chain.  If that
-	 * chain exists, append this buffer to it */
-	if (!list_empty(&q->queued)) {
-		list_add_tail(&buf->vb.queue, &q->queued);
-		buf->vb.state = VIDEOBUF_QUEUED;
-		dprintk(DBG_BUFF, "%s: [%p/%d] appended to queued\n",
-			__func__, buf, buf->vb.i);
-
-	/* else if the 'active' chain doesn't yet exist we create it now */
-	} else if (list_empty(&q->active)) {
-		dprintk(DBG_BUFF, "%s: [%p/%d] first active\n",
-			__func__, buf, buf->vb.i);
-		list_add_tail(&buf->vb.queue, &q->active);
-		q->start_dma(dev, q, buf);	/* 1st one - start dma */
-		/* TODO - why have we removed buf->count and q->count? */
-		buf->activate(dev, buf, NULL);
-
-	/* else we would like to put this buffer on the tail of the
-	 * active chain, provided it is "compatible". */
-	} else {
-		/* "compatibility" depends upon the type of buffer */
-		prev = list_entry(q->active.prev, struct tw68_buf, vb.queue);
-		if (q->buf_compat(prev, buf)) {
-			/* If "compatible", append to active chain */
-			prev->risc.jmp[1] = cpu_to_le32(buf->risc.dma);
-			/* the param 'prev' is only for debug printing */
-			buf->activate(dev, buf, prev);
-			list_add_tail(&buf->vb.queue, &q->active);
-			dprintk(DBG_BUFF, "%s: [%p/%d] appended to active\n",
-				__func__, buf, buf->vb.i);
-		} else {
-			/* If "incompatible", append to queued chain */
-			list_add_tail(&buf->vb.queue, &q->queued);
-			buf->vb.state = VIDEOBUF_QUEUED;
-			dprintk(DBG_BUFF, "%s: [%p/%d] incompatible - appended "
-				"to queued\n", __func__, buf, buf->vb.i);
-		}
-	}
-}
-
-/*
- * tw68_buffer_timeout
- *
- * This routine is set as the video_q.timeout.function
- *
- * Log the event, try to reset the h/w.
- * Flag the current buffer as failed, try to start again with next buff
- */
-void tw68_buffer_timeout(unsigned long data)
-{
-	struct tw68_dmaqueue *q = (struct tw68_dmaqueue *)data;
-	struct tw68_dev *dev = q->dev;
-	struct tw68_buf *buf;
-	unsigned long flags;
-
-	dprintk(DBG_FLOW, "%s: called\n", __func__);
-	spin_lock_irqsave(&dev->slock, flags);
-
-	/* flag all current active buffers as failed */
-	while (!list_empty(&q->active)) {
-		buf = list_entry(q->active.next, struct tw68_buf, vb.queue);
-		list_del(&buf->vb.queue);
-		buf->vb.state = VIDEOBUF_ERROR;
-		wake_up(&buf->vb.done);
-		printk(KERN_INFO "%s/0: [%p/%d] timeout - dma=0x%08lx\n",
-			dev->name, buf, buf->vb.i,
-			(unsigned long)buf->risc.dma);
-	}
-	tw68_buffer_requeue(dev, q);
-	spin_unlock_irqrestore(&dev->slock, flags);
-}
+struct pci_device_id tw68_pci_tbl[] = {
+	{PCI_DEVICE(PCI_VENDOR_ID_TECHWELL, PCI_DEVICE_ID_6800)},
+	{PCI_DEVICE(PCI_VENDOR_ID_TECHWELL, PCI_DEVICE_ID_6801)},
+	{PCI_DEVICE(PCI_VENDOR_ID_TECHWELL, PCI_DEVICE_ID_6804)},
+	{PCI_DEVICE(PCI_VENDOR_ID_TECHWELL, PCI_DEVICE_ID_6816_1)},
+	{PCI_DEVICE(PCI_VENDOR_ID_TECHWELL, PCI_DEVICE_ID_6816_2)},
+	{PCI_DEVICE(PCI_VENDOR_ID_TECHWELL, PCI_DEVICE_ID_6816_3)},
+	{PCI_DEVICE(PCI_VENDOR_ID_TECHWELL, PCI_DEVICE_ID_6816_4)},
+	{0,}
+};
 
 /* ------------------------------------------------------------------ */
-/* early init (no i2c, no irq) */
 
-/* Called from tw68_hw_init1 and tw68_resume */
-static int tw68_hw_enable1(struct tw68_dev *dev)
-{
-	return 0;
-}
 
 /*
  * The device is given a "soft reset". According to the specifications,
@@ -367,7 +91,6 @@ static int tw68_hw_enable1(struct tw68_dev *dev)
  */
 static int tw68_hw_init1(struct tw68_dev *dev)
 {
-	dprintk(DBG_FLOW, "%s: called\n", __func__);
 	/* Assure all interrupts are disabled */
 	tw_writel(TW68_INTMASK, 0);		/* 020 */
 	/* Clear any pending interrupts */
@@ -415,7 +138,7 @@ static int tw68_hw_init1(struct tw68_dev *dev)
 	tw_writeb(TW68_AGCGAIN, 0xf0);	/* 288	AGC gain when loop disabled */
 	tw_writeb(TW68_PEAKWT, 0xd8);	/* 28C	White peak threshold */
 	tw_writeb(TW68_CLMPL, 0x3c);	/* 290	Y channel clamp level */
-//	tw_writeb(TW68_SYNCT, 0x38);	/* 294	Sync amplitude */
+/*	tw_writeb(TW68_SYNCT, 0x38);*/	/* 294	Sync amplitude */
 	tw_writeb(TW68_SYNCT, 0x30);	/* 294	Sync amplitude */
 	tw_writeb(TW68_MISSCNT, 0x44);	/* 298	Horiz sync, VCR detect sens */
 	tw_writeb(TW68_PCLAMP, 0x28);	/* 29C	Clamp pos from PLL sync */
@@ -465,80 +188,9 @@ static int tw68_hw_init1(struct tw68_dev *dev)
 
 	/* Initialize any subsystems */
 	tw68_video_init1(dev);
-	tw68_vbi_init1(dev);
-	if (card_has_mpeg(dev))
-		tw68_ts_init1(dev);
-	tw68_input_init1(dev);
-
-	/* Do any other h/w early initialisation at this point */
-	tw68_hw_enable1(dev);
-
-	return 0;
-}
-
-/* late init (with i2c + irq) */
-static int tw68_hw_enable2(struct tw68_dev *dev)
-{
-
-	dprintk(DBG_FLOW, "%s: called\n", __func__);
-#ifdef	TW68_TESTING
-	dev->pci_irqmask |= TW68_I2C_INTS;
-#endif
-	tw_setl(TW68_INTMASK, dev->pci_irqmask);
 	return 0;
 }
 
-static int tw68_hw_init2(struct tw68_dev *dev)
-{
-	dprintk(DBG_FLOW, "%s: called\n", __func__);
-	tw68_video_init2(dev);	/* initialise video function first */
-	tw68_tvaudio_init2(dev);/* audio next */
-
-	/* all other board-related things, incl. enabling interrupts */
-	tw68_hw_enable2(dev);
-	return 0;
-}
-
-/* shutdown */
-static int tw68_hwfini(struct tw68_dev *dev)
-{
-	dprintk(DBG_FLOW, "%s: called\n", __func__);
-	if (card_has_mpeg(dev))
-		tw68_ts_fini(dev);
-	tw68_input_fini(dev);
-	tw68_vbi_fini(dev);
-	tw68_tvaudio_fini(dev);
-	return 0;
-}
-
-static void __devinit must_configure_manually(void)
-{
-	unsigned int i, p;
-
-	printk(KERN_WARNING
-	       "tw68: <rant>\n"
-	       "tw68:  Congratulations!  Your TV card vendor saved a few\n"
-	       "tw68:  cents for a eeprom, thus your pci board has no\n"
-	       "tw68:  subsystem ID and I can't identify it automatically\n"
-	       "tw68: </rant>\n"
-	       "tw68: I feel better now.  Ok, here is the good news:\n"
-	       "tw68: You can use the card=<nr> insmod option to specify\n"
-	       "tw68: which board you have.  The list:\n");
-	for (i = 0; i < tw68_bcount; i++) {
-		printk(KERN_WARNING "tw68:   card=%d -> %-40.40s",
-		       i, tw68_boards[i].name);
-		for (p = 0; tw68_pci_tbl[p].driver_data; p++) {
-			if (tw68_pci_tbl[p].driver_data != i)
-				continue;
-			printk(" %04x:%04x",
-			       tw68_pci_tbl[p].subvendor,
-			       tw68_pci_tbl[p].subdevice);
-		}
-		printk("\n");
-	}
-}
-
-
 static irqreturn_t tw68_irq(int irq, void *dev_id)
 {
 	struct tw68_dev *dev = dev_id;
@@ -548,126 +200,39 @@ static irqreturn_t tw68_irq(int irq, void *dev_id)
 	status = orig = tw_readl(TW68_INTSTAT) & dev->pci_irqmask;
 	/* Check if anything to do */
 	if (0 == status)
-		return IRQ_RETVAL(0);	/* Nope - return */
+		return IRQ_NONE;	/* Nope - return */
 	for (loop = 0; loop < 10; loop++) {
 		if (status & dev->board_virqmask)	/* video interrupt */
 			tw68_irq_video_done(dev, status);
-#ifdef TW68_TESTING
-		if (status & TW68_I2C_INTS)
-			tw68_irq_i2c(dev, status);
-#endif
 		status = tw_readl(TW68_INTSTAT) & dev->pci_irqmask;
 		if (0 == status)
-			goto out;
+			return IRQ_HANDLED;
 	}
-	dprintk(DBG_UNEXPECTED, "%s: **** INTERRUPT NOT HANDLED - clearing mask"
-				" (orig 0x%08x, cur 0x%08x)",
-				dev->name, orig, tw_readl(TW68_INTSTAT));
-	dprintk(DBG_UNEXPECTED, "%s: pci_irqmask 0x%08x; board_virqmask "
-				"0x%08x ****\n", dev->name,
-				dev->pci_irqmask, dev->board_virqmask);
+	dev_dbg(&dev->pci->dev, "%s: **** INTERRUPT NOT HANDLED - clearing mask (orig 0x%08x, cur 0x%08x)",
+			dev->name, orig, tw_readl(TW68_INTSTAT));
+	dev_dbg(&dev->pci->dev, "%s: pci_irqmask 0x%08x; board_virqmask 0x%08x ****\n",
+			dev->name, dev->pci_irqmask, dev->board_virqmask);
 	tw_clearl(TW68_INTMASK, dev->pci_irqmask);
-out:
-	return IRQ_RETVAL(1);
-}
-
-int tw68_set_dmabits(struct tw68_dev *dev)
-{
-	return 0;
-}
-
-static struct video_device *vdev_init(struct tw68_dev *dev,
-				      struct video_device *template,
-				      char *type)
-{
-	struct video_device *vfd;
-
-	dprintk(DBG_FLOW, "%s: called\n", __func__);
-	vfd = video_device_alloc();
-	if (NULL == vfd)
-		return NULL;
-	*vfd = *template;
-	vfd->minor   = -1;
-	vfd->parent  = &dev->pci->dev;
-	vfd->release = video_device_release;
-	/* vfd->debug   = tw_video_debug; */
-	snprintf(vfd->name, sizeof(vfd->name), "%s %s (%s)",
-		 dev->name, type, tw68_boards[dev->board].name);
-	return vfd;
+	return IRQ_HANDLED;
 }
 
-static void tw68_unregister_video(struct tw68_dev *dev)
-{
-
-	dprintk(DBG_FLOW, "%s: called\n", __func__);
-	if (dev->video_dev) {
-		if (-1 != dev->video_dev->minor)
-			video_unregister_device(dev->video_dev);
-		else
-			video_device_release(dev->video_dev);
-		dev->video_dev = NULL;
-	}
-	if (dev->vbi_dev) {
-		if (-1 != dev->vbi_dev->minor)
-			video_unregister_device(dev->vbi_dev);
-		else
-			video_device_release(dev->vbi_dev);
-		dev->vbi_dev = NULL;
-	}
-	if (dev->radio_dev) {
-		if (-1 != dev->radio_dev->minor)
-			video_unregister_device(dev->radio_dev);
-		else
-			video_device_release(dev->radio_dev);
-		dev->radio_dev = NULL;
-	}
-}
-
-static void mpeg_ops_attach(struct tw68_mpeg_ops *ops,
-			    struct tw68_dev *dev)
-{
-	int err;
-
-	dprintk(DBG_FLOW, "%s: called\n", __func__);
-	if (NULL != dev->mops)
-		return;
-	if (tw68_boards[dev->board].mpeg != ops->type)
-		return;
-	err = ops->init(dev);
-	if (0 != err)
-		return;
-	dev->mops = ops;
-}
-
-static void mpeg_ops_detach(struct tw68_mpeg_ops *ops,
-			    struct tw68_dev *dev)
-{
-
-	if (NULL == dev->mops)
-		return;
-	if (dev->mops != ops)
-		return;
-	dev->mops->fini(dev);
-	dev->mops = NULL;
-}
-
-static int __devinit tw68_initdev(struct pci_dev *pci_dev,
+static int tw68_initdev(struct pci_dev *pci_dev,
 				     const struct pci_device_id *pci_id)
 {
 	struct tw68_dev *dev;
-	struct tw68_mpeg_ops *mops;
+	int vidnr = -1;
 	int err;
 
-	if (tw68_devcount == TW68_MAXBOARDS)
-		return -ENOMEM;
-
-	dev = kzalloc(sizeof(*dev), GFP_KERNEL);
+	dev = devm_kzalloc(&pci_dev->dev, sizeof(*dev), GFP_KERNEL);
 	if (NULL == dev)
 		return -ENOMEM;
 
+	dev->instance = v4l2_device_set_name(&dev->v4l2_dev, "tw68",
+						&tw68_instance);
+
 	err = v4l2_device_register(&pci_dev->dev, &dev->v4l2_dev);
 	if (err)
-		goto fail0;
+		return err;
 
 	/* pci init */
 	dev->pci = pci_dev;
@@ -676,33 +241,10 @@ static int __devinit tw68_initdev(struct pci_dev *pci_dev,
 		goto fail1;
 	}
 
-	dev->nr = tw68_devcount;
-	sprintf(dev->name, "tw%x[%d]", pci_dev->device, dev->nr);
+	dev->name = dev->v4l2_dev.name;
 
-	/* pci quirks */
-	if (pci_pci_problems) {
-		if (pci_pci_problems & PCIPCI_TRITON)
-			printk(KERN_INFO "%s: quirk: PCIPCI_TRITON\n",
-				dev->name);
-		if (pci_pci_problems & PCIPCI_NATOMA)
-			printk(KERN_INFO "%s: quirk: PCIPCI_NATOMA\n",
-				dev->name);
-		if (pci_pci_problems & PCIPCI_VIAETBF)
-			printk(KERN_INFO "%s: quirk: PCIPCI_VIAETBF\n",
-				dev->name);
-		if (pci_pci_problems & PCIPCI_VSFX)
-			printk(KERN_INFO "%s: quirk: PCIPCI_VSFX\n",
-				dev->name);
-#ifdef PCIPCI_ALIMAGIK
-		if (pci_pci_problems & PCIPCI_ALIMAGIK) {
-			printk(KERN_INFO "%s: quirk: PCIPCI_ALIMAGIK "
-				"-- latency fixup\n", dev->name);
-			latency = 0x0A;
-		}
-#endif
-	}
 	if (UNSET != latency) {
-		printk(KERN_INFO "%s: setting pci latency timer to %d\n",
+		pr_info("%s: setting pci latency timer to %d\n",
 		       dev->name, latency);
 		pci_write_config_byte(pci_dev, PCI_LATENCY_TIMER, latency);
 	}
@@ -710,13 +252,12 @@ static int __devinit tw68_initdev(struct pci_dev *pci_dev,
 	/* print pci info */
 	pci_read_config_byte(pci_dev, PCI_CLASS_REVISION, &dev->pci_rev);
 	pci_read_config_byte(pci_dev, PCI_LATENCY_TIMER,  &dev->pci_lat);
-	printk(KERN_INFO "%s: found at %s, rev: %d, irq: %d, "
-	       "latency: %d, mmio: 0x%llx\n", dev->name,
-	       pci_name(pci_dev), dev->pci_rev, pci_dev->irq, dev->pci_lat,
-	       (unsigned long long)pci_resource_start(pci_dev, 0));
+	pr_info("%s: found at %s, rev: %d, irq: %d, latency: %d, mmio: 0x%llx\n",
+		dev->name, pci_name(pci_dev), dev->pci_rev, pci_dev->irq,
+		dev->pci_lat, (u64)pci_resource_start(pci_dev, 0));
 	pci_set_master(pci_dev);
 	if (!pci_dma_supported(pci_dev, DMA_BIT_MASK(32))) {
-		printk("%s: Oops: no 32bit PCI DMA ???\n", dev->name);
+		pr_info("%s: Oops: no 32bit PCI DMA ???\n", dev->name);
 		err = -EIO;
 		goto fail1;
 	}
@@ -730,7 +271,7 @@ static int __devinit tw68_initdev(struct pci_dev *pci_dev,
 		dev->vdecoder = TW6801;
 		dev->board_virqmask = TW68_VID_INTS | TW68_VID_INTSX;
 		break;
-	case PCI_DEVICE_ID_6804:	/* Video decoder for TW6805 */
+	case PCI_DEVICE_ID_6804:	/* Video decoder for TW6804 */
 		dev->vdecoder = TW6804;
 		dev->board_virqmask = TW68_VID_INTS | TW68_VID_INTSX;
 		break;
@@ -739,35 +280,13 @@ static int __devinit tw68_initdev(struct pci_dev *pci_dev,
 		dev->board_virqmask = TW68_VID_INTS | TW68_VID_INTSX;
 		break;
 	}
-	/* board config */
-	dev->board = pci_id->driver_data;
-	if (card[dev->nr] >= 0 &&
-	    card[dev->nr] < tw68_bcount)
-		dev->board = card[dev->nr];
-	if (TW68_BOARD_NOAUTO == dev->board) {
-		must_configure_manually();
-		dev->board = TW68_BOARD_UNKNOWN;
-	}
-	dev->autodetected = card[dev->nr] != dev->board;
-	dev->tuner_type = tw68_boards[dev->board].tuner_type;
-	dev->tuner_addr = tw68_boards[dev->board].tuner_addr;
-	dev->radio_type = tw68_boards[dev->board].radio_type;
-	dev->radio_addr = tw68_boards[dev->board].radio_addr;
-	dev->tda9887_conf = tw68_boards[dev->board].tda9887_conf;
-	if (UNSET != tuner[dev->nr])
-		dev->tuner_type = tuner[dev->nr];
-	printk(KERN_INFO "%s: subsystem: %04x:%04x, board: %s [card=%d,%s]\n",
-		dev->name, pci_dev->subsystem_vendor,
-		pci_dev->subsystem_device, tw68_boards[dev->board].name,
-		dev->board, dev->autodetected ?
-		"autodetected" : "insmod option");
 
 	/* get mmio */
 	if (!request_mem_region(pci_resource_start(pci_dev, 0),
 				pci_resource_len(pci_dev, 0),
 				dev->name)) {
 		err = -EBUSY;
-		printk(KERN_ERR "%s: can't get MMIO memory @ 0x%llx\n",
+		pr_err("%s: can't get MMIO memory @ 0x%llx\n",
 			dev->name,
 			(unsigned long long)pci_resource_start(pci_dev, 0));
 		goto fail1;
@@ -777,185 +296,75 @@ static int __devinit tw68_initdev(struct pci_dev *pci_dev,
 	dev->bmmio = (__u8 __iomem *)dev->lmmio;
 	if (NULL == dev->lmmio) {
 		err = -EIO;
-		printk(KERN_ERR "%s: can't ioremap() MMIO memory\n",
+		pr_err("%s: can't ioremap() MMIO memory\n",
 		       dev->name);
 		goto fail2;
 	}
 	/* initialize hardware #1 */
-	/* First, take care of anything unique to a particular card */
-	tw68_board_init1(dev);
 	/* Then do any initialisation wanted before interrupts are on */
 	tw68_hw_init1(dev);
 
 	/* get irq */
-	err = request_irq(pci_dev->irq, tw68_irq,
+	err = devm_request_irq(&pci_dev->dev, pci_dev->irq, tw68_irq,
 			  IRQF_SHARED | IRQF_DISABLED, dev->name, dev);
 	if (err < 0) {
-		printk(KERN_ERR "%s: can't get IRQ %d\n",
+		pr_err("%s: can't get IRQ %d\n",
 		       dev->name, pci_dev->irq);
 		goto fail3;
 	}
 
-#ifdef TW68_TESTING
-	dev->pci_irqmask |= TW68_SBDONE;
-	tw_setl(TW68_INTMASK, dev->pci_irqmask);
-	printk(KERN_INFO "Calling tw68_i2c_register\n");
-	/* Register the i2c bus */
-	tw68_i2c_register(dev);
-#endif
-
 	/*
 	 *  Now do remainder of initialisation, first for
 	 *  things unique for this card, then for general board
 	 */
-	tw68_board_init2(dev);
-
-	tw68_hw_init2(dev);
-
-#if 0
-	/* load i2c helpers */
-	if (card_is_empress(dev)) {
-		struct v4l2_subdev *sd =
-			v4l2_i2c_new_subdev(&dev->i2c_adap, "saa6752hs",
-				"saa6752hs", 0x20);
-
-		if (sd)
-			sd->grp_id = GRP_EMPRESS;
-	}
-
-	request_submodules(dev);
-#endif
-
-	v4l2_prio_init(&dev->prio);
-
-	mutex_lock(&tw68_devlist_lock);
-	list_for_each_entry(mops, &mops_list, next)
-		mpeg_ops_attach(mops, dev);
-	list_add_tail(&dev->devlist, &tw68_devlist);
-	mutex_unlock(&tw68_devlist_lock);
-
-	/* check for signal */
-	tw68_irq_video_signalchange(dev);
-
-#if 0
-	if (TUNER_ABSENT != dev->tuner_type)
-		tw_call_all(dev, core, s_standby, 0);
-#endif
-
-	dev->video_dev = vdev_init(dev, &tw68_video_template, "video");
-	err = video_register_device(dev->video_dev, VFL_TYPE_GRABBER,
-				    video_nr[dev->nr]);
+	if (dev->instance < TW68_MAXBOARDS)
+		vidnr = video_nr[dev->instance];
+	/* initialise video function first */
+	err = tw68_video_init2(dev, vidnr);
 	if (err < 0) {
-		printk(KERN_INFO "%s: can't register video device\n",
+		pr_err("%s: can't register video device\n",
 		       dev->name);
 		goto fail4;
 	}
-	printk(KERN_INFO "%s: registered device video%d [v4l2]\n",
-	       dev->name, dev->video_dev->num);
-
-	dev->vbi_dev = vdev_init(dev, &tw68_video_template, "vbi");
-
-	err = video_register_device(dev->vbi_dev, VFL_TYPE_VBI,
-				    vbi_nr[dev->nr]);
-	if (err < 0) {
-		printk(KERN_INFO "%s: can't register vbi device\n",
-			dev->name);
-		goto fail4;
-	}
-	printk(KERN_INFO "%s: registered device vbi%d\n",
-	       dev->name, dev->vbi_dev->num);
-
-	if (card_has_radio(dev)) {
-		dev->radio_dev = vdev_init(dev, &tw68_radio_template,
-					   "radio");
-		err = video_register_device(dev->radio_dev, VFL_TYPE_RADIO,
-					    radio_nr[dev->nr]);
-		if (err < 0) {
-			/* TODO - need to unregister vbi? */
-			printk(KERN_INFO "%s: can't register radio device\n",
-				dev->name);
-			goto fail4;
-		}
-		printk(KERN_INFO "%s: registered device radio%d\n",
-		       dev->name, dev->radio_dev->num);
-	}
-
-	/* everything worked */
-	tw68_devcount++;
+	tw_setl(TW68_INTMASK, dev->pci_irqmask);
 
-	if (tw68_dmasound_init && !dev->dmasound.priv_data)
-		tw68_dmasound_init(dev);
+	pr_info("%s: registered device %s\n",
+	       dev->name, video_device_node_name(&dev->vdev));
 
 	return 0;
 
- fail4:
-	tw68_unregister_video(dev);
-#ifdef TW68_TESTING
-	tw68_i2c_unregister(dev);
-#endif
-	free_irq(pci_dev->irq, dev);
- fail3:
-	tw68_hwfini(dev);
+fail4:
+	video_unregister_device(&dev->vdev);
+fail3:
 	iounmap(dev->lmmio);
- fail2:
+fail2:
 	release_mem_region(pci_resource_start(pci_dev, 0),
 			   pci_resource_len(pci_dev, 0));
- fail1:
+fail1:
 	v4l2_device_unregister(&dev->v4l2_dev);
- fail0:
-	kfree(dev);
 	return err;
 }
 
-static void __devexit tw68_finidev(struct pci_dev *pci_dev)
+static void tw68_finidev(struct pci_dev *pci_dev)
 {
 	struct v4l2_device *v4l2_dev = pci_get_drvdata(pci_dev);
 	struct tw68_dev *dev =
 		container_of(v4l2_dev, struct tw68_dev, v4l2_dev);
-	struct tw68_mpeg_ops *mops;
-
-	dprintk(DBG_FLOW, "%s: called\n", __func__);
-	/* Release DMA sound modules if present */
-	if (tw68_dmasound_exit && dev->dmasound.priv_data)
-		tw68_dmasound_exit(dev);
 
 	/* shutdown subsystems */
-	tw68_hwfini(dev);
 	tw_clearl(TW68_DMAC, TW68_DMAP_EN | TW68_FIFO_EN);
 	tw_writel(TW68_INTMASK, 0);
 
 	/* unregister */
-	mutex_lock(&tw68_devlist_lock);
-	list_del(&dev->devlist);
-	list_for_each_entry(mops, &mops_list, next)
-		mpeg_ops_detach(mops, dev);
-	mutex_unlock(&tw68_devlist_lock);
-	tw68_devcount--;
-
-#ifdef TW68_TESTING
-	tw68_i2c_unregister(dev);
-#endif
-	tw68_unregister_video(dev);
-
-
-	/* the DMA sound modules should be unloaded before reaching
-	   this, but just in case they are still present... */
-	if (dev->dmasound.priv_data != NULL) {
-		free_irq(pci_dev->irq, &dev->dmasound);
-		dev->dmasound.priv_data = NULL;
-	}
-
+	video_unregister_device(&dev->vdev);
+	v4l2_ctrl_handler_free(&dev->hdl);
 
 	/* release resources */
-	free_irq(pci_dev->irq, dev);
 	iounmap(dev->lmmio);
 	release_mem_region(pci_resource_start(pci_dev, 0),
 			   pci_resource_len(pci_dev, 0));
 
 	v4l2_device_unregister(&dev->v4l2_dev);
-
-	/* free memory */
-	kfree(dev);
 }
 
 #ifdef CONFIG_PM
@@ -966,28 +375,15 @@ static int tw68_suspend(struct pci_dev *pci_dev , pm_message_t state)
 	struct tw68_dev *dev = container_of(v4l2_dev,
 				struct tw68_dev, v4l2_dev);
 
-	dprintk(DBG_FLOW, "%s: called\n", __func__);
 	tw_clearl(TW68_DMAC, TW68_DMAP_EN | TW68_FIFO_EN);
 	dev->pci_irqmask &= ~TW68_VID_INTS;
 	tw_writel(TW68_INTMASK, 0);
 
-	dev->insuspend = 1;
 	synchronize_irq(pci_dev->irq);
 
-	/* Disable timeout timers - if we have active buffers, we will
-	   fill them on resume*/
-
-	del_timer(&dev->video_q.timeout);
-	del_timer(&dev->vbi_q.timeout);
-	del_timer(&dev->ts_q.timeout);
-
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,38)
-   if (dev->remote)
-		tw68_ir_stop(dev);
-#endif
-
 	pci_save_state(pci_dev);
 	pci_set_power_state(pci_dev, pci_choose_state(pci_dev, state));
+	vb2_discard_done(&dev->vidq);
 
 	return 0;
 }
@@ -997,54 +393,25 @@ static int tw68_resume(struct pci_dev *pci_dev)
 	struct v4l2_device *v4l2_dev = pci_get_drvdata(pci_dev);
 	struct tw68_dev *dev = container_of(v4l2_dev,
 					    struct tw68_dev, v4l2_dev);
+	struct tw68_buf *buf;
 	unsigned long flags;
 
-	dprintk(DBG_FLOW, "%s: called\n", __func__);
 	pci_set_power_state(pci_dev, PCI_D0);
 	pci_restore_state(pci_dev);
 
 	/* Do things that are done in tw68_initdev ,
 		except of initializing memory structures.*/
 
-	tw68_board_init1(dev);
-
-	/* tw68_hw_init1 */
-	if (tw68_boards[dev->board].video_out)
-		tw68_videoport_init(dev);
-	if (card_has_mpeg(dev))
-		tw68_ts_init_hw(dev);
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,38)
-	if (dev->remote)
-		tw68_ir_start(dev, dev->remote);
-#endif
-	tw68_hw_enable1(dev);
-
 	msleep(100);
 
-	tw68_board_init2(dev);
-
-	/*tw68_hw_init2*/
 	tw68_set_tvnorm_hw(dev);
-	tw68_tvaudio_setmute(dev);
-/*	tw68_tvaudio_setvolume(dev, dev->ctl_volume); */
-	tw68_tvaudio_init(dev);
-	tw68_irq_video_signalchange(dev);
 
 	/*resume unfinished buffer(s)*/
 	spin_lock_irqsave(&dev->slock, flags);
-	tw68_buffer_requeue(dev, &dev->video_q);
-	tw68_buffer_requeue(dev, &dev->vbi_q);
-	tw68_buffer_requeue(dev, &dev->ts_q);
-
-	/* FIXME: Disable DMA audio sound - temporary till proper support
-		  is implemented*/
+	buf = container_of(dev->active.next, struct tw68_buf, list);
 
-	dev->dmasound.dma_running = 0;
+	tw68_video_start_dma(dev, buf);
 
-	/* start DMA now*/
-	dev->insuspend = 0;
-	smp_wmb();
-	tw68_set_dmabits(dev);
 	spin_unlock_irqrestore(&dev->slock, flags);
 
 	return 0;
@@ -1057,35 +424,11 @@ static struct pci_driver tw68_pci_driver = {
 	.name	  = "tw68",
 	.id_table = tw68_pci_tbl,
 	.probe	  = tw68_initdev,
-	.remove	  = __devexit_p(tw68_finidev),
+	.remove	  = tw68_finidev,
 #ifdef CONFIG_PM
 	.suspend  = tw68_suspend,
 	.resume   = tw68_resume
 #endif
 };
 
-static int tw68_init(void)
-{
-	if (core_debug & DBG_FLOW)
-		printk(KERN_DEBUG "%s: called\n", __func__);
-	INIT_LIST_HEAD(&tw68_devlist);
-	printk(KERN_INFO "tw68: v4l2 driver version %d.%d.%d loaded\n",
-		(TW68_VERSION_CODE >> 16) & 0xff,
-		(TW68_VERSION_CODE >> 8) & 0xff,
-		TW68_VERSION_CODE & 0xff);
-#if 0
-	printk(KERN_INFO "tw68: snapshot date %04d-%02d-%02d\n",
-		SNAPSHOT/10000, (SNAPSHOT/100)%100, SNAPSHOT%100);
-#endif
-	return pci_register_driver(&tw68_pci_driver);
-}
-
-static void module_cleanup(void)
-{
-	if (core_debug & DBG_FLOW)
-		printk(KERN_DEBUG "%s: called\n", __func__);
-	pci_unregister_driver(&tw68_pci_driver);
-}
-
-module_init(tw68_init);
-module_exit(module_cleanup);
+module_pci_driver(tw68_pci_driver);
diff --git a/drivers/media/pci/tw68/tw68-i2c.c b/drivers/media/pci/tw68/tw68-i2c.c
deleted file mode 100644
index 38659d0b1e18..000000000000
--- a/drivers/media/pci/tw68/tw68-i2c.c
+++ /dev/null
@@ -1,245 +0,0 @@
-/*
- *  tw68 code to handle the i2c interface.
- *
- *  Much of this code is derived from the bt87x driver.  The original
- *  work was by Gerd Knorr; more recently the code was enhanced by Mauro
- *  Carvalho Chehab.  Their work is gratefully acknowledged.  Full credit
- *  goes to them - any problems within this code are mine.
- *
- *  Copyright (C) 2009  William M. Brack <wbrack@mmm.com.hk>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License along
- *  with this program; if not, write to the Free Software Foundation, Inc.,
- *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
- */
-
-#include <linux/init.h>
-#include <linux/list.h>
-#include <linux/module.h>
-#include <linux/kernel.h>
-#include <linux/slab.h>
-#include <linux/delay.h>
-
-#include "tw68.h"
-#include <media/v4l2-common.h>
-#include <linux/i2c-algo-bit.h>
-
-/*----------------------------------------------------------------*/
-
-static unsigned int i2c_debug;
-module_param(i2c_debug, int, 0644);
-MODULE_PARM_DESC(i2c_debug, "enable debug messages [i2c]");
-
-#if 0
-static unsigned int i2c_scan;
-module_param(i2c_scan, int, 0444);
-MODULE_PARM_DESC(i2c_scan, "scan i2c bus at insmod time");
-#endif
-
-#define d1printk if (1 == i2c_debug) printk
-
-#define	I2C_CLOCK	0xa6	/* 99.4 kHz */
-
-/*----------------------------------------------------------------------*/
-/* Although the TW68xx i2c controller has a "hardware" mode, where all of
- * the low-level i2c/smbbus is handled by the chip, it appears that mode
- * is not suitable for linux i2c handling routines because extended "bursts"
- * of data (sequences of bytes without intervening START/STOP bits) are
- * not possible.  Instead, we put the chip into "software" mode, and handle
- * the i2c bus at a low level.  To accomplish this, we use the routines
- * from the i2c modules.
- *
- * Because the particular boards which I had for testing did not have any
- * devices attached to the i2c bus, I have been unable to test these
- * routines.
- */
-
-/*----------------------------------------------------------------------*/
-/* I2C functions - "bit-banging" adapter (software i2c) 		*/
-
-/* tw68_bit_setcl
- * Handles "toggling" the i2c clock bit
- */
-static void tw68_bit_setscl(void *data, int state)
-{
-	struct tw68_dev *dev = data;
-
-	tw_andorb(TW68_SBUSC, (state ? 1 : 0) << TW68_SSCLK, TW68_SSCLK_B);
-}
-
-/* tw68_bit_setsda
- * Handles "toggling" the i2c data bit
- */
-static void tw68_bit_setsda(void *data, int state)
-{
-	struct tw68_dev *dev = data;
-
-	tw_andorb(TW68_SBUSC, (state ? 1 : 0) << TW68_SSDAT, TW68_SSDAT_B);
-}
-
-/* tw68_bit_getscl
- *
- * Returns the current state of the clock bit
- */
-static int tw68_bit_getscl(void *data)
-{
-	struct tw68_dev *dev = data;
-
-	return (tw_readb(TW68_SBUSC) & TW68_SSCLK_B) ? 1 : 0;
-}
-
-/* tw68_bit_getsda
- *
- * Returns the current state of the data bit
- */
-static int tw68_bit_getsda(void *data)
-{
-	struct tw68_dev *dev = data;
-
-	return (tw_readb(TW68_SBUSC) & TW68_SSDAT_B) ? 1 : 0;
-}
-
-static struct i2c_algo_bit_data __devinitdata tw68_i2c_algo_bit_template = {
-	.setsda	 = tw68_bit_setsda,
-	.setscl	 = tw68_bit_setscl,
-	.getsda	 = tw68_bit_getsda,
-	.getscl	 = tw68_bit_getscl,
-	.udelay	 = 16,
-	.timeout = 200,
-};
-
-static struct i2c_client tw68_client_template = {
-	.name		= "tw68 internal",
-};
-
-/*----------------------------------------------------------------*/
-
-static int attach_inform(struct i2c_client *client)
-{
-/*	struct tw68_dev *dev = client->adapter->algo_data; */
-
-	d1printk("%s i2c attach [addr=0x%x,client=%s]\n",
-		client->driver->driver.name, client->addr, client->name);
-
-	switch (client->addr) {
-		/* No info yet on what addresses to expect */
-	}
-
-	return 0;
-}
-
-static struct i2c_adapter tw68_adap_sw_template = {
-	.owner		= THIS_MODULE,
-	.name		= "tw68_sw",
-	.client_register = attach_inform,
-};
-
-static int tw68_i2c_eeprom(struct tw68_dev *dev, unsigned char *eedata,
-			   int len)
-{
-	unsigned char buf;
-	int i, err;
-
-	dev->i2c_client.addr = 0xa0 >> 1;
-	buf = 256 - len;
-
-	err = i2c_master_send(&dev->i2c_client, &buf, 1);
-	if (1 != err) {
-		printk(KERN_INFO "%s: Huh, no eeprom present (err = %d)?\n",
-			dev->name, err);
-		return -1;
-	}
-	err = i2c_master_recv(&dev->i2c_client, eedata, len);
-	if (len != err) {
-		printk(KERN_WARNING "%s: i2c eeprom read error (err=%d)\n",
-			dev->name, err);
-		return -1;
-	}
-
-	for (i = 0; i < len; i++) {
-		if (0 == (i % 16))
-			printk(KERN_INFO "%s: i2c eeprom %02x:",
-				dev->name, i);
-		printk(KERN_INFO " %02x", eedata[i]);
-		if (15 == (i % 16))
-			printk("\n");
-	}
-	return 0;
-}
-
-#if 0
-static char *i2c_devs[128] = {
-	[0xa0 >> 1] = "eeprom",
-};
-
-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, 1);
-		if (rc < 0)
-			continue;
-		printk(KERN_INFO "%s: i2c scan: found device "
-				 "@ 0x%x [%s]\n", name, i << 1,
-				 i2c_devs[i] ? i2c_devs[i] : "???");
-	}
-}
-#endif
-
-int __devinit tw68_i2c_register(struct tw68_dev *dev)
-{
-	int rc;
-
-printk(KERN_DEBUG "%s: Registering i2c module\n", __func__);
-	tw_writeb(TW68_I2C_RST, 1);	/* reset the i2c module */
-
-	memcpy(&dev->i2c_client, &tw68_client_template,
-		sizeof(tw68_client_template));
-
-	memcpy(&dev->i2c_adap, &tw68_adap_sw_template,
-		sizeof(tw68_adap_sw_template));
-	dev->i2c_adap.algo_data = &dev->i2c_algo;
-	dev->i2c_adap.dev.parent = &dev->pci->dev;
-
-	memcpy(&dev->i2c_algo, &tw68_i2c_algo_bit_template,
-		sizeof(tw68_i2c_algo_bit_template));
-	dev->i2c_algo.data = dev;
-	/* TODO - may want to set better name (see bttv code) */
-
-	i2c_set_adapdata(&dev->i2c_adap, &dev->v4l2_dev);
-	dev->i2c_client.adapter = &dev->i2c_adap;
-
-	/* Assure chip is in "software" mode */
-	tw_writel(TW68_SBUSC, TW68_SSDAT | TW68_SSCLK);
-	tw68_bit_setscl(dev, 1);
-	tw68_bit_setsda(dev, 1);
-
-	rc = i2c_bit_add_bus(&dev->i2c_adap);
-
-	tw68_i2c_eeprom(dev, dev->eedata, sizeof(dev->eedata));
-#if 0
-	if (i2c_scan)
-		do_i2c_scan(dev->name, &dev->i2c_client);
-#endif
-
-	return rc;
-}
-
-int tw68_i2c_unregister(struct tw68_dev *dev)
-{
-	i2c_del_adapter(&dev->i2c_adap);
-	return 0;
-}
diff --git a/drivers/media/pci/tw68/tw68-reg.h b/drivers/media/pci/tw68/tw68-reg.h
index 314bc43cd9d3..f60b3a896fa7 100644
--- a/drivers/media/pci/tw68/tw68-reg.h
+++ b/drivers/media/pci/tw68/tw68-reg.h
@@ -8,7 +8,11 @@
  *  acknowledged.  Full credit goes to them - any problems within this code
  *  are mine.
  *
- *  Copyright (C) William M. Brack <wbrack@mmm.com.hk>
+ *  Copyright (C) William M. Brack
+ *
+ *  Refactored and updated to the latest v4l core frameworks:
+ *
+ *  Copyright (C) 2014 Hans Verkuil <hverkuil@xs4all.nl>
  *
  *  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
@@ -19,10 +23,6 @@
  *  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 _TW68_REG_H_
diff --git a/drivers/media/pci/tw68/tw68-risc.c b/drivers/media/pci/tw68/tw68-risc.c
index 66273bbd51c5..7439db212a69 100644
--- a/drivers/media/pci/tw68/tw68-risc.c
+++ b/drivers/media/pci/tw68/tw68-risc.c
@@ -9,7 +9,11 @@
  *  acknowledged.  Full credit goes to them - any problems within this code
  *  are mine.
  *
- *  Copyright (C) 2009  William M. Brack <wbrack@mmm.com.hk>
+ *  Copyright (C) 2009  William M. Brack
+ *
+ *  Refactored and updated to the latest v4l core frameworks:
+ *
+ *  Copyright (C) 2014 Hans Verkuil <hverkuil@xs4all.nl>
  *
  *  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
@@ -20,16 +24,10 @@
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License along
- *  with this program; if not, write to the Free Software Foundation, Inc.,
- *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  */
 
 #include "tw68.h"
 
-#define NO_SYNC_LINE (-1U)
-
 /**
  *  @rp		pointer to current risc program position
  *  @sglist	pointer to "scatter-gather list" of buffer pointers
@@ -38,32 +36,35 @@
  *  @bpl	number of bytes per scan line
  *  @padding	number of bytes of padding to add
  *  @lines	number of lines in field
- *  @lpi	lines per IRQ, or 0 to not generate irqs
- *		Note: IRQ to be generated _after_ lpi lines are transferred
+ *  @jump	insert a jump at the start
  */
 static __le32 *tw68_risc_field(__le32 *rp, struct scatterlist *sglist,
 			    unsigned int offset, u32 sync_line,
 			    unsigned int bpl, unsigned int padding,
-			    unsigned int lines, unsigned int lpi)
+			    unsigned int lines, bool jump)
 {
 	struct scatterlist *sg;
 	unsigned int line, todo, done;
 
-	/* sync instruction */
-	if (sync_line != NO_SYNC_LINE) {
-		if (sync_line == 1)
-			*(rp++) = cpu_to_le32(RISC_SYNCO);
-		else
-			*(rp++) = cpu_to_le32(RISC_SYNCE);
+	if (jump) {
+		*(rp++) = cpu_to_le32(RISC_JUMP);
 		*(rp++) = 0;
 	}
+
+	/* sync instruction */
+	if (sync_line == 1)
+		*(rp++) = cpu_to_le32(RISC_SYNCO);
+	else
+		*(rp++) = cpu_to_le32(RISC_SYNCE);
+	*(rp++) = 0;
+
 	/* scan lines */
 	sg = sglist;
 	for (line = 0; line < lines; line++) {
 		/* calculate next starting position */
 		while (offset && offset >= sg_dma_len(sg)) {
 			offset -= sg_dma_len(sg);
-			sg++;
+			sg = sg_next(sg);
 		}
 		if (bpl <= sg_dma_len(sg) - offset) {
 			/* fits into current chunk */
@@ -86,7 +87,7 @@ static __le32 *tw68_risc_field(__le32 *rp, struct scatterlist *sglist,
 						done);
 			*(rp++) = cpu_to_le32(sg_dma_address(sg) + offset);
 			todo -= done;
-			sg++;
+			sg = sg_next(sg);
 			/* succeeding fragments have no offset */
 			while (todo > sg_dma_len(sg)) {
 				*(rp++) = cpu_to_le32(RISC_INLINE |
@@ -94,7 +95,7 @@ static __le32 *tw68_risc_field(__le32 *rp, struct scatterlist *sglist,
 						sg_dma_len(sg));
 				*(rp++) = cpu_to_le32(sg_dma_address(sg));
 				todo -= sg_dma_len(sg);
-				sg++;
+				sg = sg_next(sg);
 				done += sg_dma_len(sg);
 			}
 			if (todo) {
@@ -107,9 +108,6 @@ static __le32 *tw68_risc_field(__le32 *rp, struct scatterlist *sglist,
 			offset = todo;
 		}
 		offset += padding;
-		/* If this line needs an interrupt, put it in */
-		if (lpi && line > 0 && !(line % lpi))
-			*(rp-2) |= RISC_INT_BIT;
 	}
 
 	return rp;
@@ -118,25 +116,25 @@ static __le32 *tw68_risc_field(__le32 *rp, struct scatterlist *sglist,
 /**
  * tw68_risc_buffer
  *
- * 	This routine is called by tw68-video.  It allocates
- * 	memory for the dma controller "program" and then fills in that
- * 	memory with the appropriate "instructions".
+ *	This routine is called by tw68-video.  It allocates
+ *	memory for the dma controller "program" and then fills in that
+ *	memory with the appropriate "instructions".
  *
- * 	@pci_dev	structure with info about the pci
- * 			slot which our device is in.
- * 	@risc		structure with info about the memory
- * 			used for our controller program.
- * 	@sglist		scatter-gather list entry
- * 	@top_offset	offset within the risc program area for the
- * 			first odd frame line
- * 	@bottom_offset	offset within the risc program area for the
- * 			first even frame line
- * 	@bpl		number of data bytes per scan line
- * 	@padding	number of extra bytes to add at end of line
- * 	@lines		number of scan lines
+ *	@pci_dev	structure with info about the pci
+ *			slot which our device is in.
+ *	@risc		structure with info about the memory
+ *			used for our controller program.
+ *	@sglist		scatter-gather list entry
+ *	@top_offset	offset within the risc program area for the
+ *			first odd frame line
+ *	@bottom_offset	offset within the risc program area for the
+ *			first even frame line
+ *	@bpl		number of data bytes per scan line
+ *	@padding	number of extra bytes to add at end of line
+ *	@lines		number of scan lines
  */
 int tw68_risc_buffer(struct pci_dev *pci,
-			struct btcx_riscmem *risc,
+			struct tw68_buf *buf,
 			struct scatterlist *sglist,
 			unsigned int top_offset,
 			unsigned int bottom_offset,
@@ -146,7 +144,6 @@ int tw68_risc_buffer(struct pci_dev *pci,
 {
 	u32 instructions, fields;
 	__le32 *rp;
-	int rc;
 
 	fields = 0;
 	if (UNSET != top_offset)
@@ -155,29 +152,31 @@ int tw68_risc_buffer(struct pci_dev *pci,
 		fields++;
 	/*
 	 * estimate risc mem: worst case is one write per page border +
-	 * one write per scan line + syncs + jump (all 2 dwords).
+	 * one write per scan line + syncs + 2 jumps (all 2 dwords).
 	 * Padding can cause next bpl to start close to a page border.
 	 * First DMA region may be smaller than PAGE_SIZE
 	 */
 	instructions  = fields * (1 + (((bpl + padding) * lines) /
-			 PAGE_SIZE) + lines) + 2;
-	rc = btcx_riscmem_alloc(pci, risc, instructions * 8);
-	if (rc < 0)
-		return rc;
+			 PAGE_SIZE) + lines) + 4;
+	buf->size = instructions * 8;
+	buf->cpu = pci_alloc_consistent(pci, buf->size, &buf->dma);
+	if (buf->cpu == NULL)
+		return -ENOMEM;
 
 	/* write risc instructions */
-	rp = risc->cpu;
+	rp = buf->cpu;
 	if (UNSET != top_offset)	/* generates SYNCO */
 		rp = tw68_risc_field(rp, sglist, top_offset, 1,
-				     bpl, padding, lines, 0);
+				     bpl, padding, lines, true);
 	if (UNSET != bottom_offset)	/* generates SYNCE */
 		rp = tw68_risc_field(rp, sglist, bottom_offset, 2,
-				     bpl, padding, lines, 0);
+				     bpl, padding, lines, top_offset == UNSET);
 
 	/* save pointer to jmp instruction address */
-	risc->jmp = rp;
+	buf->jmp = rp;
+	buf->cpu[1] = cpu_to_le32(buf->dma + 8);
 	/* assure risc buffer hasn't overflowed */
-	BUG_ON((risc->jmp - risc->cpu + 2) * sizeof(*risc->cpu) > risc->size);
+	BUG_ON((buf->jmp - buf->cpu + 2) * sizeof(buf->cpu[0]) > buf->size);
 	return 0;
 }
 
@@ -204,65 +203,28 @@ static void tw68_risc_decode(u32 risc, u32 addr)
 
 	p = RISC_OP(risc);
 	if (!(risc & 0x80000000) || !instr[p].name) {
-		printk(KERN_DEBUG "0x%08x [ INVALID ]\n", risc);
+		pr_debug("0x%08x [ INVALID ]\n", risc);
 		return;
 	}
-	printk(KERN_DEBUG "0x%08x %-9s IRQ=%d",
+	pr_debug("0x%08x %-9s IRQ=%d",
 		risc, instr[p].name, (risc >> 27) & 1);
 	if (instr[p].has_data_type)
-		printk(KERN_DEBUG " Type=%d", (risc >> 24) & 7);
+		pr_debug(" Type=%d", (risc >> 24) & 7);
 	if (instr[p].has_byte_info)
-		printk(KERN_DEBUG " Start=0x%03x Count=%03u",
+		pr_debug(" Start=0x%03x Count=%03u",
 			(risc >> 12) & 0xfff, risc & 0xfff);
 	if (instr[p].has_addr)
-		printk(KERN_DEBUG " StartAddr=0x%08x", addr);
-	printk(KERN_DEBUG "\n");
+		pr_debug(" StartAddr=0x%08x", addr);
+	pr_debug("\n");
 }
 
-void tw68_risc_program_dump(struct tw68_core *core,
-			    struct btcx_riscmem *risc)
+void tw68_risc_program_dump(struct tw68_core *core, struct tw68_buf *buf)
 {
-	__le32 *addr;
+	const __le32 *addr;
 
-	printk(KERN_DEBUG "%s: risc_program_dump: risc=%p, "
-			  "risc->cpu=0x%p, risc->jmp=0x%p\n",
-			  core->name, risc, risc->cpu, risc->jmp);
-	for (addr = risc->cpu; addr <= risc->jmp; addr += 2)
+	pr_debug("%s: risc_program_dump: risc=%p, buf->cpu=0x%p, buf->jmp=0x%p\n",
+		  core->name, buf, buf->cpu, buf->jmp);
+	for (addr = buf->cpu; addr <= buf->jmp; addr += 2)
 		tw68_risc_decode(*addr, *(addr+1));
 }
-EXPORT_SYMBOL_GPL(tw68_risc_program_dump);
 #endif
-
-/*
- * tw68_risc_stopper
- * 	Normally, the risc code generated for a buffer ends with a
- * 	JUMP instruction to direct the DMAP processor to the code for
- * 	the next buffer.  However, when there is no additional buffer
- * 	currently available, the code instead jumps to this routine.
- *
- * 	My first try for a "stopper" program was just a simple
- * 	"jump to self" instruction.  Unfortunately, this caused the
- * 	video FIFO to overflow.  My next attempt was to just disable
- * 	the DMAP processor.  Unfortunately, this caused the video
- * 	decoder to lose its synchronization.  The solution to this was to
- * 	add a "Sync-Odd" instruction, which "eats" all the video data
- * 	until the start of the next odd field.
- */
-int tw68_risc_stopper(struct pci_dev *pci, struct btcx_riscmem *risc)
-{
-	__le32 *rp;
-	int rc;
-
-	rc = btcx_riscmem_alloc(pci, risc, 8*4);
-	if (rc < 0)
-		return rc;
-
-	/* write risc inststructions */
-	rp = risc->cpu;
-	*(rp++) = cpu_to_le32(RISC_SYNCO);
-	*(rp++) = 0;
-	*(rp++) = cpu_to_le32(RISC_JUMP);
-	*(rp++) = cpu_to_le32(risc->dma);
-	risc->jmp = risc->cpu;
-	return 0;
-}
diff --git a/drivers/media/pci/tw68/tw68-ts.c b/drivers/media/pci/tw68/tw68-ts.c
deleted file mode 100644
index dacd6e621bae..000000000000
--- a/drivers/media/pci/tw68/tw68-ts.c
+++ /dev/null
@@ -1,66 +0,0 @@
-/*
- *  tw68_ts.c
- *  Part of the device driver for Techwell 68xx based cards
- *
- *  Much of this code is derived from the cx88 and sa7134 drivers, which
- *  were in turn derived from the bt87x driver.  The original work was by
- *  Gerd Knorr; more recently the code was enhanced by Mauro Carvalho Chehab,
- *  Hans Verkuil, Andy Walls and many others.  Their work is gratefully
- *  acknowledged.  Full credit goes to them - any problems within this code
- *  are mine.
- *
- *  Copyright (C) 2009  William M. Brack <wbrack@mmm.com.hk>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License along
- *  with this program; if not, write to the Free Software Foundation, Inc.,
- *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
- */
-
-#include "tw68.h"
-
-int tw68_ts_init1(struct tw68_dev *dev)
-{
-	return 0;
-}
-
-int tw68_ts_ini(struct tw68_dev *dev)
-{
-	return 0;
-}
-
-int tw68_ts_fini(struct tw68_dev *dev)
-{
-	return 0;
-}
-
-void tw68_irq_ts_done(struct tw68_dev *dev, unsigned long status)
-{
-	return;
-}
-
-int tw68_ts_register(struct tw68_mpeg_ops *ops)
-{
-	return 0;
-}
-
-void tw68_ts_unregister(struct tw68_mpeg_ops *ops)
-{
-	return;
-}
-
-int tw68_ts_init_hw(struct tw68_dev *dev)
-{
-	return 0;
-}
-
-
diff --git a/drivers/media/pci/tw68/tw68-tvaudio.c b/drivers/media/pci/tw68/tw68-tvaudio.c
deleted file mode 100644
index 656d462196f4..000000000000
--- a/drivers/media/pci/tw68/tw68-tvaudio.c
+++ /dev/null
@@ -1,80 +0,0 @@
-/*
- *  tw68_controls.c
- *  Part of the device driver for Techwell 68xx based cards
- *
- *  Much of this code is derived from the cx88 and sa7134 drivers, which
- *  were in turn derived from the bt87x driver.  The original work was by
- *  Gerd Knorr; more recently the code was enhanced by Mauro Carvalho Chehab,
- *  Hans Verkuil, Andy Walls and many others.  Their work is gratefully
- *  acknowledged.  Full credit goes to them - any problems within this code
- *  are mine.
- *
- *  Copyright (C) 2009  William M. Brack <wbrack@mmm.com.hk>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License along
- *  with this program; if not, write to the Free Software Foundation, Inc.,
- *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
- */
-
-#include "tw68.h"
-
-int tw68_tvaudio_rx2mode(u32 rx)
-{
-	return 0;
-}
-
-void tw68_tvaudio_setmute(struct tw68_dev *dev)
-{
-	return;
-}
-
-void tw68_tvaudio_setinput(struct tw68_dev *dev, struct tw68_input *in)
-{
-	return;
-}
-
-void tw68_tvaudio_setvolume(struct tw68_dev *dev, int level)
-{
-	return;
-}
-
-int tw68_tvaudio_getstereo(struct tw68_dev *dev)
-{
-	return 0;
-}
-
-void tw68_tvaudio_init(struct tw68_dev *dev)
-{
-	return;
-}
-
-int tw68_tvaudio_init2(struct tw68_dev *dev)
-{
-	return 0;
-}
-
-int tw68_tvaudio_fini(struct tw68_dev *dev)
-{
-	return 0;
-}
-
-int tw68_tvaudio_do_scan(struct tw68_dev *dev)
-{
-	return 0;
-}
-
-void tw68_enable_i2s(struct tw68_dev *dev)
-{
-	return;
-}
-
diff --git a/drivers/media/pci/tw68/tw68-vbi.c b/drivers/media/pci/tw68/tw68-vbi.c
deleted file mode 100644
index fbad3b998848..000000000000
--- a/drivers/media/pci/tw68/tw68-vbi.c
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
- *  tw68_controls.c
- *  Part of the device driver for Techwell 68xx based cards
- *
- *  Much of this code is derived from the cx88 and sa7134 drivers, which
- *  were in turn derived from the bt87x driver.  The original work was by
- *  Gerd Knorr; more recently the code was enhanced by Mauro Carvalho Chehab,
- *  Hans Verkuil, Andy Walls and many others.  Their work is gratefully
- *  acknowledged.  Full credit goes to them - any problems within this code
- *  are mine.
- *
- *  Copyright (C) 2009  William M. Brack <wbrack@mmm.com.hk>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License along
- *  with this program; if not, write to the Free Software Foundation, Inc.,
- *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
- */
-
-#include "tw68.h"
-
-static int buffer_setup(struct videobuf_queue *q, unsigned int *count,
-			unsigned int *size) {
-	printk(KERN_INFO "%s: shouldn't be here!\n", __func__);
-	return 0;
-}
-static int buffer_prepare(struct videobuf_queue *q,
-			  struct videobuf_buffer *vb,
-			  enum v4l2_field field)
-{
-	printk(KERN_INFO "%s: shouldn't be here!\n", __func__);
-	return 0;
-}
-static void buffer_queue(struct videobuf_queue *q,
-			 struct videobuf_buffer *vb)
-{
-	printk(KERN_INFO "%s: shouldn't be here!\n", __func__);
-}
-static void buffer_release(struct videobuf_queue *q,
-			   struct videobuf_buffer *vb)
-{
-	printk(KERN_INFO "%s: shouldn't be here!\n", __func__);
-}
-struct videobuf_queue_ops tw68_vbi_qops = {
-	.buf_setup    = buffer_setup,
-	.buf_prepare  = buffer_prepare,
-	.buf_queue    = buffer_queue,
-	.buf_release  = buffer_release,
-};
-
-/* ------------------------------------------------------------------ */
-
-int tw68_vbi_init1(struct tw68_dev *dev)
-{
-	return 0;
-}
-
-int tw68_vbi_fini(struct tw68_dev *dev)
-{
-	return 0;
-}
-
-void tw68_irq_vbi_done(struct tw68_dev *dev, unsigned long status)
-{
-	return;
-}
-
diff --git a/drivers/media/pci/tw68/tw68-video.c b/drivers/media/pci/tw68/tw68-video.c
index ca08ca38d3bd..66fae2345fdd 100644
--- a/drivers/media/pci/tw68/tw68-video.c
+++ b/drivers/media/pci/tw68/tw68-video.c
@@ -8,7 +8,11 @@
  *  acknowledged.  Full credit goes to them - any problems within this code
  *  are mine.
  *
- *  Copyright (C) 2009  William M. Brack <wbrack@mmm.com.hk>
+ *  Copyright (C) 2009  William M. Brack
+ *
+ *  Refactored and updated to the latest v4l core frameworks:
+ *
+ *  Copyright (C) 2014 Hans Verkuil <hverkuil@xs4all.nl>
  *
  *  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
@@ -19,39 +23,16 @@
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License along
- *  with this program; if not, write to the Free Software Foundation, Inc.,
- *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  */
 
 #include <linux/module.h>
 #include <media/v4l2-common.h>
-#include <linux/sort.h>
+#include <media/v4l2-event.h>
+#include <media/videobuf2-dma-sg.h>
 
 #include "tw68.h"
 #include "tw68-reg.h"
 
-unsigned int video_debug;
-
-static unsigned int gbuffers	= 8;
-static unsigned int noninterlaced; /* 0 */
-static unsigned int gbufsz	= 768*576*4;
-static unsigned int gbufsz_max	= 768*576*4;
-static char secam[]		= "--";
-
-module_param(video_debug, int, 0644);
-MODULE_PARM_DESC(video_debug, "enable debug messages [video]");
-module_param(gbuffers, int, 0444);
-MODULE_PARM_DESC(gbuffers, "number of capture buffers, range 2-32");
-module_param(noninterlaced, int, 0644);
-MODULE_PARM_DESC(noninterlaced, "capture non interlaced video");
-module_param_string(secam, secam, sizeof(secam), 0644);
-MODULE_PARM_DESC(secam, "force SECAM variant, either DK,L or Lc");
-
-#define dprintk(level, fmt, arg...)     if (video_debug & (level)) \
-	printk(KERN_DEBUG "%s/0: " fmt, dev->name , ## arg)
-
 /* ------------------------------------------------------------------ */
 /* data structs for video                                             */
 /*
@@ -60,7 +41,7 @@ MODULE_PARM_DESC(secam, "force SECAM variant, either DK,L or Lc");
  * as "planar".  These affect overlay mode, and are flagged with a field
  * ".planar" in the format.  Do we need to implement this in this driver?
  */
-static struct tw68_format formats[] = {
+static const struct tw68_format formats[] = {
 	{
 		.name		= "15 bpp RGB, le",
 		.fourcc		= V4L2_PIX_FMT_RGB555,
@@ -145,47 +126,8 @@ static struct tw68_format formats[] = {
  * match, then for an entry which contains the desired id.  The table
  * entries should therefore be ordered in ascending order of specificity.
  */
-static struct tw68_tvnorm tvnorms[]		= {
+static const struct tw68_tvnorm tvnorms[] = {
 	{
-		.name		= "PAL-BG",
-		.id		= V4L2_STD_PAL_BG,
-		NORM_625_50,
-
-		.sync_control	= 0x18,
-		.luma_control	= 0x40,
-		.chroma_ctrl1	= 0x81,
-		.chroma_gain	= 0x2a,
-		.chroma_ctrl2	= 0x06,
-		.vgate_misc	= 0x1c,
-		.format		= VideoFormatPALBDGHI,
-
-	}, {
-		.name		= "PAL-I",
-		.id		= V4L2_STD_PAL_I,
-		NORM_625_50,
-
-		.sync_control	= 0x18,
-		.luma_control	= 0x40,
-		.chroma_ctrl1	= 0x81,
-		.chroma_gain	= 0x2a,
-		.chroma_ctrl2	= 0x06,
-		.vgate_misc	= 0x1c,
-		.format		= VideoFormatPALBDGHI,
-
-	}, {
-		.name		= "PAL-DK",
-		.id		= V4L2_STD_PAL_DK,
-		NORM_625_50,
-
-		.sync_control	= 0x18,
-		.luma_control	= 0x40,
-		.chroma_ctrl1	= 0x81,
-		.chroma_gain	= 0x2a,
-		.chroma_ctrl2	= 0x06,
-		.vgate_misc	= 0x1c,
-		.format		= VideoFormatPALBDGHI,
-
-	}, {
 		.name		= "PAL", /* autodetect */
 		.id		= V4L2_STD_PAL,
 		NORM_625_50,
@@ -197,7 +139,6 @@ static struct tw68_tvnorm tvnorms[]		= {
 		.chroma_ctrl2	= 0x06,
 		.vgate_misc	= 0x1c,
 		.format		= VideoFormatPALBDGHI,
-
 	}, {
 		.name		= "NTSC",
 		.id		= V4L2_STD_NTSC,
@@ -210,46 +151,6 @@ static struct tw68_tvnorm tvnorms[]		= {
 		.chroma_ctrl2	= 0x0e,
 		.vgate_misc	= 0x18,
 		.format		= VideoFormatNTSC,
-
-	}, {
-		.name		= "SECAM-DK",
-		.id		= V4L2_STD_SECAM_DK,
-		NORM_625_50,
-
-		.sync_control	= 0x18,
-		.luma_control	= 0x1b,
-		.chroma_ctrl1	= 0xd1,
-		.chroma_gain	= 0x80,
-		.chroma_ctrl2	= 0x00,
-		.vgate_misc	= 0x1c,
-		.format		= VideoFormatSECAM,
-
-	}, {
-		.name		= "SECAM-L",
-		.id		= V4L2_STD_SECAM_L,
-		NORM_625_50,
-
-		.sync_control	= 0x18,
-		.luma_control	= 0x1b,
-		.chroma_ctrl1	= 0xd1,
-		.chroma_gain	= 0x80,
-		.chroma_ctrl2	= 0x00,
-		.vgate_misc	= 0x1c,
-		.format		= VideoFormatSECAM,
-
-	}, {
-		.name		= "SECAM-LC",
-		.id		= V4L2_STD_SECAM_LC,
-		NORM_625_50,
-
-		.sync_control	= 0x18,
-		.luma_control	= 0x1b,
-		.chroma_ctrl1	= 0xd1,
-		.chroma_gain	= 0x80,
-		.chroma_ctrl2	= 0x00,
-		.vgate_misc	= 0x1c,
-		.format		= VideoFormatSECAM,
-
 	}, {
 		.name		= "SECAM",
 		.id		= V4L2_STD_SECAM,
@@ -262,7 +163,6 @@ static struct tw68_tvnorm tvnorms[]		= {
 		.chroma_ctrl2	= 0x00,
 		.vgate_misc	= 0x1c,
 		.format		= VideoFormatSECAM,
-
 	}, {
 		.name		= "PAL-M",
 		.id		= V4L2_STD_PAL_M,
@@ -275,7 +175,6 @@ static struct tw68_tvnorm tvnorms[]		= {
 		.chroma_ctrl2	= 0x0e,
 		.vgate_misc	= 0x18,
 		.format		= VideoFormatPALM,
-
 	}, {
 		.name		= "PAL-Nc",
 		.id		= V4L2_STD_PAL_Nc,
@@ -288,7 +187,6 @@ static struct tw68_tvnorm tvnorms[]		= {
 		.chroma_ctrl2	= 0x06,
 		.vgate_misc	= 0x1c,
 		.format		= VideoFormatPALNC,
-
 	}, {
 		.name		= "PAL-60",
 		.id		= V4L2_STD_PAL_60,
@@ -309,127 +207,11 @@ static struct tw68_tvnorm tvnorms[]		= {
 		.chroma_ctrl2	= 0x06,
 		.vgate_misc	= 0x1c,
 		.format		= VideoFormatPAL60,
-
-	}, {
-/*
- * 	FIXME:  The following are meant to be "catch-all", and need
- *		to be further thought out!
- */
-		.name		= "STD-525-60",
-		.id		= V4L2_STD_525_60,
-		NORM_525_60,
-
-		.sync_control	= 0x59,
-		.luma_control	= 0x40,
-		.chroma_ctrl1	= 0x89,
-		.chroma_gain	= 0x2a,
-		.chroma_ctrl2	= 0x0e,
-		.vgate_misc	= 0x18,
-		.format		= VideoFormatNTSC,
-
-	}, {
-		.name		= "STD-625-50",
-		.id		= V4L2_STD_625_50,
-		NORM_625_50,
-
-		.sync_control	= 0x18,
-		.luma_control	= 0x40,
-		.chroma_ctrl1	= 0x81,
-		.chroma_gain	= 0x2a,
-		.chroma_ctrl2	= 0x06,
-		.vgate_misc	= 0x1c,
-		.format		= VideoFormatPALBDGHI,
 	}
 };
 #define TVNORMS ARRAY_SIZE(tvnorms)
 
-static const struct v4l2_queryctrl no_ctrl		= {
-	.name		= "42",
-	.flags		= V4L2_CTRL_FLAG_DISABLED,
-};
-static const struct v4l2_queryctrl video_ctrls[]		= {
-	/* --- video --- */
-	{
-		.id		= V4L2_CID_BRIGHTNESS,
-		.name		= "Brightness",
-		.minimum	= -128,
-		.maximum	= 127,
-		.step		= 1,
-		.default_value	= 20,
-		.type		= V4L2_CTRL_TYPE_INTEGER,
-	}, {
-		.id		= V4L2_CID_CONTRAST,
-		.name		= "Contrast",
-		.minimum	= 0,
-		.maximum	= 255,
-		.step		= 1,
-		.default_value	= 100,
-		.type		= V4L2_CTRL_TYPE_INTEGER,
-	}, {
-		.id		= V4L2_CID_SATURATION,
-		.name		= "Saturation",
-		.minimum	= 0,
-		.maximum	= 255,
-		.step		= 1,
-		.default_value	= 128,
-		.type		= V4L2_CTRL_TYPE_INTEGER,
-	}, {
-		.id		= V4L2_CID_HUE,
-		.name		= "Hue",
-		.minimum	= -128,
-		.maximum	= 127,
-		.step		= 1,
-		.default_value	= 0,
-		.type		= V4L2_CTRL_TYPE_INTEGER,
-	}, {
-		.id		= V4L2_CID_COLOR_KILLER,
-		.name		= "Color Killer",
-		.minimum	= 0,
-		.maximum	= 1,
-		.default_value	= 1,
-		.type		= V4L2_CTRL_TYPE_BOOLEAN,
-	}, {
-		.id		= V4L2_CID_CHROMA_AGC,
-		.name		= "Chroma AGC",
-		.minimum	= 0,
-		.maximum	= 1,
-		.default_value	= 1,
-		.type		= V4L2_CTRL_TYPE_BOOLEAN,
-	},
-	/* --- audio --- */
-	{
-		.id		= V4L2_CID_AUDIO_MUTE,
-		.name		= "Mute",
-		.minimum	= 0,
-		.maximum	= 1,
-		.type		= V4L2_CTRL_TYPE_BOOLEAN,
-	}, {
-		.id		= V4L2_CID_AUDIO_VOLUME,
-		.name		= "Volume",
-		.minimum	= -15,
-		.maximum	= 15,
-		.step		= 1,
-		.default_value	= 0,
-		.type		= V4L2_CTRL_TYPE_INTEGER,
-	}
-};
-static const unsigned int CTRLS = ARRAY_SIZE(video_ctrls);
-
-/*
- * Routine to lookup a control by its ID, and return a pointer
- * to the entry in the video_ctrls array for that control.
- */
-static const struct v4l2_queryctrl *ctrl_by_id(unsigned int id)
-{
-	unsigned int i;
-
-	for (i = 0; i < CTRLS; i++)
-		if (video_ctrls[i].id == id)
-			return video_ctrls+i;
-	return NULL;
-}
-
-static struct tw68_format *format_by_fourcc(unsigned int fourcc)
+static const struct tw68_format *format_by_fourcc(unsigned int fourcc)
 {
 	unsigned int i;
 
@@ -439,99 +221,22 @@ static struct tw68_format *format_by_fourcc(unsigned int fourcc)
 	return NULL;
 }
 
-/* ----------------------------------------------------------------------- */
-/* resource management                                                     */
-
-static int res_get(struct tw68_fh *fh, unsigned int bit)
-{
-	struct tw68_dev *dev = fh->dev;
-
-	if (fh->resources & bit)
-		/* have it already allocated */
-		return 1;
-
-	/* is it free? */
-	mutex_lock(&dev->lock);
-	if (dev->resources & bit) {
-		/* no, someone else uses it */
-		mutex_unlock(&fh->dev->lock);
-		return 0;
-	}
-	/* it's free, grab it */
-	fh->resources  |= bit;
-	dev->resources |= bit;
-	dprintk(DBG_FLOW, "%s: %d\n", __func__, bit);
-	mutex_unlock(&dev->lock);
-	return 1;
-}
-
-static int res_check(struct tw68_fh *fh, unsigned int bit)
-{
-	return fh->resources & bit;
-}
-
-static int res_locked(struct tw68_dev *dev, unsigned int bit)
-{
-	return dev->resources & bit;
-}
-
-static void res_free(struct tw68_fh *fh,
-		     unsigned int bits)
-{
-	struct tw68_dev *dev = fh->dev;
-
-	BUG_ON((fh->resources & bits) != bits);
-
-	mutex_lock(&fh->dev->lock);
-	fh->resources  &= ~bits;
-	fh->dev->resources &= ~bits;
-	dprintk(DBG_FLOW, "%s: %d\n", __func__, bits);
-	mutex_unlock(&fh->dev->lock);
-}
 
 /* ------------------------------------------------------------------ */
 /*
  * Note that the cropping rectangles are described in terms of a single
  * frame, i.e. line positions are only 1/2 the interlaced equivalent
  */
-static void set_tvnorm(struct tw68_dev *dev, struct tw68_tvnorm *norm)
+static void set_tvnorm(struct tw68_dev *dev, const struct tw68_tvnorm *norm)
 {
-	dprintk(DBG_FLOW, "%s: %s\n", __func__, norm->name);
-	dev->tvnorm = norm;
-
-	/* setup cropping */
-	dev->crop_bounds.left    = norm->h_start;
-	dev->crop_defrect.left   = norm->h_start;
-	dev->crop_bounds.width   = norm->h_stop - norm->h_start + 1;
-	dev->crop_defrect.width  = norm->h_stop - norm->h_start + 1;
-
-	dev->crop_bounds.top     = norm->video_v_start;
-	dev->crop_defrect.top    = norm->video_v_start;
-	dev->crop_bounds.height  = (((norm->id & V4L2_STD_525_60) ?
-				    524 : 624)) / 2 - dev->crop_bounds.top;
-	dev->crop_defrect.height = (norm->video_v_stop -
-				    norm->video_v_start + 1);
-
-	dev->crop_current = dev->crop_defrect;
-
 	if (norm != dev->tvnorm) {
+		dev->width = 720;
+		dev->height = (norm->id & V4L2_STD_525_60) ? 480 : 576;
 		dev->tvnorm = norm;
 		tw68_set_tvnorm_hw(dev);
 	}
 }
 
-static void video_mux(struct tw68_dev *dev, int input)
-{
-	dprintk(DBG_FLOW, "%s: input = %d [%s]\n", __func__, input,
-		card_in(dev, input).name);
-	/*
-	 * dev->input shows current application request,
-	 * dev->hw_input shows current hardware setting
-	 */
-	dev->input = &card_in(dev, input);
-	tw68_tvaudio_setinput(dev, &card_in(dev, input));
-}
-
 /*
  * tw68_set_scale
  *
@@ -544,7 +249,7 @@ static void video_mux(struct tw68_dev *dev, int input)
  * before scaling.  HDELAY represents the number of pixels skipped
  * between the start of the horizontal sync and the start of the image.
  * HSCALE is calculated using the formula
- * 	HSCALE = (HACTIVE / (#pixels desired)) * 256
+ *	HSCALE = (HACTIVE / (#pixels desired)) * 256
  *
  * The vertical registers are similar, except based upon the total number
  * of lines in the image, and the first line of the image (i.e. ignoring
@@ -555,16 +260,16 @@ static void video_mux(struct tw68_dev *dev, int input)
  * these values, especially HSCALE.
  *
  * Parameters:
- * 	@dev		pointer to the device structure, needed for
- * 			getting current norm (as well as debug print)
- * 	@width		actual image width (from user buffer)
- * 	@height		actual image height
- * 	@field		indicates Top, Bottom or Interlaced
+ *	@dev		pointer to the device structure, needed for
+ *			getting current norm (as well as debug print)
+ *	@width		actual image width (from user buffer)
+ *	@height		actual image height
+ *	@field		indicates Top, Bottom or Interlaced
  */
 static int tw68_set_scale(struct tw68_dev *dev, unsigned int width,
 			  unsigned int height, enum v4l2_field field)
 {
-
+	const struct tw68_tvnorm *norm = dev->tvnorm;
 	/* set individually for debugging clarity */
 	int hactive, hdelay, hscale;
 	int vactive, vdelay, vscale;
@@ -573,41 +278,38 @@ static int tw68_set_scale(struct tw68_dev *dev, unsigned int width,
 	if (V4L2_FIELD_HAS_BOTH(field))	/* if field is interlaced */
 		height /= 2;		/* we must set for 1-frame */
 
-	dprintk(DBG_FLOW, "%s: width=%d, height=%d, both=%d\n  Crop rect: "
-		    "top=%d, left=%d, width=%d height=%d\n"
-		    "  tvnorm h_delay=%d, h_start=%d, h_stop=%d, "
-		    "v_delay=%d, v_start=%d, v_stop=%d\n" , __func__,
+	pr_debug("%s: width=%d, height=%d, both=%d\n"
+		 "  tvnorm h_delay=%d, h_start=%d, h_stop=%d, "
+		 "v_delay=%d, v_start=%d, v_stop=%d\n" , __func__,
 		width, height, V4L2_FIELD_HAS_BOTH(field),
-		dev->crop_bounds.top, dev->crop_bounds.left,
-		dev->crop_bounds.width, dev->crop_bounds.height,
-		dev->tvnorm->h_delay, dev->tvnorm->h_start, dev->tvnorm->h_stop,
-		dev->tvnorm->v_delay, dev->tvnorm->video_v_start,
-		dev->tvnorm->video_v_stop);
+		norm->h_delay, norm->h_start, norm->h_stop,
+		norm->v_delay, norm->video_v_start,
+		norm->video_v_stop);
 
 	switch (dev->vdecoder) {
 	case TW6800:
-		hdelay = dev->tvnorm->h_delay0;
+		hdelay = norm->h_delay0;
 		break;
 	default:
-		hdelay = dev->tvnorm->h_delay;
+		hdelay = norm->h_delay;
 		break;
 	}
-	hdelay += dev->crop_bounds.left;
-	hactive = dev->crop_bounds.width;
+
+	hdelay += norm->h_start;
+	hactive = norm->h_stop - norm->h_start + 1;
 
 	hscale = (hactive * 256) / (width);
 
-	vdelay = dev->tvnorm->v_delay + dev->crop_bounds.top -
-		 dev->crop_defrect.top;
-	vactive = dev->crop_bounds.height;
+	vdelay = norm->v_delay;
+	vactive = ((norm->id & V4L2_STD_525_60) ? 524 : 624) / 2 - norm->video_v_start;
 	vscale = (vactive * 256) / height;
 
-	dprintk(DBG_FLOW, "%s: %dx%d [%s%s,%s]\n", __func__,
+	pr_debug("%s: %dx%d [%s%s,%s]\n", __func__,
 		width, height,
 		V4L2_FIELD_HAS_TOP(field)    ? "T" : "",
 		V4L2_FIELD_HAS_BOTTOM(field) ? "B" : "",
 		v4l2_norm_to_name(dev->tvnorm->id));
-	dprintk(DBG_FLOW, "%s: hactive=%d, hdelay=%d, hscale=%d; "
+	pr_debug("%s: hactive=%d, hdelay=%d, hscale=%d; "
 		"vactive=%d, vdelay=%d, vscale=%d\n", __func__,
 		hactive, hdelay, hscale, vactive, vdelay, vscale);
 
@@ -615,7 +317,7 @@ static int tw68_set_scale(struct tw68_dev *dev, unsigned int width,
 		((vactive & 0x300) >> 4) |
 		((hdelay & 0x300)  >> 6) |
 		((hactive & 0x300) >> 8);
-	dprintk(DBG_FLOW, "%s: setting CROP_HI=%02x, VDELAY_LO=%02x, "
+	pr_debug("%s: setting CROP_HI=%02x, VDELAY_LO=%02x, "
 		"VACTIVE_LO=%02x, HDELAY_LO=%02x, HACTIVE_LO=%02x\n",
 		__func__, comb, vdelay, vactive, hdelay, hactive);
 	tw_writeb(TW68_CROP_HI, comb);
@@ -625,7 +327,7 @@ static int tw68_set_scale(struct tw68_dev *dev, unsigned int width,
 	tw_writeb(TW68_HACTIVE_LO, hactive & 0xff);
 
 	comb = ((vscale & 0xf00) >> 4) | ((hscale & 0xf00) >> 8);
-	dprintk(DBG_FLOW, "%s: setting SCALE_HI=%02x, VSCALE_LO=%02x, "
+	pr_debug("%s: setting SCALE_HI=%02x, VSCALE_LO=%02x, "
 		"HSCALE_LO=%02x\n", __func__, comb, vscale, hscale);
 	tw_writeb(TW68_SCALE_HI, comb);
 	tw_writeb(TW68_VSCALE_LO, vscale);
@@ -636,28 +338,21 @@ static int tw68_set_scale(struct tw68_dev *dev, unsigned int width,
 
 /* ------------------------------------------------------------------ */
 
-static int tw68_video_start_dma(struct tw68_dev *dev, struct tw68_dmaqueue *q,
-				struct tw68_buf *buf) {
-
-	dprintk(DBG_FLOW, "%s: Starting risc program\n", __func__);
-	/* Assure correct input */
-	if (dev->hw_input != dev->input) {
-		dev->hw_input = dev->input;
-		tw_andorb(TW68_INFORM, 0x03 << 2, dev->input->vmux << 2);
-	}
+int tw68_video_start_dma(struct tw68_dev *dev, struct tw68_buf *buf)
+{
 	/* Set cropping and scaling */
-	tw68_set_scale(dev, buf->vb.width, buf->vb.height, buf->vb.field);
+	tw68_set_scale(dev, dev->width, dev->height, dev->field);
 	/*
 	 *  Set start address for RISC program.  Note that if the DMAP
 	 *  processor is currently running, it must be stopped before
 	 *  a new address can be set.
 	 */
 	tw_clearl(TW68_DMAC, TW68_DMAP_EN);
-	tw_writel(TW68_DMAP_SA, cpu_to_le32(buf->risc.dma));
+	tw_writel(TW68_DMAP_SA, cpu_to_le32(buf->dma));
 	/* Clear any pending interrupts */
 	tw_writel(TW68_INTSTAT, dev->board_virqmask);
 	/* Enable the risc engine and the fifo */
-	tw_andorl(TW68_DMAC, 0xff, buf->fmt->twformat |
+	tw_andorl(TW68_DMAC, 0xff, dev->fmt->twformat |
 		ColorFormatGamma | TW68_DMAP_EN | TW68_FIFO_EN);
 	dev->pci_irqmask |= dev->board_virqmask;
 	tw_setl(TW68_INTMASK, dev->pci_irqmask);
@@ -665,638 +360,244 @@ static int tw68_video_start_dma(struct tw68_dev *dev, struct tw68_dmaqueue *q,
 }
 
 /* ------------------------------------------------------------------ */
-/* videobuf queue operations                                          */
 
-/*
- * check_buf_fmt
- *
- * callback from tw68-core buffer_queue to determine whether the
- * current buffer and the previous one are "compatible" (i.e. the
- * risc programs can be chained without requiring a format change)
- */
-static int tw68_check_video_fmt(struct tw68_buf *prev, struct tw68_buf *buf)
+/* nr of (tw68-)pages for the given buffer size */
+static int tw68_buffer_pages(int size)
 {
-	return (prev->vb.width  == buf->vb.width  &&
-		prev->vb.height == buf->vb.height &&
-		prev->fmt       == buf->fmt);
+	size  = PAGE_ALIGN(size);
+	size += PAGE_SIZE; /* for non-page-aligned buffers */
+	size /= 4096;
+	return size;
 }
 
-/*
- * buffer_setup
- *
- * Calculate required size of buffer and maximum number allowed
- */
-static int
-buffer_setup(struct videobuf_queue *q, unsigned int *count,
-	     unsigned int *size)
+/* calc max # of buffers from size (must not exceed the 4MB virtual
+ * address space per DMA channel) */
+static int tw68_buffer_count(unsigned int size, unsigned int count)
 {
-	struct tw68_fh *fh = q->priv_data;
+	unsigned int maxcount;
 
-	*size = fh->fmt->depth * fh->width * fh->height >> 3;
-	if (0 == *count)
-		*count = gbuffers;
-	*count = tw68_buffer_count(*size, *count);
-	return 0;
+	maxcount = 1024 / tw68_buffer_pages(size);
+	if (count > maxcount)
+		count = maxcount;
+	return count;
 }
 
-static int buffer_activate(struct tw68_dev *dev, struct tw68_buf *buf,
-			   struct tw68_buf *next)
-{
-	dprintk(DBG_BUFF, "%s: dev=%p, buf=%p, next=%p\n",
-		__func__, dev, buf, next);
-	if (dev->hw_input != dev->input) {
-		dev->hw_input = dev->input;
-		tw_andorb(TW68_INFORM, 0x03 << 2,
-			  dev->hw_input->vmux << 2);
-	}
-	buf->vb.state = VIDEOBUF_ACTIVE;
-	/* TODO - need to assure scaling/cropping are set correctly */
-	mod_timer(&dev->video_q.timeout, jiffies+BUFFER_TIMEOUT);
-	return 0;
-}
+/* ------------------------------------------------------------- */
+/* vb2 queue operations                                          */
 
-/*
-* buffer_prepare
-*
-* Set the ancilliary information into the buffer structure.  This
-* includes generating the necessary risc program if it hasn't already
-* been done for the current buffer format.
-* The structure fh contains the details of the format requested by the
-* user - type, width, height and #fields.  This is compared with the
-* last format set for the current buffer.  If they differ, the risc
-* code (which controls the filling of the buffer) is (re-)generated.
-*/
-static int
-buffer_prepare(struct videobuf_queue *q, struct videobuf_buffer *vb,
-	       enum v4l2_field field)
+static int tw68_queue_setup(struct vb2_queue *q, const struct v4l2_format *fmt,
+			   unsigned int *num_buffers, unsigned int *num_planes,
+			   unsigned int sizes[], void *alloc_ctxs[])
 {
-	struct tw68_fh   *fh  = q->priv_data;
-	struct tw68_dev  *dev = fh->dev;
-	struct tw68_buf *buf = container_of(vb, struct tw68_buf, vb);
-	struct videobuf_dmabuf *dma = videobuf_to_dma(&buf->vb);
-	int rc, init_buffer = 0;
-	unsigned int maxw, maxh;
-
-	BUG_ON(NULL == fh->fmt);
-	maxw = dev->tvnorm->h_stop - dev->tvnorm->h_start + 1;
-	maxh = 2*(dev->tvnorm->video_v_stop - dev->tvnorm->video_v_start + 1);
-	if (fh->width  < 48 || fh->width  > maxw || fh->height > maxh
-		|| fh->height < 16) {
-		dprintk(DBG_UNEXPECTED, "%s: invalid dimensions - "
-			"fh->width=%d, fh->height=%d, maxw=%d, maxh=%d\n",
-			__func__, fh->width, fh->height, maxw, maxh);
-		return -EINVAL;
-	}
-	buf->vb.size = (fh->width * fh->height * (fh->fmt->depth)) >> 3;
-	if (0 != buf->vb.baddr  &&  buf->vb.bsize < buf->vb.size)
-		return -EINVAL;
-
-	if (buf->fmt       != fh->fmt    ||
-	    buf->vb.width  != fh->width  ||
-	    buf->vb.height != fh->height ||
-	    buf->vb.field  != field) {
-		dprintk(DBG_BUFF, "%s: buf - fmt=%p, width=%3d, height=%3d, "
-			"field=%d\n%s: fh  - fmt=%p, width=%3d, height=%3d, "
-			"field=%d\n", __func__, buf->fmt, buf->vb.width,
-			buf->vb.height, buf->vb.field, __func__, fh->fmt,
-			fh->width, fh->height, field);
-		buf->fmt       = fh->fmt;
-		buf->vb.width  = fh->width;
-		buf->vb.height = fh->height;
-		buf->vb.field  = field;
-		init_buffer = 1;	/* force risc code re-generation */
-	}
-	buf->input = dev->input;
+	struct tw68_dev *dev = vb2_get_drv_priv(q);
+	unsigned tot_bufs = q->num_buffers + *num_buffers;
 
-	if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
-		rc = videobuf_iolock(q, &buf->vb, NULL);
-		if (0 != rc)
-			goto fail;
-		init_buffer = 1;	/* force risc code re-generation */
-	}
-	dprintk(DBG_BUFF, "%s: q=%p, vb=%p, init_buffer=%d\n",
-		__func__, q, vb, init_buffer);
-
-	if (init_buffer) {
-		buf->bpl = buf->vb.width * (buf->fmt->depth) >> 3;
-		dprintk(DBG_TESTING, "%s: Generating new risc code "
-			"[%dx%dx%d](%d)\n", __func__, buf->vb.width,
-			buf->vb.height, buf->fmt->depth, buf->bpl);
-		switch (buf->vb.field) {
-		case V4L2_FIELD_TOP:
-			tw68_risc_buffer(dev->pci, &buf->risc,
-					 dma->sglist,
-					 0, UNSET,
-					 buf->bpl, 0,
-					 buf->vb.height);
-			break;
-		case V4L2_FIELD_BOTTOM:
-			tw68_risc_buffer(dev->pci, &buf->risc,
-					 dma->sglist,
-					 UNSET, 0,
-					 buf->bpl, 0,
-					 buf->vb.height);
-			break;
-		case V4L2_FIELD_INTERLACED:
-			tw68_risc_buffer(dev->pci, &buf->risc,
-					 dma->sglist,
-					 0, buf->bpl,
-					 buf->bpl, buf->bpl,
-					 buf->vb.height >> 1);
-			break;
-		case V4L2_FIELD_SEQ_TB:
-			tw68_risc_buffer(dev->pci, &buf->risc,
-					 dma->sglist,
-					 0, buf->bpl * (buf->vb.height >> 1),
-					 buf->bpl, 0,
-					 buf->vb.height >> 1);
-			break;
-		case V4L2_FIELD_SEQ_BT:
-			tw68_risc_buffer(dev->pci, &buf->risc,
-					 dma->sglist,
-					 buf->bpl * (buf->vb.height >> 1), 0,
-					 buf->bpl, 0,
-					 buf->vb.height >> 1);
-			break;
-		default:
-			BUG();
-		}
-	}
-	dprintk(DBG_BUFF, "%s: [%p/%d] - %dx%d %dbpp \"%s\" - dma=0x%08lx\n",
-		__func__, buf, buf->vb.i, fh->width, fh->height,
-		fh->fmt->depth, fh->fmt->name, (unsigned long)buf->risc.dma);
+	sizes[0] = (dev->fmt->depth * dev->width * dev->height) >> 3;
+	/*
+	 * We allow create_bufs, but only if the sizeimage is the same as the
+	 * current sizeimage. The tw68_buffer_count calculation becomes quite
+	 * difficult otherwise.
+	 */
+	if (fmt && fmt->fmt.pix.sizeimage < sizes[0])
+		return -EINVAL;
+	*num_planes = 1;
+	if (tot_bufs < 2)
+		tot_bufs = 2;
+	tot_bufs = tw68_buffer_count(sizes[0], tot_bufs);
+	*num_buffers = tot_bufs - q->num_buffers;
 
-	buf->vb.state = VIDEOBUF_PREPARED;
-	buf->activate = buffer_activate;
 	return 0;
-
- fail:
-	tw68_dma_free(q, buf);
-	return rc;
 }
 
 /*
- * buffer_queue
+ * The risc program for each buffers works as follows: it starts with a simple
+ * 'JUMP to addr + 8', which is effectively a NOP. Then the program to DMA the
+ * buffer follows and at the end we have a JUMP back to the start + 8 (skipping
+ * the initial JUMP).
+ *
+ * This is the program of the first buffer to be queued if the active list is
+ * empty and it just keeps DMAing this buffer without generating any interrupts.
  *
- * Callback whenever a buffer has been requested (by read() or QBUF)
+ * If a new buffer is added then the initial JUMP in the program generates an
+ * interrupt as well which signals that the previous buffer has been DMAed
+ * successfully and that it can be returned to userspace.
+ *
+ * It also sets the final jump of the previous buffer to the start of the new
+ * buffer, thus chaining the new buffer into the DMA chain. This is a single
+ * atomic u32 write, so there is no race condition.
+ *
+ * The end-result of all this that you only get an interrupt when a buffer
+ * is ready, so the control flow is very easy.
  */
-static void
-buffer_queue(struct videobuf_queue *q, struct videobuf_buffer *vb)
+static void tw68_buf_queue(struct vb2_buffer *vb)
 {
-	struct tw68_fh	*fh = q->priv_data;
-	struct tw68_buf	*buf = container_of(vb, struct tw68_buf, vb);
+	struct vb2_queue *vq = vb->vb2_queue;
+	struct tw68_dev *dev = vb2_get_drv_priv(vq);
+	struct tw68_buf *buf = container_of(vb, struct tw68_buf, vb);
+	struct tw68_buf *prev;
+	unsigned long flags;
+
+	spin_lock_irqsave(&dev->slock, flags);
 
-	tw68_buffer_queue(fh->dev, &fh->dev->video_q, buf);
+	/* append a 'JUMP to start of buffer' to the buffer risc program */
+	buf->jmp[0] = cpu_to_le32(RISC_JUMP);
+	buf->jmp[1] = cpu_to_le32(buf->dma + 8);
+
+	if (!list_empty(&dev->active)) {
+		prev = list_entry(dev->active.prev, struct tw68_buf, list);
+		buf->cpu[0] |= cpu_to_le32(RISC_INT_BIT);
+		prev->jmp[1] = cpu_to_le32(buf->dma);
+	}
+	list_add_tail(&buf->list, &dev->active);
+	spin_unlock_irqrestore(&dev->slock, flags);
 }
 
 /*
- * buffer_release
+ * buffer_prepare
  *
- * Free a buffer previously allocated.
+ * Set the ancilliary information into the buffer structure.  This
+ * includes generating the necessary risc program if it hasn't already
+ * been done for the current buffer format.
+ * The structure fh contains the details of the format requested by the
+ * user - type, width, height and #fields.  This is compared with the
+ * last format set for the current buffer.  If they differ, the risc
+ * code (which controls the filling of the buffer) is (re-)generated.
  */
-static void buffer_release(struct videobuf_queue *q,
-			   struct videobuf_buffer *vb)
+static int tw68_buf_prepare(struct vb2_buffer *vb)
 {
+	struct vb2_queue *vq = vb->vb2_queue;
+	struct tw68_dev *dev = vb2_get_drv_priv(vq);
 	struct tw68_buf *buf = container_of(vb, struct tw68_buf, vb);
+	struct sg_table *dma = vb2_dma_sg_plane_desc(vb, 0);
+	unsigned size, bpl;
+	int rc;
 
-	tw68_dma_free(q, buf);
-}
-
-static struct videobuf_queue_ops video_qops = {
-	.buf_setup    = buffer_setup,
-	.buf_prepare  = buffer_prepare,
-	.buf_queue    = buffer_queue,
-	.buf_release  = buffer_release,
-};
-
-/* ------------------------------------------------------------------ */
+	size = (dev->width * dev->height * dev->fmt->depth) >> 3;
+	if (vb2_plane_size(vb, 0) < size)
+		return -EINVAL;
+	vb2_set_plane_payload(vb, 0, size);
 
-static int tw68_g_ctrl_internal(struct tw68_dev *dev, struct tw68_fh *fh,
-				struct v4l2_control *c)
-{
-	const struct v4l2_queryctrl *ctrl;
+	rc = dma_map_sg(&dev->pci->dev, dma->sgl, dma->nents, DMA_FROM_DEVICE);
+	if (!rc)
+		return -EIO;
 
-	dprintk(DBG_FLOW, "%s\n", __func__);
-	ctrl = ctrl_by_id(c->id);
-	if (NULL == ctrl)
-		return -EINVAL;
-	switch (c->id) {
-	case V4L2_CID_BRIGHTNESS:
-		c->value = (char)tw_readb(TW68_BRIGHT);
-		break;
-	case V4L2_CID_HUE:
-		c->value = (char)tw_readb(TW68_HUE);
-		break;
-	case V4L2_CID_CONTRAST:
-		c->value = tw_readb(TW68_CONTRAST);
-		break;
-	case V4L2_CID_SATURATION:
-		c->value = tw_readb(TW68_SAT_U);
-		break;
-	case V4L2_CID_COLOR_KILLER:
-		c->value = 0 != (tw_readb(TW68_MISC2) & 0xe0);
+	bpl = (dev->width * dev->fmt->depth) >> 3;
+	switch (dev->field) {
+	case V4L2_FIELD_TOP:
+		tw68_risc_buffer(dev->pci, buf, dma->sgl,
+				 0, UNSET, bpl, 0, dev->height);
 		break;
-	case V4L2_CID_CHROMA_AGC:
-		c->value = 0 != (tw_readb(TW68_LOOP) & 0x30);
+	case V4L2_FIELD_BOTTOM:
+		tw68_risc_buffer(dev->pci, buf, dma->sgl,
+				 UNSET, 0, bpl, 0, dev->height);
 		break;
-	case V4L2_CID_AUDIO_MUTE:
-		/*hack to suppresss tvtime complaint */
-		c->value = 0;
+	case V4L2_FIELD_SEQ_TB:
+		tw68_risc_buffer(dev->pci, buf, dma->sgl,
+				 0, bpl * (dev->height >> 1),
+				 bpl, 0, dev->height >> 1);
 		break;
-#if 0
-	case V4L2_CID_AUDIO_VOLUME:
-		c->value = dev->ctl_volume;
+	case V4L2_FIELD_SEQ_BT:
+		tw68_risc_buffer(dev->pci, buf, dma->sgl,
+				 bpl * (dev->height >> 1), 0,
+				 bpl, 0, dev->height >> 1);
 		break;
-#endif
+	case V4L2_FIELD_INTERLACED:
 	default:
-		return -EINVAL;
+		tw68_risc_buffer(dev->pci, buf, dma->sgl,
+				 0, bpl, bpl, bpl, dev->height >> 1);
+		break;
 	}
 	return 0;
 }
 
-static int tw68_g_ctrl(struct file *file, void *priv, struct v4l2_control *c)
+static void tw68_buf_finish(struct vb2_buffer *vb)
+{
+	struct vb2_queue *vq = vb->vb2_queue;
+	struct tw68_dev *dev = vb2_get_drv_priv(vq);
+	struct sg_table *dma = vb2_dma_sg_plane_desc(vb, 0);
+	struct tw68_buf *buf = container_of(vb, struct tw68_buf, vb);
+
+	dma_unmap_sg(&dev->pci->dev, dma->sgl, dma->nents, DMA_FROM_DEVICE);
+
+	pci_free_consistent(dev->pci, buf->size, buf->cpu, buf->dma);
+}
+
+static int tw68_start_streaming(struct vb2_queue *q, unsigned int count)
+{
+	struct tw68_dev *dev = vb2_get_drv_priv(q);
+	struct tw68_buf *buf =
+		container_of(dev->active.next, struct tw68_buf, list);
+
+	dev->seqnr = 0;
+	tw68_video_start_dma(dev, buf);
+	return 0;
+}
+
+static void tw68_stop_streaming(struct vb2_queue *q)
 {
-	struct tw68_fh *fh = priv;
+	struct tw68_dev *dev = vb2_get_drv_priv(q);
 
-	return tw68_g_ctrl_internal(fh->dev, fh, c);
+	/* Stop risc & fifo */
+	tw_clearl(TW68_DMAC, TW68_DMAP_EN | TW68_FIFO_EN);
+	while (!list_empty(&dev->active)) {
+		struct tw68_buf *buf =
+			container_of(dev->active.next, struct tw68_buf, list);
+
+		list_del(&buf->list);
+		vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
+	}
 }
 
-static int tw68_s_ctrl_value(struct tw68_dev *dev, __u32 id, int val)
+static struct vb2_ops tw68_video_qops = {
+	.queue_setup	= tw68_queue_setup,
+	.buf_queue	= tw68_buf_queue,
+	.buf_prepare	= tw68_buf_prepare,
+	.buf_finish	= tw68_buf_finish,
+	.start_streaming = tw68_start_streaming,
+	.stop_streaming = tw68_stop_streaming,
+	.wait_prepare	= vb2_ops_wait_prepare,
+	.wait_finish	= vb2_ops_wait_finish,
+};
+
+/* ------------------------------------------------------------------ */
+
+static int tw68_s_ctrl(struct v4l2_ctrl *ctrl)
 {
-	int err = 0;
+	struct tw68_dev *dev =
+		container_of(ctrl->handler, struct tw68_dev, hdl);
 
-	dprintk(DBG_FLOW, "%s\n", __func__);
-	switch (id) {
+	switch (ctrl->id) {
 	case V4L2_CID_BRIGHTNESS:
-		tw_writeb(TW68_BRIGHT, val);
+		tw_writeb(TW68_BRIGHT, ctrl->val);
 		break;
 	case V4L2_CID_HUE:
-		tw_writeb(TW68_HUE, val);
+		tw_writeb(TW68_HUE, ctrl->val);
 		break;
 	case V4L2_CID_CONTRAST:
-		tw_writeb(TW68_CONTRAST, val);
+		tw_writeb(TW68_CONTRAST, ctrl->val);
 		break;
 	case V4L2_CID_SATURATION:
-		tw_writeb(TW68_SAT_U, val);
-		tw_writeb(TW68_SAT_V, val);
+		tw_writeb(TW68_SAT_U, ctrl->val);
+		tw_writeb(TW68_SAT_V, ctrl->val);
 		break;
 	case V4L2_CID_COLOR_KILLER:
-		if (val)
+		if (ctrl->val)
 			tw_andorb(TW68_MISC2, 0xe0, 0xe0);
 		else
 			tw_andorb(TW68_MISC2, 0xe0, 0x00);
 		break;
 	case V4L2_CID_CHROMA_AGC:
-		if (val)
+		if (ctrl->val)
 			tw_andorb(TW68_LOOP, 0x30, 0x20);
 		else
 			tw_andorb(TW68_LOOP, 0x30, 0x00);
 		break;
-	case V4L2_CID_AUDIO_MUTE:
-		/* hack to suppress tvtime complaint */
-		break;
-#if 0
-	case V4L2_CID_AUDIO_VOLUME:
-		dev->ctl_volume = val;
-		tw68_tvaudio_setvolume(dev, dev->ctl_volume);
-		break;
-	case V4L2_CID_HFLIP:
-		dev->ctl_mirror = val;
-		break;
-	case V4L2_CID_PRIVATE_AUTOMUTE:
-	{
-		struct v4l2_priv_tun_config tda9887_cfg;
-
-		tda9887_cfg.tuner = TUNER_TDA9887;
-		tda9887_cfg.priv = &dev->tda9887_conf;
-
-		dev->ctl_automute = val;
-		if (dev->tda9887_conf) {
-			if (dev->ctl_automute)
-				dev->tda9887_conf |= TDA9887_AUTOMUTE;
-			else
-				dev->tda9887_conf &= ~TDA9887_AUTOMUTE;
-
-			tw_call_all(dev, tuner, s_config, &tda9887_cfg);
-		}
-		break;
 	}
-#endif
-	default:
-		err = -EINVAL;
-	}
-	return err;
-}
-
-static int tw68_s_ctrl_internal(struct tw68_dev *dev,  struct tw68_fh *fh,
-			 struct v4l2_control *c)
-{
-	const struct v4l2_queryctrl *ctrl;
-	int err;
-
-	dprintk(DBG_FLOW, "%s\n", __func__);
-	if (fh) {
-#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,34)
-		err = v4l2_prio_check(&dev->prio, &fh->prio);
-#else
-		err = v4l2_prio_check(&dev->prio, fh->prio);
-#endif
-		if (0 != err)
-			return err;
-	}
-
-	mutex_lock(&dev->lock);
-
-	ctrl = ctrl_by_id(c->id);
-	if (NULL == ctrl) {
-		err = -EINVAL;
-		goto error;
-	}
-
-	dprintk(DBG_BUFF, "%s: name=%s val=%d\n", __func__,
-		ctrl->name, c->value);
-	switch (ctrl->type) {
-	case V4L2_CTRL_TYPE_BOOLEAN:
-	case V4L2_CTRL_TYPE_MENU:
-	case V4L2_CTRL_TYPE_INTEGER:
-		if (c->value < ctrl->minimum)
-			c->value = ctrl->minimum;
-		if (c->value > ctrl->maximum)
-			c->value = ctrl->maximum;
-		break;
-	default:
-		/* nothing */;
-	};
-	err = tw68_s_ctrl_value(dev, c->id, c->value);
-
-error:
-	mutex_unlock(&dev->lock);
-	return err;
-}
-
-static int tw68_s_ctrl(struct file *file, void *f, struct v4l2_control *c)
-{
-	struct tw68_fh *fh = f;
-
-	return tw68_s_ctrl_internal(fh->dev, fh, c);
-}
-
-/* ------------------------------------------------------------------ */
-
-/*
- * Returns a pointer to the currently used queue (e.g. video, vbi, etc.)
- */
-static struct videobuf_queue *tw68_queue(struct tw68_fh *fh)
-{
-	struct videobuf_queue *q = NULL;
-
-	switch (fh->type) {
-	case V4L2_BUF_TYPE_VIDEO_CAPTURE:
-		q = &fh->cap;
-		break;
-	case V4L2_BUF_TYPE_VBI_CAPTURE:
-		q = &fh->vbi;
-		break;
-	default:
-		BUG();
-	}
-	return q;
-}
-
-static int tw68_resource(struct tw68_fh *fh)
-{
-	if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
-		return RESOURCE_VIDEO;
-
-	if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE)
-		return RESOURCE_VBI;
-
-	BUG();
-	return 0;
-}
-
-static int video_open(struct file *file)
-{
-	int minor = video_devdata(file)->minor;
-	struct tw68_dev *dev;
-	struct tw68_fh *fh;
-	enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-	int radio = 0;
-
-	mutex_lock(&tw68_devlist_lock);
-	list_for_each_entry(dev, &tw68_devlist, devlist) {
-		if (dev->video_dev && (dev->video_dev->minor == minor))
-			goto found;
-		if (dev->radio_dev && (dev->radio_dev->minor == minor)) {
-			radio = 1;
-			goto found;
-		}
-		if (dev->vbi_dev && (dev->vbi_dev->minor == minor)) {
-			type = V4L2_BUF_TYPE_VBI_CAPTURE;
-			goto found;
-		}
-	}
-	mutex_unlock(&tw68_devlist_lock);
-	return -ENODEV;
-
-found:
-	mutex_unlock(&tw68_devlist_lock);
-
-	dprintk(DBG_FLOW, "%s: minor=%d radio=%d type=%s\n", __func__, minor,
-		radio, v4l2_type_names[type]);
-
-	/* allocate + initialize per filehandle data */
-	fh = kzalloc(sizeof(*fh), GFP_KERNEL);
-	if (NULL == fh)
-		return -ENOMEM;
-
-	file->private_data = fh;
-	fh->dev      = dev;
-	fh->radio    = radio;
-	fh->type     = type;
-	fh->fmt      = format_by_fourcc(V4L2_PIX_FMT_BGR24);
-	fh->width    = 720;
-	fh->height   = 576;
-	v4l2_prio_open(&dev->prio, &fh->prio);
-
-	videobuf_queue_sg_init(&fh->cap, &video_qops,
-			    &dev->pci->dev, &dev->slock,
-			    V4L2_BUF_TYPE_VIDEO_CAPTURE,
-			    V4L2_FIELD_INTERLACED,
-			    sizeof(struct tw68_buf),
-#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,37)
-			    fh
-#else
-			    fh, &dev->lock
-#endif
-             );
-	videobuf_queue_sg_init(&fh->vbi, &tw68_vbi_qops,
-			    &dev->pci->dev, &dev->slock,
-			    V4L2_BUF_TYPE_VBI_CAPTURE,
-			    V4L2_FIELD_SEQ_TB,
-			    sizeof(struct tw68_buf),
-#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,37)
-			    fh
-#else
-			    fh, &dev->lock
-#endif
-             );
-	if (fh->radio) {
-		/* switch to radio mode */
-		tw68_tvaudio_setinput(dev, &card(dev).radio);
-		tw_call_all(dev, tuner, s_radio);
-	} else {
-		/* switch to video/vbi mode */
-		tw68_tvaudio_setinput(dev, dev->input);
-	}
-	return 0;
-}
-
-static ssize_t
-video_read(struct file *file, char __user *data, size_t count, loff_t *ppos)
-{
-	struct tw68_fh *fh = file->private_data;
-
-	switch (fh->type) {
-	case V4L2_BUF_TYPE_VIDEO_CAPTURE:
-		if (res_locked(fh->dev, RESOURCE_VIDEO))
-			return -EBUSY;
-		return videobuf_read_one(tw68_queue(fh),
-					 data, count, ppos,
-					 file->f_flags & O_NONBLOCK);
-	case V4L2_BUF_TYPE_VBI_CAPTURE:
-		if (!res_get(fh, RESOURCE_VBI))
-			return -EBUSY;
-		return videobuf_read_stream(tw68_queue(fh),
-					    data, count, ppos, 1,
-					    file->f_flags & O_NONBLOCK);
-		break;
-	default:
-		BUG();
-		return 0;
-	}
-}
-
-static unsigned int
-video_poll(struct file *file, struct poll_table_struct *wait)
-{
-	struct tw68_fh *fh = file->private_data;
-	struct videobuf_buffer *buf = NULL;
-
-	if (V4L2_BUF_TYPE_VBI_CAPTURE == fh->type)
-		return videobuf_poll_stream(file, &fh->vbi, wait);
-
-	if (res_check(fh, RESOURCE_VIDEO)) {
-		if (!list_empty(&fh->cap.stream))
-			buf = list_entry(fh->cap.stream.next,
-				struct videobuf_buffer, stream);
-	} else {
-		mutex_lock(&fh->cap.vb_lock);
-		if (UNSET == fh->cap.read_off) {
-			/* need to capture a new frame */
-			if (res_locked(fh->dev, RESOURCE_VIDEO))
-				goto err;
-			if (0 != fh->cap.ops->buf_prepare(&fh->cap,
-					fh->cap.read_buf, fh->cap.field))
-				goto err;
-			fh->cap.ops->buf_queue(&fh->cap, fh->cap.read_buf);
-			fh->cap.read_off = 0;
-		}
-		mutex_unlock(&fh->cap.vb_lock);
-		buf = fh->cap.read_buf;
-	}
-
-	if (!buf)
-		return POLLERR;
-
-	poll_wait(file, &buf->done, wait);
-	if (buf->state == VIDEOBUF_DONE ||
-	    buf->state == VIDEOBUF_ERROR)
-		return POLLIN | POLLRDNORM;
-	return 0;
-
-err:
-	mutex_unlock(&fh->cap.vb_lock);
-	return POLLERR;
-}
-
-static int video_release(struct file *file)
-{
-	struct tw68_fh  *fh  = file->private_data;
-	struct tw68_dev *dev = fh->dev;
-
-	/* stop video capture */
-	if (res_check(fh, RESOURCE_VIDEO)) {
-		videobuf_streamoff(&fh->cap);
-		res_free(fh , RESOURCE_VIDEO);
-	}
-	if (fh->cap.read_buf) {
-		buffer_release(&fh->cap, fh->cap.read_buf);
-		kfree(fh->cap.read_buf);
-	}
-
-	/* stop vbi capture */
-	if (res_check(fh, RESOURCE_VBI)) {
-		videobuf_stop(&fh->vbi);
-		res_free(fh, RESOURCE_VBI);
-	}
-
-#if 0
-	tw_call_all(dev, core, s_standby, 0);
-#endif
-
-	/* free stuff */
-	videobuf_mmap_free(&fh->cap);
-	videobuf_mmap_free(&fh->vbi);
-
-#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,34)
-	v4l2_prio_close(&dev->prio, &fh->prio);
-#else
-	v4l2_prio_close(&dev->prio, fh->prio);
-#endif
-	file->private_data = NULL;
-	kfree(fh);
 	return 0;
 }
 
-static int video_mmap(struct file *file, struct vm_area_struct * vma)
-{
-	struct tw68_fh *fh = file->private_data;
-
-	return videobuf_mmap_mapper(tw68_queue(fh), vma);
-}
-
 /* ------------------------------------------------------------------ */
 
-#if 0
-static int tw68_try_get_set_fmt_vbi_cap(struct file *file, void *priv,
-						struct v4l2_format *f)
-{
-	struct tw68_fh *fh = priv;
-	struct tw68_dev *dev = fh->dev;
-	struct tw68_tvnorm *norm = dev->tvnorm;
-
-	f->fmt.vbi.sampling_rate = 6750000 * 4;
-	f->fmt.vbi.samples_per_line = 2048 /* VBI_LINE_LENGTH */;
-	f->fmt.vbi.sample_format = V4L2_PIX_FMT_GREY;
-	f->fmt.vbi.offset = 64 * 4;
-	f->fmt.vbi.start[0] = norm->vbi_v_start_0;
-	f->fmt.vbi.count[0] = norm->vbi_v_stop_0 - norm->vbi_v_start_0 + 1;
-	f->fmt.vbi.start[1] = norm->vbi_v_start_1;
-	f->fmt.vbi.count[1] = f->fmt.vbi.count[0];
-	f->fmt.vbi.flags = 0; /* VBI_UNSYNC VBI_INTERLACED */
-
-#if 0
-	if (V4L2_STD_PAL == norm->id) {
-		/* FIXME */
-		f->fmt.vbi.start[0] += 3;
-		f->fmt.vbi.start[1] += 3*2;
-	}
-#endif
-	return 0;
-}
-#endif
-
 /*
  * Note that this routine returns what is stored in the fh structure, and
  * does not interrogate any of the device registers.
@@ -1304,54 +605,50 @@ static int tw68_try_get_set_fmt_vbi_cap(struct file *file, void *priv,
 static int tw68_g_fmt_vid_cap(struct file *file, void *priv,
 				struct v4l2_format *f)
 {
-	struct tw68_fh *fh = priv;
-	struct tw68_dev *dev = fh->dev;
-
-	dprintk(DBG_FLOW, "%s\n", __func__);
-	f->fmt.pix.width        = fh->width;
-	f->fmt.pix.height       = fh->height;
-	f->fmt.pix.field        = fh->cap.field;
-	f->fmt.pix.pixelformat  = fh->fmt->fourcc;
+	struct tw68_dev *dev = video_drvdata(file);
+
+	f->fmt.pix.width        = dev->width;
+	f->fmt.pix.height       = dev->height;
+	f->fmt.pix.field        = dev->field;
+	f->fmt.pix.pixelformat  = dev->fmt->fourcc;
 	f->fmt.pix.bytesperline =
-		(f->fmt.pix.width * (fh->fmt->depth)) >> 3;
+		(f->fmt.pix.width * (dev->fmt->depth)) >> 3;
 	f->fmt.pix.sizeimage =
 		f->fmt.pix.height * f->fmt.pix.bytesperline;
 	f->fmt.pix.colorspace	= V4L2_COLORSPACE_SMPTE170M;
+	f->fmt.pix.priv = 0;
 	return 0;
 }
 
 static int tw68_try_fmt_vid_cap(struct file *file, void *priv,
 						struct v4l2_format *f)
 {
-	struct tw68_fh *fh = priv;
-	struct tw68_dev *dev = fh->dev;
-	struct tw68_format *fmt;
+	struct tw68_dev *dev = video_drvdata(file);
+	const struct tw68_format *fmt;
 	enum v4l2_field field;
-	unsigned int maxw, maxh;
+	unsigned int maxh;
 
-	dprintk(DBG_FLOW, "%s\n", __func__);
 	fmt = format_by_fourcc(f->fmt.pix.pixelformat);
 	if (NULL == fmt)
 		return -EINVAL;
 
 	field = f->fmt.pix.field;
-	maxw  = min(dev->crop_current.width*4,  dev->crop_bounds.width);
-	maxh  = min(dev->crop_current.height*4, dev->crop_bounds.height);
+	maxh  = (dev->tvnorm->id & V4L2_STD_525_60) ? 480 : 576;
 
-	if (V4L2_FIELD_ANY == field) {
-		field = (f->fmt.pix.height > maxh/2)
-			? V4L2_FIELD_INTERLACED
-			: V4L2_FIELD_BOTTOM;
-	}
 	switch (field) {
 	case V4L2_FIELD_TOP:
 	case V4L2_FIELD_BOTTOM:
 		break;
 	case V4L2_FIELD_INTERLACED:
+	case V4L2_FIELD_SEQ_BT:
+	case V4L2_FIELD_SEQ_TB:
 		maxh = maxh * 2;
 		break;
 	default:
-		return -EINVAL;
+		field = (f->fmt.pix.height > maxh / 2)
+			? V4L2_FIELD_INTERLACED
+			: V4L2_FIELD_BOTTOM;
+		break;
 	}
 
 	f->fmt.pix.field = field;
@@ -1359,8 +656,8 @@ static int tw68_try_fmt_vid_cap(struct file *file, void *priv,
 		f->fmt.pix.width  = 48;
 	if (f->fmt.pix.height < 32)
 		f->fmt.pix.height = 32;
-	if (f->fmt.pix.width > maxw)
-		f->fmt.pix.width = maxw;
+	if (f->fmt.pix.width > 720)
+		f->fmt.pix.width = 720;
 	if (f->fmt.pix.height > maxh)
 		f->fmt.pix.height = maxh;
 	f->fmt.pix.width &= ~0x03;
@@ -1368,7 +665,7 @@ static int tw68_try_fmt_vid_cap(struct file *file, void *priv,
 		(f->fmt.pix.width * (fmt->depth)) >> 3;
 	f->fmt.pix.sizeimage =
 		f->fmt.pix.height * f->fmt.pix.bytesperline;
-
+	f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
 	return 0;
 }
 
@@ -1381,76 +678,35 @@ static int tw68_try_fmt_vid_cap(struct file *file, void *priv,
 static int tw68_s_fmt_vid_cap(struct file *file, void *priv,
 					struct v4l2_format *f)
 {
-	struct tw68_fh *fh = priv;
-	struct tw68_dev *dev = fh->dev;
+	struct tw68_dev *dev = video_drvdata(file);
 	int err;
 
-	dprintk(DBG_FLOW, "%s\n", __func__);
 	err = tw68_try_fmt_vid_cap(file, priv, f);
 	if (0 != err)
 		return err;
 
-	fh->fmt       = format_by_fourcc(f->fmt.pix.pixelformat);
-	fh->width     = f->fmt.pix.width;
-	fh->height    = f->fmt.pix.height;
-	fh->cap.field = f->fmt.pix.field;
-	/*
-	 * The following lines are to make v4l2-test program happy.
-	 * The docs should be checked to assure they make sense.
-	 */
-	f->fmt.pix.colorspace	= V4L2_COLORSPACE_SMPTE170M;
-	f->fmt.pix.priv = 0;
-	return 0;
-}
-
-static int tw68_queryctrl(struct file *file, void *priv,
-			  struct v4l2_queryctrl *c)
-{
-	const struct v4l2_queryctrl *ctrl;
-	struct tw68_fh *fh = priv;
-	struct tw68_dev *dev = fh->dev;
-
-	dprintk(DBG_FLOW, "%s\n", __func__);
-	if ((c->id <  V4L2_CID_BASE || c->id >= V4L2_CID_LASTP1)
-#if 0
-	     && (c->id <  V4L2_CID_PRIVATE_BASE ||
-	     c->id >= V4L2_CID_PRIVATE_LASTP1)
-#endif
-	)
-		return -EINVAL;
-	ctrl = ctrl_by_id(c->id);
-	if (NULL == ctrl)
-		return -EINVAL;
-	*c = *ctrl;
+	dev->fmt = format_by_fourcc(f->fmt.pix.pixelformat);
+	dev->width = f->fmt.pix.width;
+	dev->height = f->fmt.pix.height;
+	dev->field = f->fmt.pix.field;
 	return 0;
 }
 
 static int tw68_enum_input(struct file *file, void *priv,
 					struct v4l2_input *i)
 {
-	struct tw68_fh *fh = priv;
-	struct tw68_dev *dev = fh->dev;
+	struct tw68_dev *dev = video_drvdata(file);
 	unsigned int n;
 
 	n = i->index;
-	dprintk(DBG_FLOW, "%s: index is %d\n", __func__, n);
-	if (n >= TW68_INPUT_MAX) {
-		dprintk(DBG_FLOW, "%s: INPUT_MAX reached\n", __func__);
-		return -EINVAL;
-	}
-	if (NULL == card_in(dev, n).name) {
-		dprintk(DBG_FLOW, "%s: End of list\n", __func__);
+	if (n >= TW68_INPUT_MAX)
 		return -EINVAL;
-	}
-	memset(i, 0, sizeof(*i));
 	i->index = n;
-	i->type  = V4L2_INPUT_TYPE_CAMERA;
-	strcpy(i->name, card_in(dev, n).name);
-	if (card_in(dev, n).tv)
-		i->type = V4L2_INPUT_TYPE_TUNER;
-	i->audioset = 1;
+	i->type = V4L2_INPUT_TYPE_CAMERA;
+	snprintf(i->name, sizeof(i->name), "Composite %d", n);
+
 	/* If the query is for the current input, get live data */
-	if (n == dev->hw_input->vmux) {
+	if (n == dev->input) {
 		int v1 = tw_readb(TW68_STATUS1);
 		int v2 = tw_readb(TW68_MVSN);
 
@@ -1465,305 +721,86 @@ static int tw68_enum_input(struct file *file, void *priv,
 		if (0 != (v2 & (1 << 2)))
 			i->status |= V4L2_IN_ST_MACROVISION;
 	}
-	i->std = TW68_NORMS;
+	i->std = video_devdata(file)->tvnorms;
 	return 0;
 }
 
 static int tw68_g_input(struct file *file, void *priv, unsigned int *i)
 {
-	struct tw68_fh *fh = priv;
-	struct tw68_dev *dev = fh->dev;
+	struct tw68_dev *dev = video_drvdata(file);
 
-	dprintk(DBG_FLOW, "%s\n", __func__);
-	*i = dev->input->vmux;
+	*i = dev->input;
 	return 0;
 }
 
 static int tw68_s_input(struct file *file, void *priv, unsigned int i)
 {
-	struct tw68_fh *fh = priv;
-	struct tw68_dev *dev = fh->dev;
-	int err;
-
-	dprintk(DBG_FLOW, "%s\n", __func__);
-#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,34)
-		err = v4l2_prio_check(&dev->prio, &fh->prio);
-#else
-		err = v4l2_prio_check(&dev->prio, fh->prio);
-#endif
-		if (0 != err)
-	if (0 != err)
-		return err;
+	struct tw68_dev *dev = video_drvdata(file);
 
-	if (i < 0  ||  i >= TW68_INPUT_MAX)
-		return -EINVAL;
-	if (NULL == card_in(dev, i).name)
+	if (i >= TW68_INPUT_MAX)
 		return -EINVAL;
-	mutex_lock(&dev->lock);
-	video_mux(dev, i);
-	mutex_unlock(&dev->lock);
+	dev->input = i;
+	tw_andorb(TW68_INFORM, 0x03 << 2, dev->input << 2);
 	return 0;
 }
 
 static int tw68_querycap(struct file *file, void  *priv,
 					struct v4l2_capability *cap)
 {
-	struct tw68_fh *fh = priv;
-	struct tw68_dev *dev = fh->dev;
+	struct tw68_dev *dev = video_drvdata(file);
 
-	unsigned int tuner_type = dev->tuner_type;
-
-	dprintk(DBG_FLOW, "%s\n", __func__);
 	strcpy(cap->driver, "tw68");
-	strlcpy(cap->card, tw68_boards[dev->board].name,
+	strlcpy(cap->card, "Techwell Capture Card",
 		sizeof(cap->card));
 	sprintf(cap->bus_info, "PCI:%s", pci_name(dev->pci));
-	cap->version = TW68_VERSION_CODE;
-	cap->capabilities =
+	cap->device_caps =
 		V4L2_CAP_VIDEO_CAPTURE |
-		V4L2_CAP_VBI_CAPTURE |
 		V4L2_CAP_READWRITE |
-		V4L2_CAP_STREAMING |
-		V4L2_CAP_TUNER;
+		V4L2_CAP_STREAMING;
 
-	if ((tuner_type == TUNER_ABSENT) || (tuner_type == UNSET))
-		cap->capabilities &= ~V4L2_CAP_TUNER;
+	cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
 	return 0;
 }
 
-static int tw68_s_std_internal(struct tw68_dev *dev, struct tw68_fh *fh,
-			v4l2_std_id *id)
+static int tw68_s_std(struct file *file, void *priv, v4l2_std_id id)
 {
-/*	unsigned long flags; */
+	struct tw68_dev *dev = video_drvdata(file);
 	unsigned int i;
-	v4l2_std_id fixup;
-	int err;
 
-	dprintk(DBG_FLOW, "%s\n", __func__);
-	if (fh) {
-#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,34)
-		err = v4l2_prio_check(&dev->prio, &fh->prio);
-#else
-		err = v4l2_prio_check(&dev->prio, fh->prio);
-#endif
-		if (0 != err)
-		if (0 != err)
-			return err;
-	}
+	if (vb2_is_busy(&dev->vidq))
+		return -EBUSY;
 
 	/* Look for match on complete norm id (may have mult bits) */
 	for (i = 0; i < TVNORMS; i++) {
-		if (*id == tvnorms[i].id)
+		if (id == tvnorms[i].id)
 			break;
 	}
 
 	/* If no exact match, look for norm which contains this one */
-	if (i == TVNORMS)
-		for (i = 0; i < TVNORMS; i++) {
-			if (*id & tvnorms[i].id)
+	if (i == TVNORMS) {
+		for (i = 0; i < TVNORMS; i++)
+			if (id & tvnorms[i].id)
 				break;
-		}
+	}
 	/* If still not matched, give up */
 	if (i == TVNORMS)
 		return -EINVAL;
 
-	/* TODO - verify this additional work with SECAM applies to TW */
-	if ((*id & V4L2_STD_SECAM) && (secam[0] != '-')) {
-		if (secam[0] == 'L' || secam[0] == 'l') {
-			if (secam[1] == 'C' || secam[1] == 'c')
-				fixup = V4L2_STD_SECAM_LC;
-			else
-				fixup = V4L2_STD_SECAM_L;
-		} else {
-			if (secam[0] == 'D' || secam[0] == 'd')
-				fixup = V4L2_STD_SECAM_DK;
-			else
-				fixup = V4L2_STD_SECAM;
-		}
-		for (i = 0; i < TVNORMS; i++)
-			if (fixup == tvnorms[i].id)
-				break;
-	}
-
-	*id = tvnorms[i].id;
-	mutex_lock(&dev->lock);
 	set_tvnorm(dev, &tvnorms[i]);	/* do the actual setting */
-	tw68_tvaudio_do_scan(dev);
-	mutex_unlock(&dev->lock);
 	return 0;
 }
 
-static int tw68_s_std(struct file *file, void *priv, v4l2_std_id *id)
-{
-	struct tw68_fh *fh = priv;
-	struct tw68_dev *dev = fh->dev;
-
-	dprintk(DBG_FLOW, "%s\n", __func__);
-	return tw68_s_std_internal(fh->dev, fh, id);
-}
-
 static int tw68_g_std(struct file *file, void *priv, v4l2_std_id *id)
 {
-	struct tw68_fh *fh = priv;
-	struct tw68_dev *dev = fh->dev;
+	struct tw68_dev *dev = video_drvdata(file);
 
-	dprintk(DBG_FLOW, "%s\n", __func__);
 	*id = dev->tvnorm->id;
 	return 0;
 }
 
-static int tw68_g_tuner(struct file *file, void *priv,
-					struct v4l2_tuner *t)
-{
-	struct tw68_fh *fh = priv;
-	struct tw68_dev *dev = fh->dev;
-	int n;
-
-	if (unlikely(UNSET == dev->tuner_type))
-		return -EINVAL;
-	if (0 != t->index)
-		return -EINVAL;
-	memset(t, 0, sizeof(*t));
-	for (n = 0; n < TW68_INPUT_MAX; n++)
-		if (card_in(dev, n).tv)
-			break;
-	if (n == TW68_INPUT_MAX)
-		return -EINVAL;
-#if 0
-	if (NULL != card_in(dev, n).name) {
-		strcpy(t->name, "Television");
-		t->type = V4L2_TUNER_ANALOG_TV;
-		t->capability = V4L2_TUNER_CAP_NORM |
-			V4L2_TUNER_CAP_STEREO |
-			V4L2_TUNER_CAP_LANG1 |
-			V4L2_TUNER_CAP_LANG2;
-		t->rangehigh = 0xffffffffUL;
-		t->rxsubchans = tw68_tvaudio_getstereo(dev);
-		t->audmode = tw68_tvaudio_rx2mode(t->rxsubchans);
-	}
-	if (0 != (saa_readb(TW68_STATUS_VIDEO1) & 0x03))
-		t->signal = 0xffff;
-#endif
-	return 0;
-}
-
-static int tw68_s_tuner(struct file *file, void *priv,
-					struct v4l2_tuner *t)
-{
-	struct tw68_fh *fh = priv;
-	struct tw68_dev *dev = fh->dev;
-	int err;
-#if 0
-	int rx, mode
-#endif
-
-#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,34)
-		err = v4l2_prio_check(&dev->prio, &fh->prio);
-#else
-		err = v4l2_prio_check(&dev->prio, fh->prio);
-#endif
-		if (0 != err)
-	if (0 != err)
-		return err;
-
-#if 0
-	mode = dev->thread.mode;
-	if (UNSET == mode) {
-		rx   = tw68_tvaudio_getstereo(dev);
-		mode = tw68_tvaudio_rx2mode(t->rxsubchans);
-	}
-	if (mode != t->audmode)
-		dev->thread.mode = t->audmode;
-#endif
-	return 0;
-}
-
-static int tw68_g_frequency(struct file *file, void *priv,
-					struct v4l2_frequency *f)
-{
-	struct tw68_fh *fh = priv;
-	struct tw68_dev *dev = fh->dev;
-
-	if (unlikely(dev->tuner_type))
-		return -EINVAL;
-	f->type = fh->radio ? V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV;
-/*	f->frequency = dev->ctl_freq; */
-
-	return 0;
-}
-
-static int tw68_s_frequency(struct file *file, void *priv,
-					struct v4l2_frequency *f)
-{
-	struct tw68_fh *fh = priv;
-	struct tw68_dev *dev = fh->dev;
-	int err;
-
-	if (unlikely(UNSET == dev->tuner_type))
-		return -EINVAL;
-#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,34)
-		err = v4l2_prio_check(&dev->prio, &fh->prio);
-#else
-		err = v4l2_prio_check(&dev->prio, fh->prio);
-#endif
-		if (0 != err)
-	if (0 != err)
-		return err;
-
-	if (0 != f->tuner)
-		return -EINVAL;
-	if (0 == fh->radio && V4L2_TUNER_ANALOG_TV != f->type)
-		return -EINVAL;
-	if (1 == fh->radio && V4L2_TUNER_RADIO != f->type)
-		return -EINVAL;
-	mutex_lock(&dev->lock);
-/*	dev->ctl_freq = f->frequency; */
-
-	tw_call_all(dev, tuner, s_frequency, f);
-
-	tw68_tvaudio_do_scan(dev);
-	mutex_unlock(&dev->lock);
-	return 0;
-}
-
-static int tw68_g_audio(struct file *file, void *priv, struct v4l2_audio *a)
-{
-	strcpy(a->name, "audio");
-	return 0;
-}
-
-static int tw68_s_audio(struct file *file, void *priv, struct v4l2_audio *a)
-{
-	return 0;
-}
-
-static int tw68_g_priority(struct file *file, void *f, enum v4l2_priority *p)
-{
-	struct tw68_fh *fh = f;
-	struct tw68_dev *dev = fh->dev;
-
-	dprintk(DBG_FLOW, "%s\n", __func__);
-	*p = v4l2_prio_max(&dev->prio);
-	return 0;
-}
-
-static int tw68_s_priority(struct file *file, void *f,
-					enum v4l2_priority prio)
-{
-	struct tw68_fh *fh = f;
-	struct tw68_dev *dev = fh->dev;
-
-	dprintk(DBG_FLOW, "%s\n", __func__);
-	return v4l2_prio_change(&dev->prio, &fh->prio, prio);
-}
-
 static int tw68_enum_fmt_vid_cap(struct file *file, void  *priv,
 					struct v4l2_fmtdesc *f)
 {
-	struct tw68_fh *fh = priv;
-	struct tw68_dev *dev = fh->dev;
-
-	dprintk(DBG_FLOW, "%s\n", __func__);
 	if (f->index >= FORMATS)
 		return -EINVAL;
 
@@ -1775,149 +812,6 @@ static int tw68_enum_fmt_vid_cap(struct file *file, void  *priv,
 	return 0;
 }
 
-static int tw68_cropcap(struct file *file, void *priv,
-					struct v4l2_cropcap *cap)
-{
-	struct tw68_fh *fh = priv;
-	struct tw68_dev *dev = fh->dev;
-
-	dprintk(DBG_FLOW, "%s\n", __func__);
-	if (cap->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
-		return -EINVAL;
-	cap->bounds  = dev->crop_bounds;
-	cap->defrect = dev->crop_defrect;
-	cap->pixelaspect.numerator   = 1;
-	cap->pixelaspect.denominator = 1;
-	if (dev->tvnorm->id & V4L2_STD_525_60) {
-		cap->pixelaspect.numerator   = 11;
-		cap->pixelaspect.denominator = 10;
-	}
-	if (dev->tvnorm->id & V4L2_STD_625_50) {
-		cap->pixelaspect.numerator   = 54;
-		cap->pixelaspect.denominator = 59;
-	}
-	return 0;
-}
-
-static int tw68_g_crop(struct file *file, void *f, struct v4l2_crop *crop)
-{
-	struct tw68_fh *fh = f;
-	struct tw68_dev *dev = fh->dev;
-
-	dprintk(DBG_FLOW, "%s\n", __func__);
-	if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
-		return -EINVAL;
-	crop->c = dev->crop_current;
-	return 0;
-}
-
-static int tw68_s_crop(struct file *file, void *f, struct v4l2_crop *crop)
-{
-	struct tw68_fh *fh = f;
-	struct tw68_dev *dev = fh->dev;
-	struct v4l2_rect *b = &dev->crop_bounds;
-
-	dprintk(DBG_FLOW, "%s\n", __func__);
-	if (res_locked(fh->dev, RESOURCE_VIDEO))
-		return -EBUSY;
-
-	if ((crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) ||
-	    (crop->c.height < 0) || (crop->c.width < 0)) {
-		dprintk(DBG_UNEXPECTED, "%s: invalid request\n", __func__);
-		return -EINVAL;
-	}
-
-	if (crop->c.top < b->top)
-		crop->c.top = b->top;
-	if (crop->c.top > b->top + b->height)
-		crop->c.top = b->top + b->height;
-	if (crop->c.height > b->top - crop->c.top + b->height)
-		crop->c.height = b->top - crop->c.top + b->height;
-
-	if (crop->c.left < b->left)
-		crop->c.left = b->left;
-	if (crop->c.left > b->left + b->width)
-		crop->c.left = b->left + b->width;
-	if (crop->c.width > b->left - crop->c.left + b->width)
-		crop->c.width = b->left - crop->c.left + b->width;
-
-	dprintk(DBG_FLOW, "%s: setting cropping rectangle: top=%d, left=%d, "
-		    "width=%d, height=%d\n", __func__, crop->c.top,
-		    crop->c.left, crop->c.width, crop->c.height);
-	dev->crop_current = crop->c;
-	return 0;
-}
-
-/*
- * Wrappers for the v4l2_ioctl_ops functions
- */
-#ifdef CONFIG_VIDEO_V4L1_COMPAT
-static int vidiocgmbuf(struct file *file, void *priv, struct video_mbuf *mbuf)
-{
-	struct tw68_fh *fh = file->private_data;
-	return videobuf_cgmbuf(tw68_queue(fh), mbuf, 8);
-}
-#endif
-
-static int tw68_reqbufs(struct file *file, void *priv,
-					struct v4l2_requestbuffers *p)
-{
-	struct tw68_fh *fh = priv;
-	return videobuf_reqbufs(tw68_queue(fh), p);
-}
-
-static int tw68_querybuf(struct file *file, void *priv,
-					struct v4l2_buffer *b)
-{
-	struct tw68_fh *fh = priv;
-	return videobuf_querybuf(tw68_queue(fh), b);
-}
-
-static int tw68_qbuf(struct file *file, void *priv, struct v4l2_buffer *b)
-{
-	struct tw68_fh *fh = priv;
-	return videobuf_qbuf(tw68_queue(fh), b);
-}
-
-static int tw68_dqbuf(struct file *file, void *priv, struct v4l2_buffer *b)
-{
-	struct tw68_fh *fh = priv;
-	return videobuf_dqbuf(tw68_queue(fh), b,
-				file->f_flags & O_NONBLOCK);
-}
-
-static int tw68_streamon(struct file *file, void *priv,
-					enum v4l2_buf_type type)
-{
-	struct tw68_fh *fh = priv;
-	struct tw68_dev *dev = fh->dev;
-	int res = tw68_resource(fh);
-
-	dprintk(DBG_FLOW, "%s\n", __func__);
-	if (!res_get(fh, res))
-		return -EBUSY;
-
-	tw68_buffer_requeue(dev, &dev->video_q);
-	return videobuf_streamon(tw68_queue(fh));
-}
-
-static int tw68_streamoff(struct file *file, void *priv,
-					enum v4l2_buf_type type)
-{
-	int err;
-	struct tw68_fh *fh = priv;
-	struct tw68_dev *dev = fh->dev;
-	int res = tw68_resource(fh);
-
-	dprintk(DBG_FLOW, "%s\n", __func__);
-	err = videobuf_streamoff(tw68_queue(fh));
-	if (err < 0)
-		return err;
-	res_free(fh, res);
-	return 0;
-}
-
-#ifdef CONFIG_VIDEO_ADV_DEBUG
 /*
  * Used strictly for internal development and debugging, this routine
  * prints out the current register contents for the tw68xx device.
@@ -1928,7 +822,7 @@ static void tw68_dump_regs(struct tw68_dev *dev)
 	int i, j, k;
 	unsigned char *cptr;
 
-	printk(KERN_DEBUG "Full dump of TW68 registers:\n");
+	pr_info("Full dump of TW68 registers:\n");
 	/* First we do the PCI regs, 8 4-byte regs per line */
 	for (i = 0; i < 0x100; i += 32) {
 		cptr = line;
@@ -1941,7 +835,7 @@ static void tw68_dump_regs(struct tw68_dev *dev)
 			cptr += sprintf(cptr, "%08x ", tw_readl(j));
 		*cptr++ = '\n';
 		*cptr = 0;
-		printk(KERN_DEBUG "%s", line);
+		pr_info("%s", line);
 	}
 	/* Next the control regs, which are single-byte, address mod 4 */
 	while (i < 0x400) {
@@ -1958,29 +852,24 @@ static void tw68_dump_regs(struct tw68_dev *dev)
 		}
 		*cptr++ = '\n';
 		*cptr = 0;
-		printk(KERN_DEBUG "%s", line);
+		pr_info("%s", line);
 	}
 }
 
 static int vidioc_log_status(struct file *file, void *priv)
 {
-	struct tw68_fh *fh = priv;
-	struct tw68_dev *dev = fh->dev;
+	struct tw68_dev *dev = video_drvdata(file);
 
 	tw68_dump_regs(dev);
-	return 0;
+	return v4l2_ctrl_log_status(file, priv);
 }
 
+#ifdef CONFIG_VIDEO_ADV_DEBUG
 static int vidioc_g_register(struct file *file, void *priv,
 			      struct v4l2_dbg_register *reg)
 {
-	struct tw68_fh *fh = priv;
-	struct tw68_dev *dev = fh->dev;	/* needed for tw_readb */
+	struct tw68_dev *dev = video_drvdata(file);
 
-	dprintk(DBG_FLOW, "%s\n", __func__);
-	if (!v4l2_chip_match_host(&reg->match))
-		dprintk(DBG_UNEXPECTED, "%s: match failed\n", __func__);
-		return -EINVAL;
 	if (reg->size == 1)
 		reg->val = tw_readb(reg->reg);
 	else
@@ -1989,17 +878,10 @@ static int vidioc_g_register(struct file *file, void *priv,
 }
 
 static int vidioc_s_register(struct file *file, void *priv,
-				struct v4l2_dbg_register *reg)
+				const struct v4l2_dbg_register *reg)
 {
-	struct tw68_fh *fh = priv;
-	struct tw68_dev *dev = fh->dev;	/* needed for tw_writeb */
+	struct tw68_dev *dev = video_drvdata(file);
 
-	dprintk(DBG_FLOW, "%s: request to set reg 0x%04x to 0x%02x\n",
-		__func__, (unsigned int)reg->reg, (unsigned int)reg->val);
-	if (!v4l2_chip_match_host(&reg->match)) {
-		dprintk(DBG_UNEXPECTED, "%s: match failed\n", __func__);
-		return -EINVAL;
-	}
 	if (reg->size == 1)
 		tw_writeb(reg->reg, reg->val);
 	else
@@ -2008,151 +890,120 @@ static int vidioc_s_register(struct file *file, void *priv,
 }
 #endif
 
+static const struct v4l2_ctrl_ops tw68_ctrl_ops = {
+	.s_ctrl = tw68_s_ctrl,
+};
+
 static const struct v4l2_file_operations video_fops = {
 	.owner			= THIS_MODULE,
-	.open			= video_open,
-	.release		= video_release,
-	.read			= video_read,
-	.poll			= video_poll,
-	.mmap			= video_mmap,
-	.ioctl			= video_ioctl2,
+	.open			= v4l2_fh_open,
+	.release		= vb2_fop_release,
+	.read			= vb2_fop_read,
+	.poll			= vb2_fop_poll,
+	.mmap			= vb2_fop_mmap,
+	.unlocked_ioctl		= video_ioctl2,
 };
 
 static const struct v4l2_ioctl_ops video_ioctl_ops = {
 	.vidioc_querycap		= tw68_querycap,
 	.vidioc_enum_fmt_vid_cap	= tw68_enum_fmt_vid_cap,
-	.vidioc_reqbufs			= tw68_reqbufs,
-	.vidioc_querybuf		= tw68_querybuf,
-	.vidioc_qbuf			= tw68_qbuf,
-	.vidioc_dqbuf			= tw68_dqbuf,
+	.vidioc_reqbufs			= vb2_ioctl_reqbufs,
+	.vidioc_create_bufs		= vb2_ioctl_create_bufs,
+	.vidioc_querybuf		= vb2_ioctl_querybuf,
+	.vidioc_qbuf			= vb2_ioctl_qbuf,
+	.vidioc_dqbuf			= vb2_ioctl_dqbuf,
 	.vidioc_s_std			= tw68_s_std,
 	.vidioc_g_std			= tw68_g_std,
 	.vidioc_enum_input		= tw68_enum_input,
 	.vidioc_g_input			= tw68_g_input,
 	.vidioc_s_input			= tw68_s_input,
-	.vidioc_queryctrl		= tw68_queryctrl,
-	.vidioc_g_ctrl			= tw68_g_ctrl,
-	.vidioc_s_ctrl			= tw68_s_ctrl,
-	.vidioc_streamon		= tw68_streamon,
-	.vidioc_streamoff		= tw68_streamoff,
-	.vidioc_g_priority		= tw68_g_priority,
-	.vidioc_s_priority		= tw68_s_priority,
+	.vidioc_streamon		= vb2_ioctl_streamon,
+	.vidioc_streamoff		= vb2_ioctl_streamoff,
 	.vidioc_g_fmt_vid_cap		= tw68_g_fmt_vid_cap,
 	.vidioc_try_fmt_vid_cap		= tw68_try_fmt_vid_cap,
 	.vidioc_s_fmt_vid_cap		= tw68_s_fmt_vid_cap,
-	.vidioc_cropcap			= tw68_cropcap,
-	.vidioc_g_crop			= tw68_g_crop,
-	.vidioc_s_crop			= tw68_s_crop,
-/*
- * Functions not yet implemented / not yet passing tests.
- */
-
-#if 0
-	.vidioc_g_fmt_vbi_cap		= tw68_try_get_set_fmt_vbi_cap,
-	.vidioc_try_fmt_vbi_cap		= tw68_try_get_set_fmt_vbi_cap,
-	.vidioc_s_fmt_vbi_cap		= tw68_try_get_set_fmt_vbi_cap,
-#endif
-	.vidioc_g_audio			= tw68_g_audio,
-	.vidioc_s_audio			= tw68_s_audio,
-	.vidioc_g_tuner			= tw68_g_tuner,
-	.vidioc_s_tuner			= tw68_s_tuner,
-	.vidioc_g_frequency		= tw68_g_frequency,
-	.vidioc_s_frequency		= tw68_s_frequency,
-#ifdef CONFIG_VIDEO_V4L1_COMPAT
-	.vidiocgmbuf			= vidiocgmbuf,
-#endif
-#ifdef CONFIG_VIDEO_ADV_DEBUG
 	.vidioc_log_status		= vidioc_log_status,
+	.vidioc_subscribe_event		= v4l2_ctrl_subscribe_event,
+	.vidioc_unsubscribe_event	= v4l2_event_unsubscribe,
+#ifdef CONFIG_VIDEO_ADV_DEBUG
 	.vidioc_g_register              = vidioc_g_register,
 	.vidioc_s_register              = vidioc_s_register,
 #endif
 };
 
-/* ------------------------------------------------------------------ */
-/* exported stuff                                                     */
-struct video_device tw68_video_template = {
+static struct video_device tw68_video_template = {
 	.name			= "tw68_video",
 	.fops			= &video_fops,
 	.ioctl_ops		= &video_ioctl_ops,
-	.minor			= -1,
+	.release		= video_device_release_empty,
 	.tvnorms		= TW68_NORMS,
-	.current_norm		= V4L2_STD_PAL,
-};
-
-struct video_device tw68_radio_template = {
-	.name			= "tw68_radio",
 };
 
-int tw68_videoport_init(struct tw68_dev *dev)
-{
-	return 0;
-}
-
+/* ------------------------------------------------------------------ */
+/* exported stuff                                                     */
 void tw68_set_tvnorm_hw(struct tw68_dev *dev)
 {
 	tw_andorb(TW68_SDT, 0x07, dev->tvnorm->format);
-	return;
 }
 
 int tw68_video_init1(struct tw68_dev *dev)
 {
-	int i;
-
-	dprintk(DBG_FLOW, "%s\n", __func__);
-	/* sanitycheck insmod options */
-	if (gbuffers < 2 || gbuffers > VIDEO_MAX_FRAME)
-		gbuffers = 2;
-	if (gbufsz < 0 || gbufsz > gbufsz_max)
-		gbufsz = gbufsz_max;
-	gbufsz = (gbufsz + PAGE_SIZE - 1) & PAGE_MASK;
-
-	/* put some sensible defaults into the data structures ... */
-	for (i = 0; i < CTRLS; i++)
-		tw68_s_ctrl_value(dev, video_ctrls[i].id,
-				  video_ctrls[i].default_value);
-#if 0
-	if (dev->tda9887_conf && dev->ctl_automute)
-		dev->tda9887_conf |= TDA9887_AUTOMUTE;
-	dev->automute       = 0;
-#endif
-	INIT_LIST_HEAD(&dev->video_q.queued);
-	INIT_LIST_HEAD(&dev->video_q.active);
-	init_timer(&dev->video_q.timeout);
-	dev->video_q.timeout.function	= tw68_buffer_timeout;
-	dev->video_q.timeout.data	= (unsigned long)(&dev->video_q);
-	dev->video_q.dev		= dev;
-	dev->video_q.buf_compat		= tw68_check_video_fmt;
-	dev->video_q.start_dma		= tw68_video_start_dma;
-	tw68_risc_stopper(dev->pci, &dev->video_q.stopper);
-
-	if (tw68_boards[dev->board].video_out)
-		tw68_videoport_init(dev);
-
+	struct v4l2_ctrl_handler *hdl = &dev->hdl;
+
+	v4l2_ctrl_handler_init(hdl, 6);
+	v4l2_ctrl_new_std(hdl, &tw68_ctrl_ops,
+			V4L2_CID_BRIGHTNESS, -128, 127, 1, 20);
+	v4l2_ctrl_new_std(hdl, &tw68_ctrl_ops,
+			V4L2_CID_CONTRAST, 0, 255, 1, 100);
+	v4l2_ctrl_new_std(hdl, &tw68_ctrl_ops,
+			V4L2_CID_SATURATION, 0, 255, 1, 128);
+	/* NTSC only */
+	v4l2_ctrl_new_std(hdl, &tw68_ctrl_ops,
+			V4L2_CID_HUE, -128, 127, 1, 0);
+	v4l2_ctrl_new_std(hdl, &tw68_ctrl_ops,
+			V4L2_CID_COLOR_KILLER, 0, 1, 1, 0);
+	v4l2_ctrl_new_std(hdl, &tw68_ctrl_ops,
+			V4L2_CID_CHROMA_AGC, 0, 1, 1, 1);
+	if (hdl->error) {
+		v4l2_ctrl_handler_free(hdl);
+		return hdl->error;
+	}
+	dev->v4l2_dev.ctrl_handler = hdl;
+	v4l2_ctrl_handler_setup(hdl);
 	return 0;
 }
 
-int tw68_video_init2(struct tw68_dev *dev)
+int tw68_video_init2(struct tw68_dev *dev, int video_nr)
 {
-	dprintk(DBG_FLOW, "%s\n", __func__);
+	int ret;
+
 	set_tvnorm(dev, &tvnorms[0]);
-	video_mux(dev, 0);
-/*
-	tw68_tvaudio_setmut(dev);
-	tw68_tvaudio_setvolume(dev, dev->ctl_volume);
-*/
-	return 0;
-}
 
-/*
- * tw68_irq_video_signalchange
- *
- * TODO:
- * Check for presence of video signal.  If not present, mute audio.
- * If present, log type of signal present.
- */
-void tw68_irq_video_signalchange(struct tw68_dev *dev)
-{
-	return;
+	dev->fmt      = format_by_fourcc(V4L2_PIX_FMT_BGR24);
+	dev->width    = 720;
+	dev->height   = 576;
+	dev->field    = V4L2_FIELD_INTERLACED;
+
+	INIT_LIST_HEAD(&dev->active);
+	dev->vidq.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+	dev->vidq.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
+	dev->vidq.io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ | VB2_DMABUF;
+	dev->vidq.ops = &tw68_video_qops;
+	dev->vidq.mem_ops = &vb2_dma_sg_memops;
+	dev->vidq.drv_priv = dev;
+	dev->vidq.gfp_flags = __GFP_DMA32;
+	dev->vidq.buf_struct_size = sizeof(struct tw68_buf);
+	dev->vidq.lock = &dev->lock;
+	dev->vidq.min_buffers_needed = 2;
+	ret = vb2_queue_init(&dev->vidq);
+	if (ret)
+		return ret;
+	dev->vdev = tw68_video_template;
+	dev->vdev.v4l2_dev = &dev->v4l2_dev;
+	dev->vdev.lock = &dev->lock;
+	dev->vdev.queue = &dev->vidq;
+	video_set_drvdata(&dev->vdev, dev);
+	return video_register_device(&dev->vdev, VFL_TYPE_GRABBER, video_nr);
 }
 
 /*
@@ -2171,60 +1022,39 @@ void tw68_irq_video_done(struct tw68_dev *dev, unsigned long status)
 	 * for the current buffer.
 	 */
 	if (status & TW68_DMAPI) {
-		struct tw68_dmaqueue *q = &dev->video_q;
-		dprintk(DBG_FLOW | DBG_TESTING, "DMAPI interrupt\n");
+		struct tw68_buf *buf;
+
 		spin_lock(&dev->slock);
-		/*
-		 * tw68_wakeup will take care of the buffer handling,
-		 * plus any non-video requirements.
-		 */
-		tw68_wakeup(q, &dev->video_fieldcount);
+		buf = list_entry(dev->active.next, struct tw68_buf, list);
+		list_del(&buf->list);
 		spin_unlock(&dev->slock);
-		/* Check whether we have gotten into 'stopper' code */
-		reg = tw_readl(TW68_DMAP_PP);
-		if ((reg >= q->stopper.dma) &&
-		    (reg < q->stopper.dma + q->stopper.size)) {
-			/* Yes - log the information */
-			dprintk(DBG_FLOW | DBG_TESTING,
-				"%s: stopper risc code entered\n", __func__);
-		}
+		v4l2_get_timestamp(&buf->vb.v4l2_buf.timestamp);
+		buf->vb.v4l2_buf.field = dev->field;
+		buf->vb.v4l2_buf.sequence = dev->seqnr++;
+		vb2_buffer_done(&buf->vb, VB2_BUF_STATE_DONE);
 		status &= ~(TW68_DMAPI);
 		if (0 == status)
 			return;
 	}
-	if (status & (TW68_VLOCK | TW68_HLOCK)) { /* lost sync */
-		dprintk(DBG_UNUSUAL, "Lost sync\n");
-	}
-	if (status & TW68_PABORT) {	/* TODO - what should we do? */
-		dprintk(DBG_UNEXPECTED, "PABORT interrupt\n");
-	}
-	if (status & TW68_DMAPERR) {
-		dprintk(DBG_UNEXPECTED, "DMAPERR interrupt\n");
-#if 0
-		/* Stop risc & fifo */
-		tw_clearl(TW68_DMAC, TW68_DMAP_EN | TW68_FIFO_EN);
-		tw_clearl(TW68_INTMASK, dev->board_virqmask);
-		dev->pci_irqmask &= ~dev->board_virqmask;
-#endif
-	}
+	if (status & (TW68_VLOCK | TW68_HLOCK))
+		dev_dbg(&dev->pci->dev, "Lost sync\n");
+	if (status & TW68_PABORT)
+		dev_err(&dev->pci->dev, "PABORT interrupt\n");
+	if (status & TW68_DMAPERR)
+		dev_err(&dev->pci->dev, "DMAPERR interrupt\n");
 	/*
 	 * On TW6800, FDMIS is apparently generated if video input is switched
 	 * during operation.  Therefore, it is not enabled for that chip.
 	 */
-	if (status & TW68_FDMIS) {	/* logic error somewhere */
-		dprintk(DBG_UNEXPECTED, "FDMIS interrupt\n");
-		/* Stop risc & fifo */
-//		tw_clearl(TW68_DMAC, TW68_DMAP_EN | TW68_FIFO_EN);
-//		tw_clearl(TW68_INTMASK, dev->board_virqmask);
-//		dev->pci_irqmask &= ~dev->board_virqmask;
-	}
-	if (status & TW68_FFOF) {	/* probably a logic error */
+	if (status & TW68_FDMIS)
+		dev_dbg(&dev->pci->dev, "FDMIS interrupt\n");
+	if (status & TW68_FFOF) {
+		/* probably a logic error */
 		reg = tw_readl(TW68_DMAC) & TW68_FIFO_EN;
 		tw_clearl(TW68_DMAC, TW68_FIFO_EN);
-		dprintk(DBG_UNUSUAL, "FFOF interrupt\n");
+		dev_dbg(&dev->pci->dev, "FFOF interrupt\n");
 		tw_setl(TW68_DMAC, reg);
 	}
 	if (status & TW68_FFERR)
-		dprintk(DBG_UNEXPECTED, "FFERR interrupt\n");
-	return;
+		dev_dbg(&dev->pci->dev, "FFERR interrupt\n");
 }
diff --git a/drivers/media/pci/tw68/tw68.h b/drivers/media/pci/tw68/tw68.h
index e723efb5e623..2c8abe26b13b 100644
--- a/drivers/media/pci/tw68/tw68.h
+++ b/drivers/media/pci/tw68/tw68.h
@@ -8,7 +8,11 @@
  *  acknowledged.  Full credit goes to them - any problems within this code
  *  are mine.
  *
- *  Copyright (C) 2009  William M. Brack <wbrack@mmm.com.hk>
+ *  Copyright (C) 2009  William M. Brack
+ *
+ *  Refactored and updated to the latest v4l core frameworks:
+ *
+ *  Copyright (C) 2014 Hans Verkuil <hverkuil@xs4all.nl>
  *
  *  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
@@ -19,54 +23,26 @@
  *  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/version.h>
-#define	TW68_VERSION_CODE	KERNEL_VERSION(0, 0, 8)
-
 #include <linux/pci.h>
-#include <linux/i2c.h>
-#include <linux/i2c-algo-bit.h>
 #include <linux/videodev2.h>
-#include <linux/kdev_t.h>
-#include <linux/input.h>
 #include <linux/notifier.h>
 #include <linux/delay.h>
 #include <linux/mutex.h>
-
-#include <asm/io.h>
+#include <linux/io.h>
 
 #include <media/v4l2-common.h>
 #include <media/v4l2-ioctl.h>
+#include <media/v4l2-ctrls.h>
 #include <media/v4l2-device.h>
+#include <media/videobuf2-dma-sg.h>
 
-#include <media/tuner.h>
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,38)
-#  include <media/ir-common.h>
-#endif
-#include <media/ir-kbd-i2c.h>
-#include <media/videobuf-dma-sg.h>
-
-#include "btcx-risc.h"
 #include "tw68-reg.h"
 
 #define	UNSET	(-1U)
 
-/*
- * dprintk statement within the code use a 'level' argument.  For
- * our purposes, we use the following levels:
- */
-#define	DBG_UNEXPECTED		(1 << 0)
-#define	DBG_UNUSUAL		(1 << 1)
-#define	DBG_TESTING		(1 << 2)
-#define	DBG_BUFF		(1 << 3)
-#define	DBG_FLOW		(1 << 15)
-
 /* system vendor and device ID's */
 #define	PCI_VENDOR_ID_TECHWELL	0x1797
 #define	PCI_DEVICE_ID_6800	0x6800
@@ -83,15 +59,9 @@
 #define	PCI_DEVICE_ID_6816_3   0x6812
 #define	PCI_DEVICE_ID_6816_4   0x6813
 
-/* subsystem vendor ID's */
-#define	TW68_PCI_ID_TECHWELL	0x1797
-
-#define TW68_NORMS (\
-	V4L2_STD_NTSC   | V4L2_STD_PAL       | V4L2_STD_SECAM    | \
-	V4L2_STD_PAL_BG | V4L2_STD_PAL_DK    | V4L2_STD_PAL_I    | \
-	V4L2_STD_PAL_M  | V4L2_STD_PAL_Nc    | V4L2_STD_PAL_60   | \
-	V4L2_STD_525_60 | V4L2_STD_625_50    | \
-	V4L2_STD_SECAM_L| V4L2_STD_SECAM_LC  | V4L2_STD_SECAM_DK)
+#define TW68_NORMS ( \
+	V4L2_STD_NTSC    | V4L2_STD_PAL       | V4L2_STD_SECAM    | \
+	V4L2_STD_PAL_M   | V4L2_STD_PAL_Nc    | V4L2_STD_PAL_60)
 
 #define	TW68_VID_INTS	(TW68_FFERR | TW68_PABORT | TW68_DMAPERR | \
 			 TW68_FFOF   | TW68_DMAPI)
@@ -101,12 +71,13 @@
 #define	TW68_I2C_INTS	(TW68_SBERR | TW68_SBDONE | TW68_SBERR2  | \
 			 TW68_SBDONE2)
 
-typedef enum {
+enum tw68_decoder_type {
 	TW6800,
 	TW6801,
 	TW6804,
 	TWXXXX,
-} TW68_DECODER_TYPE;
+};
+
 /* ----------------------------------------------------------- */
 /* static data                                                 */
 
@@ -153,164 +124,24 @@ struct tw68_format {
 #define	TW68_BOARD_GENERIC_6802		1
 
 #define	TW68_MAXBOARDS			16
-#define	TW68_INPUT_MAX			8
-
-/* ----------------------------------------------------------- */
-/* enums						       */
-
-enum tw68_mpeg_type {
-	TW68_MPEG_UNUSED,
-	TW68_MPEG_EMPRESS,
-	TW68_MPEG_DVB,
-};
-
-enum tw68_audio_in {
-	TV      = 1,
-	LINE1   = 2,
-	LINE2   = 3,
-	LINE2_LEFT,
-};
-
-enum tw68_video_out {
-	CCIR656 = 1,
-};
-
-/* Structs for card definition */
-struct tw68_input {
-	char			*name;		/* text description */
-	unsigned int		vmux;		/* mux value */
-	enum tw68_audio_in	mux;
-	unsigned int		gpio;
-	unsigned int		tv:1;
-};
-
-struct tw68_board {
-	char			*name;
-	unsigned int		audio_clock;
-
-	/* input switching */
-	unsigned int		gpiomask;
-	struct tw68_input	inputs[TW68_INPUT_MAX];
-	struct tw68_input	radio;
-	struct tw68_input	mute;
-
-	/* i2c chip info */
-	unsigned int		tuner_type;
-	unsigned int		radio_type;
-	unsigned char		tuner_addr;
-	unsigned char		radio_addr;
-
-	unsigned int		tda9887_conf;
-	unsigned int		tuner_config;
-
-	enum tw68_video_out	video_out;
-	enum tw68_mpeg_type	mpeg;
-	unsigned int		vid_port_opts;
-};
-
-#define card_has_radio(dev)	(NULL != tw68_boards[dev->board].radio.name)
-#define card_has_mpeg(dev)	(TW68_MPEG_UNUSED != \
-					tw68_boards[dev->board].mpeg)
-#define card_in(dev, n)		(tw68_boards[dev->board].inputs[n])
-#define card(dev)		(tw68_boards[dev->board])
+#define	TW68_INPUT_MAX			4
 
 /* ----------------------------------------------------------- */
 /* device / file handle status                                 */
 
-#define	RESOURCE_VIDEO			1
-#define	RESOURCE_VBI			2
-
-#define	INTERLACE_AUTO			0
-#define	INTERLACE_ON			1
-#define	INTERLACE_OFF			2
-
 #define	BUFFER_TIMEOUT	msecs_to_jiffies(500)	/* 0.5 seconds */
 
 struct tw68_dev;	/* forward delclaration */
 
-/* tvaudio thread status */
-struct tw68_thread {
-	struct task_struct	*thread;
-	unsigned int		scan1;
-	unsigned int		scan2;
-	unsigned int		mode;
-	unsigned int		stopped;
-};
-
 /* buffer for one video/vbi/ts frame */
 struct tw68_buf {
-	/* common v4l buffer stuff -- must be first */
-	struct videobuf_buffer vb;
-
-	/* tw68 specific */
-	struct tw68_format	*fmt;
-	struct tw68_input	*input;
-	unsigned int		top_seen;
-	int (*activate)(struct tw68_dev *dev,
-			struct tw68_buf *buf,
-			struct tw68_buf *next);
-	struct btcx_riscmem	risc;
-	unsigned int		bpl;
-};
+	struct vb2_buffer vb;
+	struct list_head list;
 
-struct tw68_dmaqueue {
-	struct tw68_dev		*dev;
-	struct list_head	active;
-	struct list_head	queued;
-	struct timer_list	timeout;
-	struct btcx_riscmem	stopper;
-	int (*buf_compat)(struct tw68_buf *prev,
-			  struct tw68_buf *buf);
-	int (*start_dma)(struct tw68_dev *dev,
-			 struct tw68_dmaqueue *q,
-			 struct tw68_buf *buf);
-};
-
-/* video filehandle status */
-struct tw68_fh {
-	struct tw68_dev		*dev;
-	unsigned int		radio;
-	enum v4l2_buf_type	type;
-	unsigned int		resources;
-	enum v4l2_priority	prio;
-
-	/* video capture */
-	struct tw68_format	*fmt;
-	unsigned int		width, height;
-	struct videobuf_queue	cap;	/* also used for overlay */
-
-	/* vbi capture */
-	struct videobuf_queue	vbi;
-};
-
-/* dmasound dsp status */
-struct tw68_dmasound {
-	struct mutex		lock;
-	int			minor_mixer;
-	int			minor_dsp;
-	unsigned int		users_dsp;
-
-	/* mixer */
-	enum tw68_audio_in	input;
-	unsigned int		count;
-	unsigned int		line1;
-	unsigned int		line2;
-
-	/* dsp */
-	unsigned int		afmt;
-	unsigned int		rate;
-	unsigned int		channels;
-	unsigned int		recording_on;
-	unsigned int		dma_running;
-	unsigned int		blocks;
-	unsigned int		blksize;
-	unsigned int		bufsize;
-	struct videobuf_dmabuf	dma;
-	unsigned int		dma_blk;
-	unsigned int		read_offset;
-	unsigned int		read_count;
-	void 			*priv_data;
-	struct snd_pcm_substream	*substream;
+	unsigned int   size;
+	__le32         *cpu;
+	__le32         *jmp;
+	dma_addr_t     dma;
 };
 
 struct tw68_fmt {
@@ -321,58 +152,20 @@ struct tw68_fmt {
 	u32			twformat;
 };
 
-/* ts/mpeg status */
-struct tw68_ts {
-	/* TS capture */
-	int			nr_packets;
-	int			nr_bufs;
-};
-
-/* ts/mpeg ops */
-struct tw68_mpeg_ops {
-	enum tw68_mpeg_type	type;
-	struct list_head	next;
-	int			(*init)(struct tw68_dev *dev);
-	int			(*fini)(struct tw68_dev *dev);
-	void			(*signal_change)(struct tw68_dev *dev);
-};
-
-enum tw68_ts_status {
-	TW68_TS_STOPPED,
-	TW68_TS_BUFF_DONE,
-	TW68_TS_STARTED,
-};
-
 /* global device status */
 struct tw68_dev {
-	struct list_head	devlist;
 	struct mutex		lock;
 	spinlock_t		slock;
-	struct v4l2_prio_state	prio;
+	u16			instance;
 	struct v4l2_device	v4l2_dev;
-	/* workstruct for loading modules */
-	struct work_struct request_module_wk;
-
-	/* insmod option/autodetected */
-	int			autodetected;
 
 	/* various device info */
-	TW68_DECODER_TYPE	vdecoder;
-	unsigned int		resources;
-	struct video_device	*video_dev;
-	struct video_device	*radio_dev;
-	struct video_device	*vbi_dev;
-	struct tw68_dmasound	dmasound;
-
-#if LINUX_VERSION_CODE < KERNEL_VERSION(3,0,0)
-	/* infrared remote */
-	int			has_remote;
-	struct card_ir		*remote;
-#endif
+	enum tw68_decoder_type	vdecoder;
+	struct video_device	vdev;
+	struct v4l2_ctrl_handler hdl;
 
 	/* pci i/o */
-	char			name[32];
-	int			nr;
+	char			*name;
 	struct pci_dev		*pci;
 	unsigned char		pci_rev, pci_lat;
 	u32			__iomem *lmmio;
@@ -381,75 +174,18 @@ struct tw68_dev {
 	/* The irq mask to be used will depend upon the chip type */
 	u32			board_virqmask;
 
-	/* config info */
-	unsigned int		board;
-	unsigned int		tuner_type;
-	unsigned int 		radio_type;
-	unsigned char		tuner_addr;
-	unsigned char		radio_addr;
-
-	unsigned int		tda9887_conf;
-	unsigned int		gpio_value;
-
-	/* i2c i/o */
-	struct i2c_algo_bit_data i2c_algo;
-	struct i2c_adapter	i2c_adap;
-	struct i2c_client	i2c_client;
-	u32			i2c_state;
-	u32			i2c_done;
-	wait_queue_head_t	i2c_queue;
-	int			i2c_rc;
-	unsigned char		eedata[256];
-
-	/* video+ts+vbi capture */
-	struct tw68_dmaqueue	video_q;
-	struct tw68_dmaqueue	vbi_q;
-	unsigned int		video_fieldcount;
-	unsigned int		vbi_fieldcount;
+	/* video capture */
+	const struct tw68_format *fmt;
+	unsigned		width, height;
+	unsigned		seqnr;
+	unsigned		field;
+	struct vb2_queue	vidq;
+	struct list_head	active;
 
 	/* various v4l controls */
-	struct tw68_tvnorm	*tvnorm;	/* video */
-	struct tw68_tvaudio	*tvaudio;
-#if 0
-	unsigned int		ctl_input;
-	int			ctl_bright;
-	int			ctl_contrast;
-	int			ctl_hue;
-	int			ctl_saturation;
-	int			ctl_freq;
-	int			ctl_mute;	/* audio */
-	int			ctl_volume;
-	int			ctl_invert;	/* private */
-	int			ctl_mirror;
-	int			ctl_y_odd;
-	int			ctl_y_even;
-	int			ctl_automute;
-#endif
-
-	/* crop */
-	struct v4l2_rect	crop_bounds;
-	struct v4l2_rect	crop_defrect;
-	struct v4l2_rect	crop_current;
-
-	/* other global state info */
-	unsigned int		automute;
-	struct tw68_thread	thread;
-	/* input is latest requested by app, hw_input is current hw setting */
-	struct tw68_input	*input;
-	struct tw68_input	*hw_input;
-	unsigned int		hw_mute;
-	int			last_carrier;
-	int			nosignal;
-	unsigned int		insuspend;
-
-	/* TW68_MPEG_* */
-	struct tw68_ts		ts;
-	struct tw68_dmaqueue	ts_q;
-	enum tw68_ts_status 	ts_state;
-	unsigned int 		buff_cnt;
-	struct tw68_mpeg_ops	*mops;
-
-	void (*gate_ctrl)(struct tw68_dev *dev, int open);
+	const struct tw68_tvnorm *tvnorm;	/* video */
+
+	int			input;
 };
 
 /* ----------------------------------------------------------- */
@@ -473,116 +209,23 @@ struct tw68_dev {
 #define	tw_clearb(reg, bit)	\
 		writeb((readb(dev->bmmio+(reg)) & ~(bit)), \
 		dev->bmmio + (reg))
-#define tw_call_all(dev, o, f, args...) do {				\
-	if (dev->gate_ctrl)						\
-		dev->gate_ctrl(dev, 1);					\
-	v4l2_device_call_all(&(dev)->v4l2_dev, 0, o, f , ##args);	\
-	if (dev->gate_ctrl)						\
-		dev->gate_ctrl(dev, 0);					\
-} while (0)
 
 #define tw_wait(us) { udelay(us); }
 
-static inline struct tw68_dev *to_tw68_dev(struct v4l2_device *v4l2_dev)
-{
-	return container_of(v4l2_dev, struct tw68_dev, v4l2_dev);
-}
-
-/* ----------------------------------------------------------- */
-/* tw68-core.c                                                */
-
-extern struct list_head  tw68_devlist;
-extern struct mutex tw68_devlist_lock;
-extern unsigned int irq_debug;
-
-int tw68_buffer_count(unsigned int size, unsigned int count);
-void tw68_buffer_queue(struct tw68_dev *dev, struct tw68_dmaqueue *q,
-		      struct tw68_buf *buf);
-void tw68_buffer_timeout(unsigned long data);
-int tw68_set_dmabits(struct tw68_dev *dev);
-void tw68_dma_free(struct videobuf_queue *q, struct tw68_buf *buf);
-void tw68_wakeup(struct tw68_dmaqueue *q, unsigned int *field_count);
-int tw68_buffer_requeue(struct tw68_dev *dev, struct tw68_dmaqueue *q);
-
-/* ----------------------------------------------------------- */
-/* tw68-cards.c                                                */
-
-extern struct tw68_board tw68_boards[];
-extern const unsigned int tw68_bcount;
-extern struct pci_device_id __devinitdata tw68_pci_tbl[];
-
-int tw68_board_init1(struct tw68_dev *dev);
-int tw68_board_init2(struct tw68_dev *dev);
-int tw68_tuner_callback(void *priv, int component, int command, int arg);
-
-/* ----------------------------------------------------------- */
-/* tw68-i2c.c                                                  */
-
-int tw68_i2c_register(struct tw68_dev *dev);
-int tw68_i2c_unregister(struct tw68_dev *dev);
-void tw68_irq_i2c(struct tw68_dev *dev, int status);
-
 /* ----------------------------------------------------------- */
 /* tw68-video.c                                                */
 
-extern unsigned int video_debug;
-extern struct video_device tw68_video_template;
-extern struct video_device tw68_radio_template;
-
-int tw68_videoport_init(struct tw68_dev *dev);
 void tw68_set_tvnorm_hw(struct tw68_dev *dev);
 
 int tw68_video_init1(struct tw68_dev *dev);
-int tw68_video_init2(struct tw68_dev *dev);
-void tw68_irq_video_signalchange(struct tw68_dev *dev);
+int tw68_video_init2(struct tw68_dev *dev, int video_nr);
 void tw68_irq_video_done(struct tw68_dev *dev, unsigned long status);
-
-/* ----------------------------------------------------------- */
-/* tw68-ts.c                                                   */
-
-int tw68_ts_init1(struct tw68_dev *dev);
-int tw68_ts_fini(struct tw68_dev *dev);
-void tw68_irq_ts_done(struct tw68_dev *dev, unsigned long status);
-
-int tw68_ts_register(struct tw68_mpeg_ops *ops);
-void tw68_ts_unregister(struct tw68_mpeg_ops *ops);
-
-int tw68_ts_init_hw(struct tw68_dev *dev);
-
-/* ----------------------------------------------------------- */
-/* tw68-vbi.c                                                  */
-
-extern struct videobuf_queue_ops tw68_vbi_qops;
-extern struct video_device tw68_vbi_template;
-
-int tw68_vbi_init1(struct tw68_dev *dev);
-int tw68_vbi_fini(struct tw68_dev *dev);
-void tw68_irq_vbi_done(struct tw68_dev *dev, unsigned long status);
-
-/* ----------------------------------------------------------- */
-/* tw68-tvaudio.c                                              */
-
-int tw68_tvaudio_rx2mode(u32 rx);
-
-void tw68_tvaudio_setmute(struct tw68_dev *dev);
-void tw68_tvaudio_setinput(struct tw68_dev *dev,
-			      struct tw68_input *in);
-void tw68_tvaudio_setvolume(struct tw68_dev *dev, int level);
-int tw68_tvaudio_getstereo(struct tw68_dev *dev);
-void tw68_tvaudio_init(struct tw68_dev *dev);
-int tw68_tvaudio_init2(struct tw68_dev *dev);
-int tw68_tvaudio_fini(struct tw68_dev *dev);
-int tw68_tvaudio_do_scan(struct tw68_dev *dev);
-int tw_dsp_writel(struct tw68_dev *dev, int reg, u32 value);
-void tw68_enable_i2s(struct tw68_dev *dev);
+int tw68_video_start_dma(struct tw68_dev *dev, struct tw68_buf *buf);
 
 /* ----------------------------------------------------------- */
 /* tw68-risc.c                                                 */
 
-int tw68_risc_buffer(struct pci_dev *pci, struct btcx_riscmem *risc,
+int tw68_risc_buffer(struct pci_dev *pci, struct tw68_buf *buf,
 	struct scatterlist *sglist, unsigned int top_offset,
 	unsigned int bottom_offset, unsigned int bpl,
 	unsigned int padding, unsigned int lines);
-int tw68_risc_stopper(struct pci_dev *pci, struct btcx_riscmem *risc);
-int tw68_risc_overlay(struct tw68_fh *fh, struct btcx_riscmem *risc,
-		      int field_type);