90 files changed, 11025 insertions, 768 deletions

diff --git a/drivers/media/usb/Kconfig b/drivers/media/usb/Kconfig
index 39d824e2bb69..94d51e092db3 100644
--- a/drivers/media/usb/Kconfig
+++ b/drivers/media/usb/Kconfig
@@ -27,6 +27,7 @@ source "drivers/media/usb/hdpvr/Kconfig"
 source "drivers/media/usb/tlg2300/Kconfig"
 source "drivers/media/usb/usbvision/Kconfig"
 source "drivers/media/usb/stk1160/Kconfig"
+source "drivers/media/usb/go7007/Kconfig"
 endif
 
 if (MEDIA_ANALOG_TV_SUPPORT || MEDIA_DIGITAL_TV_SUPPORT)
@@ -52,5 +53,11 @@ if (MEDIA_CAMERA_SUPPORT || MEDIA_ANALOG_TV_SUPPORT || MEDIA_DIGITAL_TV_SUPPORT)
 source "drivers/media/usb/em28xx/Kconfig"
 endif
 
+if MEDIA_SDR_SUPPORT
+        comment "Software defined radio USB devices"
+source "drivers/media/usb/msi2500/Kconfig"
+source "drivers/media/usb/airspy/Kconfig"
+endif
+
 endif #MEDIA_USB_SUPPORT
 endif #USB
diff --git a/drivers/media/usb/Makefile b/drivers/media/usb/Makefile
index 7ac4b143dce8..f438efffefc5 100644
--- a/drivers/media/usb/Makefile
+++ b/drivers/media/usb/Makefile
@@ -9,6 +9,8 @@ obj-y += zr364xx/ stkwebcam/ s2255/
 obj-$(CONFIG_USB_VIDEO_CLASS)   += uvc/
 obj-$(CONFIG_USB_GSPCA)         += gspca/
 obj-$(CONFIG_USB_PWC)           += pwc/
+obj-$(CONFIG_USB_MSI2500)       += msi2500/
+obj-$(CONFIG_USB_AIRSPY)        += airspy/
 obj-$(CONFIG_VIDEO_CPIA2) += cpia2/
 obj-$(CONFIG_VIDEO_AU0828) += au0828/
 obj-$(CONFIG_VIDEO_HDPVR)       += hdpvr/
@@ -20,3 +22,4 @@ obj-$(CONFIG_VIDEO_CX231XX) += cx231xx/
 obj-$(CONFIG_VIDEO_TM6000) += tm6000/
 obj-$(CONFIG_VIDEO_EM28XX) += em28xx/
 obj-$(CONFIG_VIDEO_USBTV) += usbtv/
+obj-$(CONFIG_VIDEO_GO7007) += go7007/
diff --git a/drivers/media/usb/airspy/Kconfig b/drivers/media/usb/airspy/Kconfig
new file mode 100644
index 000000000000..10b204cf4dbc
--- /dev/null
+++ b/drivers/media/usb/airspy/Kconfig
@@ -0,0 +1,10 @@
+config USB_AIRSPY
+        tristate "AirSpy"
+        depends on VIDEO_V4L2
+        select VIDEOBUF2_VMALLOC
+        ---help---
+          This is a video4linux2 driver for AirSpy SDR device.
+
+          To compile this driver as a module, choose M here: the
+          module will be called airspy
+
diff --git a/drivers/media/usb/airspy/Makefile b/drivers/media/usb/airspy/Makefile
new file mode 100644
index 000000000000..8d8e61c1a349
--- /dev/null
+++ b/drivers/media/usb/airspy/Makefile
@@ -0,0 +1 @@
+obj-$(CONFIG_USB_AIRSPY)              += airspy.o
diff --git a/drivers/media/usb/airspy/airspy.c b/drivers/media/usb/airspy/airspy.c
new file mode 100644
index 000000000000..cb0e515d80ae
--- /dev/null
+++ b/drivers/media/usb/airspy/airspy.c
@@ -0,0 +1,1132 @@
+/*
+ * AirSpy SDR driver
+ *
+ * Copyright (C) 2014 Antti Palosaari <crope@iki.fi>
+ *
+ *    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.
+ */
+
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/usb.h>
+#include <media/v4l2-device.h>
+#include <media/v4l2-ioctl.h>
+#include <media/v4l2-ctrls.h>
+#include <media/v4l2-event.h>
+#include <media/videobuf2-vmalloc.h>
+
+/* AirSpy USB API commands (from AirSpy Library) */
+enum {
+        CMD_INVALID                       = 0x00,
+        CMD_RECEIVER_MODE                 = 0x01,
+        CMD_SI5351C_WRITE                 = 0x02,
+        CMD_SI5351C_READ                  = 0x03,
+        CMD_R820T_WRITE                   = 0x04,
+        CMD_R820T_READ                    = 0x05,
+        CMD_SPIFLASH_ERASE                = 0x06,
+        CMD_SPIFLASH_WRITE                = 0x07,
+        CMD_SPIFLASH_READ                 = 0x08,
+        CMD_BOARD_ID_READ                 = 0x09,
+        CMD_VERSION_STRING_READ           = 0x0a,
+        CMD_BOARD_PARTID_SERIALNO_READ    = 0x0b,
+        CMD_SET_SAMPLE_RATE               = 0x0c,
+        CMD_SET_FREQ                      = 0x0d,
+        CMD_SET_LNA_GAIN                  = 0x0e,
+        CMD_SET_MIXER_GAIN                = 0x0f,
+        CMD_SET_VGA_GAIN                  = 0x10,
+        CMD_SET_LNA_AGC                   = 0x11,
+        CMD_SET_MIXER_AGC                 = 0x12,
+        CMD_SET_PACKING                   = 0x13,
+};
+
+/*
+ *       bEndpointAddress     0x81  EP 1 IN
+ *         Transfer Type            Bulk
+ *       wMaxPacketSize     0x0200  1x 512 bytes
+ */
+#define MAX_BULK_BUFS            (6)
+#define BULK_BUFFER_SIZE         (128 * 512)
+
+static const struct v4l2_frequency_band bands[] = {
+        {
+                .tuner = 0,
+                .type = V4L2_TUNER_ADC,
+                .index = 0,
+                .capability = V4L2_TUNER_CAP_1HZ | V4L2_TUNER_CAP_FREQ_BANDS,
+                .rangelow   = 20000000,
+                .rangehigh  = 20000000,
+        },
+};
+
+static const struct v4l2_frequency_band bands_rf[] = {
+        {
+                .tuner = 1,
+                .type = V4L2_TUNER_RF,
+                .index = 0,
+                .capability = V4L2_TUNER_CAP_1HZ | V4L2_TUNER_CAP_FREQ_BANDS,
+                .rangelow   =   24000000,
+                .rangehigh  = 1750000000,
+        },
+};
+
+/* stream formats */
+struct airspy_format {
+        char    *name;
+        u32     pixelformat;
+        u32     buffersize;
+};
+
+/* format descriptions for capture and preview */
+static struct airspy_format formats[] = {
+        {
+                .name           = "Real U12LE",
+                .pixelformat    = V4L2_SDR_FMT_RU12LE,
+                .buffersize     = BULK_BUFFER_SIZE,
+        },
+};
+
+static const unsigned int NUM_FORMATS = ARRAY_SIZE(formats);
+
+/* intermediate buffers with raw data from the USB device */
+struct airspy_frame_buf {
+        struct vb2_buffer vb;   /* common v4l buffer stuff -- must be first */
+        struct list_head list;
+};
+
+struct airspy {
+#define POWER_ON           (1 << 1)
+#define URB_BUF            (1 << 2)
+#define USB_STATE_URB_BUF  (1 << 3)
+        unsigned long flags;
+
+        struct usb_device *udev;
+        struct video_device vdev;
+        struct v4l2_device v4l2_dev;
+
+        /* videobuf2 queue and queued buffers list */
+        struct vb2_queue vb_queue;
+        struct list_head queued_bufs;
+        spinlock_t queued_bufs_lock; /* Protects queued_bufs */
+        unsigned sequence;           /* Buffer sequence counter */
+        unsigned int vb_full;        /* vb is full and packets dropped */
+
+        /* Note if taking both locks v4l2_lock must always be locked first! */
+        struct mutex v4l2_lock;      /* Protects everything else */
+        struct mutex vb_queue_lock;  /* Protects vb_queue and capt_file */
+
+        struct urb     *urb_list[MAX_BULK_BUFS];
+        int            buf_num;
+        unsigned long  buf_size;
+        u8             *buf_list[MAX_BULK_BUFS];
+        dma_addr_t     dma_addr[MAX_BULK_BUFS];
+        int            urbs_initialized;
+        int            urbs_submitted;
+
+        /* USB control message buffer */
+        #define BUF_SIZE 24
+        u8 buf[BUF_SIZE];
+
+        /* Current configuration */
+        unsigned int f_adc;
+        unsigned int f_rf;
+        u32 pixelformat;
+        u32 buffersize;
+
+        /* Controls */
+        struct v4l2_ctrl_handler hdl;
+        struct v4l2_ctrl *lna_gain_auto;
+        struct v4l2_ctrl *lna_gain;
+        struct v4l2_ctrl *mixer_gain_auto;
+        struct v4l2_ctrl *mixer_gain;
+        struct v4l2_ctrl *if_gain;
+
+        /* Sample rate calc */
+        unsigned long jiffies_next;
+        unsigned int sample;
+        unsigned int sample_measured;
+};
+
+#define airspy_dbg_usb_control_msg(_udev, _r, _t, _v, _i, _b, _l) { \
+        char *_direction; \
+        if (_t & USB_DIR_IN) \
+                _direction = "<<<"; \
+        else \
+                _direction = ">>>"; \
+        dev_dbg(&_udev->dev, "%s: %02x %02x %02x %02x %02x %02x %02x %02x " \
+                        "%s %*ph\n",  __func__, _t, _r, _v & 0xff, _v >> 8, \
+                        _i & 0xff, _i >> 8, _l & 0xff, _l >> 8, _direction, \
+                        _l, _b); \
+}
+
+/* execute firmware command */
+static int airspy_ctrl_msg(struct airspy *s, u8 request, u16 value, u16 index,
+                u8 *data, u16 size)
+{
+        int ret;
+        unsigned int pipe;
+        u8 requesttype;
+
+        switch (request) {
+        case CMD_RECEIVER_MODE:
+        case CMD_SET_FREQ:
+                pipe = usb_sndctrlpipe(s->udev, 0);
+                requesttype = (USB_TYPE_VENDOR | USB_DIR_OUT);
+                break;
+        case CMD_BOARD_ID_READ:
+        case CMD_VERSION_STRING_READ:
+        case CMD_BOARD_PARTID_SERIALNO_READ:
+        case CMD_SET_LNA_GAIN:
+        case CMD_SET_MIXER_GAIN:
+        case CMD_SET_VGA_GAIN:
+        case CMD_SET_LNA_AGC:
+        case CMD_SET_MIXER_AGC:
+                pipe = usb_rcvctrlpipe(s->udev, 0);
+                requesttype = (USB_TYPE_VENDOR | USB_DIR_IN);
+                break;
+        default:
+                dev_err(&s->udev->dev, "Unknown command %02x\n", request);
+                ret = -EINVAL;
+                goto err;
+        }
+
+        /* write request */
+        if (!(requesttype & USB_DIR_IN))
+                memcpy(s->buf, data, size);
+
+        ret = usb_control_msg(s->udev, pipe, request, requesttype, value,
+                        index, s->buf, size, 1000);
+        airspy_dbg_usb_control_msg(s->udev, request, requesttype, value,
+                        index, s->buf, size);
+        if (ret < 0) {
+                dev_err(&s->udev->dev,
+                                "usb_control_msg() failed %d request %02x\n",
+                                ret, request);
+                goto err;
+        }
+
+        /* read request */
+        if (requesttype & USB_DIR_IN)
+                memcpy(data, s->buf, size);
+
+        return 0;
+err:
+        return ret;
+}
+
+/* Private functions */
+static struct airspy_frame_buf *airspy_get_next_fill_buf(struct airspy *s)
+{
+        unsigned long flags = 0;
+        struct airspy_frame_buf *buf = NULL;
+
+        spin_lock_irqsave(&s->queued_bufs_lock, flags);
+        if (list_empty(&s->queued_bufs))
+                goto leave;
+
+        buf = list_entry(s->queued_bufs.next,
+                        struct airspy_frame_buf, list);
+        list_del(&buf->list);
+leave:
+        spin_unlock_irqrestore(&s->queued_bufs_lock, flags);
+        return buf;
+}
+
+static unsigned int airspy_convert_stream(struct airspy *s,
+                void *dst, void *src, unsigned int src_len)
+{
+        unsigned int dst_len;
+
+        if (s->pixelformat == V4L2_SDR_FMT_RU12LE) {
+                memcpy(dst, src, src_len);
+                dst_len = src_len;
+        } else {
+                dst_len = 0;
+        }
+
+        /* calculate samping rate and output it in 10 seconds intervals */
+        if (unlikely(time_is_before_jiffies(s->jiffies_next))) {
+                #define MSECS 10000UL
+                unsigned int samples = s->sample - s->sample_measured;
+                s->jiffies_next = jiffies + msecs_to_jiffies(MSECS);
+                s->sample_measured = s->sample;
+                dev_dbg(&s->udev->dev,
+                                "slen=%d samples=%u msecs=%lu sample rate=%lu\n",
+                                src_len, samples, MSECS,
+                                samples * 1000UL / MSECS);
+        }
+
+        /* total number of samples */
+        s->sample += src_len / 2;
+
+        return dst_len;
+}
+
+/*
+ * This gets called for the bulk stream pipe. This is done in interrupt
+ * time, so it has to be fast, not crash, and not stall. Neat.
+ */
+static void airspy_urb_complete(struct urb *urb)
+{
+        struct airspy *s = urb->context;
+        struct airspy_frame_buf *fbuf;
+
+        dev_dbg_ratelimited(&s->udev->dev,
+                        "%s: status=%d length=%d/%d errors=%d\n",
+                        __func__, urb->status, urb->actual_length,
+                        urb->transfer_buffer_length, urb->error_count);
+
+        switch (urb->status) {
+        case 0:             /* success */
+        case -ETIMEDOUT:    /* NAK */
+                break;
+        case -ECONNRESET:   /* kill */
+        case -ENOENT:
+        case -ESHUTDOWN:
+                return;
+        default:            /* error */
+                dev_err_ratelimited(&s->udev->dev, "URB failed %d\n",
+                                urb->status);
+                break;
+        }
+
+        if (likely(urb->actual_length > 0)) {
+                void *ptr;
+                unsigned int len;
+                /* get free framebuffer */
+                fbuf = airspy_get_next_fill_buf(s);
+                if (unlikely(fbuf == NULL)) {
+                        s->vb_full++;
+                        dev_notice_ratelimited(&s->udev->dev,
+                                        "videobuf is full, %d packets dropped\n",
+                                        s->vb_full);
+                        goto skip;
+                }
+
+                /* fill framebuffer */
+                ptr = vb2_plane_vaddr(&fbuf->vb, 0);
+                len = airspy_convert_stream(s, ptr, urb->transfer_buffer,
+                                urb->actual_length);
+                vb2_set_plane_payload(&fbuf->vb, 0, len);
+                v4l2_get_timestamp(&fbuf->vb.v4l2_buf.timestamp);
+                fbuf->vb.v4l2_buf.sequence = s->sequence++;
+                vb2_buffer_done(&fbuf->vb, VB2_BUF_STATE_DONE);
+        }
+skip:
+        usb_submit_urb(urb, GFP_ATOMIC);
+}
+
+static int airspy_kill_urbs(struct airspy *s)
+{
+        int i;
+
+        for (i = s->urbs_submitted - 1; i >= 0; i--) {
+                dev_dbg(&s->udev->dev, "%s: kill urb=%d\n", __func__, i);
+                /* stop the URB */
+                usb_kill_urb(s->urb_list[i]);
+        }
+        s->urbs_submitted = 0;
+
+        return 0;
+}
+
+static int airspy_submit_urbs(struct airspy *s)
+{
+        int i, ret;
+
+        for (i = 0; i < s->urbs_initialized; i++) {
+                dev_dbg(&s->udev->dev, "%s: submit urb=%d\n", __func__, i);
+                ret = usb_submit_urb(s->urb_list[i], GFP_ATOMIC);
+                if (ret) {
+                        dev_err(&s->udev->dev,
+                                        "Could not submit URB no. %d - get them all back\n",
+                                        i);
+                        airspy_kill_urbs(s);
+                        return ret;
+                }
+                s->urbs_submitted++;
+        }
+
+        return 0;
+}
+
+static int airspy_free_stream_bufs(struct airspy *s)
+{
+        if (s->flags & USB_STATE_URB_BUF) {
+                while (s->buf_num) {
+                        s->buf_num--;
+                        dev_dbg(&s->udev->dev, "%s: free buf=%d\n",
+                                        __func__, s->buf_num);
+                        usb_free_coherent(s->udev, s->buf_size,
+                                          s->buf_list[s->buf_num],
+                                          s->dma_addr[s->buf_num]);
+                }
+        }
+        s->flags &= ~USB_STATE_URB_BUF;
+
+        return 0;
+}
+
+static int airspy_alloc_stream_bufs(struct airspy *s)
+{
+        s->buf_num = 0;
+        s->buf_size = BULK_BUFFER_SIZE;
+
+        dev_dbg(&s->udev->dev,
+                        "%s: all in all I will use %u bytes for streaming\n",
+                        __func__,  MAX_BULK_BUFS * BULK_BUFFER_SIZE);
+
+        for (s->buf_num = 0; s->buf_num < MAX_BULK_BUFS; s->buf_num++) {
+                s->buf_list[s->buf_num] = usb_alloc_coherent(s->udev,
+                                BULK_BUFFER_SIZE, GFP_ATOMIC,
+                                &s->dma_addr[s->buf_num]);
+                if (!s->buf_list[s->buf_num]) {
+                        dev_dbg(&s->udev->dev, "%s: alloc buf=%d failed\n",
+                                        __func__, s->buf_num);
+                        airspy_free_stream_bufs(s);
+                        return -ENOMEM;
+                }
+
+                dev_dbg(&s->udev->dev, "%s: alloc buf=%d %p (dma %llu)\n",
+                                __func__, s->buf_num,
+                                s->buf_list[s->buf_num],
+                                (long long)s->dma_addr[s->buf_num]);
+                s->flags |= USB_STATE_URB_BUF;
+        }
+
+        return 0;
+}
+
+static int airspy_free_urbs(struct airspy *s)
+{
+        int i;
+
+        airspy_kill_urbs(s);
+
+        for (i = s->urbs_initialized - 1; i >= 0; i--) {
+                if (s->urb_list[i]) {
+                        dev_dbg(&s->udev->dev, "%s: free urb=%d\n",
+                                        __func__, i);
+                        /* free the URBs */
+                        usb_free_urb(s->urb_list[i]);
+                }
+        }
+        s->urbs_initialized = 0;
+
+        return 0;
+}
+
+static int airspy_alloc_urbs(struct airspy *s)
+{
+        int i, j;
+
+        /* allocate the URBs */
+        for (i = 0; i < MAX_BULK_BUFS; i++) {
+                dev_dbg(&s->udev->dev, "%s: alloc urb=%d\n", __func__, i);
+                s->urb_list[i] = usb_alloc_urb(0, GFP_ATOMIC);
+                if (!s->urb_list[i]) {
+                        dev_dbg(&s->udev->dev, "%s: failed\n", __func__);
+                        for (j = 0; j < i; j++)
+                                usb_free_urb(s->urb_list[j]);
+                        return -ENOMEM;
+                }
+                usb_fill_bulk_urb(s->urb_list[i],
+                                s->udev,
+                                usb_rcvbulkpipe(s->udev, 0x81),
+                                s->buf_list[i],
+                                BULK_BUFFER_SIZE,
+                                airspy_urb_complete, s);
+
+                s->urb_list[i]->transfer_flags = URB_NO_TRANSFER_DMA_MAP;
+                s->urb_list[i]->transfer_dma = s->dma_addr[i];
+                s->urbs_initialized++;
+        }
+
+        return 0;
+}
+
+/* Must be called with vb_queue_lock hold */
+static void airspy_cleanup_queued_bufs(struct airspy *s)
+{
+        unsigned long flags = 0;
+
+        dev_dbg(&s->udev->dev, "%s:\n", __func__);
+
+        spin_lock_irqsave(&s->queued_bufs_lock, flags);
+        while (!list_empty(&s->queued_bufs)) {
+                struct airspy_frame_buf *buf;
+                buf = list_entry(s->queued_bufs.next,
+                                struct airspy_frame_buf, list);
+                list_del(&buf->list);
+                vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
+        }
+        spin_unlock_irqrestore(&s->queued_bufs_lock, flags);
+}
+
+/* The user yanked out the cable... */
+static void airspy_disconnect(struct usb_interface *intf)
+{
+        struct v4l2_device *v = usb_get_intfdata(intf);
+        struct airspy *s = container_of(v, struct airspy, v4l2_dev);
+
+        dev_dbg(&s->udev->dev, "%s:\n", __func__);
+
+        mutex_lock(&s->vb_queue_lock);
+        mutex_lock(&s->v4l2_lock);
+        /* No need to keep the urbs around after disconnection */
+        s->udev = NULL;
+        v4l2_device_disconnect(&s->v4l2_dev);
+        video_unregister_device(&s->vdev);
+        mutex_unlock(&s->v4l2_lock);
+        mutex_unlock(&s->vb_queue_lock);
+
+        v4l2_device_put(&s->v4l2_dev);
+}
+
+/* Videobuf2 operations */
+static int airspy_queue_setup(struct vb2_queue *vq,
+                const struct v4l2_format *fmt, unsigned int *nbuffers,
+                unsigned int *nplanes, unsigned int sizes[], void *alloc_ctxs[])
+{
+        struct airspy *s = vb2_get_drv_priv(vq);
+
+        dev_dbg(&s->udev->dev, "%s: *nbuffers=%d\n", __func__, *nbuffers);
+
+        /* Need at least 8 buffers */
+        if (vq->num_buffers + *nbuffers < 8)
+                *nbuffers = 8 - vq->num_buffers;
+        *nplanes = 1;
+        sizes[0] = PAGE_ALIGN(s->buffersize);
+
+        dev_dbg(&s->udev->dev, "%s: nbuffers=%d sizes[0]=%d\n",
+                        __func__, *nbuffers, sizes[0]);
+        return 0;
+}
+
+static void airspy_buf_queue(struct vb2_buffer *vb)
+{
+        struct airspy *s = vb2_get_drv_priv(vb->vb2_queue);
+        struct airspy_frame_buf *buf =
+                        container_of(vb, struct airspy_frame_buf, vb);
+        unsigned long flags = 0;
+
+        /* Check the device has not disconnected between prep and queuing */
+        if (unlikely(!s->udev)) {
+                vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
+                return;
+        }
+
+        spin_lock_irqsave(&s->queued_bufs_lock, flags);
+        list_add_tail(&buf->list, &s->queued_bufs);
+        spin_unlock_irqrestore(&s->queued_bufs_lock, flags);
+}
+
+static int airspy_start_streaming(struct vb2_queue *vq, unsigned int count)
+{
+        struct airspy *s = vb2_get_drv_priv(vq);
+        int ret;
+
+        dev_dbg(&s->udev->dev, "%s:\n", __func__);
+
+        if (!s->udev)
+                return -ENODEV;
+
+        mutex_lock(&s->v4l2_lock);
+
+        set_bit(POWER_ON, &s->flags);
+
+        s->sequence = 0;
+
+        ret = airspy_alloc_stream_bufs(s);
+        if (ret)
+                goto err;
+
+        ret = airspy_alloc_urbs(s);
+        if (ret)
+                goto err;
+
+        ret = airspy_submit_urbs(s);
+        if (ret)
+                goto err;
+
+        /* start hardware streaming */
+        ret = airspy_ctrl_msg(s, CMD_RECEIVER_MODE, 1, 0, NULL, 0);
+        if (ret)
+                goto err;
+err:
+        mutex_unlock(&s->v4l2_lock);
+
+        return ret;
+}
+
+static void airspy_stop_streaming(struct vb2_queue *vq)
+{
+        struct airspy *s = vb2_get_drv_priv(vq);
+
+        dev_dbg(&s->udev->dev, "%s:\n", __func__);
+
+        mutex_lock(&s->v4l2_lock);
+
+        /* stop hardware streaming */
+        airspy_ctrl_msg(s, CMD_RECEIVER_MODE, 0, 0, NULL, 0);
+
+        airspy_kill_urbs(s);
+        airspy_free_urbs(s);
+        airspy_free_stream_bufs(s);
+
+        airspy_cleanup_queued_bufs(s);
+
+        clear_bit(POWER_ON, &s->flags);
+
+        mutex_unlock(&s->v4l2_lock);
+}
+
+static struct vb2_ops airspy_vb2_ops = {
+        .queue_setup            = airspy_queue_setup,
+        .buf_queue              = airspy_buf_queue,
+        .start_streaming        = airspy_start_streaming,
+        .stop_streaming         = airspy_stop_streaming,
+        .wait_prepare           = vb2_ops_wait_prepare,
+        .wait_finish            = vb2_ops_wait_finish,
+};
+
+static int airspy_querycap(struct file *file, void *fh,
+                struct v4l2_capability *cap)
+{
+        struct airspy *s = video_drvdata(file);
+
+        dev_dbg(&s->udev->dev, "%s:\n", __func__);
+
+        strlcpy(cap->driver, KBUILD_MODNAME, sizeof(cap->driver));
+        strlcpy(cap->card, s->vdev.name, sizeof(cap->card));
+        usb_make_path(s->udev, cap->bus_info, sizeof(cap->bus_info));
+        cap->device_caps = V4L2_CAP_SDR_CAPTURE | V4L2_CAP_STREAMING |
+                        V4L2_CAP_READWRITE | V4L2_CAP_TUNER;
+        cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
+
+        return 0;
+}
+
+static int airspy_enum_fmt_sdr_cap(struct file *file, void *priv,
+                struct v4l2_fmtdesc *f)
+{
+        struct airspy *s = video_drvdata(file);
+
+        dev_dbg(&s->udev->dev, "%s: index=%d\n", __func__, f->index);
+
+        if (f->index >= NUM_FORMATS)
+                return -EINVAL;
+
+        strlcpy(f->description, formats[f->index].name, sizeof(f->description));
+        f->pixelformat = formats[f->index].pixelformat;
+
+        return 0;
+}
+
+static int airspy_g_fmt_sdr_cap(struct file *file, void *priv,
+                struct v4l2_format *f)
+{
+        struct airspy *s = video_drvdata(file);
+
+        dev_dbg(&s->udev->dev, "%s: pixelformat fourcc %4.4s\n", __func__,
+                        (char *)&s->pixelformat);
+
+        f->fmt.sdr.pixelformat = s->pixelformat;
+        f->fmt.sdr.buffersize = s->buffersize;
+        memset(f->fmt.sdr.reserved, 0, sizeof(f->fmt.sdr.reserved));
+
+        return 0;
+}
+
+static int airspy_s_fmt_sdr_cap(struct file *file, void *priv,
+                struct v4l2_format *f)
+{
+        struct airspy *s = video_drvdata(file);
+        struct vb2_queue *q = &s->vb_queue;
+        int i;
+
+        dev_dbg(&s->udev->dev, "%s: pixelformat fourcc %4.4s\n", __func__,
+                        (char *)&f->fmt.sdr.pixelformat);
+
+        if (vb2_is_busy(q))
+                return -EBUSY;
+
+        memset(f->fmt.sdr.reserved, 0, sizeof(f->fmt.sdr.reserved));
+        for (i = 0; i < NUM_FORMATS; i++) {
+                if (formats[i].pixelformat == f->fmt.sdr.pixelformat) {
+                        s->pixelformat = formats[i].pixelformat;
+                        s->buffersize = formats[i].buffersize;
+                        f->fmt.sdr.buffersize = formats[i].buffersize;
+                        return 0;
+                }
+        }
+
+        s->pixelformat = formats[0].pixelformat;
+        s->buffersize = formats[0].buffersize;
+        f->fmt.sdr.pixelformat = formats[0].pixelformat;
+        f->fmt.sdr.buffersize = formats[0].buffersize;
+
+        return 0;
+}
+
+static int airspy_try_fmt_sdr_cap(struct file *file, void *priv,
+                struct v4l2_format *f)
+{
+        struct airspy *s = video_drvdata(file);
+        int i;
+
+        dev_dbg(&s->udev->dev, "%s: pixelformat fourcc %4.4s\n", __func__,
+                        (char *)&f->fmt.sdr.pixelformat);
+
+        memset(f->fmt.sdr.reserved, 0, sizeof(f->fmt.sdr.reserved));
+        for (i = 0; i < NUM_FORMATS; i++) {
+                if (formats[i].pixelformat == f->fmt.sdr.pixelformat) {
+                        f->fmt.sdr.buffersize = formats[i].buffersize;
+                        return 0;
+                }
+        }
+
+        f->fmt.sdr.pixelformat = formats[0].pixelformat;
+        f->fmt.sdr.buffersize = formats[0].buffersize;
+
+        return 0;
+}
+
+static int airspy_s_tuner(struct file *file, void *priv,
+                const struct v4l2_tuner *v)
+{
+        struct airspy *s = video_drvdata(file);
+        int ret;
+
+        dev_dbg(&s->udev->dev, "%s: index=%d\n", __func__, v->index);
+
+        if (v->index == 0)
+                ret = 0;
+        else if (v->index == 1)
+                ret = 0;
+        else
+                ret = -EINVAL;
+
+        return ret;
+}
+
+static int airspy_g_tuner(struct file *file, void *priv, struct v4l2_tuner *v)
+{
+        struct airspy *s = video_drvdata(file);
+        int ret;
+
+        dev_dbg(&s->udev->dev, "%s: index=%d\n", __func__, v->index);
+
+        if (v->index == 0) {
+                strlcpy(v->name, "AirSpy ADC", sizeof(v->name));
+                v->type = V4L2_TUNER_ADC;
+                v->capability = V4L2_TUNER_CAP_1HZ | V4L2_TUNER_CAP_FREQ_BANDS;
+                v->rangelow  = bands[0].rangelow;
+                v->rangehigh = bands[0].rangehigh;
+                ret = 0;
+        } else if (v->index == 1) {
+                strlcpy(v->name, "AirSpy RF", sizeof(v->name));
+                v->type = V4L2_TUNER_RF;
+                v->capability = V4L2_TUNER_CAP_1HZ | V4L2_TUNER_CAP_FREQ_BANDS;
+                v->rangelow  = bands_rf[0].rangelow;
+                v->rangehigh = bands_rf[0].rangehigh;
+                ret = 0;
+        } else {
+                ret = -EINVAL;
+        }
+
+        return ret;
+}
+
+static int airspy_g_frequency(struct file *file, void *priv,
+                struct v4l2_frequency *f)
+{
+        struct airspy *s = video_drvdata(file);
+        int ret  = 0;
+        dev_dbg(&s->udev->dev, "%s: tuner=%d type=%d\n",
+                        __func__, f->tuner, f->type);
+
+        if (f->tuner == 0) {
+                f->type = V4L2_TUNER_ADC;
+                f->frequency = s->f_adc;
+                ret = 0;
+        } else if (f->tuner == 1) {
+                f->type = V4L2_TUNER_RF;
+                f->frequency = s->f_rf;
+        } else {
+                ret = -EINVAL;
+        }
+
+        return ret;
+}
+
+static int airspy_s_frequency(struct file *file, void *priv,
+                const struct v4l2_frequency *f)
+{
+        struct airspy *s = video_drvdata(file);
+        int ret;
+        u8 buf[4];
+
+        dev_dbg(&s->udev->dev, "%s: tuner=%d type=%d frequency=%u\n",
+                        __func__, f->tuner, f->type, f->frequency);
+
+        if (f->tuner == 0) {
+                s->f_adc = clamp_t(unsigned int, f->frequency,
+                                bands[0].rangelow,
+                                bands[0].rangehigh);
+                dev_dbg(&s->udev->dev, "%s: ADC frequency=%u Hz\n",
+                                __func__, s->f_adc);
+                ret = 0;
+        } else if (f->tuner == 1) {
+                s->f_rf = clamp_t(unsigned int, f->frequency,
+                                bands_rf[0].rangelow,
+                                bands_rf[0].rangehigh);
+                dev_dbg(&s->udev->dev, "%s: RF frequency=%u Hz\n",
+                                __func__, s->f_rf);
+                buf[0] = (s->f_rf >>  0) & 0xff;
+                buf[1] = (s->f_rf >>  8) & 0xff;
+                buf[2] = (s->f_rf >> 16) & 0xff;
+                buf[3] = (s->f_rf >> 24) & 0xff;
+                ret = airspy_ctrl_msg(s, CMD_SET_FREQ, 0, 0, buf, 4);
+        } else {
+                ret = -EINVAL;
+        }
+
+        return ret;
+}
+
+static int airspy_enum_freq_bands(struct file *file, void *priv,
+                struct v4l2_frequency_band *band)
+{
+        struct airspy *s = video_drvdata(file);
+        int ret;
+        dev_dbg(&s->udev->dev, "%s: tuner=%d type=%d index=%d\n",
+                        __func__, band->tuner, band->type, band->index);
+
+        if (band->tuner == 0) {
+                if (band->index >= ARRAY_SIZE(bands)) {
+                        ret = -EINVAL;
+                } else {
+                        *band = bands[band->index];
+                        ret = 0;
+                }
+        } else if (band->tuner == 1) {
+                if (band->index >= ARRAY_SIZE(bands_rf)) {
+                        ret = -EINVAL;
+                } else {
+                        *band = bands_rf[band->index];
+                        ret = 0;
+                }
+        } else {
+                ret = -EINVAL;
+        }
+
+        return ret;
+}
+
+static const struct v4l2_ioctl_ops airspy_ioctl_ops = {
+        .vidioc_querycap          = airspy_querycap,
+
+        .vidioc_enum_fmt_sdr_cap  = airspy_enum_fmt_sdr_cap,
+        .vidioc_g_fmt_sdr_cap     = airspy_g_fmt_sdr_cap,
+        .vidioc_s_fmt_sdr_cap     = airspy_s_fmt_sdr_cap,
+        .vidioc_try_fmt_sdr_cap   = airspy_try_fmt_sdr_cap,
+
+        .vidioc_reqbufs           = vb2_ioctl_reqbufs,
+        .vidioc_create_bufs       = vb2_ioctl_create_bufs,
+        .vidioc_prepare_buf       = vb2_ioctl_prepare_buf,
+        .vidioc_querybuf          = vb2_ioctl_querybuf,
+        .vidioc_qbuf              = vb2_ioctl_qbuf,
+        .vidioc_dqbuf             = vb2_ioctl_dqbuf,
+
+        .vidioc_streamon          = vb2_ioctl_streamon,
+        .vidioc_streamoff         = vb2_ioctl_streamoff,
+
+        .vidioc_g_tuner           = airspy_g_tuner,
+        .vidioc_s_tuner           = airspy_s_tuner,
+
+        .vidioc_g_frequency       = airspy_g_frequency,
+        .vidioc_s_frequency       = airspy_s_frequency,
+        .vidioc_enum_freq_bands   = airspy_enum_freq_bands,
+
+        .vidioc_subscribe_event   = v4l2_ctrl_subscribe_event,
+        .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
+        .vidioc_log_status        = v4l2_ctrl_log_status,
+};
+
+static const struct v4l2_file_operations airspy_fops = {
+        .owner                    = THIS_MODULE,
+        .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 struct video_device airspy_template = {
+        .name                     = "AirSpy SDR",
+        .release                  = video_device_release_empty,
+        .fops                     = &airspy_fops,
+        .ioctl_ops                = &airspy_ioctl_ops,
+};
+
+static void airspy_video_release(struct v4l2_device *v)
+{
+        struct airspy *s = container_of(v, struct airspy, v4l2_dev);
+
+        v4l2_ctrl_handler_free(&s->hdl);
+        v4l2_device_unregister(&s->v4l2_dev);
+        kfree(s);
+}
+
+static int airspy_set_lna_gain(struct airspy *s)
+{
+        int ret;
+        u8 u8tmp;
+
+        dev_dbg(&s->udev->dev, "%s: lna auto=%d->%d val=%d->%d\n",
+                        __func__, s->lna_gain_auto->cur.val,
+                        s->lna_gain_auto->val, s->lna_gain->cur.val,
+                        s->lna_gain->val);
+
+        ret = airspy_ctrl_msg(s, CMD_SET_LNA_AGC, 0, s->lna_gain_auto->val,
+                        &u8tmp, 1);
+        if (ret)
+                goto err;
+
+        if (s->lna_gain_auto->val == false) {
+                ret = airspy_ctrl_msg(s, CMD_SET_LNA_GAIN, 0, s->lna_gain->val,
+                                &u8tmp, 1);
+                if (ret)
+                        goto err;
+        }
+err:
+        if (ret)
+                dev_dbg(&s->udev->dev, "%s: failed=%d\n", __func__, ret);
+
+        return ret;
+}
+
+static int airspy_set_mixer_gain(struct airspy *s)
+{
+        int ret;
+        u8 u8tmp;
+
+        dev_dbg(&s->udev->dev, "%s: mixer auto=%d->%d val=%d->%d\n",
+                        __func__, s->mixer_gain_auto->cur.val,
+                        s->mixer_gain_auto->val, s->mixer_gain->cur.val,
+                        s->mixer_gain->val);
+
+        ret = airspy_ctrl_msg(s, CMD_SET_MIXER_AGC, 0, s->mixer_gain_auto->val,
+                        &u8tmp, 1);
+        if (ret)
+                goto err;
+
+        if (s->mixer_gain_auto->val == false) {
+                ret = airspy_ctrl_msg(s, CMD_SET_MIXER_GAIN, 0,
+                                s->mixer_gain->val, &u8tmp, 1);
+                if (ret)
+                        goto err;
+        }
+err:
+        if (ret)
+                dev_dbg(&s->udev->dev, "%s: failed=%d\n", __func__, ret);
+
+        return ret;
+}
+
+static int airspy_set_if_gain(struct airspy *s)
+{
+        int ret;
+        u8 u8tmp;
+
+        dev_dbg(&s->udev->dev, "%s: val=%d->%d\n",
+                        __func__, s->if_gain->cur.val, s->if_gain->val);
+
+        ret = airspy_ctrl_msg(s, CMD_SET_VGA_GAIN, 0, s->if_gain->val,
+                        &u8tmp, 1);
+        if (ret)
+                goto err;
+err:
+        if (ret)
+                dev_dbg(&s->udev->dev, "%s: failed=%d\n", __func__, ret);
+
+        return ret;
+}
+
+static int airspy_s_ctrl(struct v4l2_ctrl *ctrl)
+{
+        struct airspy *s = container_of(ctrl->handler, struct airspy, hdl);
+        int ret;
+
+        switch (ctrl->id) {
+        case  V4L2_CID_RF_TUNER_LNA_GAIN_AUTO:
+        case  V4L2_CID_RF_TUNER_LNA_GAIN:
+                ret = airspy_set_lna_gain(s);
+                break;
+        case  V4L2_CID_RF_TUNER_MIXER_GAIN_AUTO:
+        case  V4L2_CID_RF_TUNER_MIXER_GAIN:
+                ret = airspy_set_mixer_gain(s);
+                break;
+        case  V4L2_CID_RF_TUNER_IF_GAIN:
+                ret = airspy_set_if_gain(s);
+                break;
+        default:
+                dev_dbg(&s->udev->dev, "%s: unknown ctrl: id=%d name=%s\n",
+                                __func__, ctrl->id, ctrl->name);
+                ret = -EINVAL;
+        }
+
+        return ret;
+}
+
+static const struct v4l2_ctrl_ops airspy_ctrl_ops = {
+        .s_ctrl = airspy_s_ctrl,
+};
+
+static int airspy_probe(struct usb_interface *intf,
+                const struct usb_device_id *id)
+{
+        struct usb_device *udev = interface_to_usbdev(intf);
+        struct airspy *s = NULL;
+        int ret;
+        u8 u8tmp, buf[BUF_SIZE];
+
+        s = kzalloc(sizeof(struct airspy), GFP_KERNEL);
+        if (s == NULL) {
+                dev_err(&udev->dev,
+                                "Could not allocate memory for airspy state\n");
+                return -ENOMEM;
+        }
+
+        mutex_init(&s->v4l2_lock);
+        mutex_init(&s->vb_queue_lock);
+        spin_lock_init(&s->queued_bufs_lock);
+        INIT_LIST_HEAD(&s->queued_bufs);
+        s->udev = udev;
+        s->f_adc = bands[0].rangelow;
+        s->f_rf = bands_rf[0].rangelow;
+        s->pixelformat = formats[0].pixelformat;
+        s->buffersize = formats[0].buffersize;
+
+        /* Detect device */
+        ret = airspy_ctrl_msg(s, CMD_BOARD_ID_READ, 0, 0, &u8tmp, 1);
+        if (ret == 0)
+                ret = airspy_ctrl_msg(s, CMD_VERSION_STRING_READ, 0, 0,
+                                buf, BUF_SIZE);
+        if (ret) {
+                dev_err(&s->udev->dev, "Could not detect board\n");
+                goto err_free_mem;
+        }
+
+        buf[BUF_SIZE - 1] = '\0';
+
+        dev_info(&s->udev->dev, "Board ID: %02x\n", u8tmp);
+        dev_info(&s->udev->dev, "Firmware version: %s\n", buf);
+
+        /* Init videobuf2 queue structure */
+        s->vb_queue.type = V4L2_BUF_TYPE_SDR_CAPTURE;
+        s->vb_queue.io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ;
+        s->vb_queue.drv_priv = s;
+        s->vb_queue.buf_struct_size = sizeof(struct airspy_frame_buf);
+        s->vb_queue.ops = &airspy_vb2_ops;
+        s->vb_queue.mem_ops = &vb2_vmalloc_memops;
+        s->vb_queue.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
+        ret = vb2_queue_init(&s->vb_queue);
+        if (ret) {
+                dev_err(&s->udev->dev, "Could not initialize vb2 queue\n");
+                goto err_free_mem;
+        }
+
+        /* Init video_device structure */
+        s->vdev = airspy_template;
+        s->vdev.queue = &s->vb_queue;
+        s->vdev.queue->lock = &s->vb_queue_lock;
+        video_set_drvdata(&s->vdev, s);
+
+        /* Register the v4l2_device structure */
+        s->v4l2_dev.release = airspy_video_release;
+        ret = v4l2_device_register(&intf->dev, &s->v4l2_dev);
+        if (ret) {
+                dev_err(&s->udev->dev,
+                                "Failed to register v4l2-device (%d)\n", ret);
+                goto err_free_mem;
+        }
+
+        /* Register controls */
+        v4l2_ctrl_handler_init(&s->hdl, 5);
+        s->lna_gain_auto = v4l2_ctrl_new_std(&s->hdl, &airspy_ctrl_ops,
+                        V4L2_CID_RF_TUNER_LNA_GAIN_AUTO, 0, 1, 1, 0);
+        s->lna_gain = v4l2_ctrl_new_std(&s->hdl, &airspy_ctrl_ops,
+                        V4L2_CID_RF_TUNER_LNA_GAIN, 0, 14, 1, 8);
+        v4l2_ctrl_auto_cluster(2, &s->lna_gain_auto, 0, false);
+        s->mixer_gain_auto = v4l2_ctrl_new_std(&s->hdl, &airspy_ctrl_ops,
+                        V4L2_CID_RF_TUNER_MIXER_GAIN_AUTO, 0, 1, 1, 0);
+        s->mixer_gain = v4l2_ctrl_new_std(&s->hdl, &airspy_ctrl_ops,
+                        V4L2_CID_RF_TUNER_MIXER_GAIN, 0, 15, 1, 8);
+        v4l2_ctrl_auto_cluster(2, &s->mixer_gain_auto, 0, false);
+        s->if_gain = v4l2_ctrl_new_std(&s->hdl, &airspy_ctrl_ops,
+                        V4L2_CID_RF_TUNER_IF_GAIN, 0, 15, 1, 0);
+        if (s->hdl.error) {
+                ret = s->hdl.error;
+                dev_err(&s->udev->dev, "Could not initialize controls\n");
+                goto err_free_controls;
+        }
+
+        v4l2_ctrl_handler_setup(&s->hdl);
+
+        s->v4l2_dev.ctrl_handler = &s->hdl;
+        s->vdev.v4l2_dev = &s->v4l2_dev;
+        s->vdev.lock = &s->v4l2_lock;
+
+        ret = video_register_device(&s->vdev, VFL_TYPE_SDR, -1);
+        if (ret) {
+                dev_err(&s->udev->dev,
+                                "Failed to register as video device (%d)\n",
+                                ret);
+                goto err_unregister_v4l2_dev;
+        }
+        dev_info(&s->udev->dev, "Registered as %s\n",
+                        video_device_node_name(&s->vdev));
+        dev_notice(&s->udev->dev,
+                        "%s: SDR API is still slightly experimental and functionality changes may follow\n",
+                        KBUILD_MODNAME);
+        return 0;
+
+err_free_controls:
+        v4l2_ctrl_handler_free(&s->hdl);
+err_unregister_v4l2_dev:
+        v4l2_device_unregister(&s->v4l2_dev);
+err_free_mem:
+        kfree(s);
+        return ret;
+}
+
+/* USB device ID list */
+static struct usb_device_id airspy_id_table[] = {
+        { USB_DEVICE(0x1d50, 0x60a1) }, /* AirSpy */
+        { }
+};
+MODULE_DEVICE_TABLE(usb, airspy_id_table);
+
+/* USB subsystem interface */
+static struct usb_driver airspy_driver = {
+        .name                     = KBUILD_MODNAME,
+        .probe                    = airspy_probe,
+        .disconnect               = airspy_disconnect,
+        .id_table                 = airspy_id_table,
+};
+
+module_usb_driver(airspy_driver);
+
+MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
+MODULE_DESCRIPTION("AirSpy SDR");
+MODULE_LICENSE("GPL");
diff --git a/drivers/media/usb/au0828/Kconfig b/drivers/media/usb/au0828/Kconfig
index 953a37c613b1..1d410ac8f9a8 100644
--- a/drivers/media/usb/au0828/Kconfig
+++ b/drivers/media/usb/au0828/Kconfig
@@ -20,9 +20,17 @@ config VIDEO_AU0828_V4L2
         bool "Auvitek AU0828 v4l2 analog video support"
         depends on VIDEO_AU0828 && VIDEO_V4L2
         select DVB_AU8522_V4L if MEDIA_SUBDRV_AUTOSELECT
+        select VIDEO_TUNER
         default y
         ---help---
           This is a video4linux driver for Auvitek's USB device.
 
           Choose Y here to include support for v4l2 analog video
           capture within the au0828 driver.
+
+config VIDEO_AU0828_RC
+        bool "AU0828 Remote Controller support"
+        depends on RC_CORE
+        depends on VIDEO_AU0828
+        ---help---
+           Enables Remote Controller support on au0828 driver.
diff --git a/drivers/media/usb/au0828/Makefile b/drivers/media/usb/au0828/Makefile
index be3bdf698022..3dc7539a5c4e 100644
--- a/drivers/media/usb/au0828/Makefile
+++ b/drivers/media/usb/au0828/Makefile
@@ -4,6 +4,10 @@ ifeq ($(CONFIG_VIDEO_AU0828_V4L2),y)
   au0828-objs   += au0828-video.o au0828-vbi.o
 endif
 
+ifeq ($(CONFIG_VIDEO_AU0828_RC),y)
+  au0828-objs   += au0828-input.o
+endif
+
 obj-$(CONFIG_VIDEO_AU0828) += au0828.o
 
 ccflags-y += -Idrivers/media/tuners
diff --git a/drivers/media/usb/au0828/au0828-cards.c b/drivers/media/usb/au0828/au0828-cards.c
index 7fdadf9bc90b..2c6b7da137ed 100644
--- a/drivers/media/usb/au0828/au0828-cards.c
+++ b/drivers/media/usb/au0828/au0828-cards.c
@@ -46,7 +46,7 @@ struct au0828_board au0828_boards[] = {
                 .name   = "Hauppauge HVR850",
                 .tuner_type = TUNER_XC5000,
                 .tuner_addr = 0x61,
-                .i2c_clk_divider = AU0828_I2C_CLK_20KHZ,
+                .i2c_clk_divider = AU0828_I2C_CLK_250KHZ,
                 .input = {
                         {
                                 .type = AU0828_VMUX_TELEVISION,
@@ -71,13 +71,14 @@ struct au0828_board au0828_boards[] = {
                 .name   = "Hauppauge HVR950Q",
                 .tuner_type = TUNER_XC5000,
                 .tuner_addr = 0x61,
+                .has_ir_i2c = 1,
                 /* The au0828 hardware i2c implementation does not properly
                    support the xc5000's i2c clock stretching.  So we need to
                    lower the clock frequency enough where the 15us clock
                    stretch fits inside of a normal clock cycle, or else the
                    au0828 fails to set the STOP bit.  A 30 KHz clock puts the
                    clock pulse width at 18us */
-                .i2c_clk_divider = AU0828_I2C_CLK_20KHZ,
+                .i2c_clk_divider = AU0828_I2C_CLK_250KHZ,
                 .input = {
                         {
                                 .type = AU0828_VMUX_TELEVISION,
@@ -108,7 +109,7 @@ struct au0828_board au0828_boards[] = {
                 .name   = "DViCO FusionHDTV USB",
                 .tuner_type = UNSET,
                 .tuner_addr = ADDR_UNSET,
-                .i2c_clk_divider = AU0828_I2C_CLK_20KHZ,
+                .i2c_clk_divider = AU0828_I2C_CLK_250KHZ,
         },
         [AU0828_BOARD_HAUPPAUGE_WOODBURY] = {
                 .name = "Hauppauge Woodbury",
diff --git a/drivers/media/usb/au0828/au0828-core.c b/drivers/media/usb/au0828/au0828-core.c
index ab45a6f9dcc9..56025e689442 100644
--- a/drivers/media/usb/au0828/au0828-core.c
+++ b/drivers/media/usb/au0828/au0828-core.c
@@ -32,10 +32,12 @@
  * 2 = USB handling
  * 4 = I2C related
  * 8 = Bridge related
+ * 16 = IR related
  */
 int au0828_debug;
 module_param_named(debug, au0828_debug, int, 0644);
-MODULE_PARM_DESC(debug, "enable debug messages");
+MODULE_PARM_DESC(debug,
+                 "set debug bitmask: 1=general, 2=USB, 4=I2C, 8=bridge, 16=IR");
 
 static unsigned int disable_usb_speed_check;
 module_param(disable_usb_speed_check, int, 0444);
@@ -151,6 +153,9 @@ static void au0828_usb_disconnect(struct usb_interface *interface)
 
         dprintk(1, "%s()\n", __func__);
 
+#ifdef CONFIG_VIDEO_AU0828_RC
+        au0828_rc_unregister(dev);
+#endif
         /* Digital TV */
         au0828_dvb_unregister(dev);
 
@@ -261,9 +266,15 @@ static int au0828_usb_probe(struct usb_interface *interface,
                 pr_err("%s() au0282_dev_register failed\n",
                        __func__);
 
+#ifdef CONFIG_VIDEO_AU0828_RC
+        /* Remote controller */
+        au0828_rc_register(dev);
+#endif
 
-        /* Store the pointer to the au0828_dev so it can be accessed in
-           au0828_usb_disconnect */
+        /*
+         * Store the pointer to the au0828_dev so it can be accessed in
+         * au0828_usb_disconnect
+         */
         usb_set_intfdata(interface, dev);
 
         printk(KERN_INFO "Registered device AU0828 [%s]\n",
@@ -279,6 +290,8 @@ static struct usb_driver au0828_usb_driver = {
         .probe          = au0828_usb_probe,
         .disconnect     = au0828_usb_disconnect,
         .id_table       = au0828_usb_id_table,
+
+        /* FIXME: Add suspend and resume functions */
 };
 
 static int __init au0828_init(void)
@@ -298,6 +311,10 @@ static int __init au0828_init(void)
                 printk(KERN_INFO "%s() Bridge Debugging is enabled\n",
                        __func__);
 
+        if (au0828_debug & 16)
+                printk(KERN_INFO "%s() IR Debugging is enabled\n",
+                       __func__);
+
         printk(KERN_INFO "au0828 driver loaded\n");
 
         ret = usb_register(&au0828_usb_driver);
@@ -318,4 +335,4 @@ module_exit(au0828_exit);
 MODULE_DESCRIPTION("Driver for Auvitek AU0828 based products");
 MODULE_AUTHOR("Steven Toth <stoth@linuxtv.org>");
 MODULE_LICENSE("GPL");
-MODULE_VERSION("0.0.2");
+MODULE_VERSION("0.0.3");
diff --git a/drivers/media/usb/au0828/au0828-i2c.c b/drivers/media/usb/au0828/au0828-i2c.c
index 17ec3651b10e..daaeaf1b089c 100644
--- a/drivers/media/usb/au0828/au0828-i2c.c
+++ b/drivers/media/usb/au0828/au0828-i2c.c
@@ -141,25 +141,27 @@ static int i2c_sendbytes(struct i2c_adapter *i2c_adap,
 {
         int i, strobe = 0;
         struct au0828_dev *dev = i2c_adap->algo_data;
+        u8 i2c_speed = dev->board.i2c_clk_divider;
 
         dprintk(4, "%s()\n", __func__);
 
         au0828_write(dev, AU0828_I2C_MULTIBYTE_MODE_2FF, 0x01);
 
-        /* Set the I2C clock */
         if (((dev->board.tuner_type == TUNER_XC5000) ||
              (dev->board.tuner_type == TUNER_XC5000C)) &&
-            (dev->board.tuner_addr == msg->addr) &&
-            (msg->len == 64)) {
-                /* Hack to speed up firmware load.  The xc5000 lets us do up
-                   to 400 KHz when in firmware download mode */
-                au0828_write(dev, AU0828_I2C_CLK_DIVIDER_202,
-                             AU0828_I2C_CLK_250KHZ);
-        } else {
-                /* Use the i2c clock speed in the board configuration */
-                au0828_write(dev, AU0828_I2C_CLK_DIVIDER_202,
-                             dev->board.i2c_clk_divider);
+            (dev->board.tuner_addr == msg->addr)) {
+                /*
+                 * Due to I2C clock stretch, we need to use a lower speed
+                 * on xc5000 for commands. However, firmware transfer can
+                 * speed up to 400 KHz.
+                 */
+                if (msg->len == 64)
+                        i2c_speed = AU0828_I2C_CLK_250KHZ;
+                else
+                        i2c_speed = AU0828_I2C_CLK_20KHZ;
         }
+        /* Set the I2C clock */
+        au0828_write(dev, AU0828_I2C_CLK_DIVIDER_202, i2c_speed);
 
         /* Hardware needs 8 bit addresses */
         au0828_write(dev, AU0828_I2C_DEST_ADDR_203, msg->addr << 1);
@@ -228,15 +230,24 @@ static int i2c_readbytes(struct i2c_adapter *i2c_adap,
         const struct i2c_msg *msg, int joined)
 {
         struct au0828_dev *dev = i2c_adap->algo_data;
+        u8 i2c_speed = dev->board.i2c_clk_divider;
         int i;
 
         dprintk(4, "%s()\n", __func__);
 
         au0828_write(dev, AU0828_I2C_MULTIBYTE_MODE_2FF, 0x01);
 
+        /*
+         * Due to xc5000c clock stretch, we cannot use full speed at
+         * readings from xc5000, as otherwise they'll fail.
+         */
+        if (((dev->board.tuner_type == TUNER_XC5000) ||
+             (dev->board.tuner_type == TUNER_XC5000C)) &&
+            (dev->board.tuner_addr == msg->addr))
+                i2c_speed = AU0828_I2C_CLK_20KHZ;
+
         /* Set the I2C clock */
-        au0828_write(dev, AU0828_I2C_CLK_DIVIDER_202,
-                     dev->board.i2c_clk_divider);
+        au0828_write(dev, AU0828_I2C_CLK_DIVIDER_202, i2c_speed);
 
         /* Hardware needs 8 bit addresses */
         au0828_write(dev, AU0828_I2C_DEST_ADDR_203, msg->addr << 1);
diff --git a/drivers/media/usb/au0828/au0828-input.c b/drivers/media/usb/au0828/au0828-input.c
new file mode 100644
index 000000000000..fd0d3a90ce7d
--- /dev/null
+++ b/drivers/media/usb/au0828/au0828-input.c
@@ -0,0 +1,386 @@
+/*
+  handle au0828 IR remotes via linux kernel input layer.
+
+   Copyright (C) 2014 Mauro Carvalho Chehab <mchehab@samsung.com>
+   Copyright (c) 2014 Samsung Electronics Co., Ltd.
+
+  Based on em28xx-input.c.
+
+  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.
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <linux/interrupt.h>
+#include <linux/usb.h>
+#include <linux/slab.h>
+#include <media/rc-core.h>
+
+#include "au0828.h"
+
+struct au0828_rc {
+        struct au0828_dev *dev;
+        struct rc_dev *rc;
+        char name[32];
+        char phys[32];
+
+        /* poll decoder */
+        int polling;
+        struct delayed_work work;
+
+        /* i2c slave address of external device (if used) */
+        u16 i2c_dev_addr;
+
+        int  (*get_key_i2c)(struct au0828_rc *ir);
+};
+
+/*
+ * AU8522 has a builtin IR receiver. Add functions to get IR from it
+ */
+
+static int au8522_rc_write(struct au0828_rc *ir, u16 reg, u8 data)
+{
+        int rc;
+        char buf[] = { (reg >> 8) | 0x80, reg & 0xff, data };
+        struct i2c_msg msg = { .addr = ir->i2c_dev_addr, .flags = 0,
+                               .buf = buf, .len = sizeof(buf) };
+
+        rc = i2c_transfer(ir->dev->i2c_client.adapter, &msg, 1);
+
+        if (rc < 0)
+                return rc;
+
+        return (rc == 1) ? 0 : -EIO;
+}
+
+static int au8522_rc_read(struct au0828_rc *ir, u16 reg, int val,
+                                 char *buf, int size)
+{
+        int rc;
+        char obuf[3];
+        struct i2c_msg msg[2] = { { .addr = ir->i2c_dev_addr, .flags = 0,
+                                    .buf = obuf, .len = 2 },
+                                  { .addr = ir->i2c_dev_addr, .flags = I2C_M_RD,
+                                    .buf = buf, .len = size } };
+
+        obuf[0] = 0x40 | reg >> 8;
+        obuf[1] = reg & 0xff;
+        if (val >= 0) {
+                obuf[2] = val;
+                msg[0].len++;
+        }
+
+        rc = i2c_transfer(ir->dev->i2c_client.adapter, msg, 2);
+
+        if (rc < 0)
+                return rc;
+
+        return (rc == 2) ? 0 : -EIO;
+}
+
+static int au8522_rc_andor(struct au0828_rc *ir, u16 reg, u8 mask, u8 value)
+{
+        int rc;
+        char buf;
+
+        rc = au8522_rc_read(ir, reg, -1, &buf, 1);
+        if (rc < 0)
+                return rc;
+
+        buf = (buf & ~mask) | (value & mask);
+
+        return au8522_rc_write(ir, reg, buf);
+}
+
+#define au8522_rc_set(ir, reg, bit) au8522_rc_andor(ir, (reg), (bit), (bit))
+#define au8522_rc_clear(ir, reg, bit) au8522_rc_andor(ir, (reg), (bit), 0)
+
+/* Remote Controller time units */
+
+#define AU8522_UNIT             200000 /* ns */
+#define NEC_START_SPACE         (4500000 / AU8522_UNIT)
+#define NEC_START_PULSE         (562500 * 16)
+#define RC5_START_SPACE         (4 * AU8522_UNIT)
+#define RC5_START_PULSE         888888
+
+static int au0828_get_key_au8522(struct au0828_rc *ir)
+{
+        unsigned char buf[40];
+        DEFINE_IR_RAW_EVENT(rawir);
+        int i, j, rc;
+        int prv_bit, bit, width;
+        bool first = true;
+
+        /* Check IR int */
+        rc = au8522_rc_read(ir, 0xe1, -1, buf, 1);
+        if (rc < 0 || !(buf[0] & (1 << 4)))
+                return 0;
+
+        /* Something arrived. Get the data */
+        rc = au8522_rc_read(ir, 0xe3, 0x11, buf, sizeof(buf));
+
+
+        if (rc < 0)
+                return rc;
+
+        /* Disable IR */
+        au8522_rc_clear(ir, 0xe0, 1 << 4);
+
+        usleep_range(45000, 46000);
+
+        /* Enable IR */
+        au8522_rc_set(ir, 0xe0, 1 << 4);
+
+        dprintk(16, "RC data received: %*ph\n", 40, buf);
+
+        prv_bit = (buf[0] >> 7) & 0x01;
+        width = 0;
+        for (i = 0; i < sizeof(buf); i++) {
+                for (j = 7; j >= 0; j--) {
+                        bit = (buf[i] >> j) & 0x01;
+                        if (bit == prv_bit) {
+                                width++;
+                                continue;
+                        }
+
+                        /*
+                         * Fix an au8522 bug: the first pulse event
+                         * is lost. So, we need to fake it, based on the
+                         * protocol. That means that not all raw decoders
+                         * will work, as we need to add a hack for each
+                         * protocol, based on the first space.
+                         * So, we only support RC5 and NEC.
+                         */
+
+                        if (first) {
+                                first = false;
+
+                                init_ir_raw_event(&rawir);
+                                rawir.pulse = true;
+                                if (width > NEC_START_SPACE - 2 &&
+                                    width < NEC_START_SPACE + 2) {
+                                        /* NEC protocol */
+                                        rawir.duration = NEC_START_PULSE;
+                                        dprintk(16, "Storing NEC start %s with duration %d",
+                                                rawir.pulse ? "pulse" : "space",
+                                                rawir.duration);
+                                } else {
+                                        /* RC5 protocol */
+                                        rawir.duration = RC5_START_PULSE;
+                                        dprintk(16, "Storing RC5 start %s with duration %d",
+                                                rawir.pulse ? "pulse" : "space",
+                                                rawir.duration);
+                                }
+                                ir_raw_event_store(ir->rc, &rawir);
+                        }
+
+                        init_ir_raw_event(&rawir);
+                        rawir.pulse = prv_bit ? false : true;
+                        rawir.duration = AU8522_UNIT * width;
+                        dprintk(16, "Storing %s with duration %d",
+                                rawir.pulse ? "pulse" : "space",
+                                rawir.duration);
+                        ir_raw_event_store(ir->rc, &rawir);
+
+                        width = 1;
+                        prv_bit = bit;
+                }
+        }
+
+        init_ir_raw_event(&rawir);
+        rawir.pulse = prv_bit ? false : true;
+        rawir.duration = AU8522_UNIT * width;
+        dprintk(16, "Storing end %s with duration %d",
+                rawir.pulse ? "pulse" : "space",
+                rawir.duration);
+        ir_raw_event_store(ir->rc, &rawir);
+
+        ir_raw_event_handle(ir->rc);
+
+        return 1;
+}
+
+/*
+ * Generic IR code
+ */
+
+static void au0828_rc_work(struct work_struct *work)
+{
+        struct au0828_rc *ir = container_of(work, struct au0828_rc, work.work);
+        int rc;
+
+        rc = ir->get_key_i2c(ir);
+        if (rc < 0)
+                pr_info("Error while getting RC scancode\n");
+
+        schedule_delayed_work(&ir->work, msecs_to_jiffies(ir->polling));
+}
+
+static int au0828_rc_start(struct rc_dev *rc)
+{
+        struct au0828_rc *ir = rc->priv;
+
+        INIT_DELAYED_WORK(&ir->work, au0828_rc_work);
+
+        /* Enable IR */
+        au8522_rc_set(ir, 0xe0, 1 << 4);
+
+        schedule_delayed_work(&ir->work, msecs_to_jiffies(ir->polling));
+
+        return 0;
+}
+
+static void au0828_rc_stop(struct rc_dev *rc)
+{
+        struct au0828_rc *ir = rc->priv;
+
+        /* Disable IR */
+        au8522_rc_clear(ir, 0xe0, 1 << 4);
+
+        cancel_delayed_work_sync(&ir->work);
+}
+
+static int au0828_probe_i2c_ir(struct au0828_dev *dev)
+{
+        int i = 0;
+        const unsigned short addr_list[] = {
+                 0x47, I2C_CLIENT_END
+        };
+
+        while (addr_list[i] != I2C_CLIENT_END) {
+                if (i2c_probe_func_quick_read(dev->i2c_client.adapter,
+                                              addr_list[i]) == 1)
+                        return addr_list[i];
+                i++;
+        }
+
+        return -ENODEV;
+}
+
+int au0828_rc_register(struct au0828_dev *dev)
+{
+        struct au0828_rc *ir;
+        struct rc_dev *rc;
+        int err = -ENOMEM;
+        u16 i2c_rc_dev_addr = 0;
+
+        if (!dev->board.has_ir_i2c)
+                return 0;
+
+        i2c_rc_dev_addr = au0828_probe_i2c_ir(dev);
+        if (!i2c_rc_dev_addr)
+                return -ENODEV;
+
+        ir = kzalloc(sizeof(*ir), GFP_KERNEL);
+        rc = rc_allocate_device();
+        if (!ir || !rc)
+                goto error;
+
+        /* record handles to ourself */
+        ir->dev = dev;
+        dev->ir = ir;
+        ir->rc = rc;
+
+        rc->priv = ir;
+        rc->open = au0828_rc_start;
+        rc->close = au0828_rc_stop;
+
+        if (dev->board.has_ir_i2c) {    /* external i2c device */
+                switch (dev->boardnr) {
+                case AU0828_BOARD_HAUPPAUGE_HVR950Q:
+                        rc->map_name = RC_MAP_HAUPPAUGE;
+                        ir->get_key_i2c = au0828_get_key_au8522;
+                        break;
+                default:
+                        err = -ENODEV;
+                        goto error;
+                }
+
+                ir->i2c_dev_addr = i2c_rc_dev_addr;
+        }
+
+        /* This is how often we ask the chip for IR information */
+        ir->polling = 100; /* ms */
+
+        /* init input device */
+        snprintf(ir->name, sizeof(ir->name), "au0828 IR (%s)",
+                 dev->board.name);
+
+        usb_make_path(dev->usbdev, ir->phys, sizeof(ir->phys));
+        strlcat(ir->phys, "/input0", sizeof(ir->phys));
+
+        rc->input_name = ir->name;
+        rc->input_phys = ir->phys;
+        rc->input_id.bustype = BUS_USB;
+        rc->input_id.version = 1;
+        rc->input_id.vendor = le16_to_cpu(dev->usbdev->descriptor.idVendor);
+        rc->input_id.product = le16_to_cpu(dev->usbdev->descriptor.idProduct);
+        rc->dev.parent = &dev->usbdev->dev;
+        rc->driver_name = "au0828-input";
+        rc->driver_type = RC_DRIVER_IR_RAW;
+        rc->allowed_protocols = RC_BIT_NEC | RC_BIT_RC5;
+
+        /* all done */
+        err = rc_register_device(rc);
+        if (err)
+                goto error;
+
+        pr_info("Remote controller %s initalized\n", ir->name);
+
+        return 0;
+
+error:
+        dev->ir = NULL;
+        rc_free_device(rc);
+        kfree(ir);
+        return err;
+}
+
+void au0828_rc_unregister(struct au0828_dev *dev)
+{
+        struct au0828_rc *ir = dev->ir;
+
+        /* skip detach on non attached boards */
+        if (!ir)
+                return;
+
+        if (ir->rc)
+                rc_unregister_device(ir->rc);
+
+        /* done */
+        kfree(ir);
+        dev->ir = NULL;
+}
+
+int au0828_rc_suspend(struct au0828_dev *dev)
+{
+        struct au0828_rc *ir = dev->ir;
+
+        if (!ir)
+                return 0;
+
+        cancel_delayed_work_sync(&ir->work);
+
+        return 0;
+}
+
+int au0828_rc_resume(struct au0828_dev *dev)
+{
+        struct au0828_rc *ir = dev->ir;
+
+        if (!ir)
+                return 0;
+
+        schedule_delayed_work(&ir->work, msecs_to_jiffies(ir->polling));
+
+        return 0;
+}
diff --git a/drivers/media/usb/au0828/au0828-video.c b/drivers/media/usb/au0828/au0828-video.c
index 9038194513c5..98f7ea1d6d63 100644
--- a/drivers/media/usb/au0828/au0828-video.c
+++ b/drivers/media/usb/au0828/au0828-video.c
@@ -787,23 +787,40 @@ static int au0828_i2s_init(struct au0828_dev *dev)
 
 /*
  * Auvitek au0828 analog stream enable
- * Please set interface0 to AS5 before enable the stream
  */
 static int au0828_analog_stream_enable(struct au0828_dev *d)
 {
+        struct usb_interface *iface;
+        int ret, h, w;
+
         dprintk(1, "au0828_analog_stream_enable called\n");
+
+        iface = usb_ifnum_to_if(d->usbdev, 0);
+        if (iface && iface->cur_altsetting->desc.bAlternateSetting != 5) {
+                dprintk(1, "Changing intf#0 to alt 5\n");
+                /* set au0828 interface0 to AS5 here again */
+                ret = usb_set_interface(d->usbdev, 0, 5);
+                if (ret < 0) {
+                        printk(KERN_INFO "Au0828 can't set alt setting to 5!\n");
+                        return -EBUSY;
+                }
+        }
+
+        h = d->height / 2 + 2;
+        w = d->width * 2;
+
         au0828_writereg(d, AU0828_SENSORCTRL_VBI_103, 0x00);
         au0828_writereg(d, 0x106, 0x00);
         /* set x position */
         au0828_writereg(d, 0x110, 0x00);
         au0828_writereg(d, 0x111, 0x00);
-        au0828_writereg(d, 0x114, 0xa0);
-        au0828_writereg(d, 0x115, 0x05);
+        au0828_writereg(d, 0x114, w & 0xff);
+        au0828_writereg(d, 0x115, w >> 8);
         /* set y position */
         au0828_writereg(d, 0x112, 0x00);
         au0828_writereg(d, 0x113, 0x00);
-        au0828_writereg(d, 0x116, 0xf2);
-        au0828_writereg(d, 0x117, 0x00);
+        au0828_writereg(d, 0x116, h & 0xff);
+        au0828_writereg(d, 0x117, h >> 8);
         au0828_writereg(d, AU0828_SENSORCTRL_100, 0xb3);
 
         return 0;
@@ -1002,15 +1019,6 @@ static int au0828_v4l2_open(struct file *filp)
                 return -ERESTARTSYS;
         }
         if (dev->users == 0) {
-                /* set au0828 interface0 to AS5 here again */
-                ret = usb_set_interface(dev->usbdev, 0, 5);
-                if (ret < 0) {
-                        mutex_unlock(&dev->lock);
-                        printk(KERN_INFO "Au0828 can't set alternate to 5!\n");
-                        kfree(fh);
-                        return -EBUSY;
-                }
-
                 au0828_analog_stream_enable(dev);
                 au0828_analog_stream_reset(dev);
 
@@ -1252,13 +1260,6 @@ static int au0828_set_format(struct au0828_dev *dev, unsigned int cmd,
                 }
         }
 
-        /* set au0828 interface0 to AS5 here again */
-        ret = usb_set_interface(dev->usbdev, 0, 5);
-        if (ret < 0) {
-                printk(KERN_INFO "Au0828 can't set alt setting to 5!\n");
-                return -EBUSY;
-        }
-
         au0828_analog_stream_enable(dev);
 
         return 0;
@@ -1364,9 +1365,11 @@ static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id norm)
 
         i2c_gate_ctrl(dev, 1);
 
-        /* FIXME: when we support something other than NTSC, we are going to
-           have to make the au0828 bridge adjust the size of its capture
-           buffer, which is currently hardcoded at 720x480 */
+        /*
+         * FIXME: when we support something other than 60Hz standards,
+         * we are going to have to make the au0828 bridge adjust the size
+         * of its capture buffer, which is currently hardcoded at 720x480
+         */
 
         v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_std, norm);
 
@@ -1723,6 +1726,7 @@ static int vidioc_streamoff(struct file *file, void *priv,
                 dev->vid_timeout_running = 0;
                 del_timer_sync(&dev->vid_timeout);
 
+                au0828_analog_stream_disable(dev);
                 v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_stream, 0);
                 rc = au0828_stream_interrupt(dev);
                 if (rc != 0)
@@ -1915,7 +1919,7 @@ static const struct video_device au0828_video_template = {
         .fops                       = &au0828_v4l_fops,
         .release                    = video_device_release,
         .ioctl_ops                  = &video_ioctl_ops,
-        .tvnorms                    = V4L2_STD_NTSC_M,
+        .tvnorms                    = V4L2_STD_NTSC_M | V4L2_STD_PAL_M,
 };
 
 /**************************************************************************/
@@ -1928,7 +1932,8 @@ int au0828_analog_register(struct au0828_dev *dev,
         struct usb_endpoint_descriptor *endpoint;
         int i, ret;
 
-        dprintk(1, "au0828_analog_register called!\n");
+        dprintk(1, "au0828_analog_register called for intf#%d!\n",
+                interface->cur_altsetting->desc.bInterfaceNumber);
 
         /* set au0828 usb interface0 to as5 */
         retval = usb_set_interface(dev->usbdev,
@@ -1952,6 +1957,9 @@ int au0828_analog_register(struct au0828_dev *dev,
                         dev->max_pkt_size = (tmp & 0x07ff) *
                                 (((tmp & 0x1800) >> 11) + 1);
                         dev->isoc_in_endpointaddr = endpoint->bEndpointAddress;
+                        dprintk(1,
+                                "Found isoc endpoint 0x%02x, max size = %d\n",
+                                dev->isoc_in_endpointaddr, dev->max_pkt_size);
                 }
         }
         if (!(dev->isoc_in_endpointaddr)) {
@@ -2008,14 +2016,12 @@ int au0828_analog_register(struct au0828_dev *dev,
         *dev->vdev = au0828_video_template;
         dev->vdev->v4l2_dev = &dev->v4l2_dev;
         dev->vdev->lock = &dev->lock;
-        set_bit(V4L2_FL_USE_FH_PRIO, &dev->vdev->flags);
         strcpy(dev->vdev->name, "au0828a video");
 
         /* Setup the VBI device */
         *dev->vbi_dev = au0828_video_template;
         dev->vbi_dev->v4l2_dev = &dev->v4l2_dev;
         dev->vbi_dev->lock = &dev->lock;
-        set_bit(V4L2_FL_USE_FH_PRIO, &dev->vbi_dev->flags);
         strcpy(dev->vbi_dev->name, "au0828a vbi");
 
         /* Register the v4l2 device */
diff --git a/drivers/media/usb/au0828/au0828.h b/drivers/media/usb/au0828/au0828.h
index 7112b9d956fa..96bec05d7dac 100644
--- a/drivers/media/usb/au0828/au0828.h
+++ b/drivers/media/usb/au0828/au0828.h
@@ -88,6 +88,7 @@ struct au0828_board {
         unsigned int tuner_type;
         unsigned char tuner_addr;
         unsigned char i2c_clk_divider;
+        unsigned char has_ir_i2c:1;
         struct au0828_input input[AU0828_MAX_INPUT];
 
 };
@@ -213,6 +214,10 @@ struct au0828_dev {
         struct v4l2_device v4l2_dev;
         struct v4l2_ctrl_handler v4l2_ctrl_hdl;
 #endif
+#ifdef CONFIG_VIDEO_AU0828_RC
+        struct au0828_rc *ir;
+#endif
+
         int users;
         unsigned int resources; /* resources in use */
         struct video_device *vdev;
@@ -319,3 +324,9 @@ extern struct videobuf_queue_ops au0828_vbi_qops;
         do { if (au0828_debug & level)\
                 printk(KERN_DEBUG DRIVER_NAME "/0: " fmt, ## arg);\
         } while (0)
+
+/* au0828-input.c */
+int au0828_rc_register(struct au0828_dev *dev);
+void au0828_rc_unregister(struct au0828_dev *dev);
+int au0828_rc_suspend(struct au0828_dev *dev);
+int au0828_rc_resume(struct au0828_dev *dev);
diff --git a/drivers/media/usb/cpia2/cpia2_v4l.c b/drivers/media/usb/cpia2/cpia2_v4l.c
index d5d42b6e94be..9caea8344547 100644
--- a/drivers/media/usb/cpia2/cpia2_v4l.c
+++ b/drivers/media/usb/cpia2/cpia2_v4l.c
@@ -1169,7 +1169,6 @@ int cpia2_register_camera(struct camera_data *cam)
         cam->vdev.lock = &cam->v4l2_lock;
         cam->vdev.ctrl_handler = hdl;
         cam->vdev.v4l2_dev = &cam->v4l2_dev;
-        set_bit(V4L2_FL_USE_FH_PRIO, &cam->vdev.flags);
 
         reset_camera_struct_v4l(cam);
 
diff --git a/drivers/media/usb/cx231xx/Kconfig b/drivers/media/usb/cx231xx/Kconfig
index f14c5e89a567..569aa298c03f 100644
--- a/drivers/media/usb/cx231xx/Kconfig
+++ b/drivers/media/usb/cx231xx/Kconfig
@@ -47,6 +47,8 @@ config VIDEO_CX231XX_DVB
         select DVB_MB86A20S if MEDIA_SUBDRV_AUTOSELECT
         select DVB_LGDT3305 if MEDIA_SUBDRV_AUTOSELECT
         select DVB_TDA18271C2DD if MEDIA_SUBDRV_AUTOSELECT
+        select DVB_SI2165 if MEDIA_SUBDRV_AUTOSELECT
+        select MEDIA_TUNER_SI2157 if MEDIA_SUBDRV_AUTOSELECT
 
         ---help---
           This adds support for DVB cards based on the
diff --git a/drivers/media/usb/cx231xx/cx231xx-417.c b/drivers/media/usb/cx231xx/cx231xx-417.c
index 30a0c69fb42f..459bb0e98971 100644
--- a/drivers/media/usb/cx231xx/cx231xx-417.c
+++ b/drivers/media/usb/cx231xx/cx231xx-417.c
@@ -1563,7 +1563,6 @@ static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
         f->fmt.pix.width = dev->ts1.width;
         f->fmt.pix.height = dev->ts1.height;
         f->fmt.pix.field = V4L2_FIELD_INTERLACED;
-        f->fmt.pix.priv = 0;
         dprintk(1, "VIDIOC_G_FMT: w: %d, h: %d\n",
                 dev->ts1.width, dev->ts1.height);
         dprintk(3, "exit vidioc_g_fmt_vid_cap()\n");
@@ -1582,7 +1581,6 @@ static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
         f->fmt.pix.sizeimage = mpeglines * mpeglinesize;
         f->fmt.pix.field = V4L2_FIELD_INTERLACED;
         f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
-        f->fmt.pix.priv = 0;
         dprintk(1, "VIDIOC_TRY_FMT: w: %d, h: %d\n",
                 dev->ts1.width, dev->ts1.height);
         dprintk(3, "exit vidioc_try_fmt_vid_cap()\n");
@@ -1923,7 +1921,6 @@ static struct video_device *cx231xx_video_dev_alloc(
         vfd->v4l2_dev = &dev->v4l2_dev;
         vfd->lock = &dev->lock;
         vfd->release = video_device_release;
-        set_bit(V4L2_FL_USE_FH_PRIO, &vfd->flags);
         vfd->ctrl_handler = &dev->mpeg_ctrl_handler.hdl;
         video_set_drvdata(vfd, dev);
         if (dev->tuner_type == TUNER_ABSENT) {
diff --git a/drivers/media/usb/cx231xx/cx231xx-avcore.c b/drivers/media/usb/cx231xx/cx231xx-avcore.c
index 89de00bf4f82..a428c10e1a16 100644
--- a/drivers/media/usb/cx231xx/cx231xx-avcore.c
+++ b/drivers/media/usb/cx231xx/cx231xx-avcore.c
@@ -352,6 +352,7 @@ int cx231xx_afe_update_power_control(struct cx231xx *dev,
         case CX231XX_BOARD_CNXT_RDU_253S:
         case CX231XX_BOARD_CNXT_VIDEO_GRABBER:
         case CX231XX_BOARD_HAUPPAUGE_EXETER:
+        case CX231XX_BOARD_HAUPPAUGE_930C_HD_1113xx:
         case CX231XX_BOARD_HAUPPAUGE_USBLIVE2:
         case CX231XX_BOARD_PV_PLAYTV_USB_HYBRID:
         case CX231XX_BOARD_HAUPPAUGE_USB2_FM_PAL:
diff --git a/drivers/media/usb/cx231xx/cx231xx-cards.c b/drivers/media/usb/cx231xx/cx231xx-cards.c
index 2ee03e4ddd86..8039b769f258 100644
--- a/drivers/media/usb/cx231xx/cx231xx-cards.c
+++ b/drivers/media/usb/cx231xx/cx231xx-cards.c
@@ -704,6 +704,84 @@ struct cx231xx_board cx231xx_boards[] = {
                         }
                 },
         },
+        [CX231XX_BOARD_HAUPPAUGE_930C_HD_1113xx] = {
+                .name = "Hauppauge WinTV 930C-HD (1113xx) / PCTV QuatroStick 521e",
+                .tuner_type = TUNER_NXP_TDA18271,
+                .tuner_addr = 0x60,
+                .tuner_gpio = RDE250_XCV_TUNER,
+                .tuner_sif_gpio = 0x05,
+                .tuner_scl_gpio = 0x1a,
+                .tuner_sda_gpio = 0x1b,
+                .decoder = CX231XX_AVDECODER,
+                .output_mode = OUT_MODE_VIP11,
+                .demod_xfer_mode = 0,
+                .ctl_pin_status_mask = 0xFFFFFFC4,
+                .agc_analog_digital_select_gpio = 0x0c,
+                .gpio_pin_status_mask = 0x4001000,
+                .tuner_i2c_master = 1,
+                .demod_i2c_master = 2,
+                .has_dvb = 1,
+                .demod_addr = 0x0e,
+                .norm = V4L2_STD_PAL,
+
+                .input = {{
+                        .type = CX231XX_VMUX_TELEVISION,
+                        .vmux = CX231XX_VIN_3_1,
+                        .amux = CX231XX_AMUX_VIDEO,
+                        .gpio = NULL,
+                }, {
+                        .type = CX231XX_VMUX_COMPOSITE1,
+                        .vmux = CX231XX_VIN_2_1,
+                        .amux = CX231XX_AMUX_LINE_IN,
+                        .gpio = NULL,
+                }, {
+                        .type = CX231XX_VMUX_SVIDEO,
+                        .vmux = CX231XX_VIN_1_1 |
+                                (CX231XX_VIN_1_2 << 8) |
+                                CX25840_SVIDEO_ON,
+                        .amux = CX231XX_AMUX_LINE_IN,
+                        .gpio = NULL,
+                } },
+        },
+        [CX231XX_BOARD_HAUPPAUGE_930C_HD_1114xx] = {
+                .name = "Hauppauge WinTV 930C-HD (1114xx) / PCTV QuatroStick 522e",
+                .tuner_type = TUNER_ABSENT,
+                .tuner_addr = 0x60,
+                .tuner_gpio = RDE250_XCV_TUNER,
+                .tuner_sif_gpio = 0x05,
+                .tuner_scl_gpio = 0x1a,
+                .tuner_sda_gpio = 0x1b,
+                .decoder = CX231XX_AVDECODER,
+                .output_mode = OUT_MODE_VIP11,
+                .demod_xfer_mode = 0,
+                .ctl_pin_status_mask = 0xFFFFFFC4,
+                .agc_analog_digital_select_gpio = 0x0c,
+                .gpio_pin_status_mask = 0x4001000,
+                .tuner_i2c_master = 1,
+                .demod_i2c_master = 2,
+                .has_dvb = 1,
+                .demod_addr = 0x0e,
+                .norm = V4L2_STD_PAL,
+
+                .input = {{
+                        .type = CX231XX_VMUX_TELEVISION,
+                        .vmux = CX231XX_VIN_3_1,
+                        .amux = CX231XX_AMUX_VIDEO,
+                        .gpio = NULL,
+                }, {
+                        .type = CX231XX_VMUX_COMPOSITE1,
+                        .vmux = CX231XX_VIN_2_1,
+                        .amux = CX231XX_AMUX_LINE_IN,
+                        .gpio = NULL,
+                }, {
+                        .type = CX231XX_VMUX_SVIDEO,
+                        .vmux = CX231XX_VIN_1_1 |
+                                (CX231XX_VIN_1_2 << 8) |
+                                CX25840_SVIDEO_ON,
+                        .amux = CX231XX_AMUX_LINE_IN,
+                        .gpio = NULL,
+                } },
+        },
 };
 const unsigned int cx231xx_bcount = ARRAY_SIZE(cx231xx_boards);
 
@@ -733,10 +811,20 @@ struct usb_device_id cx231xx_id_table[] = {
          .driver_info = CX231XX_BOARD_HAUPPAUGE_USB2_FM_NTSC},
         {USB_DEVICE(0x2040, 0xb120),
          .driver_info = CX231XX_BOARD_HAUPPAUGE_EXETER},
+        {USB_DEVICE(0x2040, 0xb130),
+         .driver_info = CX231XX_BOARD_HAUPPAUGE_930C_HD_1113xx},
+        {USB_DEVICE(0x2040, 0xb131),
+         .driver_info = CX231XX_BOARD_HAUPPAUGE_930C_HD_1114xx},
         {USB_DEVICE(0x2040, 0xb140),
          .driver_info = CX231XX_BOARD_HAUPPAUGE_EXETER},
         {USB_DEVICE(0x2040, 0xc200),
          .driver_info = CX231XX_BOARD_HAUPPAUGE_USBLIVE2},
+        /* PCTV QuatroStick 521e */
+        {USB_DEVICE(0x2013, 0x0259),
+         .driver_info = CX231XX_BOARD_HAUPPAUGE_930C_HD_1113xx},
+        /* PCTV QuatroStick 522e */
+        {USB_DEVICE(0x2013, 0x025e),
+         .driver_info = CX231XX_BOARD_HAUPPAUGE_930C_HD_1114xx},
         {USB_DEVICE_VER(USB_VID_PIXELVIEW, USB_PID_PIXELVIEW_SBTVD, 0x4000, 0x4001),
          .driver_info = CX231XX_BOARD_PV_PLAYTV_USB_HYBRID},
         {USB_DEVICE(USB_VID_PIXELVIEW, 0x5014),
@@ -886,6 +974,50 @@ static void cx231xx_config_tuner(struct cx231xx *dev)
 
 }
 
+static int read_eeprom(struct cx231xx *dev, u8 *eedata, int len)
+{
+        int ret = 0;
+        u8 addr = 0xa0 >> 1;
+        u8 start_offset = 0;
+        int len_todo = len;
+        u8 *eedata_cur = eedata;
+        int i;
+        struct i2c_msg msg_write = { .addr = addr, .flags = 0,
+                .buf = &start_offset, .len = 1 };
+        struct i2c_msg msg_read = { .addr = addr, .flags = I2C_M_RD };
+
+        /* mutex_lock(&dev->i2c_lock); */
+        cx231xx_enable_i2c_port_3(dev, false);
+
+        /* start reading at offset 0 */
+        ret = i2c_transfer(&dev->i2c_bus[1].i2c_adap, &msg_write, 1);
+        if (ret < 0) {
+                cx231xx_err("Can't read eeprom\n");
+                return ret;
+        }
+
+        while (len_todo > 0) {
+                msg_read.len = (len_todo > 64) ? 64 : len_todo;
+                msg_read.buf = eedata_cur;
+
+                ret = i2c_transfer(&dev->i2c_bus[1].i2c_adap, &msg_read, 1);
+                if (ret < 0) {
+                        cx231xx_err("Can't read eeprom\n");
+                        return ret;
+                }
+                eedata_cur += msg_read.len;
+                len_todo -= msg_read.len;
+        }
+
+        cx231xx_enable_i2c_port_3(dev, true);
+        /* mutex_unlock(&dev->i2c_lock); */
+
+        for (i = 0; i + 15 < len; i += 16)
+                cx231xx_info("i2c eeprom %02x: %*ph\n", i, 16, &eedata[i]);
+
+        return 0;
+}
+
 void cx231xx_card_setup(struct cx231xx *dev)
 {
 
@@ -917,6 +1049,21 @@ void cx231xx_card_setup(struct cx231xx *dev)
                 else
                         cx231xx_config_tuner(dev);
         }
+
+        switch (dev->model) {
+        case CX231XX_BOARD_HAUPPAUGE_930C_HD_1113xx:
+        case CX231XX_BOARD_HAUPPAUGE_930C_HD_1114xx:
+                {
+                        struct tveeprom tvee;
+                        static u8 eeprom[256];
+
+                        read_eeprom(dev, eeprom, sizeof(eeprom));
+                        tveeprom_hauppauge_analog(&dev->i2c_bus[1].i2c_client,
+                                                &tvee, eeprom + 0xc0);
+                        break;
+                }
+        }
+
 }
 
 /*
@@ -964,12 +1111,6 @@ void cx231xx_release_resources(struct cx231xx *dev)
 
         /* Mark device as unused */
         clear_bit(dev->devno, &cx231xx_devused);
-
-        kfree(dev->video_mode.alt_max_pkt_size);
-        kfree(dev->vbi_mode.alt_max_pkt_size);
-        kfree(dev->sliced_cc_mode.alt_max_pkt_size);
-        kfree(dev->ts1_mode.alt_max_pkt_size);
-        kfree(dev);
 }
 
 /*
@@ -1003,7 +1144,11 @@ static int cx231xx_init_dev(struct cx231xx *dev, struct usb_device *udev,
         dev->cx231xx_gpio_i2c_write = cx231xx_gpio_i2c_write;
 
         /* Query cx231xx to find what pcb config it is related to */
-        initialize_cx231xx(dev);
+        retval = initialize_cx231xx(dev);
+        if (retval < 0) {
+                cx231xx_errdev("Failed to read PCB config\n");
+                return retval;
+        }
 
         /*To workaround error number=-71 on EP0 for VideoGrabber,
                  need set alt here.*/
@@ -1121,6 +1266,117 @@ static void flush_request_modules(struct cx231xx *dev)
 #define flush_request_modules(dev)
 #endif /* CONFIG_MODULES */
 
+static int cx231xx_init_v4l2(struct cx231xx *dev,
+                             struct usb_device *udev,
+                             struct usb_interface *interface,
+                             int isoc_pipe)
+{
+        struct usb_interface *uif;
+        int i, idx;
+
+        /* Video Init */
+
+        /* compute alternate max packet sizes for video */
+        idx = dev->current_pcb_config.hs_config_info[0].interface_info.video_index + 1;
+        if (idx >= dev->max_iad_interface_count) {
+                cx231xx_errdev("Video PCB interface #%d doesn't exist\n", idx);
+                return -ENODEV;
+        }
+
+        uif = udev->actconfig->interface[idx];
+
+        dev->video_mode.end_point_addr = uif->altsetting[0].endpoint[isoc_pipe].desc.bEndpointAddress;
+        dev->video_mode.num_alt = uif->num_altsetting;
+
+        cx231xx_info("EndPoint Addr 0x%x, Alternate settings: %i\n",
+                     dev->video_mode.end_point_addr,
+                     dev->video_mode.num_alt);
+
+        dev->video_mode.alt_max_pkt_size = devm_kmalloc_array(&udev->dev, 32, dev->video_mode.num_alt, GFP_KERNEL);
+        if (dev->video_mode.alt_max_pkt_size == NULL) {
+                cx231xx_errdev("out of memory!\n");
+                return -ENOMEM;
+        }
+
+        for (i = 0; i < dev->video_mode.num_alt; i++) {
+                u16 tmp = le16_to_cpu(uif->altsetting[i].endpoint[isoc_pipe].desc.wMaxPacketSize);
+                dev->video_mode.alt_max_pkt_size[i] = (tmp & 0x07ff) * (((tmp & 0x1800) >> 11) + 1);
+                cx231xx_info("Alternate setting %i, max size= %i\n", i,
+                             dev->video_mode.alt_max_pkt_size[i]);
+        }
+
+        /* VBI Init */
+
+        idx = dev->current_pcb_config.hs_config_info[0].interface_info.vanc_index + 1;
+        if (idx >= dev->max_iad_interface_count) {
+                cx231xx_errdev("VBI PCB interface #%d doesn't exist\n", idx);
+                return -ENODEV;
+        }
+        uif = udev->actconfig->interface[idx];
+
+        dev->vbi_mode.end_point_addr =
+            uif->altsetting[0].endpoint[isoc_pipe].desc.
+                        bEndpointAddress;
+
+        dev->vbi_mode.num_alt = uif->num_altsetting;
+        cx231xx_info("EndPoint Addr 0x%x, Alternate settings: %i\n",
+                     dev->vbi_mode.end_point_addr,
+                     dev->vbi_mode.num_alt);
+
+        /* compute alternate max packet sizes for vbi */
+        dev->vbi_mode.alt_max_pkt_size = devm_kmalloc_array(&udev->dev, 32, dev->vbi_mode.num_alt, GFP_KERNEL);
+        if (dev->vbi_mode.alt_max_pkt_size == NULL) {
+                cx231xx_errdev("out of memory!\n");
+                return -ENOMEM;
+        }
+
+        for (i = 0; i < dev->vbi_mode.num_alt; i++) {
+                u16 tmp =
+                    le16_to_cpu(uif->altsetting[i].endpoint[isoc_pipe].
+                                desc.wMaxPacketSize);
+                dev->vbi_mode.alt_max_pkt_size[i] =
+                    (tmp & 0x07ff) * (((tmp & 0x1800) >> 11) + 1);
+                cx231xx_info("Alternate setting %i, max size= %i\n", i,
+                             dev->vbi_mode.alt_max_pkt_size[i]);
+        }
+
+        /* Sliced CC VBI init */
+
+        /* compute alternate max packet sizes for sliced CC */
+        idx = dev->current_pcb_config.hs_config_info[0].interface_info.hanc_index + 1;
+        if (idx >= dev->max_iad_interface_count) {
+                cx231xx_errdev("Sliced CC PCB interface #%d doesn't exist\n", idx);
+                return -ENODEV;
+        }
+        uif = udev->actconfig->interface[idx];
+
+        dev->sliced_cc_mode.end_point_addr =
+            uif->altsetting[0].endpoint[isoc_pipe].desc.
+                        bEndpointAddress;
+
+        dev->sliced_cc_mode.num_alt = uif->num_altsetting;
+        cx231xx_info("EndPoint Addr 0x%x, Alternate settings: %i\n",
+                     dev->sliced_cc_mode.end_point_addr,
+                     dev->sliced_cc_mode.num_alt);
+        dev->sliced_cc_mode.alt_max_pkt_size = devm_kmalloc_array(&udev->dev, 32, dev->sliced_cc_mode.num_alt, GFP_KERNEL);
+
+        if (dev->sliced_cc_mode.alt_max_pkt_size == NULL) {
+                cx231xx_errdev("out of memory!\n");
+                return -ENOMEM;
+        }
+
+        for (i = 0; i < dev->sliced_cc_mode.num_alt; i++) {
+                u16 tmp = le16_to_cpu(uif->altsetting[i].endpoint[isoc_pipe].
+                                desc.wMaxPacketSize);
+                dev->sliced_cc_mode.alt_max_pkt_size[i] =
+                    (tmp & 0x07ff) * (((tmp & 0x1800) >> 11) + 1);
+                cx231xx_info("Alternate setting %i, max size= %i\n", i,
+                             dev->sliced_cc_mode.alt_max_pkt_size[i]);
+        }
+
+        return 0;
+}
+
 /*
  * cx231xx_usb_probe()
  * checks for supported devices
@@ -1135,6 +1391,7 @@ static int cx231xx_usb_probe(struct usb_interface *interface,
         int nr = 0, ifnum;
         int i, isoc_pipe = 0;
         char *speed;
+        u8 idx;
         struct usb_interface_assoc_descriptor *assoc_desc;
 
         ifnum = interface->altsetting[0].desc.bInterfaceNumber;
@@ -1157,16 +1414,16 @@ static int cx231xx_usb_probe(struct usb_interface *interface,
                 }
         } while (test_and_set_bit(nr, &cx231xx_devused));
 
+        udev = usb_get_dev(interface_to_usbdev(interface));
+
         /* allocate memory for our device state and initialize it */
-        dev = kzalloc(sizeof(*dev), GFP_KERNEL);
+        dev = devm_kzalloc(&udev->dev, sizeof(*dev), GFP_KERNEL);
         if (dev == NULL) {
                 cx231xx_err(DRIVER_NAME ": out of memory!\n");
                 clear_bit(nr, &cx231xx_devused);
                 return -ENOMEM;
         }
 
-        udev = usb_get_dev(interface_to_usbdev(interface));
-
         snprintf(dev->name, 29, "cx231xx #%d", nr);
         dev->devno = nr;
         dev->model = id->driver_info;
@@ -1185,8 +1442,7 @@ static int cx231xx_usb_probe(struct usb_interface *interface,
         dev->vbi_or_sliced_cc_mode = 0;
 
         /* get maximum no.of IAD interfaces */
-        assoc_desc = udev->actconfig->intf_assoc[0];
-        dev->max_iad_interface_count = assoc_desc->bInterfaceCount;
+        dev->max_iad_interface_count = udev->config->desc.bNumInterfaces;
 
         /* init CIR module TBD */
 
@@ -1238,120 +1494,31 @@ static int cx231xx_usb_probe(struct usb_interface *interface,
         /* save our data pointer in this interface device */
         usb_set_intfdata(interface, dev);
 
-        /*
-         * AV device initialization - only done at the last interface
-         */
-
         /* Create v4l2 device */
         retval = v4l2_device_register(&interface->dev, &dev->v4l2_dev);
         if (retval) {
                 cx231xx_errdev("v4l2_device_register failed\n");
-                retval = -EIO;
                 goto err_v4l2;
         }
+
         /* allocate device struct */
         retval = cx231xx_init_dev(dev, udev, nr);
         if (retval)
                 goto err_init;
 
-        /* compute alternate max packet sizes for video */
-        uif = udev->actconfig->interface[dev->current_pcb_config.
-                       hs_config_info[0].interface_info.video_index + 1];
-
-        dev->video_mode.end_point_addr = uif->altsetting[0].
-                        endpoint[isoc_pipe].desc.bEndpointAddress;
-
-        dev->video_mode.num_alt = uif->num_altsetting;
-        cx231xx_info("EndPoint Addr 0x%x, Alternate settings: %i\n",
-                     dev->video_mode.end_point_addr,
-                     dev->video_mode.num_alt);
-        dev->video_mode.alt_max_pkt_size =
-                kmalloc(32 * dev->video_mode.num_alt, GFP_KERNEL);
-
-        if (dev->video_mode.alt_max_pkt_size == NULL) {
-                cx231xx_errdev("out of memory!\n");
-                retval = -ENOMEM;
-                goto err_video_alt;
-        }
-
-        for (i = 0; i < dev->video_mode.num_alt; i++) {
-                u16 tmp = le16_to_cpu(uif->altsetting[i].endpoint[isoc_pipe].
-                                desc.wMaxPacketSize);
-                dev->video_mode.alt_max_pkt_size[i] =
-                    (tmp & 0x07ff) * (((tmp & 0x1800) >> 11) + 1);
-                cx231xx_info("Alternate setting %i, max size= %i\n", i,
-                             dev->video_mode.alt_max_pkt_size[i]);
-        }
-
-        /* compute alternate max packet sizes for vbi */
-        uif = udev->actconfig->interface[dev->current_pcb_config.
-                                       hs_config_info[0].interface_info.
-                                       vanc_index + 1];
-
-        dev->vbi_mode.end_point_addr =
-            uif->altsetting[0].endpoint[isoc_pipe].desc.
-                        bEndpointAddress;
-
-        dev->vbi_mode.num_alt = uif->num_altsetting;
-        cx231xx_info("EndPoint Addr 0x%x, Alternate settings: %i\n",
-                     dev->vbi_mode.end_point_addr,
-                     dev->vbi_mode.num_alt);
-        dev->vbi_mode.alt_max_pkt_size =
-            kmalloc(32 * dev->vbi_mode.num_alt, GFP_KERNEL);
-
-        if (dev->vbi_mode.alt_max_pkt_size == NULL) {
-                cx231xx_errdev("out of memory!\n");
-                retval = -ENOMEM;
-                goto err_vbi_alt;
-        }
-
-        for (i = 0; i < dev->vbi_mode.num_alt; i++) {
-                u16 tmp =
-                    le16_to_cpu(uif->altsetting[i].endpoint[isoc_pipe].
-                                desc.wMaxPacketSize);
-                dev->vbi_mode.alt_max_pkt_size[i] =
-                    (tmp & 0x07ff) * (((tmp & 0x1800) >> 11) + 1);
-                cx231xx_info("Alternate setting %i, max size= %i\n", i,
-                             dev->vbi_mode.alt_max_pkt_size[i]);
-        }
-
-        /* compute alternate max packet sizes for sliced CC */
-        uif = udev->actconfig->interface[dev->current_pcb_config.
-                                       hs_config_info[0].interface_info.
-                                       hanc_index + 1];
-
-        dev->sliced_cc_mode.end_point_addr =
-            uif->altsetting[0].endpoint[isoc_pipe].desc.
-                        bEndpointAddress;
-
-        dev->sliced_cc_mode.num_alt = uif->num_altsetting;
-        cx231xx_info("EndPoint Addr 0x%x, Alternate settings: %i\n",
-                     dev->sliced_cc_mode.end_point_addr,
-                     dev->sliced_cc_mode.num_alt);
-        dev->sliced_cc_mode.alt_max_pkt_size =
-                kmalloc(32 * dev->sliced_cc_mode.num_alt, GFP_KERNEL);
-
-        if (dev->sliced_cc_mode.alt_max_pkt_size == NULL) {
-                cx231xx_errdev("out of memory!\n");
-                retval = -ENOMEM;
-                goto err_sliced_cc_alt;
-        }
-
-        for (i = 0; i < dev->sliced_cc_mode.num_alt; i++) {
-                u16 tmp = le16_to_cpu(uif->altsetting[i].endpoint[isoc_pipe].
-                                desc.wMaxPacketSize);
-                dev->sliced_cc_mode.alt_max_pkt_size[i] =
-                    (tmp & 0x07ff) * (((tmp & 0x1800) >> 11) + 1);
-                cx231xx_info("Alternate setting %i, max size= %i\n", i,
-                             dev->sliced_cc_mode.alt_max_pkt_size[i]);
-        }
+        retval = cx231xx_init_v4l2(dev, udev, interface, isoc_pipe);
+        if (retval)
+                goto err_init;
 
         if (dev->current_pcb_config.ts1_source != 0xff) {
                 /* compute alternate max packet sizes for TS1 */
-                uif = udev->actconfig->interface[dev->current_pcb_config.
-                                               hs_config_info[0].
-                                               interface_info.
-                                               ts1_index + 1];
+                idx = dev->current_pcb_config.hs_config_info[0].interface_info.ts1_index + 1;
+                if (idx >= dev->max_iad_interface_count) {
+                        cx231xx_errdev("TS1 PCB interface #%d doesn't exist\n", idx);
+                        retval = -ENODEV;
+                        goto err_video_alt;
+                }
+                uif = udev->actconfig->interface[idx];
 
                 dev->ts1_mode.end_point_addr =
                     uif->altsetting[0].endpoint[isoc_pipe].
@@ -1361,13 +1528,12 @@ static int cx231xx_usb_probe(struct usb_interface *interface,
                 cx231xx_info("EndPoint Addr 0x%x, Alternate settings: %i\n",
                              dev->ts1_mode.end_point_addr,
                              dev->ts1_mode.num_alt);
-                dev->ts1_mode.alt_max_pkt_size =
-                        kmalloc(32 * dev->ts1_mode.num_alt, GFP_KERNEL);
 
+                dev->ts1_mode.alt_max_pkt_size = devm_kmalloc_array(&udev->dev, 32, dev->ts1_mode.num_alt, GFP_KERNEL);
                 if (dev->ts1_mode.alt_max_pkt_size == NULL) {
                         cx231xx_errdev("out of memory!\n");
                         retval = -ENOMEM;
-                        goto err_ts1_alt;
+                        goto err_video_alt;
                 }
 
                 for (i = 0; i < dev->ts1_mode.num_alt; i++) {
@@ -1394,12 +1560,6 @@ static int cx231xx_usb_probe(struct usb_interface *interface,
         request_modules(dev);
 
         return 0;
-err_ts1_alt:
-        kfree(dev->sliced_cc_mode.alt_max_pkt_size);
-err_sliced_cc_alt:
-        kfree(dev->vbi_mode.alt_max_pkt_size);
-err_vbi_alt:
-        kfree(dev->video_mode.alt_max_pkt_size);
 err_video_alt:
         /* cx231xx_uninit_dev: */
         cx231xx_close_extension(dev);
@@ -1415,7 +1575,6 @@ err_v4l2:
 err_if:
         usb_put_dev(udev);
         clear_bit(dev->devno, &cx231xx_devused);
-        kfree(dev);
         return retval;
 }
 
diff --git a/drivers/media/usb/cx231xx/cx231xx-core.c b/drivers/media/usb/cx231xx/cx231xx-core.c
index 4ba3ce09b713..513194aa6561 100644
--- a/drivers/media/usb/cx231xx/cx231xx-core.c
+++ b/drivers/media/usb/cx231xx/cx231xx-core.c
@@ -726,6 +726,7 @@ int cx231xx_set_mode(struct cx231xx *dev, enum cx231xx_mode set_mode)
                         errCode = cx231xx_set_agc_analog_digital_mux_select(dev, 1);
                         break;
                 case CX231XX_BOARD_HAUPPAUGE_EXETER:
+                case CX231XX_BOARD_HAUPPAUGE_930C_HD_1113xx:
                         errCode = cx231xx_set_power_mode(dev,
                                                 POLARIS_AVMODE_DIGITAL);
                         break;
@@ -744,6 +745,7 @@ int cx231xx_set_mode(struct cx231xx *dev, enum cx231xx_mode set_mode)
                 case CX231XX_BOARD_CNXT_RDE_253S:
                 case CX231XX_BOARD_CNXT_RDU_253S:
                 case CX231XX_BOARD_HAUPPAUGE_EXETER:
+                case CX231XX_BOARD_HAUPPAUGE_930C_HD_1113xx:
                 case CX231XX_BOARD_PV_PLAYTV_USB_HYBRID:
                 case CX231XX_BOARD_HAUPPAUGE_USB2_FM_PAL:
                 case CX231XX_BOARD_HAUPPAUGE_USB2_FM_NTSC:
@@ -1379,6 +1381,7 @@ int cx231xx_dev_init(struct cx231xx *dev)
         case CX231XX_BOARD_CNXT_RDE_253S:
         case CX231XX_BOARD_CNXT_RDU_253S:
         case CX231XX_BOARD_HAUPPAUGE_EXETER:
+        case CX231XX_BOARD_HAUPPAUGE_930C_HD_1113xx:
         case CX231XX_BOARD_PV_PLAYTV_USB_HYBRID:
         case CX231XX_BOARD_HAUPPAUGE_USB2_FM_PAL:
         case CX231XX_BOARD_HAUPPAUGE_USB2_FM_NTSC:
diff --git a/drivers/media/usb/cx231xx/cx231xx-dvb.c b/drivers/media/usb/cx231xx/cx231xx-dvb.c
index 4504bc6a700b..1fa79741d199 100644
--- a/drivers/media/usb/cx231xx/cx231xx-dvb.c
+++ b/drivers/media/usb/cx231xx/cx231xx-dvb.c
@@ -32,7 +32,9 @@
 #include "tda18271.h"
 #include "s5h1411.h"
 #include "lgdt3305.h"
+#include "si2165.h"
 #include "mb86a20s.h"
+#include "si2157.h"
 
 MODULE_DESCRIPTION("driver for cx231xx based DVB cards");
 MODULE_AUTHOR("Srinivasa Deevi <srinivasa.deevi@conexant.com>");
@@ -67,6 +69,7 @@ struct cx231xx_dvb {
         struct dmx_frontend fe_hw;
         struct dmx_frontend fe_mem;
         struct dvb_net net;
+        struct i2c_client *i2c_client_tuner;
 };
 
 static struct s5h1432_config dvico_s5h1432_config = {
@@ -151,6 +154,18 @@ static struct tda18271_config pv_tda18271_config = {
         .small_i2c = TDA18271_03_BYTE_CHUNK_INIT,
 };
 
+static const struct si2165_config hauppauge_930C_HD_1113xx_si2165_config = {
+        .i2c_addr       = 0x64,
+        .chip_mode      = SI2165_MODE_PLL_XTAL,
+        .ref_freq_Hz    = 16000000,
+};
+
+static const struct si2165_config pctv_quatro_stick_1114xx_si2165_config = {
+        .i2c_addr       = 0x64,
+        .chip_mode      = SI2165_MODE_PLL_EXT,
+        .ref_freq_Hz    = 24000000,
+};
+
 static inline void print_err_status(struct cx231xx *dev, int packet, int status)
 {
         char *errmsg = "Unknown";
@@ -549,11 +564,18 @@ fail_adapter:
 
 static void unregister_dvb(struct cx231xx_dvb *dvb)
 {
+        struct i2c_client *client;
         dvb_net_release(&dvb->net);
         dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_mem);
         dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_hw);
         dvb_dmxdev_release(&dvb->dmxdev);
         dvb_dmx_release(&dvb->demux);
+        client = dvb->i2c_client_tuner;
+        /* remove I2C tuner */
+        if (client) {
+                module_put(client->dev.driver->owner);
+                i2c_unregister_device(client);
+        }
         dvb_unregister_frontend(dvb->frontend);
         dvb_frontend_detach(dvb->frontend);
         dvb_unregister_adapter(&dvb->adapter);
@@ -704,6 +726,89 @@ static int dvb_init(struct cx231xx *dev)
                            &hcw_tda18271_config);
                 break;
 
+        case CX231XX_BOARD_HAUPPAUGE_930C_HD_1113xx:
+
+                dev->dvb->frontend = dvb_attach(si2165_attach,
+                        &hauppauge_930C_HD_1113xx_si2165_config,
+                        &dev->i2c_bus[dev->board.tuner_i2c_master].i2c_adap
+                        );
+
+                if (dev->dvb->frontend == NULL) {
+                        printk(DRIVER_NAME
+                               ": Failed to attach SI2165 front end\n");
+                        result = -EINVAL;
+                        goto out_free;
+                }
+
+                dev->dvb->frontend->ops.i2c_gate_ctrl = 0;
+
+                /* define general-purpose callback pointer */
+                dvb->frontend->callback = cx231xx_tuner_callback;
+
+                dvb_attach(tda18271_attach, dev->dvb->frontend,
+                        0x60,
+                        &dev->i2c_bus[dev->board.tuner_i2c_master].i2c_adap,
+                        &hcw_tda18271_config);
+
+                dev->cx231xx_reset_analog_tuner = NULL;
+                break;
+
+        case CX231XX_BOARD_HAUPPAUGE_930C_HD_1114xx:
+        {
+                struct i2c_client *client;
+                struct i2c_board_info info;
+                struct si2157_config si2157_config;
+
+                memset(&info, 0, sizeof(struct i2c_board_info));
+
+                dev->dvb->frontend = dvb_attach(si2165_attach,
+                        &pctv_quatro_stick_1114xx_si2165_config,
+                        &dev->i2c_bus[dev->board.tuner_i2c_master].i2c_adap
+                        );
+
+                if (dev->dvb->frontend == NULL) {
+                        printk(DRIVER_NAME
+                               ": Failed to attach SI2165 front end\n");
+                        result = -EINVAL;
+                        goto out_free;
+                }
+
+                dev->dvb->frontend->ops.i2c_gate_ctrl = 0;
+
+                /* define general-purpose callback pointer */
+                dvb->frontend->callback = cx231xx_tuner_callback;
+
+                /* attach tuner */
+                memset(&si2157_config, 0, sizeof(si2157_config));
+                si2157_config.fe = dev->dvb->frontend;
+                si2157_config.inversion = true;
+                strlcpy(info.type, "si2157", I2C_NAME_SIZE);
+                info.addr = 0x60;
+                info.platform_data = &si2157_config;
+                request_module("si2157");
+
+                client = i2c_new_device(
+                        &dev->i2c_bus[dev->board.tuner_i2c_master].i2c_adap,
+                        &info);
+                if (client == NULL || client->dev.driver == NULL) {
+                        dvb_frontend_detach(dev->dvb->frontend);
+                        result = -ENODEV;
+                        goto out_free;
+                }
+
+                if (!try_module_get(client->dev.driver->owner)) {
+                        i2c_unregister_device(client);
+                        dvb_frontend_detach(dev->dvb->frontend);
+                        result = -ENODEV;
+                        goto out_free;
+                }
+
+                dev->cx231xx_reset_analog_tuner = NULL;
+
+                dev->dvb->i2c_client_tuner = client;
+                break;
+        }
+
         case CX231XX_BOARD_PV_PLAYTV_USB_HYBRID:
         case CX231XX_BOARD_KWORLD_UB430_USB_HYBRID:
 
diff --git a/drivers/media/usb/cx231xx/cx231xx-input.c b/drivers/media/usb/cx231xx/cx231xx-input.c
index 46d52fac8680..05f0434919d4 100644
--- a/drivers/media/usb/cx231xx/cx231xx-input.c
+++ b/drivers/media/usb/cx231xx/cx231xx-input.c
@@ -21,11 +21,12 @@
 #include "cx231xx.h"
 #include <linux/usb.h>
 #include <linux/slab.h>
+#include <linux/bitrev.h>
 
 #define MODULE_NAME "cx231xx-input"
 
-static int get_key_isdbt(struct IR_i2c *ir, u32 *ir_key,
-                         u32 *ir_raw)
+static int get_key_isdbt(struct IR_i2c *ir, enum rc_type *protocol,
+                         u32 *pscancode, u8 *toggle)
 {
         int     rc;
         u8      cmd, scancode;
@@ -46,21 +47,14 @@ static int get_key_isdbt(struct IR_i2c *ir, u32 *ir_key,
         if (cmd == 0xff)
                 return 0;
 
-        scancode =
-                 ((cmd & 0x01) ? 0x80 : 0) |
-                 ((cmd & 0x02) ? 0x40 : 0) |
-                 ((cmd & 0x04) ? 0x20 : 0) |
-                 ((cmd & 0x08) ? 0x10 : 0) |
-                 ((cmd & 0x10) ? 0x08 : 0) |
-                 ((cmd & 0x20) ? 0x04 : 0) |
-                 ((cmd & 0x40) ? 0x02 : 0) |
-                 ((cmd & 0x80) ? 0x01 : 0);
+        scancode = bitrev8(cmd);
 
         dev_dbg(&ir->rc->input_dev->dev, "cmd %02x, scan = %02x\n",
                 cmd, scancode);
 
-        *ir_key = scancode;
-        *ir_raw = scancode;
+        *protocol = RC_TYPE_OTHER;
+        *pscancode = scancode;
+        *toggle = 0;
         return 1;
 }
 
@@ -97,7 +91,7 @@ int cx231xx_ir_init(struct cx231xx *dev)
         dev->init_data.get_key = get_key_isdbt;
         dev->init_data.ir_codes = cx231xx_boards[dev->model].rc_map_name;
         /* The i2c micro-controller only outputs the cmd part of NEC protocol */
-        dev->init_data.rc_dev->scanmask = 0xff;
+        dev->init_data.rc_dev->scancode_mask = 0xff;
         dev->init_data.rc_dev->driver_name = "cx231xx";
         dev->init_data.type = RC_BIT_NEC;
         info.addr = 0x30;
diff --git a/drivers/media/usb/cx231xx/cx231xx-pcb-cfg.c b/drivers/media/usb/cx231xx/cx231xx-pcb-cfg.c
index 2a34ceee4802..3052c4c20229 100644
--- a/drivers/media/usb/cx231xx/cx231xx-pcb-cfg.c
+++ b/drivers/media/usb/cx231xx/cx231xx-pcb-cfg.c
@@ -654,8 +654,9 @@ static struct pcb_config cx231xx_Scenario[] = {
 
 /*****************************************************************/
 
-u32 initialize_cx231xx(struct cx231xx *dev)
+int initialize_cx231xx(struct cx231xx *dev)
 {
+        int retval;
         u32 config_info = 0;
         struct pcb_config *p_pcb_info;
         u8 usb_speed = 1;       /* from register,1--HS, 0--FS  */
@@ -670,7 +671,10 @@ u32 initialize_cx231xx(struct cx231xx *dev)
 
         /* read board config register to find out which
         pcb config it is related to */
-        cx231xx_read_ctrl_reg(dev, VRT_GET_REGISTER, BOARD_CFG_STAT, data, 4);
+        retval = cx231xx_read_ctrl_reg(dev, VRT_GET_REGISTER, BOARD_CFG_STAT,
+                                       data, 4);
+        if (retval < 0)
+                return retval;
 
         config_info = le32_to_cpu(*((__le32 *)data));
         usb_speed = (u8) (config_info & 0x1);
@@ -767,7 +771,7 @@ u32 initialize_cx231xx(struct cx231xx *dev)
                         cx231xx_info("bad senario!!!!!\n");
                         cx231xx_info("config_info=%x\n",
                                      (config_info & SELFPOWER_MASK));
-                        return 1;
+                        return -ENODEV;
                 }
         }
 
diff --git a/drivers/media/usb/cx231xx/cx231xx-pcb-cfg.h b/drivers/media/usb/cx231xx/cx231xx-pcb-cfg.h
index b3c6190e0c69..4511dc5d199c 100644
--- a/drivers/media/usb/cx231xx/cx231xx-pcb-cfg.h
+++ b/drivers/media/usb/cx231xx/cx231xx-pcb-cfg.h
@@ -221,6 +221,6 @@ enum INDEX_PCB_CONFIG{
 /***************************************************************************/
 struct cx231xx;
 
-u32 initialize_cx231xx(struct cx231xx *p_dev);
+int initialize_cx231xx(struct cx231xx *p_dev);
 
 #endif
diff --git a/drivers/media/usb/cx231xx/cx231xx-video.c b/drivers/media/usb/cx231xx/cx231xx-video.c
index 1f8751379e24..3b3ada6562ca 100644
--- a/drivers/media/usb/cx231xx/cx231xx-video.c
+++ b/drivers/media/usb/cx231xx/cx231xx-video.c
@@ -208,7 +208,7 @@ static inline void get_next_buf(struct cx231xx_dmaqueue *dma_q,
 static inline int cx231xx_isoc_copy(struct cx231xx *dev, struct urb *urb)
 {
         struct cx231xx_dmaqueue *dma_q = urb->context;
-        int i, rc = 1;
+        int i;
         unsigned char *p_buffer;
         u32 bytes_parsed = 0, buffer_size = 0;
         u8 sav_eav = 0;
@@ -299,13 +299,12 @@ static inline int cx231xx_isoc_copy(struct cx231xx *dev, struct urb *urb)
                 bytes_parsed = 0;
 
         }
-        return rc;
+        return 1;
 }
 
 static inline int cx231xx_bulk_copy(struct cx231xx *dev, struct urb *urb)
 {
         struct cx231xx_dmaqueue *dma_q = urb->context;
-        int rc = 1;
         unsigned char *p_buffer;
         u32 bytes_parsed = 0, buffer_size = 0;
         u8 sav_eav = 0;
@@ -379,7 +378,7 @@ static inline int cx231xx_bulk_copy(struct cx231xx *dev, struct urb *urb)
                 bytes_parsed = 0;
 
         }
-        return rc;
+        return 1;
 }
 
 
@@ -886,7 +885,6 @@ static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
         f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
 
         f->fmt.pix.field = V4L2_FIELD_INTERLACED;
-        f->fmt.pix.priv = 0;
 
         return 0;
 }
@@ -931,7 +929,6 @@ static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
         f->fmt.pix.sizeimage = f->fmt.pix.bytesperline * height;
         f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
         f->fmt.pix.field = V4L2_FIELD_INTERLACED;
-        f->fmt.pix.priv = 0;
 
         return 0;
 }
@@ -1620,7 +1617,7 @@ static int radio_s_tuner(struct file *file, void *priv, const struct v4l2_tuner
  */
 static int cx231xx_v4l2_open(struct file *filp)
 {
-        int errCode = 0, radio = 0;
+        int radio = 0;
         struct video_device *vdev = video_devdata(filp);
         struct cx231xx *dev = video_drvdata(filp);
         struct cx231xx_fh *fh;
@@ -1718,7 +1715,7 @@ static int cx231xx_v4l2_open(struct file *filp)
         mutex_unlock(&dev->lock);
         v4l2_fh_add(&fh->fh);
 
-        return errCode;
+        return 0;
 }
 
 /*
@@ -2066,7 +2063,6 @@ static struct video_device *cx231xx_vdev_init(struct cx231xx *dev,
         vfd->release = video_device_release;
         vfd->debug = video_debug;
         vfd->lock = &dev->lock;
-        set_bit(V4L2_FL_USE_FH_PRIO, &vfd->flags);
 
         snprintf(vfd->name, sizeof(vfd->name), "%s %s", dev->name, type_name);
 
diff --git a/drivers/media/usb/cx231xx/cx231xx.h b/drivers/media/usb/cx231xx/cx231xx.h
index babca7fb85e2..aeb1bf42b88d 100644
--- a/drivers/media/usb/cx231xx/cx231xx.h
+++ b/drivers/media/usb/cx231xx/cx231xx.h
@@ -73,6 +73,8 @@
 #define CX231XX_BOARD_ELGATO_VIDEO_CAPTURE_V2 16
 #define CX231XX_BOARD_OTG102 17
 #define CX231XX_BOARD_KWORLD_UB445_USB_HYBRID 18
+#define CX231XX_BOARD_HAUPPAUGE_930C_HD_1113xx 19
+#define CX231XX_BOARD_HAUPPAUGE_930C_HD_1114xx 20
 
 /* Limits minimum and default number of buffers */
 #define CX231XX_MIN_BUF                 4
diff --git a/drivers/media/usb/dvb-usb-v2/Kconfig b/drivers/media/usb/dvb-usb-v2/Kconfig
index 037e519bbaa2..66645b02c854 100644
--- a/drivers/media/usb/dvb-usb-v2/Kconfig
+++ b/drivers/media/usb/dvb-usb-v2/Kconfig
@@ -129,6 +129,7 @@ config DVB_USB_RTL28XXU
         depends on DVB_USB_V2 && I2C_MUX
         select DVB_RTL2830
         select DVB_RTL2832
+        select DVB_RTL2832_SDR if (MEDIA_SUBDRV_AUTOSELECT && MEDIA_SDR_SUPPORT)
         select MEDIA_TUNER_QT1010 if MEDIA_SUBDRV_AUTOSELECT
         select MEDIA_TUNER_MT2060 if MEDIA_SUBDRV_AUTOSELECT
         select MEDIA_TUNER_MXL5005S if MEDIA_SUBDRV_AUTOSELECT
diff --git a/drivers/media/usb/dvb-usb-v2/af9015.c b/drivers/media/usb/dvb-usb-v2/af9015.c
index da47d2392f2a..5ca738ab44e0 100644
--- a/drivers/media/usb/dvb-usb-v2/af9015.c
+++ b/drivers/media/usb/dvb-usb-v2/af9015.c
@@ -1213,7 +1213,7 @@ static int af9015_rc_query(struct dvb_usb_device *d)
         if ((state->rc_repeat != buf[6] || buf[0]) &&
                         !memcmp(&buf[12], state->rc_last, 4)) {
                 dev_dbg(&d->udev->dev, "%s: key repeated\n", __func__);
-                rc_keydown(d->rc_dev, state->rc_keycode, 0);
+                rc_repeat(d->rc_dev);
                 state->rc_repeat = buf[6];
                 return ret;
         }
@@ -1233,18 +1233,22 @@ static int af9015_rc_query(struct dvb_usb_device *d)
                 if (buf[14] == (u8) ~buf[15]) {
                         if (buf[12] == (u8) ~buf[13]) {
                                 /* NEC */
-                                state->rc_keycode = buf[12] << 8 | buf[14];
+                                state->rc_keycode = RC_SCANCODE_NEC(buf[12],
+                                                                    buf[14]);
                         } else {
                                 /* NEC extended*/
-                                state->rc_keycode = buf[12] << 16 |
-                                        buf[13] << 8 | buf[14];
+                                state->rc_keycode = RC_SCANCODE_NECX(buf[12] << 8 |
+                                                                     buf[13],
+                                                                     buf[14]);
                         }
                 } else {
                         /* 32 bit NEC */
-                        state->rc_keycode = buf[12] << 24 | buf[13] << 16 |
-                                        buf[14] << 8 | buf[15];
+                        state->rc_keycode = RC_SCANCODE_NEC32(buf[12] << 24 |
+                                                              buf[13] << 16 |
+                                                              buf[14] << 8  |
+                                                              buf[15]);
                 }
-                rc_keydown(d->rc_dev, state->rc_keycode, 0);
+                rc_keydown(d->rc_dev, RC_TYPE_NEC, state->rc_keycode, 0);
         } else {
                 dev_dbg(&d->udev->dev, "%s: no key press\n", __func__);
                 /* Invalidate last keypress */
diff --git a/drivers/media/usb/dvb-usb-v2/af9035.c b/drivers/media/usb/dvb-usb-v2/af9035.c
index 7b9b75f60774..75ec1c659fdd 100644
--- a/drivers/media/usb/dvb-usb-v2/af9035.c
+++ b/drivers/media/usb/dvb-usb-v2/af9035.c
@@ -799,6 +799,25 @@ static int af9035_read_config(struct dvb_usb_device *d)
                 addr += 0x10; /* shift for the 2nd tuner params */
         }
 
+        /*
+         * These AVerMedia devices has a bad EEPROM content :-(
+         * Override some wrong values here.
+         */
+        if (le16_to_cpu(d->udev->descriptor.idVendor) == USB_VID_AVERMEDIA) {
+                switch (le16_to_cpu(d->udev->descriptor.idProduct)) {
+                case USB_PID_AVERMEDIA_A835B_1835:
+                case USB_PID_AVERMEDIA_A835B_2835:
+                case USB_PID_AVERMEDIA_A835B_3835:
+                        dev_info(&d->udev->dev,
+                                 "%s: overriding tuner from %02x to %02x\n",
+                                 KBUILD_MODNAME, state->af9033_config[0].tuner,
+                                 AF9033_TUNER_IT9135_60);
+
+                        state->af9033_config[0].tuner = AF9033_TUNER_IT9135_60;
+                        break;
+                }
+        }
+
 skip_eeprom:
         /* get demod clock */
         ret = af9035_rd_reg(d, 0x00d800, &tmp);
@@ -1313,19 +1332,20 @@ static int af9035_rc_query(struct dvb_usb_device *d)
         if ((buf[2] + buf[3]) == 0xff) {
                 if ((buf[0] + buf[1]) == 0xff) {
                         /* NEC standard 16bit */
-                        key = buf[0] << 8 | buf[2];
+                        key = RC_SCANCODE_NEC(buf[0], buf[2]);
                 } else {
                         /* NEC extended 24bit */
-                        key = buf[0] << 16 | buf[1] << 8 | buf[2];
+                        key = RC_SCANCODE_NECX(buf[0] << 8 | buf[1], buf[2]);
                 }
         } else {
                 /* NEC full code 32bit */
-                key = buf[0] << 24 | buf[1] << 16 | buf[2] << 8 | buf[3];
+                key = RC_SCANCODE_NEC32(buf[0] << 24 | buf[1] << 16 |
+                                        buf[2] << 8  | buf[3]);
         }
 
         dev_dbg(&d->udev->dev, "%s: %*ph\n", __func__, 4, buf);
 
-        rc_keydown(d->rc_dev, key, 0);
+        rc_keydown(d->rc_dev, RC_TYPE_NEC, key, 0);
 
         return 0;
 
diff --git a/drivers/media/usb/dvb-usb-v2/anysee.c b/drivers/media/usb/dvb-usb-v2/anysee.c
index eeab79bdd2aa..e4a2382196f0 100644
--- a/drivers/media/usb/dvb-usb-v2/anysee.c
+++ b/drivers/media/usb/dvb-usb-v2/anysee.c
@@ -1038,7 +1038,8 @@ static int anysee_rc_query(struct dvb_usb_device *d)
         if (ircode[0]) {
                 dev_dbg(&d->udev->dev, "%s: key pressed %02x\n", __func__,
                                 ircode[1]);
-                rc_keydown(d->rc_dev, 0x08 << 8 | ircode[1], 0);
+                rc_keydown(d->rc_dev, RC_TYPE_NEC,
+                           RC_SCANCODE_NEC(0x08, ircode[1]), 0);
         }
 
         return 0;
diff --git a/drivers/media/usb/dvb-usb-v2/az6007.c b/drivers/media/usb/dvb-usb-v2/az6007.c
index c3c4b98733bf..935dbaa80ef0 100644
--- a/drivers/media/usb/dvb-usb-v2/az6007.c
+++ b/drivers/media/usb/dvb-usb-v2/az6007.c
@@ -207,24 +207,27 @@ static int az6007_streaming_ctrl(struct dvb_frontend *fe, int onoff)
 static int az6007_rc_query(struct dvb_usb_device *d)
 {
         struct az6007_device_state *st = d_to_priv(d);
-        unsigned code = 0;
+        unsigned code;
 
         az6007_read(d, AZ6007_READ_IR, 0, 0, st->data, 10);
 
         if (st->data[1] == 0x44)
                 return 0;
 
-        if ((st->data[1] ^ st->data[2]) == 0xff)
-                code = st->data[1];
-        else
-                code = st->data[1] << 8 | st->data[2];
-
-        if ((st->data[3] ^ st->data[4]) == 0xff)
-                code = code << 8 | st->data[3];
-        else
-                code = code << 16 | st->data[3] << 8 | st->data[4];
+        if ((st->data[3] ^ st->data[4]) == 0xff) {
+                if ((st->data[1] ^ st->data[2]) == 0xff)
+                        code = RC_SCANCODE_NEC(st->data[1], st->data[3]);
+                else
+                        code = RC_SCANCODE_NECX(st->data[1] << 8 | st->data[2],
+                                                st->data[3]);
+        } else {
+                code = RC_SCANCODE_NEC32(st->data[1] << 24 |
+                                         st->data[2] << 16 |
+                                         st->data[3] << 8  |
+                                         st->data[4]);
+        }
 
-        rc_keydown(d->rc_dev, code, st->data[5]);
+        rc_keydown(d->rc_dev, RC_TYPE_NEC, code, st->data[5]);
 
         return 0;
 }
diff --git a/drivers/media/usb/dvb-usb-v2/dvb_usb_core.c b/drivers/media/usb/dvb-usb-v2/dvb_usb_core.c
index f296394bb7c5..2e90310be2af 100644
--- a/drivers/media/usb/dvb-usb-v2/dvb_usb_core.c
+++ b/drivers/media/usb/dvb-usb-v2/dvb_usb_core.c
@@ -164,7 +164,7 @@ static int dvb_usbv2_remote_init(struct dvb_usb_device *d)
         dev->driver_name = (char *) d->props->driver_name;
         dev->map_name = d->rc.map_name;
         dev->driver_type = d->rc.driver_type;
-        rc_set_allowed_protocols(dev, d->rc.allowed_protos);
+        dev->allowed_protocols = d->rc.allowed_protos;
         dev->change_protocol = d->rc.change_protocol;
         dev->priv = d;
 
diff --git a/drivers/media/usb/dvb-usb-v2/lmedm04.c b/drivers/media/usb/dvb-usb-v2/lmedm04.c
index f674dc024d06..e332af731187 100644
--- a/drivers/media/usb/dvb-usb-v2/lmedm04.c
+++ b/drivers/media/usb/dvb-usb-v2/lmedm04.c
@@ -125,14 +125,13 @@ DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
 #define TUNER_RS2000    0x4
 
 struct lme2510_state {
+        unsigned long int_urb_due;
         u8 id;
         u8 tuner_config;
         u8 signal_lock;
         u8 signal_level;
         u8 signal_sn;
         u8 time_key;
-        u8 last_key;
-        u8 key_timeout;
         u8 i2c_talk_onoff;
         u8 i2c_gate;
         u8 i2c_tuner_gate_w;
@@ -287,14 +286,13 @@ static void lme2510_int_response(struct urb *lme_urb)
                 case 0xaa:
                         debug_data_snipet(1, "INT Remote data snipet", ibuf);
                         if ((ibuf[4] + ibuf[5]) == 0xff) {
-                                key = ibuf[5];
-                                key += (ibuf[3] > 0)
-                                        ? (ibuf[3] ^ 0xff) << 8 : 0;
-                                key += (ibuf[2] ^ 0xff) << 16;
+                                key = RC_SCANCODE_NECX((ibuf[2] ^ 0xff) << 8 |
+                                                       (ibuf[3] > 0) ? (ibuf[3] ^ 0xff) : 0,
+                                                       ibuf[5]);
                                 deb_info(1, "INT Key =%08x", key);
                                 if (adap_to_d(adap)->rc_dev != NULL)
                                         rc_keydown(adap_to_d(adap)->rc_dev,
-                                                key, 0);
+                                                   RC_TYPE_NEC, key, 0);
                         }
                         break;
                 case 0xbb:
@@ -323,7 +321,7 @@ static void lme2510_int_response(struct urb *lme_urb)
                                 }
                                 break;
                         case TUNER_RS2000:
-                                if (ibuf[1] == 0x3 &&  ibuf[6] == 0xff)
+                                if (ibuf[2] & 0x1)
                                         st->signal_lock = 0xff;
                                 else
                                         st->signal_lock = 0x00;
@@ -343,7 +341,12 @@ static void lme2510_int_response(struct urb *lme_urb)
                 break;
                 }
         }
+
         usb_submit_urb(lme_urb, GFP_ATOMIC);
+
+        /* interrupt urb is due every 48 msecs while streaming
+         *      add 12msecs for system lag */
+        st->int_urb_due = jiffies + msecs_to_jiffies(60);
 }
 
 static int lme2510_int_read(struct dvb_usb_adapter *adap)
@@ -584,14 +587,13 @@ static int lme2510_msg(struct dvb_usb_device *d,
                         switch (wbuf[3]) {
                         case 0x8c:
                                 rbuf[0] = 0x55;
-                                rbuf[1] = 0xff;
-                                if (st->last_key == st->time_key) {
-                                        st->key_timeout++;
-                                        if (st->key_timeout > 5)
-                                                rbuf[1] = 0;
-                                } else
-                                        st->key_timeout = 0;
-                                st->last_key = st->time_key;
+                                rbuf[1] = st->signal_lock;
+
+                                /* If int_urb_due overdue
+                                 *  set rbuf[1] to 0 to clear lock */
+                                if (time_after(jiffies, st->int_urb_due))
+                                        rbuf[1] = 0;
+
                                 break;
                         default:
                                 lme2510_usb_talk(d, wbuf, wlen, rbuf, rlen);
diff --git a/drivers/media/usb/dvb-usb-v2/mxl111sf.c b/drivers/media/usb/dvb-usb-v2/mxl111sf.c
index c7304fa8ab73..b8a707e57b99 100644
--- a/drivers/media/usb/dvb-usb-v2/mxl111sf.c
+++ b/drivers/media/usb/dvb-usb-v2/mxl111sf.c
@@ -129,7 +129,7 @@ int mxl111sf_write_reg_mask(struct mxl111sf_state *state,
                                    u8 addr, u8 mask, u8 data)
 {
         int ret;
-        u8 val;
+        u8 val = 0;
 
         if (mask != 0xff) {
                 ret = mxl111sf_read_reg(state, addr, &val);
diff --git a/drivers/media/usb/dvb-usb-v2/rtl28xxu.c b/drivers/media/usb/dvb-usb-v2/rtl28xxu.c
index a676e4452847..27b1e0397e71 100644
--- a/drivers/media/usb/dvb-usb-v2/rtl28xxu.c
+++ b/drivers/media/usb/dvb-usb-v2/rtl28xxu.c
@@ -1287,19 +1287,19 @@ static int rtl2831u_rc_query(struct dvb_usb_device *d)
                 if (buf[2] == (u8) ~buf[3]) {
                         if (buf[0] == (u8) ~buf[1]) {
                                 /* NEC standard (16 bit) */
-                                rc_code = buf[0] << 8 | buf[2];
+                                rc_code = RC_SCANCODE_NEC(buf[0], buf[2]);
                         } else {
                                 /* NEC extended (24 bit) */
-                                rc_code = buf[0] << 16 |
-                                                buf[1] << 8 | buf[2];
+                                rc_code = RC_SCANCODE_NECX(buf[0] << 8 | buf[1],
+                                                           buf[2]);
                         }
                 } else {
                         /* NEC full (32 bit) */
-                        rc_code = buf[0] << 24 | buf[1] << 16 |
-                                        buf[2] << 8 | buf[3];
+                        rc_code = RC_SCANCODE_NEC32(buf[0] << 24 | buf[1] << 16 |
+                                                    buf[2] << 8  | buf[3]);
                 }
 
-                rc_keydown(d->rc_dev, rc_code, 0);
+                rc_keydown(d->rc_dev, RC_TYPE_NEC, rc_code, 0);
 
                 ret = rtl28xx_wr_reg(d, SYS_IRRC_SR, 1);
                 if (ret)
@@ -1541,6 +1541,8 @@ static const struct usb_device_id rtl28xxu_id_table[] = {
                 &rtl2832u_props, "Peak DVB-T USB", NULL) },
         { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_SVEON_STV20_RTL2832U,
                 &rtl2832u_props, "Sveon STV20", NULL) },
+        { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_SVEON_STV21,
+                &rtl2832u_props, "Sveon STV21", NULL) },
         { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_SVEON_STV27,
                 &rtl2832u_props, "Sveon STV27", NULL) },
 
diff --git a/drivers/media/usb/dvb-usb/Kconfig b/drivers/media/usb/dvb-usb/Kconfig
index c5d95662e2e1..10aef2188fbe 100644
--- a/drivers/media/usb/dvb-usb/Kconfig
+++ b/drivers/media/usb/dvb-usb/Kconfig
@@ -117,10 +117,12 @@ config DVB_USB_CXUSB
         select DVB_TUNER_DIB0070 if MEDIA_SUBDRV_AUTOSELECT
         select DVB_ATBM8830 if MEDIA_SUBDRV_AUTOSELECT
         select DVB_LGS8GXX if MEDIA_SUBDRV_AUTOSELECT
+        select DVB_SI2168 if MEDIA_SUBDRV_AUTOSELECT
         select MEDIA_TUNER_SIMPLE if MEDIA_SUBDRV_AUTOSELECT
         select MEDIA_TUNER_XC2028 if MEDIA_SUBDRV_AUTOSELECT
         select MEDIA_TUNER_MXL5005S if MEDIA_SUBDRV_AUTOSELECT
         select MEDIA_TUNER_MAX2165 if MEDIA_SUBDRV_AUTOSELECT
+        select MEDIA_TUNER_SI2157 if MEDIA_SUBDRV_AUTOSELECT
         help
           Say Y here to support the Conexant USB2.0 hybrid reference design.
           Currently, only DVB and ATSC modes are supported, analog mode
@@ -128,6 +130,7 @@ config DVB_USB_CXUSB
 
           Medion MD95700 hybrid USB2.0 device.
           DViCO FusionHDTV (Bluebird) USB2.0 devices
+          TechnoTrend TVStick CT2-4400
 
 config DVB_USB_M920X
         tristate "Uli m920x DVB-T USB2.0 support"
diff --git a/drivers/media/usb/dvb-usb/cxusb.c b/drivers/media/usb/dvb-usb/cxusb.c
index a1c641e18362..16bc579d1404 100644
--- a/drivers/media/usb/dvb-usb/cxusb.c
+++ b/drivers/media/usb/dvb-usb/cxusb.c
@@ -42,9 +42,11 @@
 #include "dib0070.h"
 #include "lgs8gxx.h"
 #include "atbm8830.h"
+#include "si2168.h"
+#include "si2157.h"
 
 /* Max transfer size done by I2C transfer functions */
-#define MAX_XFER_SIZE  64
+#define MAX_XFER_SIZE  80
 
 /* debug */
 static int dvb_usb_cxusb_debug;
@@ -144,6 +146,22 @@ static int cxusb_d680_dmb_gpio_tuner(struct dvb_usb_device *d,
         }
 }
 
+static int cxusb_tt_ct2_4400_gpio_tuner(struct dvb_usb_device *d, int onoff)
+{
+        u8 o[2], i;
+        int rc;
+
+        o[0] = 0x83;
+        o[1] = onoff;
+        rc = cxusb_ctrl_msg(d, CMD_GPIO_WRITE, o, 2, &i, 1);
+
+        if (rc) {
+                deb_info("gpio_write failed.\n");
+                return -EIO;
+        }
+        return 0;
+}
+
 /* I2C */
 static int cxusb_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
                           int num)
@@ -505,6 +523,30 @@ static int cxusb_d680_dmb_rc_query(struct dvb_usb_device *d, u32 *event,
         return 0;
 }
 
+static int cxusb_tt_ct2_4400_rc_query(struct dvb_usb_device *d)
+{
+        u8 i[2];
+        int ret;
+        u32 cmd, keycode;
+        u8 rc5_cmd, rc5_addr, rc5_toggle;
+
+        ret = cxusb_ctrl_msg(d, 0x10, NULL, 0, i, 2);
+        if (ret)
+                return ret;
+
+        cmd = (i[0] << 8) | i[1];
+
+        if (cmd != 0xffff) {
+                rc5_cmd = cmd & 0x3F; /* bits 1-6 for command */
+                rc5_addr = (cmd & 0x07C0) >> 6; /* bits 7-11 for address */
+                rc5_toggle = (cmd & 0x0800) >> 11; /* bit 12 for toggle */
+                keycode = (rc5_addr << 8) | rc5_cmd;
+                rc_keydown(d->rc_dev, RC_BIT_RC5, keycode, rc5_toggle);
+        }
+
+        return 0;
+}
+
 static struct rc_map_table rc_map_dvico_mce_table[] = {
         { 0xfe02, KEY_TV },
         { 0xfe0e, KEY_MP3 },
@@ -1070,8 +1112,15 @@ static struct dib7000p_config cxusb_dualdig4_rev2_config = {
         .hostbus_diversity = 1,
 };
 
+struct dib0700_adapter_state {
+        int (*set_param_save)(struct dvb_frontend *);
+        struct dib7000p_ops dib7000p_ops;
+};
+
 static int cxusb_dualdig4_rev2_frontend_attach(struct dvb_usb_adapter *adap)
 {
+        struct dib0700_adapter_state *state = adap->priv;
+
         if (usb_set_interface(adap->dev->udev, 0, 1) < 0)
                 err("set interface failed");
 
@@ -1079,14 +1128,17 @@ static int cxusb_dualdig4_rev2_frontend_attach(struct dvb_usb_adapter *adap)
 
         cxusb_bluebird_gpio_pulse(adap->dev, 0x02, 1);
 
-        if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
-                                     &cxusb_dualdig4_rev2_config) < 0) {
+        if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
+                return -ENODEV;
+
+        if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
+                                       &cxusb_dualdig4_rev2_config) < 0) {
                 printk(KERN_WARNING "Unable to enumerate dib7000p\n");
                 return -ENODEV;
         }
 
-        adap->fe_adap[0].fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x80,
-                              &cxusb_dualdig4_rev2_config);
+        adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap, 0x80,
+                                              &cxusb_dualdig4_rev2_config);
         if (adap->fe_adap[0].fe == NULL)
                 return -EIO;
 
@@ -1095,7 +1147,10 @@ static int cxusb_dualdig4_rev2_frontend_attach(struct dvb_usb_adapter *adap)
 
 static int dib7070_tuner_reset(struct dvb_frontend *fe, int onoff)
 {
-        return dib7000p_set_gpio(fe, 8, 0, !onoff);
+        struct dvb_usb_adapter *adap = fe->dvb->priv;
+        struct dib0700_adapter_state *state = adap->priv;
+
+        return state->dib7000p_ops.set_gpio(fe, 8, 0, !onoff);
 }
 
 static int dib7070_tuner_sleep(struct dvb_frontend *fe, int onoff)
@@ -1110,10 +1165,6 @@ static struct dib0070_config dib7070p_dib0070_config = {
         .clock_khz = 12000,
 };
 
-struct dib0700_adapter_state {
-        int (*set_param_save) (struct dvb_frontend *);
-};
-
 static int dib7070_set_param_override(struct dvb_frontend *fe)
 {
         struct dtv_frontend_properties *p = &fe->dtv_property_cache;
@@ -1128,7 +1179,7 @@ static int dib7070_set_param_override(struct dvb_frontend *fe)
         case BAND_UHF: offset = 550; break;
         }
 
-        dib7000p_set_wbd_ref(fe, offset + dib0070_wbd_offset(fe));
+        state->dib7000p_ops.set_wbd_ref(fe, offset + dib0070_wbd_offset(fe));
 
         return state->set_param_save(fe);
 }
@@ -1136,8 +1187,14 @@ static int dib7070_set_param_override(struct dvb_frontend *fe)
 static int cxusb_dualdig4_rev2_tuner_attach(struct dvb_usb_adapter *adap)
 {
         struct dib0700_adapter_state *st = adap->priv;
-        struct i2c_adapter *tun_i2c =
-                dib7000p_get_i2c_master(adap->fe_adap[0].fe,
+        struct i2c_adapter *tun_i2c;
+
+        /*
+         * No need to call dvb7000p_attach here, as it was called
+         * already, as frontend_attach method is called first, and
+         * tuner_attach is only called on sucess.
+         */
+        tun_i2c = st->dib7000p_ops.get_i2c_master(adap->fe_adap[0].fe,
                                         DIBX000_I2C_INTERFACE_TUNER, 1);
 
         if (dvb_attach(dib0070_attach, adap->fe_adap[0].fe, tun_i2c,
@@ -1286,6 +1343,74 @@ static int cxusb_mygica_d689_frontend_attach(struct dvb_usb_adapter *adap)
         return 0;
 }
 
+static int cxusb_tt_ct2_4400_attach(struct dvb_usb_adapter *adap)
+{
+        struct dvb_usb_device *d = adap->dev;
+        struct cxusb_state *st = d->priv;
+        struct i2c_adapter *adapter;
+        struct i2c_client *client_demod;
+        struct i2c_client *client_tuner;
+        struct i2c_board_info info;
+        struct si2168_config si2168_config;
+        struct si2157_config si2157_config;
+
+        /* reset the tuner */
+        if (cxusb_tt_ct2_4400_gpio_tuner(d, 0) < 0) {
+                err("clear tuner gpio failed");
+                return -EIO;
+        }
+        msleep(100);
+        if (cxusb_tt_ct2_4400_gpio_tuner(d, 1) < 0) {
+                err("set tuner gpio failed");
+                return -EIO;
+        }
+        msleep(100);
+
+        /* attach frontend */
+        si2168_config.i2c_adapter = &adapter;
+        si2168_config.fe = &adap->fe_adap[0].fe;
+        memset(&info, 0, sizeof(struct i2c_board_info));
+        strlcpy(info.type, "si2168", I2C_NAME_SIZE);
+        info.addr = 0x64;
+        info.platform_data = &si2168_config;
+        request_module(info.type);
+        client_demod = i2c_new_device(&d->i2c_adap, &info);
+        if (client_demod == NULL || client_demod->dev.driver == NULL)
+                return -ENODEV;
+
+        if (!try_module_get(client_demod->dev.driver->owner)) {
+                i2c_unregister_device(client_demod);
+                return -ENODEV;
+        }
+
+        st->i2c_client_demod = client_demod;
+
+        /* attach tuner */
+        memset(&si2157_config, 0, sizeof(si2157_config));
+        si2157_config.fe = adap->fe_adap[0].fe;
+        memset(&info, 0, sizeof(struct i2c_board_info));
+        strlcpy(info.type, "si2157", I2C_NAME_SIZE);
+        info.addr = 0x60;
+        info.platform_data = &si2157_config;
+        request_module(info.type);
+        client_tuner = i2c_new_device(adapter, &info);
+        if (client_tuner == NULL || client_tuner->dev.driver == NULL) {
+                module_put(client_demod->dev.driver->owner);
+                i2c_unregister_device(client_demod);
+                return -ENODEV;
+        }
+        if (!try_module_get(client_tuner->dev.driver->owner)) {
+                i2c_unregister_device(client_tuner);
+                module_put(client_demod->dev.driver->owner);
+                i2c_unregister_device(client_demod);
+                return -ENODEV;
+        }
+
+        st->i2c_client_tuner = client_tuner;
+
+        return 0;
+}
+
 /*
  * DViCO has shipped two devices with the same USB ID, but only one of them
  * needs a firmware download.  Check the device class details to see if they
@@ -1367,6 +1492,7 @@ static struct dvb_usb_device_properties cxusb_bluebird_nano2_needsfirmware_prope
 static struct dvb_usb_device_properties cxusb_aver_a868r_properties;
 static struct dvb_usb_device_properties cxusb_d680_dmb_properties;
 static struct dvb_usb_device_properties cxusb_mygica_d689_properties;
+static struct dvb_usb_device_properties cxusb_tt_ct2_4400_properties;
 
 static int cxusb_probe(struct usb_interface *intf,
                        const struct usb_device_id *id)
@@ -1397,12 +1523,37 @@ static int cxusb_probe(struct usb_interface *intf,
                                      THIS_MODULE, NULL, adapter_nr) ||
             0 == dvb_usb_device_init(intf, &cxusb_mygica_d689_properties,
                                      THIS_MODULE, NULL, adapter_nr) ||
+            0 == dvb_usb_device_init(intf, &cxusb_tt_ct2_4400_properties,
+                                     THIS_MODULE, NULL, adapter_nr) ||
             0)
                 return 0;
 
         return -EINVAL;
 }
 
+static void cxusb_disconnect(struct usb_interface *intf)
+{
+        struct dvb_usb_device *d = usb_get_intfdata(intf);
+        struct cxusb_state *st = d->priv;
+        struct i2c_client *client;
+
+        /* remove I2C client for tuner */
+        client = st->i2c_client_tuner;
+        if (client) {
+                module_put(client->dev.driver->owner);
+                i2c_unregister_device(client);
+        }
+
+        /* remove I2C client for demodulator */
+        client = st->i2c_client_demod;
+        if (client) {
+                module_put(client->dev.driver->owner);
+                i2c_unregister_device(client);
+        }
+
+        dvb_usb_device_exit(intf);
+}
+
 static struct usb_device_id cxusb_table [] = {
         { USB_DEVICE(USB_VID_MEDION, USB_PID_MEDION_MD95700) },
         { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_LG064F_COLD) },
@@ -1424,6 +1575,7 @@ static struct usb_device_id cxusb_table [] = {
         { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_4_REV_2) },
         { USB_DEVICE(USB_VID_CONEXANT, USB_PID_CONEXANT_D680_DMB) },
         { USB_DEVICE(USB_VID_CONEXANT, USB_PID_MYGICA_D689) },
+        { USB_DEVICE(USB_VID_TECHNOTREND, USB_PID_TECHNOTREND_TVSTICK_CT2_4400) },
         {}              /* Terminating entry */
 };
 MODULE_DEVICE_TABLE (usb, cxusb_table);
@@ -2070,10 +2222,63 @@ static struct dvb_usb_device_properties cxusb_mygica_d689_properties = {
         }
 };
 
+static struct dvb_usb_device_properties cxusb_tt_ct2_4400_properties = {
+        .caps = DVB_USB_IS_AN_I2C_ADAPTER,
+
+        .usb_ctrl         = CYPRESS_FX2,
+
+        .size_of_priv     = sizeof(struct cxusb_state),
+
+        .num_adapters = 1,
+        .adapter = {
+                {
+                .num_frontends = 1,
+                .fe = {{
+                        .streaming_ctrl   = cxusb_streaming_ctrl,
+                        /* both frontend and tuner attached in the
+                           same function */
+                        .frontend_attach  = cxusb_tt_ct2_4400_attach,
+
+                        /* parameter for the MPEG2-data transfer */
+                        .stream = {
+                                .type = USB_BULK,
+                                .count = 8,
+                                .endpoint = 0x82,
+                                .u = {
+                                        .bulk = {
+                                                .buffersize = 4096,
+                                        }
+                                }
+                        },
+                } },
+                },
+        },
+
+        .i2c_algo = &cxusb_i2c_algo,
+        .generic_bulk_ctrl_endpoint = 0x01,
+        .generic_bulk_ctrl_endpoint_response = 0x81,
+
+        .rc.core = {
+                .rc_codes       = RC_MAP_TT_1500,
+                .allowed_protos = RC_BIT_RC5,
+                .rc_query       = cxusb_tt_ct2_4400_rc_query,
+                .rc_interval    = 150,
+        },
+
+        .num_device_descs = 1,
+        .devices = {
+                {
+                        "TechnoTrend TVStick CT2-4400",
+                        { NULL },
+                        { &cxusb_table[20], NULL },
+                },
+        }
+};
+
 static struct usb_driver cxusb_driver = {
         .name           = "dvb_usb_cxusb",
         .probe          = cxusb_probe,
-        .disconnect     = dvb_usb_device_exit,
+        .disconnect     = cxusb_disconnect,
         .id_table       = cxusb_table,
 };
 
diff --git a/drivers/media/usb/dvb-usb/cxusb.h b/drivers/media/usb/dvb-usb/cxusb.h
index 1a51eafd31b9..527ff7905e15 100644
--- a/drivers/media/usb/dvb-usb/cxusb.h
+++ b/drivers/media/usb/dvb-usb/cxusb.h
@@ -30,6 +30,8 @@
 
 struct cxusb_state {
         u8 gpio_write_state[3];
+        struct i2c_client *i2c_client_demod;
+        struct i2c_client *i2c_client_tuner;
 };
 
 #endif
diff --git a/drivers/media/usb/dvb-usb/dib0700_core.c b/drivers/media/usb/dvb-usb/dib0700_core.c
index c14285fa8271..50856dbf5496 100644
--- a/drivers/media/usb/dvb-usb/dib0700_core.c
+++ b/drivers/media/usb/dvb-usb/dib0700_core.c
@@ -658,13 +658,8 @@ out:
 struct dib0700_rc_response {
         u8 report_id;
         u8 data_state;
-        union {
-                u16 system16;
-                struct {
-                        u8 not_system;
-                        u8 system;
-                };
-        };
+        u8 system;
+        u8 not_system;
         u8 data;
         u8 not_data;
 };
@@ -674,6 +669,7 @@ static void dib0700_rc_urb_completion(struct urb *purb)
 {
         struct dvb_usb_device *d = purb->context;
         struct dib0700_rc_response *poll_reply;
+        enum rc_type protocol;
         u32 uninitialized_var(keycode);
         u8 toggle;
 
@@ -707,44 +703,55 @@ static void dib0700_rc_urb_completion(struct urb *purb)
 
         switch (d->props.rc.core.protocol) {
         case RC_BIT_NEC:
+                protocol = RC_TYPE_NEC;
                 toggle = 0;
 
                 /* NEC protocol sends repeat code as 0 0 0 FF */
-                if ((poll_reply->system == 0x00) && (poll_reply->data == 0x00)
-                    && (poll_reply->not_data == 0xff)) {
+                if (poll_reply->system     == 0x00 &&
+                    poll_reply->not_system == 0x00 &&
+                    poll_reply->data       == 0x00 &&
+                    poll_reply->not_data   == 0xff) {
                         poll_reply->data_state = 2;
                         break;
                 }
 
-                if ((poll_reply->system ^ poll_reply->not_system) != 0xff) {
+                if ((poll_reply->data ^ poll_reply->not_data) != 0xff) {
+                        deb_data("NEC32 protocol\n");
+                        keycode = RC_SCANCODE_NEC32(poll_reply->system     << 24 |
+                                                     poll_reply->not_system << 16 |
+                                                     poll_reply->data       << 8  |
+                                                     poll_reply->not_data);
+                } else if ((poll_reply->system ^ poll_reply->not_system) != 0xff) {
                         deb_data("NEC extended protocol\n");
-                        /* NEC extended code - 24 bits */
-                        keycode = be16_to_cpu(poll_reply->system16) << 8 | poll_reply->data;
+                        keycode = RC_SCANCODE_NECX(poll_reply->system << 8 |
+                                                    poll_reply->not_system,
+                                                    poll_reply->data);
+
                 } else {
                         deb_data("NEC normal protocol\n");
-                        /* normal NEC code - 16 bits */
-                        keycode = poll_reply->system << 8 | poll_reply->data;
+                        keycode = RC_SCANCODE_NEC(poll_reply->system,
+                                                   poll_reply->data);
                 }
 
                 break;
         default:
                 deb_data("RC5 protocol\n");
-                /* RC5 Protocol */
+                protocol = RC_TYPE_RC5;
                 toggle = poll_reply->report_id;
-                keycode = poll_reply->system << 8 | poll_reply->data;
+                keycode = RC_SCANCODE_RC5(poll_reply->system, poll_reply->data);
 
                 break;
         }
 
         if ((poll_reply->data + poll_reply->not_data) != 0xff) {
                 /* Key failed integrity check */
-                err("key failed integrity check: %04x %02x %02x",
-                    poll_reply->system,
+                err("key failed integrity check: %02x %02x %02x %02x",
+                    poll_reply->system,  poll_reply->not_system,
                     poll_reply->data, poll_reply->not_data);
                 goto resubmit;
         }
 
-        rc_keydown(d->rc_dev, keycode, toggle);
+        rc_keydown(d->rc_dev, protocol, keycode, toggle);
 
 resubmit:
         /* Clean the buffer before we requeue */
diff --git a/drivers/media/usb/dvb-usb/dib0700_devices.c b/drivers/media/usb/dvb-usb/dib0700_devices.c
index 10e0db8d1850..ce47d3f1c850 100644
--- a/drivers/media/usb/dvb-usb/dib0700_devices.c
+++ b/drivers/media/usb/dvb-usb/dib0700_devices.c
@@ -32,6 +32,8 @@ MODULE_PARM_DESC(force_lna_activation, "force the activation of Low-Noise-Amplif
 struct dib0700_adapter_state {
         int (*set_param_save) (struct dvb_frontend *);
         const struct firmware *frontend_firmware;
+        struct dib7000p_ops dib7000p_ops;
+        struct dib8000_ops dib8000_ops;
 };
 
 /* Hauppauge Nova-T 500 (aka Bristol)
@@ -262,6 +264,11 @@ static struct mt2266_config stk7700d_mt2266_config[2] = {
 
 static int stk7700P2_frontend_attach(struct dvb_usb_adapter *adap)
 {
+        struct dib0700_adapter_state *state = adap->priv;
+
+        if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
+                return -ENODEV;
+
         if (adap->id == 0) {
                 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
                 msleep(10);
@@ -272,16 +279,16 @@ static int stk7700P2_frontend_attach(struct dvb_usb_adapter *adap)
                 msleep(10);
                 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
                 msleep(10);
-                if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
+                if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
                                              stk7700d_dib7000p_mt2266_config)
                     != 0) {
-                        err("%s: dib7000p_i2c_enumeration failed.  Cannot continue\n", __func__);
+                        err("%s: state->dib7000p_ops.i2c_enumeration failed.  Cannot continue\n", __func__);
+                        dvb_detach(&state->dib7000p_ops);
                         return -ENODEV;
                 }
         }
 
-        adap->fe_adap[0].fe =
-                dvb_attach(dib7000p_attach, &adap->dev->i2c_adap,
+        adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap,
                            0x80 + (adap->id << 1),
                            &stk7700d_dib7000p_mt2266_config[adap->id]);
 
@@ -290,6 +297,11 @@ static int stk7700P2_frontend_attach(struct dvb_usb_adapter *adap)
 
 static int stk7700d_frontend_attach(struct dvb_usb_adapter *adap)
 {
+        struct dib0700_adapter_state *state = adap->priv;
+
+        if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
+                return -ENODEV;
+
         if (adap->id == 0) {
                 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
                 msleep(10);
@@ -301,16 +313,16 @@ static int stk7700d_frontend_attach(struct dvb_usb_adapter *adap)
                 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
                 msleep(10);
                 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
-                if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 2, 18,
+                if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap, 2, 18,
                                              stk7700d_dib7000p_mt2266_config)
                     != 0) {
-                        err("%s: dib7000p_i2c_enumeration failed.  Cannot continue\n", __func__);
+                        err("%s: state->dib7000p_ops.i2c_enumeration failed.  Cannot continue\n", __func__);
+                        dvb_detach(&state->dib7000p_ops);
                         return -ENODEV;
                 }
         }
 
-        adap->fe_adap[0].fe =
-                dvb_attach(dib7000p_attach, &adap->dev->i2c_adap,
+        adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap,
                            0x80 + (adap->id << 1),
                            &stk7700d_dib7000p_mt2266_config[adap->id]);
 
@@ -320,7 +332,10 @@ static int stk7700d_frontend_attach(struct dvb_usb_adapter *adap)
 static int stk7700d_tuner_attach(struct dvb_usb_adapter *adap)
 {
         struct i2c_adapter *tun_i2c;
-        tun_i2c = dib7000p_get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_TUNER, 1);
+        struct dib0700_adapter_state *state = adap->priv;
+
+        tun_i2c = state->dib7000p_ops.get_i2c_master(adap->fe_adap[0].fe,
+                                            DIBX000_I2C_INTERFACE_TUNER, 1);
         return dvb_attach(mt2266_attach, adap->fe_adap[0].fe, tun_i2c,
                 &stk7700d_mt2266_config[adap->id]) == NULL ? -ENODEV : 0;
 }
@@ -397,12 +412,14 @@ static int stk7700ph_xc3028_callback(void *ptr, int component,
                                      int command, int arg)
 {
         struct dvb_usb_adapter *adap = ptr;
+        struct dib0700_adapter_state *state = adap->priv;
 
         switch (command) {
         case XC2028_TUNER_RESET:
                 /* Send the tuner in then out of reset */
-                dib7000p_set_gpio(adap->fe_adap[0].fe, 8, 0, 0); msleep(10);
-                dib7000p_set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
+                state->dib7000p_ops.set_gpio(adap->fe_adap[0].fe, 8, 0, 0);
+                msleep(10);
+                state->dib7000p_ops.set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
                 break;
         case XC2028_RESET_CLK:
                 break;
@@ -428,12 +445,16 @@ static struct xc2028_config stk7700ph_xc3028_config = {
 static int stk7700ph_frontend_attach(struct dvb_usb_adapter *adap)
 {
         struct usb_device_descriptor *desc = &adap->dev->udev->descriptor;
+        struct dib0700_adapter_state *state = adap->priv;
+
+        if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
+                return -ENODEV;
 
         if (desc->idVendor  == cpu_to_le16(USB_VID_PINNACLE) &&
             desc->idProduct == cpu_to_le16(USB_PID_PINNACLE_EXPRESSCARD_320CX))
-        dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
+                dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
         else
-        dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
+                dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
         msleep(20);
         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
@@ -445,14 +466,15 @@ static int stk7700ph_frontend_attach(struct dvb_usb_adapter *adap)
         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
         msleep(10);
 
-        if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
+        if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
                                      &stk7700ph_dib7700_xc3028_config) != 0) {
-                err("%s: dib7000p_i2c_enumeration failed.  Cannot continue\n",
+                err("%s: state->dib7000p_ops.i2c_enumeration failed.  Cannot continue\n",
                     __func__);
+                dvb_detach(&state->dib7000p_ops);
                 return -ENODEV;
         }
 
-        adap->fe_adap[0].fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x80,
+        adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap, 0x80,
                 &stk7700ph_dib7700_xc3028_config);
 
         return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
@@ -461,8 +483,9 @@ static int stk7700ph_frontend_attach(struct dvb_usb_adapter *adap)
 static int stk7700ph_tuner_attach(struct dvb_usb_adapter *adap)
 {
         struct i2c_adapter *tun_i2c;
+        struct dib0700_adapter_state *state = adap->priv;
 
-        tun_i2c = dib7000p_get_i2c_master(adap->fe_adap[0].fe,
+        tun_i2c = state->dib7000p_ops.get_i2c_master(adap->fe_adap[0].fe,
                 DIBX000_I2C_INTERFACE_TUNER, 1);
 
         stk7700ph_xc3028_config.i2c_adap = tun_i2c;
@@ -489,7 +512,8 @@ static u8 rc_request[] = { REQUEST_POLL_RC, 0 };
 static int dib0700_rc_query_old_firmware(struct dvb_usb_device *d)
 {
         u8 key[4];
-        u32 keycode;
+        enum rc_type protocol;
+        u32 scancode;
         u8 toggle;
         int i;
         struct dib0700_state *st = d->priv;
@@ -516,28 +540,29 @@ static int dib0700_rc_query_old_firmware(struct dvb_usb_device *d)
 
         dib0700_rc_setup(d, NULL); /* reset ir sensor data to prevent false events */
 
-        d->last_event = 0;
         switch (d->props.rc.core.protocol) {
         case RC_BIT_NEC:
                 /* NEC protocol sends repeat code as 0 0 0 FF */
                 if ((key[3-2] == 0x00) && (key[3-3] == 0x00) &&
-                    (key[3] == 0xff))
-                        keycode = d->last_event;
-                else {
-                        keycode = key[3-2] << 8 | key[3-3];
-                        d->last_event = keycode;
+                    (key[3] == 0xff)) {
+                        rc_repeat(d->rc_dev);
+                        return 0;
                 }
 
-                rc_keydown(d->rc_dev, keycode, 0);
+                protocol = RC_TYPE_NEC;
+                scancode = RC_SCANCODE_NEC(key[3-2], key[3-3]);
+                toggle = 0;
                 break;
+
         default:
                 /* RC-5 protocol changes toggle bit on new keypress */
-                keycode = key[3-2] << 8 | key[3-3];
+                protocol = RC_TYPE_RC5;
+                scancode = RC_SCANCODE_RC5(key[3-2], key[3-3]);
                 toggle = key[3-1];
-                rc_keydown(d->rc_dev, keycode, toggle);
-
                 break;
         }
+
+        rc_keydown(d->rc_dev, protocol, scancode, toggle);
         return 0;
 }
 
@@ -673,6 +698,11 @@ static struct dib7000p_config stk7700p_dib7000p_config = {
 static int stk7700p_frontend_attach(struct dvb_usb_adapter *adap)
 {
         struct dib0700_state *st = adap->dev->priv;
+        struct dib0700_adapter_state *state = adap->priv;
+
+        if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
+                return -ENODEV;
+
         /* unless there is no real power management in DVB - we leave the device on GPIO6 */
 
         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
@@ -689,11 +719,13 @@ static int stk7700p_frontend_attach(struct dvb_usb_adapter *adap)
 
         st->mt2060_if1[0] = 1220;
 
-        if (dib7000pc_detection(&adap->dev->i2c_adap)) {
-                adap->fe_adap[0].fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 18, &stk7700p_dib7000p_config);
+        if (state->dib7000p_ops.dib7000pc_detection(&adap->dev->i2c_adap)) {
+                adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap, 18, &stk7700p_dib7000p_config);
                 st->is_dib7000pc = 1;
-        } else
+        } else {
+                memset(&state->dib7000p_ops, 0, sizeof(state->dib7000p_ops));
                 adap->fe_adap[0].fe = dvb_attach(dib7000m_attach, &adap->dev->i2c_adap, 18, &stk7700p_dib7000m_config);
+        }
 
         return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
 }
@@ -707,14 +739,16 @@ static int stk7700p_tuner_attach(struct dvb_usb_adapter *adap)
         struct i2c_adapter *prim_i2c = &adap->dev->i2c_adap;
         struct dib0700_state *st = adap->dev->priv;
         struct i2c_adapter *tun_i2c;
+        struct dib0700_adapter_state *state = adap->priv;
         s8 a;
         int if1=1220;
+
         if (adap->dev->udev->descriptor.idVendor  == cpu_to_le16(USB_VID_HAUPPAUGE) &&
                 adap->dev->udev->descriptor.idProduct == cpu_to_le16(USB_PID_HAUPPAUGE_NOVA_T_STICK)) {
                 if (!eeprom_read(prim_i2c,0x58,&a)) if1=1220+a;
         }
         if (st->is_dib7000pc)
-                tun_i2c = dib7000p_get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_TUNER, 1);
+                tun_i2c = state->dib7000p_ops.get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_TUNER, 1);
         else
                 tun_i2c = dib7000m_get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_TUNER, 1);
 
@@ -767,14 +801,20 @@ static struct dibx000_agc_config dib7070_agc_config = {
 
 static int dib7070_tuner_reset(struct dvb_frontend *fe, int onoff)
 {
+        struct dvb_usb_adapter *adap = fe->dvb->priv;
+        struct dib0700_adapter_state *state = adap->priv;
+
         deb_info("reset: %d", onoff);
-        return dib7000p_set_gpio(fe, 8, 0, !onoff);
+        return state->dib7000p_ops.set_gpio(fe, 8, 0, !onoff);
 }
 
 static int dib7070_tuner_sleep(struct dvb_frontend *fe, int onoff)
 {
+        struct dvb_usb_adapter *adap = fe->dvb->priv;
+        struct dib0700_adapter_state *state = adap->priv;
+
         deb_info("sleep: %d", onoff);
-        return dib7000p_set_gpio(fe, 9, 0, onoff);
+        return state->dib7000p_ops.set_gpio(fe, 9, 0, onoff);
 }
 
 static struct dib0070_config dib7070p_dib0070_config[2] = {
@@ -818,7 +858,7 @@ static int dib7070_set_param_override(struct dvb_frontend *fe)
                 default: offset = 550; break;
         }
         deb_info("WBD for DiB7000P: %d\n", offset + dib0070_wbd_offset(fe));
-        dib7000p_set_wbd_ref(fe, offset + dib0070_wbd_offset(fe));
+        state->dib7000p_ops.set_wbd_ref(fe, offset + dib0070_wbd_offset(fe));
         return state->set_param_save(fe);
 }
 
@@ -832,39 +872,39 @@ static int dib7770_set_param_override(struct dvb_frontend *fe)
          u8 band = BAND_OF_FREQUENCY(p->frequency/1000);
          switch (band) {
          case BAND_VHF:
-                  dib7000p_set_gpio(fe, 0, 0, 1);
+                  state->dib7000p_ops.set_gpio(fe, 0, 0, 1);
                   offset = 850;
                   break;
          case BAND_UHF:
          default:
-                  dib7000p_set_gpio(fe, 0, 0, 0);
+                  state->dib7000p_ops.set_gpio(fe, 0, 0, 0);
                   offset = 250;
                   break;
          }
          deb_info("WBD for DiB7000P: %d\n", offset + dib0070_wbd_offset(fe));
-         dib7000p_set_wbd_ref(fe, offset + dib0070_wbd_offset(fe));
+         state->dib7000p_ops.set_wbd_ref(fe, offset + dib0070_wbd_offset(fe));
          return state->set_param_save(fe);
 }
 
 static int dib7770p_tuner_attach(struct dvb_usb_adapter *adap)
 {
-         struct dib0700_adapter_state *st = adap->priv;
-         struct i2c_adapter *tun_i2c = dib7000p_get_i2c_master(adap->fe_adap[0].fe,
+        struct dib0700_adapter_state *st = adap->priv;
+        struct i2c_adapter *tun_i2c = st->dib7000p_ops.get_i2c_master(adap->fe_adap[0].fe,
                          DIBX000_I2C_INTERFACE_TUNER, 1);
 
-         if (dvb_attach(dib0070_attach, adap->fe_adap[0].fe, tun_i2c,
-                        &dib7770p_dib0070_config) == NULL)
-                 return -ENODEV;
+        if (dvb_attach(dib0070_attach, adap->fe_adap[0].fe, tun_i2c,
+                       &dib7770p_dib0070_config) == NULL)
+                return -ENODEV;
 
-         st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
-         adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib7770_set_param_override;
-         return 0;
+        st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
+        adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib7770_set_param_override;
+        return 0;
 }
 
 static int dib7070p_tuner_attach(struct dvb_usb_adapter *adap)
 {
         struct dib0700_adapter_state *st = adap->priv;
-        struct i2c_adapter *tun_i2c = dib7000p_get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_TUNER, 1);
+        struct i2c_adapter *tun_i2c = st->dib7000p_ops.get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_TUNER, 1);
 
         if (adap->id == 0) {
                 if (dvb_attach(dib0070_attach, adap->fe_adap[0].fe, tun_i2c, &dib7070p_dib0070_config[0]) == NULL)
@@ -882,28 +922,33 @@ static int dib7070p_tuner_attach(struct dvb_usb_adapter *adap)
 static int stk7700p_pid_filter(struct dvb_usb_adapter *adapter, int index,
                 u16 pid, int onoff)
 {
+        struct dib0700_adapter_state *state = adapter->priv;
         struct dib0700_state *st = adapter->dev->priv;
+
         if (st->is_dib7000pc)
-                return dib7000p_pid_filter(adapter->fe_adap[0].fe, index, pid, onoff);
+                return state->dib7000p_ops.pid_filter(adapter->fe_adap[0].fe, index, pid, onoff);
         return dib7000m_pid_filter(adapter->fe_adap[0].fe, index, pid, onoff);
 }
 
 static int stk7700p_pid_filter_ctrl(struct dvb_usb_adapter *adapter, int onoff)
 {
         struct dib0700_state *st = adapter->dev->priv;
+        struct dib0700_adapter_state *state = adapter->priv;
         if (st->is_dib7000pc)
-                return dib7000p_pid_filter_ctrl(adapter->fe_adap[0].fe, onoff);
+                return state->dib7000p_ops.pid_filter_ctrl(adapter->fe_adap[0].fe, onoff);
         return dib7000m_pid_filter_ctrl(adapter->fe_adap[0].fe, onoff);
 }
 
 static int stk70x0p_pid_filter(struct dvb_usb_adapter *adapter, int index, u16 pid, int onoff)
 {
-        return dib7000p_pid_filter(adapter->fe_adap[0].fe, index, pid, onoff);
+        struct dib0700_adapter_state *state = adapter->priv;
+        return state->dib7000p_ops.pid_filter(adapter->fe_adap[0].fe, index, pid, onoff);
 }
 
 static int stk70x0p_pid_filter_ctrl(struct dvb_usb_adapter *adapter, int onoff)
 {
-        return dib7000p_pid_filter_ctrl(adapter->fe_adap[0].fe, onoff);
+        struct dib0700_adapter_state *state = adapter->priv;
+        return state->dib7000p_ops.pid_filter_ctrl(adapter->fe_adap[0].fe, onoff);
 }
 
 static struct dibx000_bandwidth_config dib7070_bw_config_12_mhz = {
@@ -936,6 +981,11 @@ static struct dib7000p_config dib7070p_dib7000p_config = {
 static int stk7070p_frontend_attach(struct dvb_usb_adapter *adap)
 {
         struct usb_device_descriptor *p = &adap->dev->udev->descriptor;
+        struct dib0700_adapter_state *state = adap->priv;
+
+        if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
+                return -ENODEV;
+
         if (p->idVendor  == cpu_to_le16(USB_VID_PINNACLE) &&
             p->idProduct == cpu_to_le16(USB_PID_PINNACLE_PCTV72E))
                 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
@@ -954,14 +1004,15 @@ static int stk7070p_frontend_attach(struct dvb_usb_adapter *adap)
         msleep(10);
         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
 
-        if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
+        if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
                                      &dib7070p_dib7000p_config) != 0) {
-                err("%s: dib7000p_i2c_enumeration failed.  Cannot continue\n",
+                err("%s: state->dib7000p_ops.i2c_enumeration failed.  Cannot continue\n",
                     __func__);
+                dvb_detach(&state->dib7000p_ops);
                 return -ENODEV;
         }
 
-        adap->fe_adap[0].fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x80,
+        adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap, 0x80,
                 &dib7070p_dib7000p_config);
         return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
 }
@@ -988,6 +1039,11 @@ static struct dib7000p_config dib7770p_dib7000p_config = {
 static int stk7770p_frontend_attach(struct dvb_usb_adapter *adap)
 {
         struct usb_device_descriptor *p = &adap->dev->udev->descriptor;
+        struct dib0700_adapter_state *state = adap->priv;
+
+        if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
+                return -ENODEV;
+
         if (p->idVendor  == cpu_to_le16(USB_VID_PINNACLE) &&
             p->idProduct == cpu_to_le16(USB_PID_PINNACLE_PCTV72E))
                 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
@@ -1006,14 +1062,15 @@ static int stk7770p_frontend_attach(struct dvb_usb_adapter *adap)
         msleep(10);
         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
 
-        if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
+        if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
                                      &dib7770p_dib7000p_config) != 0) {
-                err("%s: dib7000p_i2c_enumeration failed.  Cannot continue\n",
+                err("%s: state->dib7000p_ops.i2c_enumeration failed.  Cannot continue\n",
                     __func__);
+                dvb_detach(&state->dib7000p_ops);
                 return -ENODEV;
         }
 
-        adap->fe_adap[0].fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x80,
+        adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap, 0x80,
                 &dib7770p_dib7000p_config);
         return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
 }
@@ -1161,12 +1218,18 @@ static struct dib8000_config dib807x_dib8000_config[2] = {
 
 static int dib80xx_tuner_reset(struct dvb_frontend *fe, int onoff)
 {
-        return dib8000_set_gpio(fe, 5, 0, !onoff);
+        struct dvb_usb_adapter *adap = fe->dvb->priv;
+        struct dib0700_adapter_state *state = adap->priv;
+
+        return state->dib8000_ops.set_gpio(fe, 5, 0, !onoff);
 }
 
 static int dib80xx_tuner_sleep(struct dvb_frontend *fe, int onoff)
 {
-        return dib8000_set_gpio(fe, 0, 0, onoff);
+        struct dvb_usb_adapter *adap = fe->dvb->priv;
+        struct dib0700_adapter_state *state = adap->priv;
+
+        return state->dib8000_ops.set_gpio(fe, 0, 0, onoff);
 }
 
 static const struct dib0070_wbd_gain_cfg dib8070_wbd_gain_cfg[] = {
@@ -1223,7 +1286,7 @@ static int dib807x_set_param_override(struct dvb_frontend *fe)
                 offset += 250; break;
         }
         deb_info("WBD for DiB8000: %d\n", offset);
-        dib8000_set_wbd_ref(fe, offset);
+        state->dib8000_ops.set_wbd_ref(fe, offset);
 
         return state->set_param_save(fe);
 }
@@ -1231,7 +1294,7 @@ static int dib807x_set_param_override(struct dvb_frontend *fe)
 static int dib807x_tuner_attach(struct dvb_usb_adapter *adap)
 {
         struct dib0700_adapter_state *st = adap->priv;
-        struct i2c_adapter *tun_i2c = dib8000_get_i2c_master(adap->fe_adap[0].fe,
+        struct i2c_adapter *tun_i2c = st->dib8000_ops.get_i2c_master(adap->fe_adap[0].fe,
                         DIBX000_I2C_INTERFACE_TUNER, 1);
 
         if (adap->id == 0) {
@@ -1252,18 +1315,27 @@ static int dib807x_tuner_attach(struct dvb_usb_adapter *adap)
 static int stk80xx_pid_filter(struct dvb_usb_adapter *adapter, int index,
         u16 pid, int onoff)
 {
-        return dib8000_pid_filter(adapter->fe_adap[0].fe, index, pid, onoff);
+        struct dib0700_adapter_state *state = adapter->priv;
+
+        return state->dib8000_ops.pid_filter(adapter->fe_adap[0].fe, index, pid, onoff);
 }
 
 static int stk80xx_pid_filter_ctrl(struct dvb_usb_adapter *adapter,
                 int onoff)
 {
-        return dib8000_pid_filter_ctrl(adapter->fe_adap[0].fe, onoff);
+        struct dib0700_adapter_state *state = adapter->priv;
+
+        return state->dib8000_ops.pid_filter_ctrl(adapter->fe_adap[0].fe, onoff);
 }
 
 /* STK807x */
 static int stk807x_frontend_attach(struct dvb_usb_adapter *adap)
 {
+        struct dib0700_adapter_state *state = adap->priv;
+
+        if (!dvb_attach(dib8000_attach, &state->dib8000_ops))
+                return -ENODEV;
+
         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
         msleep(10);
         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
@@ -1279,10 +1351,10 @@ static int stk807x_frontend_attach(struct dvb_usb_adapter *adap)
         msleep(10);
         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
 
-        dib8000_i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
+        state->dib8000_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
                                 0x80, 0);
 
-        adap->fe_adap[0].fe = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x80,
+        adap->fe_adap[0].fe = state->dib8000_ops.init(&adap->dev->i2c_adap, 0x80,
                               &dib807x_dib8000_config[0]);
 
         return adap->fe_adap[0].fe == NULL ?  -ENODEV : 0;
@@ -1291,6 +1363,11 @@ static int stk807x_frontend_attach(struct dvb_usb_adapter *adap)
 /* STK807xPVR */
 static int stk807xpvr_frontend_attach0(struct dvb_usb_adapter *adap)
 {
+        struct dib0700_adapter_state *state = adap->priv;
+
+        if (!dvb_attach(dib8000_attach, &state->dib8000_ops))
+                return -ENODEV;
+
         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
         msleep(30);
         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
@@ -1309,9 +1386,9 @@ static int stk807xpvr_frontend_attach0(struct dvb_usb_adapter *adap)
         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
 
         /* initialize IC 0 */
-        dib8000_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x22, 0x80, 0);
+        state->dib8000_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 0x22, 0x80, 0);
 
-        adap->fe_adap[0].fe = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x80,
+        adap->fe_adap[0].fe = state->dib8000_ops.init(&adap->dev->i2c_adap, 0x80,
                               &dib807x_dib8000_config[0]);
 
         return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
@@ -1319,10 +1396,15 @@ static int stk807xpvr_frontend_attach0(struct dvb_usb_adapter *adap)
 
 static int stk807xpvr_frontend_attach1(struct dvb_usb_adapter *adap)
 {
+        struct dib0700_adapter_state *state = adap->priv;
+
+        if (!dvb_attach(dib8000_attach, &state->dib8000_ops))
+                return -ENODEV;
+
         /* initialize IC 1 */
-        dib8000_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x12, 0x82, 0);
+        state->dib8000_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 0x12, 0x82, 0);
 
-        adap->fe_adap[0].fe = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x82,
+        adap->fe_adap[0].fe = state->dib8000_ops.init(&adap->dev->i2c_adap, 0x82,
                               &dib807x_dib8000_config[1]);
 
         return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
@@ -1331,104 +1413,121 @@ static int stk807xpvr_frontend_attach1(struct dvb_usb_adapter *adap)
 /* STK8096GP */
 static struct dibx000_agc_config dib8090_agc_config[2] = {
         {
-        BAND_UHF | BAND_VHF | BAND_LBAND | BAND_SBAND,
+        .band_caps = BAND_UHF | BAND_VHF | BAND_LBAND | BAND_SBAND,
         /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=1,
          * P_agc_inv_pwm1=0, P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
          * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5, P_agc_write=0 */
-        (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8)
+        .setup = (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8)
         | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
 
-        787,
-        10,
-
-        0,
-        118,
-
-        0,
-        3530,
-        1,
-        5,
+        .inv_gain = 787,
+        .time_stabiliz = 10,
 
-        65535,
-        0,
+        .alpha_level = 0,
+        .thlock = 118,
 
-        65535,
-        0,
+        .wbd_inv = 0,
+        .wbd_ref = 3530,
+        .wbd_sel = 1,
+        .wbd_alpha = 5,
 
-        0,
-        32,
-        114,
-        143,
-        144,
-        114,
-        227,
-        116,
-        117,
+        .agc1_max = 65535,
+        .agc1_min = 0,
 
-        28,
-        26,
-        31,
-        51,
+        .agc2_max = 65535,
+        .agc2_min = 0,
 
-        0,
+        .agc1_pt1 = 0,
+        .agc1_pt2 = 32,
+        .agc1_pt3 = 114,
+        .agc1_slope1 = 143,
+        .agc1_slope2 = 144,
+        .agc2_pt1 = 114,
+        .agc2_pt2 = 227,
+        .agc2_slope1 = 116,
+        .agc2_slope2 = 117,
+
+        .alpha_mant = 28,
+        .alpha_exp = 26,
+        .beta_mant = 31,
+        .beta_exp = 51,
+
+        .perform_agc_softsplit = 0,
         },
         {
-        BAND_CBAND,
+        .band_caps = BAND_CBAND,
         /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=1,
          * P_agc_inv_pwm1=0, P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
          * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5, P_agc_write=0 */
-        (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8)
+        .setup = (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8)
         | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
 
-        787,
-        10,
+        .inv_gain = 787,
+        .time_stabiliz = 10,
 
-        0,
-        118,
+        .alpha_level = 0,
+        .thlock = 118,
 
-        0,
-        3530,
-        1,
-        5,
+        .wbd_inv = 0,
+        .wbd_ref = 3530,
+        .wbd_sel = 1,
+        .wbd_alpha = 5,
 
-        0,
-        0,
+        .agc1_max = 0,
+        .agc1_min = 0,
 
-        65535,
-        0,
-
-        0,
-        32,
-        114,
-        143,
-        144,
-        114,
-        227,
-        116,
-        117,
-
-        28,
-        26,
-        31,
-        51,
+        .agc2_max = 65535,
+        .agc2_min = 0,
 
-        0,
+        .agc1_pt1 = 0,
+        .agc1_pt2 = 32,
+        .agc1_pt3 = 114,
+        .agc1_slope1 = 143,
+        .agc1_slope2 = 144,
+        .agc2_pt1 = 114,
+        .agc2_pt2 = 227,
+        .agc2_slope1 = 116,
+        .agc2_slope2 = 117,
+
+        .alpha_mant = 28,
+        .alpha_exp = 26,
+        .beta_mant = 31,
+        .beta_exp = 51,
+
+        .perform_agc_softsplit = 0,
         }
 };
 
 static struct dibx000_bandwidth_config dib8090_pll_config_12mhz = {
-        54000, 13500,
-        1, 18, 3, 1, 0,
-        0, 0, 1, 1, 2,
-        (3 << 14) | (1 << 12) | (599 << 0),
-        (0 << 25) | 0,
-        20199727,
-        12000000,
+        .internal = 54000,
+        .sampling = 13500,
+
+        .pll_prediv = 1,
+        .pll_ratio = 18,
+        .pll_range = 3,
+        .pll_reset = 1,
+        .pll_bypass = 0,
+
+        .enable_refdiv = 0,
+        .bypclk_div = 0,
+        .IO_CLK_en_core = 1,
+        .ADClkSrc = 1,
+        .modulo = 2,
+
+        .sad_cfg = (3 << 14) | (1 << 12) | (599 << 0),
+
+        .ifreq = (0 << 25) | 0,
+        .timf = 20199727,
+
+        .xtal_hz = 12000000,
 };
 
 static int dib8090_get_adc_power(struct dvb_frontend *fe)
 {
-        return dib8000_get_adc_power(fe, 1);
+        struct dvb_usb_adapter *adap = fe->dvb->priv;
+        struct dib0700_adapter_state *state = adap->priv;
+
+        return state->dib8000_ops.get_adc_power(fe, 1);
 }
 
 static void dib8090_agc_control(struct dvb_frontend *fe, u8 restart)
@@ -1551,10 +1650,10 @@ static int dib8096_set_param_override(struct dvb_frontend *fe)
         default:
                         deb_info("Warning : Rf frequency  (%iHz) is not in the supported range, using VHF switch ", fe->dtv_property_cache.frequency);
         case BAND_VHF:
-                        dib8000_set_gpio(fe, 3, 0, 1);
+                        state->dib8000_ops.set_gpio(fe, 3, 0, 1);
                         break;
         case BAND_UHF:
-                        dib8000_set_gpio(fe, 3, 0, 0);
+                        state->dib8000_ops.set_gpio(fe, 3, 0, 0);
                         break;
         }
 
@@ -1568,7 +1667,7 @@ static int dib8096_set_param_override(struct dvb_frontend *fe)
         }
 
         /** Update PLL if needed ratio **/
-        dib8000_update_pll(fe, &dib8090_pll_config_12mhz, fe->dtv_property_cache.bandwidth_hz / 1000, 0);
+        state->dib8000_ops.update_pll(fe, &dib8090_pll_config_12mhz, fe->dtv_property_cache.bandwidth_hz / 1000, 0);
 
         /** Get optimize PLL ratio to remove spurious **/
         pll_ratio = dib8090_compute_pll_parameters(fe);
@@ -1582,14 +1681,14 @@ static int dib8096_set_param_override(struct dvb_frontend *fe)
                 timf = 18179756;
 
         /** Update ratio **/
-        dib8000_update_pll(fe, &dib8090_pll_config_12mhz, fe->dtv_property_cache.bandwidth_hz / 1000, pll_ratio);
+        state->dib8000_ops.update_pll(fe, &dib8090_pll_config_12mhz, fe->dtv_property_cache.bandwidth_hz / 1000, pll_ratio);
 
-        dib8000_ctrl_timf(fe, DEMOD_TIMF_SET, timf);
+        state->dib8000_ops.ctrl_timf(fe, DEMOD_TIMF_SET, timf);
 
         if (band != BAND_CBAND) {
                 /* dib0090_get_wbd_target is returning any possible temperature compensated wbd-target */
                 target = (dib0090_get_wbd_target(fe) * 8 * 18 / 33 + 1) / 2;
-                dib8000_set_wbd_ref(fe, target);
+                state->dib8000_ops.set_wbd_ref(fe, target);
         }
 
         if (band == BAND_CBAND) {
@@ -1601,18 +1700,18 @@ static int dib8096_set_param_override(struct dvb_frontend *fe)
                         msleep(ret);
                         tune_state = dib0090_get_tune_state(fe);
                         if (tune_state == CT_AGC_STEP_0)
-                                dib8000_set_gpio(fe, 6, 0, 1);
+                                state->dib8000_ops.set_gpio(fe, 6, 0, 1);
                         else if (tune_state == CT_AGC_STEP_1) {
                                 dib0090_get_current_gain(fe, NULL, NULL, &rf_gain_limit, &ltgain);
                                 if (rf_gain_limit < 2000) /* activate the external attenuator in case of very high input power */
-                                        dib8000_set_gpio(fe, 6, 0, 0);
+                                        state->dib8000_ops.set_gpio(fe, 6, 0, 0);
                         }
                 } while (tune_state < CT_AGC_STOP);
 
                 deb_info("switching to PWM AGC\n");
                 dib0090_pwm_gain_reset(fe);
-                dib8000_pwm_agc_reset(fe);
-                dib8000_set_tune_state(fe, CT_DEMOD_START);
+                state->dib8000_ops.pwm_agc_reset(fe);
+                state->dib8000_ops.set_tune_state(fe, CT_DEMOD_START);
         } else {
                 /* for everything else than CBAND we are using standard AGC */
                 deb_info("not tuning in CBAND - standard AGC startup\n");
@@ -1625,7 +1724,7 @@ static int dib8096_set_param_override(struct dvb_frontend *fe)
 static int dib809x_tuner_attach(struct dvb_usb_adapter *adap)
 {
         struct dib0700_adapter_state *st = adap->priv;
-        struct i2c_adapter *tun_i2c = dib8000_get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_TUNER, 1);
+        struct i2c_adapter *tun_i2c = st->dib8000_ops.get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_TUNER, 1);
 
         if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c, &dib809x_dib0090_config) == NULL)
                 return -ENODEV;
@@ -1637,6 +1736,11 @@ static int dib809x_tuner_attach(struct dvb_usb_adapter *adap)
 
 static int stk809x_frontend_attach(struct dvb_usb_adapter *adap)
 {
+        struct dib0700_adapter_state *state = adap->priv;
+
+        if (!dvb_attach(dib8000_attach, &state->dib8000_ops))
+                return -ENODEV;
+
         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
         msleep(10);
         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
@@ -1652,9 +1756,9 @@ static int stk809x_frontend_attach(struct dvb_usb_adapter *adap)
         msleep(10);
         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
 
-        dib8000_i2c_enumeration(&adap->dev->i2c_adap, 1, 18, 0x80, 0);
+        state->dib8000_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 18, 0x80, 0);
 
-        adap->fe_adap[0].fe = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x80, &dib809x_dib8000_config[0]);
+        adap->fe_adap[0].fe = state->dib8000_ops.init(&adap->dev->i2c_adap, 0x80, &dib809x_dib8000_config[0]);
 
         return adap->fe_adap[0].fe == NULL ?  -ENODEV : 0;
 }
@@ -1663,16 +1767,16 @@ static int nim8096md_tuner_attach(struct dvb_usb_adapter *adap)
 {
         struct dib0700_adapter_state *st = adap->priv;
         struct i2c_adapter *tun_i2c;
-        struct dvb_frontend *fe_slave  = dib8000_get_slave_frontend(adap->fe_adap[0].fe, 1);
+        struct dvb_frontend *fe_slave  = st->dib8000_ops.get_slave_frontend(adap->fe_adap[0].fe, 1);
 
         if (fe_slave) {
-                tun_i2c = dib8000_get_i2c_master(fe_slave, DIBX000_I2C_INTERFACE_TUNER, 1);
+                tun_i2c = st->dib8000_ops.get_i2c_master(fe_slave, DIBX000_I2C_INTERFACE_TUNER, 1);
                 if (dvb_attach(dib0090_register, fe_slave, tun_i2c, &dib809x_dib0090_config) == NULL)
                         return -ENODEV;
                 fe_slave->dvb = adap->fe_adap[0].fe->dvb;
                 fe_slave->ops.tuner_ops.set_params = dib8096_set_param_override;
         }
-        tun_i2c = dib8000_get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_TUNER, 1);
+        tun_i2c = st->dib8000_ops.get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_TUNER, 1);
         if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c, &dib809x_dib0090_config) == NULL)
                 return -ENODEV;
 
@@ -1685,6 +1789,10 @@ static int nim8096md_tuner_attach(struct dvb_usb_adapter *adap)
 static int nim8096md_frontend_attach(struct dvb_usb_adapter *adap)
 {
         struct dvb_frontend *fe_slave;
+        struct dib0700_adapter_state *state = adap->priv;
+
+        if (!dvb_attach(dib8000_attach, &state->dib8000_ops))
+                return -ENODEV;
 
         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
         msleep(20);
@@ -1703,14 +1811,18 @@ static int nim8096md_frontend_attach(struct dvb_usb_adapter *adap)
         msleep(20);
         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
 
-        dib8000_i2c_enumeration(&adap->dev->i2c_adap, 2, 18, 0x80, 0);
+        state->dib8000_ops.i2c_enumeration(&adap->dev->i2c_adap, 2, 18, 0x80, 0);
 
-        adap->fe_adap[0].fe = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x80, &dib809x_dib8000_config[0]);
+        adap->fe_adap[0].fe = state->dib8000_ops.init(&adap->dev->i2c_adap, 0x80, &dib809x_dib8000_config[0]);
         if (adap->fe_adap[0].fe == NULL)
                 return -ENODEV;
 
-        fe_slave = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x82, &dib809x_dib8000_config[1]);
-        dib8000_set_slave_frontend(adap->fe_adap[0].fe, fe_slave);
+        /* Needed to increment refcount */
+        if (!dvb_attach(dib8000_attach, &state->dib8000_ops))
+                return -ENODEV;
+
+        fe_slave = state->dib8000_ops.init(&adap->dev->i2c_adap, 0x82, &dib809x_dib8000_config[1]);
+        state->dib8000_ops.set_slave_frontend(adap->fe_adap[0].fe, fe_slave);
 
         return fe_slave == NULL ?  -ENODEV : 0;
 }
@@ -1845,7 +1957,7 @@ static struct dib0090_wbd_slope dib8096p_wbd_table[] = {
         { 0xFFFF, 0, 0, 0, 0, 0},
 };
 
-static const struct dib0090_config tfe8096p_dib0090_config = {
+static struct dib0090_config tfe8096p_dib0090_config = {
         .io.clock_khz                   = 12000,
         .io.pll_bypass                  = 0,
         .io.pll_range                   = 0,
@@ -1853,8 +1965,6 @@ static const struct dib0090_config tfe8096p_dib0090_config = {
         .io.pll_loopdiv                 = 6,
         .io.adc_clock_ratio             = 0,
         .io.pll_int_loop_filt   = 0,
-        .reset                                  = dib8096p_tuner_sleep,
-        .sleep                                  = dib8096p_tuner_sleep,
 
         .freq_offset_khz_uhf    = -143,
         .freq_offset_khz_vhf    = -143,
@@ -1871,8 +1981,6 @@ static const struct dib0090_config tfe8096p_dib0090_config = {
 
         .fref_clock_ratio               = 1,
 
-        .wbd                                    = dib8096p_wbd_table,
-
         .ls_cfg_pad_drv                 = 0,
         .data_tx_drv                    = 0,
         .low_if                                 = NULL,
@@ -1983,15 +2091,15 @@ static int dib8096p_agc_startup(struct dvb_frontend *fe)
         /* dib0090_get_wbd_target is returning any possible
            temperature compensated wbd-target */
         target = (dib0090_get_wbd_target(fe) * 8  + 1) / 2;
-        dib8000_set_wbd_ref(fe, target);
+        state->dib8000_ops.set_wbd_ref(fe, target);
 
         if (dib8096p_get_best_sampling(fe, &adc) == 0) {
                 pll.pll_ratio  = adc.pll_loopdiv;
                 pll.pll_prediv = adc.pll_prediv;
 
                 dib0700_set_i2c_speed(adap->dev, 200);
-                dib8000_update_pll(fe, &pll, fe->dtv_property_cache.bandwidth_hz / 1000, 0);
-                dib8000_ctrl_timf(fe, DEMOD_TIMF_SET, adc.timf);
+                state->dib8000_ops.update_pll(fe, &pll, fe->dtv_property_cache.bandwidth_hz / 1000, 0);
+                state->dib8000_ops.ctrl_timf(fe, DEMOD_TIMF_SET, adc.timf);
                 dib0700_set_i2c_speed(adap->dev, 1000);
         }
         return 0;
@@ -2001,6 +2109,10 @@ static int tfe8096p_frontend_attach(struct dvb_usb_adapter *adap)
 {
         struct dib0700_state *st = adap->dev->priv;
         u32 fw_version;
+        struct dib0700_adapter_state *state = adap->priv;
+
+        if (!dvb_attach(dib8000_attach, &state->dib8000_ops))
+                return -ENODEV;
 
         dib0700_get_version(adap->dev, NULL, NULL, &fw_version, NULL);
         if (fw_version >= 0x10200)
@@ -2021,10 +2133,10 @@ static int tfe8096p_frontend_attach(struct dvb_usb_adapter *adap)
         msleep(20);
         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
 
-        dib8000_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x10, 0x80, 1);
+        state->dib8000_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 0x10, 0x80, 1);
 
-        adap->fe_adap[0].fe = dvb_attach(dib8000_attach,
-                        &adap->dev->i2c_adap, 0x80, &tfe8096p_dib8000_config);
+        adap->fe_adap[0].fe = state->dib8000_ops.init(&adap->dev->i2c_adap,
+                                             0x80, &tfe8096p_dib8000_config);
 
         return adap->fe_adap[0].fe == NULL ?  -ENODEV : 0;
 }
@@ -2032,13 +2144,17 @@ static int tfe8096p_frontend_attach(struct dvb_usb_adapter *adap)
 static int tfe8096p_tuner_attach(struct dvb_usb_adapter *adap)
 {
         struct dib0700_adapter_state *st = adap->priv;
-        struct i2c_adapter *tun_i2c = dib8096p_get_i2c_tuner(adap->fe_adap[0].fe);
+        struct i2c_adapter *tun_i2c = st->dib8000_ops.get_i2c_tuner(adap->fe_adap[0].fe);
+
+        tfe8096p_dib0090_config.reset = st->dib8000_ops.tuner_sleep;
+        tfe8096p_dib0090_config.sleep = st->dib8000_ops.tuner_sleep;
+        tfe8096p_dib0090_config.wbd = dib8096p_wbd_table;
 
         if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c,
                                 &tfe8096p_dib0090_config) == NULL)
                 return -ENODEV;
 
-        dib8000_set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
+        st->dib8000_ops.set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
 
         st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
         adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib8096p_agc_startup;
@@ -2479,14 +2595,14 @@ static int dib7090_agc_startup(struct dvb_frontend *fe)
         memset(&pll, 0, sizeof(struct dibx000_bandwidth_config));
         dib0090_pwm_gain_reset(fe);
         target = (dib0090_get_wbd_target(fe) * 8 + 1) / 2;
-        dib7000p_set_wbd_ref(fe, target);
+        state->dib7000p_ops.set_wbd_ref(fe, target);
 
         if (dib7090p_get_best_sampling(fe, &adc) == 0) {
                 pll.pll_ratio  = adc.pll_loopdiv;
                 pll.pll_prediv = adc.pll_prediv;
 
-                dib7000p_update_pll(fe, &pll);
-                dib7000p_ctrl_timf(fe, DEMOD_TIMF_SET, adc.timf);
+                state->dib7000p_ops.update_pll(fe, &pll);
+                state->dib7000p_ops.ctrl_timf(fe, DEMOD_TIMF_SET, adc.timf);
         }
         return 0;
 }
@@ -2501,14 +2617,17 @@ static int dib7090_agc_restart(struct dvb_frontend *fe, u8 restart)
 
 static int tfe7790p_update_lna(struct dvb_frontend *fe, u16 agc_global)
 {
+        struct dvb_usb_adapter *adap = fe->dvb->priv;
+        struct dib0700_adapter_state *state = adap->priv;
+
         deb_info("update LNA: agc global=%i", agc_global);
 
         if (agc_global < 25000) {
-                dib7000p_set_gpio(fe, 8, 0, 0);
-                dib7000p_set_agc1_min(fe, 0);
+                state->dib7000p_ops.set_gpio(fe, 8, 0, 0);
+                state->dib7000p_ops.set_agc1_min(fe, 0);
         } else {
-                dib7000p_set_gpio(fe, 8, 0, 1);
-                dib7000p_set_agc1_min(fe, 32768);
+                state->dib7000p_ops.set_gpio(fe, 8, 0, 1);
+                state->dib7000p_ops.set_agc1_min(fe, 32768);
         }
 
         return 0;
@@ -2644,13 +2763,16 @@ static struct dib7000p_config nim7090_dib7000p_config = {
 
 static int tfe7090p_pvr_update_lna(struct dvb_frontend *fe, u16 agc_global)
 {
+        struct dvb_usb_adapter *adap = fe->dvb->priv;
+        struct dib0700_adapter_state *state = adap->priv;
+
         deb_info("TFE7090P-PVR update LNA: agc global=%i", agc_global);
         if (agc_global < 25000) {
-                dib7000p_set_gpio(fe, 5, 0, 0);
-                dib7000p_set_agc1_min(fe, 0);
+                state->dib7000p_ops.set_gpio(fe, 5, 0, 0);
+                state->dib7000p_ops.set_agc1_min(fe, 0);
         } else {
-                dib7000p_set_gpio(fe, 5, 0, 1);
-                dib7000p_set_agc1_min(fe, 32768);
+                state->dib7000p_ops.set_gpio(fe, 5, 0, 1);
+                state->dib7000p_ops.set_agc1_min(fe, 32768);
         }
 
         return 0;
@@ -2714,7 +2836,7 @@ static struct dib7000p_config tfe7090pvr_dib7000p_config[2] = {
         }
 };
 
-static const struct dib0090_config nim7090_dib0090_config = {
+static struct dib0090_config nim7090_dib0090_config = {
         .io.clock_khz = 12000,
         .io.pll_bypass = 0,
         .io.pll_range = 0,
@@ -2722,14 +2844,10 @@ static const struct dib0090_config nim7090_dib0090_config = {
         .io.pll_loopdiv = 6,
         .io.adc_clock_ratio = 0,
         .io.pll_int_loop_filt = 0,
-        .reset = dib7090_tuner_sleep,
-        .sleep = dib7090_tuner_sleep,
 
         .freq_offset_khz_uhf = 0,
         .freq_offset_khz_vhf = 0,
 
-        .get_adc_power = dib7090_get_adc_power,
-
         .clkouttobamse = 1,
         .analog_output = 0,
 
@@ -2776,7 +2894,7 @@ static struct dib7000p_config tfe7790p_dib7000p_config = {
         .enMpegOutput                           = 1,
 };
 
-static const struct dib0090_config tfe7790p_dib0090_config = {
+static struct dib0090_config tfe7790p_dib0090_config = {
         .io.clock_khz = 12000,
         .io.pll_bypass = 0,
         .io.pll_range = 0,
@@ -2784,14 +2902,10 @@ static const struct dib0090_config tfe7790p_dib0090_config = {
         .io.pll_loopdiv = 6,
         .io.adc_clock_ratio = 0,
         .io.pll_int_loop_filt = 0,
-        .reset = dib7090_tuner_sleep,
-        .sleep = dib7090_tuner_sleep,
 
         .freq_offset_khz_uhf = 0,
         .freq_offset_khz_vhf = 0,
 
-        .get_adc_power = dib7090_get_adc_power,
-
         .clkouttobamse = 1,
         .analog_output = 0,
 
@@ -2813,7 +2927,7 @@ static const struct dib0090_config tfe7790p_dib0090_config = {
         .force_crystal_mode = 1,
 };
 
-static const struct dib0090_config tfe7090pvr_dib0090_config[2] = {
+static struct dib0090_config tfe7090pvr_dib0090_config[2] = {
         {
                 .io.clock_khz = 12000,
                 .io.pll_bypass = 0,
@@ -2822,14 +2936,10 @@ static const struct dib0090_config tfe7090pvr_dib0090_config[2] = {
                 .io.pll_loopdiv = 6,
                 .io.adc_clock_ratio = 0,
                 .io.pll_int_loop_filt = 0,
-                .reset = dib7090_tuner_sleep,
-                .sleep = dib7090_tuner_sleep,
 
                 .freq_offset_khz_uhf = 50,
                 .freq_offset_khz_vhf = 70,
 
-                .get_adc_power = dib7090_get_adc_power,
-
                 .clkouttobamse = 1,
                 .analog_output = 0,
 
@@ -2854,14 +2964,10 @@ static const struct dib0090_config tfe7090pvr_dib0090_config[2] = {
                 .io.pll_loopdiv = 6,
                 .io.adc_clock_ratio = 0,
                 .io.pll_int_loop_filt = 0,
-                .reset = dib7090_tuner_sleep,
-                .sleep = dib7090_tuner_sleep,
 
                 .freq_offset_khz_uhf = -50,
                 .freq_offset_khz_vhf = -70,
 
-                .get_adc_power = dib7090_get_adc_power,
-
                 .clkouttobamse = 1,
                 .analog_output = 0,
 
@@ -2883,6 +2989,11 @@ static const struct dib0090_config tfe7090pvr_dib0090_config[2] = {
 
 static int nim7090_frontend_attach(struct dvb_usb_adapter *adap)
 {
+        struct dib0700_adapter_state *state = adap->priv;
+
+        if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
+                return -ENODEV;
+
         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
         msleep(20);
         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
@@ -2895,11 +3006,12 @@ static int nim7090_frontend_attach(struct dvb_usb_adapter *adap)
         msleep(20);
         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
 
-        if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x10, &nim7090_dib7000p_config) != 0) {
-                err("%s: dib7000p_i2c_enumeration failed.  Cannot continue\n", __func__);
+        if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 0x10, &nim7090_dib7000p_config) != 0) {
+                err("%s: state->dib7000p_ops.i2c_enumeration failed.  Cannot continue\n", __func__);
+                dvb_detach(&state->dib7000p_ops);
                 return -ENODEV;
         }
-        adap->fe_adap[0].fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x80, &nim7090_dib7000p_config);
+        adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap, 0x80, &nim7090_dib7000p_config);
 
         return adap->fe_adap[0].fe == NULL ?  -ENODEV : 0;
 }
@@ -2907,12 +3019,16 @@ static int nim7090_frontend_attach(struct dvb_usb_adapter *adap)
 static int nim7090_tuner_attach(struct dvb_usb_adapter *adap)
 {
         struct dib0700_adapter_state *st = adap->priv;
-        struct i2c_adapter *tun_i2c = dib7090_get_i2c_tuner(adap->fe_adap[0].fe);
+        struct i2c_adapter *tun_i2c = st->dib7000p_ops.get_i2c_tuner(adap->fe_adap[0].fe);
+
+        nim7090_dib0090_config.reset = st->dib7000p_ops.tuner_sleep,
+        nim7090_dib0090_config.sleep = st->dib7000p_ops.tuner_sleep,
+        nim7090_dib0090_config.get_adc_power = st->dib7000p_ops.get_adc_power;
 
         if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c, &nim7090_dib0090_config) == NULL)
                 return -ENODEV;
 
-        dib7000p_set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
+        st->dib7000p_ops.set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
 
         st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
         adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib7090_agc_startup;
@@ -2922,6 +3038,10 @@ static int nim7090_tuner_attach(struct dvb_usb_adapter *adap)
 static int tfe7090pvr_frontend0_attach(struct dvb_usb_adapter *adap)
 {
         struct dib0700_state *st = adap->dev->priv;
+        struct dib0700_adapter_state *state = adap->priv;
+
+        if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
+                return -ENODEV;
 
         /* The TFE7090 requires the dib0700 to not be in master mode */
         st->disable_streaming_master_mode = 1;
@@ -2939,17 +3059,18 @@ static int tfe7090pvr_frontend0_attach(struct dvb_usb_adapter *adap)
         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
 
         /* initialize IC 0 */
-        if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x20, &tfe7090pvr_dib7000p_config[0]) != 0) {
-                err("%s: dib7000p_i2c_enumeration failed.  Cannot continue\n", __func__);
+        if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 0x20, &tfe7090pvr_dib7000p_config[0]) != 0) {
+                err("%s: state->dib7000p_ops.i2c_enumeration failed.  Cannot continue\n", __func__);
+                dvb_detach(&state->dib7000p_ops);
                 return -ENODEV;
         }
 
         dib0700_set_i2c_speed(adap->dev, 340);
-        adap->fe_adap[0].fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x90, &tfe7090pvr_dib7000p_config[0]);
+        adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap, 0x90, &tfe7090pvr_dib7000p_config[0]);
         if (adap->fe_adap[0].fe == NULL)
                 return -ENODEV;
 
-        dib7090_slave_reset(adap->fe_adap[0].fe);
+        state->dib7000p_ops.slave_reset(adap->fe_adap[0].fe);
 
         return 0;
 }
@@ -2957,19 +3078,24 @@ static int tfe7090pvr_frontend0_attach(struct dvb_usb_adapter *adap)
 static int tfe7090pvr_frontend1_attach(struct dvb_usb_adapter *adap)
 {
         struct i2c_adapter *i2c;
+        struct dib0700_adapter_state *state = adap->priv;
 
         if (adap->dev->adapter[0].fe_adap[0].fe == NULL) {
                 err("the master dib7090 has to be initialized first");
                 return -ENODEV; /* the master device has not been initialized */
         }
 
-        i2c = dib7000p_get_i2c_master(adap->dev->adapter[0].fe_adap[0].fe, DIBX000_I2C_INTERFACE_GPIO_6_7, 1);
-        if (dib7000p_i2c_enumeration(i2c, 1, 0x10, &tfe7090pvr_dib7000p_config[1]) != 0) {
-                err("%s: dib7000p_i2c_enumeration failed.  Cannot continue\n", __func__);
+        if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
+                return -ENODEV;
+
+        i2c = state->dib7000p_ops.get_i2c_master(adap->dev->adapter[0].fe_adap[0].fe, DIBX000_I2C_INTERFACE_GPIO_6_7, 1);
+        if (state->dib7000p_ops.i2c_enumeration(i2c, 1, 0x10, &tfe7090pvr_dib7000p_config[1]) != 0) {
+                err("%s: state->dib7000p_ops.i2c_enumeration failed.  Cannot continue\n", __func__);
+                dvb_detach(&state->dib7000p_ops);
                 return -ENODEV;
         }
 
-        adap->fe_adap[0].fe = dvb_attach(dib7000p_attach, i2c, 0x92, &tfe7090pvr_dib7000p_config[1]);
+        adap->fe_adap[0].fe = state->dib7000p_ops.init(i2c, 0x92, &tfe7090pvr_dib7000p_config[1]);
         dib0700_set_i2c_speed(adap->dev, 200);
 
         return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
@@ -2978,12 +3104,16 @@ static int tfe7090pvr_frontend1_attach(struct dvb_usb_adapter *adap)
 static int tfe7090pvr_tuner0_attach(struct dvb_usb_adapter *adap)
 {
         struct dib0700_adapter_state *st = adap->priv;
-        struct i2c_adapter *tun_i2c = dib7090_get_i2c_tuner(adap->fe_adap[0].fe);
+        struct i2c_adapter *tun_i2c = st->dib7000p_ops.get_i2c_tuner(adap->fe_adap[0].fe);
+
+        tfe7090pvr_dib0090_config[0].reset = st->dib7000p_ops.tuner_sleep;
+        tfe7090pvr_dib0090_config[0].sleep = st->dib7000p_ops.tuner_sleep;
+        tfe7090pvr_dib0090_config[0].get_adc_power = st->dib7000p_ops.get_adc_power;
 
         if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c, &tfe7090pvr_dib0090_config[0]) == NULL)
                 return -ENODEV;
 
-        dib7000p_set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
+        st->dib7000p_ops.set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
 
         st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
         adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib7090_agc_startup;
@@ -2993,12 +3123,16 @@ static int tfe7090pvr_tuner0_attach(struct dvb_usb_adapter *adap)
 static int tfe7090pvr_tuner1_attach(struct dvb_usb_adapter *adap)
 {
         struct dib0700_adapter_state *st = adap->priv;
-        struct i2c_adapter *tun_i2c = dib7090_get_i2c_tuner(adap->fe_adap[0].fe);
+        struct i2c_adapter *tun_i2c = st->dib7000p_ops.get_i2c_tuner(adap->fe_adap[0].fe);
+
+        tfe7090pvr_dib0090_config[1].reset = st->dib7000p_ops.tuner_sleep;
+        tfe7090pvr_dib0090_config[1].sleep = st->dib7000p_ops.tuner_sleep;
+        tfe7090pvr_dib0090_config[1].get_adc_power = st->dib7000p_ops.get_adc_power;
 
         if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c, &tfe7090pvr_dib0090_config[1]) == NULL)
                 return -ENODEV;
 
-        dib7000p_set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
+        st->dib7000p_ops.set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
 
         st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
         adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib7090_agc_startup;
@@ -3008,6 +3142,10 @@ static int tfe7090pvr_tuner1_attach(struct dvb_usb_adapter *adap)
 static int tfe7790p_frontend_attach(struct dvb_usb_adapter *adap)
 {
         struct dib0700_state *st = adap->dev->priv;
+        struct dib0700_adapter_state *state = adap->priv;
+
+        if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
+                return -ENODEV;
 
         /* The TFE7790P requires the dib0700 to not be in master mode */
         st->disable_streaming_master_mode = 1;
@@ -3024,13 +3162,14 @@ static int tfe7790p_frontend_attach(struct dvb_usb_adapter *adap)
         msleep(20);
         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
 
-        if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap,
+        if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap,
                                 1, 0x10, &tfe7790p_dib7000p_config) != 0) {
-                err("%s: dib7000p_i2c_enumeration failed.  Cannot continue\n",
+                err("%s: state->dib7000p_ops.i2c_enumeration failed.  Cannot continue\n",
                                 __func__);
+                dvb_detach(&state->dib7000p_ops);
                 return -ENODEV;
         }
-        adap->fe_adap[0].fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap,
+        adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap,
                         0x80, &tfe7790p_dib7000p_config);
 
         return adap->fe_adap[0].fe == NULL ?  -ENODEV : 0;
@@ -3040,13 +3179,18 @@ static int tfe7790p_tuner_attach(struct dvb_usb_adapter *adap)
 {
         struct dib0700_adapter_state *st = adap->priv;
         struct i2c_adapter *tun_i2c =
-                dib7090_get_i2c_tuner(adap->fe_adap[0].fe);
+                st->dib7000p_ops.get_i2c_tuner(adap->fe_adap[0].fe);
+
+
+        tfe7790p_dib0090_config.reset = st->dib7000p_ops.tuner_sleep;
+        tfe7790p_dib0090_config.sleep = st->dib7000p_ops.tuner_sleep;
+        tfe7790p_dib0090_config.get_adc_power = st->dib7000p_ops.get_adc_power;
 
         if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c,
                                 &tfe7790p_dib0090_config) == NULL)
                 return -ENODEV;
 
-        dib7000p_set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
+        st->dib7000p_ops.set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
 
         st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
         adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib7090_agc_startup;
@@ -3103,25 +3247,36 @@ static void stk7070pd_init(struct dvb_usb_device *dev)
 
 static int stk7070pd_frontend_attach0(struct dvb_usb_adapter *adap)
 {
+        struct dib0700_adapter_state *state = adap->priv;
+
+        if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
+                return -ENODEV;
+
         stk7070pd_init(adap->dev);
 
         msleep(10);
         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
 
-        if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 2, 18,
+        if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap, 2, 18,
                                      stk7070pd_dib7000p_config) != 0) {
-                err("%s: dib7000p_i2c_enumeration failed.  Cannot continue\n",
+                err("%s: state->dib7000p_ops.i2c_enumeration failed.  Cannot continue\n",
                     __func__);
+                dvb_detach(&state->dib7000p_ops);
                 return -ENODEV;
         }
 
-        adap->fe_adap[0].fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x80, &stk7070pd_dib7000p_config[0]);
+        adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap, 0x80, &stk7070pd_dib7000p_config[0]);
         return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
 }
 
 static int stk7070pd_frontend_attach1(struct dvb_usb_adapter *adap)
 {
-        adap->fe_adap[0].fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x82, &stk7070pd_dib7000p_config[1]);
+        struct dib0700_adapter_state *state = adap->priv;
+
+        if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
+                return -ENODEV;
+
+        adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap, 0x82, &stk7070pd_dib7000p_config[1]);
         return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
 }
 
@@ -3164,6 +3319,10 @@ static int novatd_frontend_attach(struct dvb_usb_adapter *adap)
 {
         struct dvb_usb_device *dev = adap->dev;
         struct dib0700_state *st = dev->priv;
+        struct dib0700_adapter_state *state = adap->priv;
+
+        if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
+                return -ENODEV;
 
         if (adap->id == 0) {
                 stk7070pd_init(dev);
@@ -3173,15 +3332,16 @@ static int novatd_frontend_attach(struct dvb_usb_adapter *adap)
                 dib0700_set_gpio(dev, GPIO1, GPIO_OUT, 0);
                 dib0700_set_gpio(dev, GPIO2, GPIO_OUT, 1);
 
-                if (dib7000p_i2c_enumeration(&dev->i2c_adap, 2, 18,
+                if (state->dib7000p_ops.i2c_enumeration(&dev->i2c_adap, 2, 18,
                                              stk7070pd_dib7000p_config) != 0) {
-                        err("%s: dib7000p_i2c_enumeration failed.  Cannot continue\n",
+                        err("%s: state->dib7000p_ops.i2c_enumeration failed.  Cannot continue\n",
                             __func__);
+                        dvb_detach(&state->dib7000p_ops);
                         return -ENODEV;
                 }
         }
 
-        adap->fe_adap[0].fe = dvb_attach(dib7000p_attach, &dev->i2c_adap,
+        adap->fe_adap[0].fe = state->dib7000p_ops.init(&dev->i2c_adap,
                         adap->id == 0 ? 0x80 : 0x82,
                         &stk7070pd_dib7000p_config[adap->id]);
 
@@ -3291,12 +3451,13 @@ static int dib0700_xc4000_tuner_callback(void *priv, int component,
                                          int command, int arg)
 {
         struct dvb_usb_adapter *adap = priv;
+        struct dib0700_adapter_state *state = adap->priv;
 
         if (command == XC4000_TUNER_RESET) {
                 /* Reset the tuner */
-                dib7000p_set_gpio(adap->fe_adap[0].fe, 8, 0, 0);
+                state->dib7000p_ops.set_gpio(adap->fe_adap[0].fe, 8, 0, 0);
                 msleep(10);
-                dib7000p_set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
+                state->dib7000p_ops.set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
         } else {
                 err("xc4000: unknown tuner callback command: %d\n", command);
                 return -EINVAL;
@@ -3374,6 +3535,10 @@ static struct dib7000p_config pctv_340e_config = {
 static int pctv340e_frontend_attach(struct dvb_usb_adapter *adap)
 {
         struct dib0700_state *st = adap->dev->priv;
+        struct dib0700_adapter_state *state = adap->priv;
+
+        if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
+                return -ENODEV;
 
         /* Power Supply on */
         dib0700_set_gpio(adap->dev, GPIO6,  GPIO_OUT, 0);
@@ -3397,12 +3562,13 @@ static int pctv340e_frontend_attach(struct dvb_usb_adapter *adap)
 
         msleep(500);
 
-        if (dib7000pc_detection(&adap->dev->i2c_adap) == 0) {
+        if (state->dib7000p_ops.dib7000pc_detection(&adap->dev->i2c_adap) == 0) {
                 /* Demodulator not found for some reason? */
+                dvb_detach(&state->dib7000p_ops);
                 return -ENODEV;
         }
 
-        adap->fe_adap[0].fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x12,
+        adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap, 0x12,
                               &pctv_340e_config);
         st->is_dib7000pc = 1;
 
@@ -3420,9 +3586,10 @@ static struct xc4000_config dib7000p_xc4000_tunerconfig = {
 static int xc4000_tuner_attach(struct dvb_usb_adapter *adap)
 {
         struct i2c_adapter *tun_i2c;
+        struct dib0700_adapter_state *state = adap->priv;
 
         /* The xc4000 is not on the main i2c bus */
-        tun_i2c = dib7000p_get_i2c_master(adap->fe_adap[0].fe,
+        tun_i2c = state->dib7000p_ops.get_i2c_master(adap->fe_adap[0].fe,
                                           DIBX000_I2C_INTERFACE_TUNER, 1);
         if (tun_i2c == NULL) {
                 printk(KERN_ERR "Could not reach tuner i2c bus\n");
@@ -3636,6 +3803,7 @@ struct dvb_usb_device_properties dib0700_devices[] = {
 
                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
                         }},
+                                .size_of_priv     = sizeof(struct dib0700_adapter_state),
                         },
                 },
 
diff --git a/drivers/media/usb/dvb-usb/dibusb.h b/drivers/media/usb/dvb-usb/dibusb.h
index e47c321b3ffc..32ab1392313f 100644
--- a/drivers/media/usb/dvb-usb/dibusb.h
+++ b/drivers/media/usb/dvb-usb/dibusb.h
@@ -36,7 +36,7 @@
 
 /*
  * i2c read
- * bulk write: 0x02 ((7bit i2c_addr << 1) & 0x01) register_bytes length_word
+ * bulk write: 0x02 ((7bit i2c_addr << 1) | 0x01) register_bytes length_word
  * bulk read:  byte_buffer (length_word bytes)
  */
 #define DIBUSB_REQ_I2C_READ                     0x02
diff --git a/drivers/media/usb/dvb-usb/dvb-usb-remote.c b/drivers/media/usb/dvb-usb/dvb-usb-remote.c
index 4058aea9272f..7b5dae3077f6 100644
--- a/drivers/media/usb/dvb-usb/dvb-usb-remote.c
+++ b/drivers/media/usb/dvb-usb/dvb-usb-remote.c
@@ -272,7 +272,7 @@ static int rc_core_dvb_usb_remote_init(struct dvb_usb_device *d)
         dev->driver_name = d->props.rc.core.module_name;
         dev->map_name = d->props.rc.core.rc_codes;
         dev->change_protocol = d->props.rc.core.change_protocol;
-        rc_set_allowed_protocols(dev, d->props.rc.core.allowed_protos);
+        dev->allowed_protocols = d->props.rc.core.allowed_protos;
         dev->driver_type = d->props.rc.core.driver_type;
         usb_to_input_id(d->udev, &dev->input_id);
         dev->input_name = "IR-receiver inside an USB DVB receiver";
diff --git a/drivers/media/usb/dvb-usb/dw2102.c b/drivers/media/usb/dvb-usb/dw2102.c
index ae0f56a32e4d..2add8c507ec9 100644
--- a/drivers/media/usb/dvb-usb/dw2102.c
+++ b/drivers/media/usb/dvb-usb/dw2102.c
@@ -1109,6 +1109,7 @@ static struct ds3000_config su3000_ds3000_config = {
 static struct cxd2820r_config cxd2820r_config = {
         .i2c_address = 0x6c, /* (0xd8 >> 1) */
         .ts_mode = 0x38,
+        .ts_clock_inv = 1,
 };
 
 static struct tda18271_config tda18271_config = {
@@ -1387,20 +1388,27 @@ static int su3000_frontend_attach(struct dvb_usb_adapter *d)
 
 static int t220_frontend_attach(struct dvb_usb_adapter *d)
 {
-        u8 obuf[3] = { 0xe, 0x80, 0 };
+        u8 obuf[3] = { 0xe, 0x87, 0 };
         u8 ibuf[] = { 0 };
 
         if (dvb_usb_generic_rw(d->dev, obuf, 3, ibuf, 1, 0) < 0)
                 err("command 0x0e transfer failed.");
 
         obuf[0] = 0xe;
-        obuf[1] = 0x83;
+        obuf[1] = 0x86;
+        obuf[2] = 1;
+
+        if (dvb_usb_generic_rw(d->dev, obuf, 3, ibuf, 1, 0) < 0)
+                err("command 0x0e transfer failed.");
+
+        obuf[0] = 0xe;
+        obuf[1] = 0x80;
         obuf[2] = 0;
 
         if (dvb_usb_generic_rw(d->dev, obuf, 3, ibuf, 1, 0) < 0)
                 err("command 0x0e transfer failed.");
 
-        msleep(100);
+        msleep(50);
 
         obuf[0] = 0xe;
         obuf[1] = 0x80;
@@ -1482,7 +1490,7 @@ static int dw2102_rc_query(struct dvb_usb_device *d)
                 if (msg.buf[0] != 0xff) {
                         deb_rc("%s: rc code: %x, %x\n",
                                         __func__, key[0], key[1]);
-                        rc_keydown(d->rc_dev, key[0], 1);
+                        rc_keydown(d->rc_dev, RC_TYPE_UNKNOWN, key[0], 0);
                 }
         }
 
@@ -1503,7 +1511,7 @@ static int prof_rc_query(struct dvb_usb_device *d)
                 if (msg.buf[0] != 0xff) {
                         deb_rc("%s: rc code: %x, %x\n",
                                         __func__, key[0], key[1]);
-                        rc_keydown(d->rc_dev, key[0]^0xff, 1);
+                        rc_keydown(d->rc_dev, RC_TYPE_UNKNOWN, key[0]^0xff, 0);
                 }
         }
 
@@ -1524,7 +1532,8 @@ static int su3000_rc_query(struct dvb_usb_device *d)
                 if (msg.buf[0] != 0xff) {
                         deb_rc("%s: rc code: %x, %x\n",
                                         __func__, key[0], key[1]);
-                        rc_keydown(d->rc_dev, key[1] << 8 | key[0], 1);
+                        rc_keydown(d->rc_dev, RC_TYPE_RC5,
+                                   RC_SCANCODE_RC5(key[1], key[0]), 0);
                 }
         }
 
diff --git a/drivers/media/usb/dvb-usb/m920x.c b/drivers/media/usb/dvb-usb/m920x.c
index 0306cb778df4..abf8ab2e02e5 100644
--- a/drivers/media/usb/dvb-usb/m920x.c
+++ b/drivers/media/usb/dvb-usb/m920x.c
@@ -245,7 +245,7 @@ static int m920x_rc_core_query(struct dvb_usb_device *d)
         else if (state == REMOTE_KEY_REPEAT)
                 rc_repeat(d->rc_dev);
         else
-                rc_keydown(d->rc_dev, rc_state[1], 0);
+                rc_keydown(d->rc_dev, RC_TYPE_UNKNOWN, rc_state[1], 0);
 
 out:
         kfree(rc_state);
diff --git a/drivers/media/usb/dvb-usb/pctv452e.c b/drivers/media/usb/dvb-usb/pctv452e.c
index 449a99605a87..bdfe8963591c 100644
--- a/drivers/media/usb/dvb-usb/pctv452e.c
+++ b/drivers/media/usb/dvb-usb/pctv452e.c
@@ -565,12 +565,12 @@ static int pctv452e_rc_query(struct dvb_usb_device *d)
 
         if ((rx[3] == 9) &&  (rx[12] & 0x01)) {
                 /* got a "press" event */
-                state->last_rc_key = (rx[7] << 8) | rx[6];
+                state->last_rc_key = RC_SCANCODE_RC5(rx[7], rx[6]);
                 if (debug > 2)
                         info("%s: cmd=0x%02x sys=0x%02x\n",
                                 __func__, rx[6], rx[7]);
 
-                rc_keydown(d->rc_dev, state->last_rc_key, 0);
+                rc_keydown(d->rc_dev, RC_TYPE_RC5, state->last_rc_key, 0);
         } else if (state->last_rc_key) {
                 rc_keyup(d->rc_dev);
                 state->last_rc_key = 0;
@@ -927,7 +927,7 @@ static struct dvb_usb_device_properties pctv452e_properties = {
 
         .rc.core = {
                 .rc_codes       = RC_MAP_DIB0700_RC5_TABLE,
-                .allowed_protos = RC_BIT_UNKNOWN,
+                .allowed_protos = RC_BIT_RC5,
                 .rc_query       = pctv452e_rc_query,
                 .rc_interval    = 100,
         },
@@ -980,7 +980,7 @@ static struct dvb_usb_device_properties tt_connect_s2_3600_properties = {
 
         .rc.core = {
                 .rc_codes       = RC_MAP_TT_1500,
-                .allowed_protos = RC_BIT_UNKNOWN,
+                .allowed_protos = RC_BIT_RC5,
                 .rc_query       = pctv452e_rc_query,
                 .rc_interval    = 100,
         },
diff --git a/drivers/media/usb/dvb-usb/technisat-usb2.c b/drivers/media/usb/dvb-usb/technisat-usb2.c
index d947e0379008..6b0b8b6b9e2a 100644
--- a/drivers/media/usb/dvb-usb/technisat-usb2.c
+++ b/drivers/media/usb/dvb-usb/technisat-usb2.c
@@ -710,7 +710,7 @@ static struct dvb_usb_device_properties technisat_usb2_devices = {
                                         .isoc = {
                                                 .framesperurb = 32,
                                                 .framesize = 2048,
-                                                .interval = 3,
+                                                .interval = 1,
                                         }
                                 }
                         },
diff --git a/drivers/media/usb/dvb-usb/ttusb2.c b/drivers/media/usb/dvb-usb/ttusb2.c
index 2ce3d19c58ef..f10717311e05 100644
--- a/drivers/media/usb/dvb-usb/ttusb2.c
+++ b/drivers/media/usb/dvb-usb/ttusb2.c
@@ -438,9 +438,9 @@ static int tt3650_rc_query(struct dvb_usb_device *d)
 
         if (rx[8] & 0x01) {
                 /* got a "press" event */
-                st->last_rc_key = (rx[3] << 8) | rx[2];
+                st->last_rc_key = RC_SCANCODE_RC5(rx[3], rx[2]);
                 deb_info("%s: cmd=0x%02x sys=0x%02x\n", __func__, rx[2], rx[3]);
-                rc_keydown(d->rc_dev, st->last_rc_key, rx[1]);
+                rc_keydown(d->rc_dev, RC_TYPE_RC5, st->last_rc_key, rx[1]);
         } else if (st->last_rc_key) {
                 rc_keyup(d->rc_dev);
                 st->last_rc_key = 0;
@@ -747,7 +747,7 @@ static struct dvb_usb_device_properties ttusb2_properties_ct3650 = {
                 .rc_interval      = 150, /* Less than IR_KEYPRESS_TIMEOUT */
                 .rc_codes         = RC_MAP_TT_1500,
                 .rc_query         = tt3650_rc_query,
-                .allowed_protos   = RC_BIT_UNKNOWN,
+                .allowed_protos   = RC_BIT_RC5,
         },
 
         .num_adapters = 1,
diff --git a/drivers/media/usb/em28xx/em28xx-camera.c b/drivers/media/usb/em28xx/em28xx-camera.c
index 12d4c0326e31..6d2ea9afd57b 100644
--- a/drivers/media/usb/em28xx/em28xx-camera.c
+++ b/drivers/media/usb/em28xx/em28xx-camera.c
@@ -366,7 +366,7 @@ int em28xx_init_camera(struct em28xx *dev)
                 v4l2->sensor_xtal = 4300000;
                 pdata.xtal = v4l2->sensor_xtal;
                 if (NULL ==
-                    v4l2_i2c_new_subdev_board(&dev->v4l2->v4l2_dev, adap,
+                    v4l2_i2c_new_subdev_board(&v4l2->v4l2_dev, adap,
                                               &mt9v011_info, NULL)) {
                         ret = -ENODEV;
                         break;
@@ -423,7 +423,7 @@ int em28xx_init_camera(struct em28xx *dev)
                 v4l2->sensor_yres = 480;
 
                 subdev =
-                     v4l2_i2c_new_subdev_board(&dev->v4l2->v4l2_dev, adap,
+                     v4l2_i2c_new_subdev_board(&v4l2->v4l2_dev, adap,
                                                &ov2640_info, NULL);
                 if (NULL == subdev) {
                         ret = -ENODEV;
diff --git a/drivers/media/usb/em28xx/em28xx-cards.c b/drivers/media/usb/em28xx/em28xx-cards.c
index 15ad47045553..a7e24848f6c8 100644
--- a/drivers/media/usb/em28xx/em28xx-cards.c
+++ b/drivers/media/usb/em28xx/em28xx-cards.c
@@ -2280,6 +2280,8 @@ struct usb_device_id em28xx_id_table[] = {
                         .driver_info = EM2820_BOARD_UNKNOWN },
         { USB_DEVICE(0xeb1a, 0x2875),
                         .driver_info = EM2820_BOARD_UNKNOWN },
+        { USB_DEVICE(0xeb1a, 0x2885), /* MSI Digivox Trio */
+                        .driver_info = EM2884_BOARD_TERRATEC_H5 },
         { USB_DEVICE(0xeb1a, 0xe300),
                         .driver_info = EM2861_BOARD_KWORLD_PVRTV_300U },
         { USB_DEVICE(0xeb1a, 0xe303),
@@ -3522,7 +3524,6 @@ static struct usb_driver em28xx_usb_driver = {
         .disconnect = em28xx_usb_disconnect,
         .suspend = em28xx_usb_suspend,
         .resume = em28xx_usb_resume,
-        .reset_resume = em28xx_usb_resume,
         .id_table = em28xx_id_table,
 };
 
diff --git a/drivers/media/usb/em28xx/em28xx-dvb.c b/drivers/media/usb/em28xx/em28xx-dvb.c
index a121ed9561fd..3a3e243edf89 100644
--- a/drivers/media/usb/em28xx/em28xx-dvb.c
+++ b/drivers/media/usb/em28xx/em28xx-dvb.c
@@ -1213,9 +1213,17 @@ static int em28xx_dvb_init(struct em28xx *dev)
                 dvb->fe[0] = dvb_attach(lgdt3305_attach,
                                            &em2870_lgdt3304_dev,
                                            &dev->i2c_adap[dev->def_i2c_bus]);
-                if (dvb->fe[0] != NULL)
-                        dvb_attach(tda18271_attach, dvb->fe[0], 0x60,
-                                   &dev->i2c_adap[dev->def_i2c_bus], &kworld_a340_config);
+                if (!dvb->fe[0]) {
+                        result = -EINVAL;
+                        goto out_free;
+                }
+                if (!dvb_attach(tda18271_attach, dvb->fe[0], 0x60,
+                        &dev->i2c_adap[dev->def_i2c_bus],
+                        &kworld_a340_config)) {
+                                dvb_frontend_detach(dvb->fe[0]);
+                                result = -EINVAL;
+                                goto out_free;
+                }
                 break;
         case EM28174_BOARD_PCTV_290E:
                 /* set default GPIO0 for LNA, used if GPIOLIB is undefined */
@@ -1545,6 +1553,7 @@ static int em28xx_dvb_init(struct em28xx *dev)
                         dvb->i2c_client_demod = client;
 
                         /* attach tuner */
+                        memset(&si2157_config, 0, sizeof(si2157_config));
                         si2157_config.fe = dvb->fe[0];
                         memset(&info, 0, sizeof(struct i2c_board_info));
                         strlcpy(info.type, "si2157", I2C_NAME_SIZE);
@@ -1645,10 +1654,14 @@ static int em28xx_dvb_fini(struct em28xx *dev)
         if (dev->disconnected) {
                 /* We cannot tell the device to sleep
                  * once it has been unplugged. */
-                if (dvb->fe[0])
+                if (dvb->fe[0]) {
                         prevent_sleep(&dvb->fe[0]->ops);
-                if (dvb->fe[1])
+                        dvb->fe[0]->exit = DVB_FE_DEVICE_REMOVED;
+                }
+                if (dvb->fe[1]) {
                         prevent_sleep(&dvb->fe[1]->ops);
+                        dvb->fe[1]->exit = DVB_FE_DEVICE_REMOVED;
+                }
         }
 
         /* remove I2C tuner */
@@ -1712,7 +1725,6 @@ static int em28xx_dvb_resume(struct em28xx *dev)
         em28xx_info("Resuming DVB extension");
         if (dev->dvb) {
                 struct em28xx_dvb *dvb = dev->dvb;
-                struct i2c_client *client = dvb->i2c_client_tuner;
 
                 if (dvb->fe[0]) {
                         ret = dvb_frontend_resume(dvb->fe[0]);
@@ -1723,22 +1735,6 @@ static int em28xx_dvb_resume(struct em28xx *dev)
                         ret = dvb_frontend_resume(dvb->fe[1]);
                         em28xx_info("fe1 resume %d", ret);
                 }
-                /* remove I2C tuner */
-                if (client) {
-                        module_put(client->dev.driver->owner);
-                        i2c_unregister_device(client);
-                }
-
-                /* remove I2C demod */
-                client = dvb->i2c_client_demod;
-                if (client) {
-                        module_put(client->dev.driver->owner);
-                        i2c_unregister_device(client);
-                }
-
-                em28xx_unregister_dvb(dvb);
-                kfree(dvb);
-                dev->dvb = NULL;
         }
 
         return 0;
diff --git a/drivers/media/usb/em28xx/em28xx-i2c.c b/drivers/media/usb/em28xx/em28xx-i2c.c
index b58d4ebf6419..1048c1a23fb6 100644
--- a/drivers/media/usb/em28xx/em28xx-i2c.c
+++ b/drivers/media/usb/em28xx/em28xx-i2c.c
@@ -501,6 +501,12 @@ static int em28xx_i2c_xfer(struct i2c_adapter *i2c_adap,
         int addr, rc, i;
         u8 reg;
 
+        /* prevent i2c xfer attempts after device is disconnected
+           some fe's try to do i2c writes/reads from their release
+           interfaces when called in disconnect path */
+        if (dev->disconnected)
+                return -ENODEV;
+
         rc = rt_mutex_trylock(&dev->i2c_bus_lock);
         if (rc < 0)
                 return rc;
diff --git a/drivers/media/usb/em28xx/em28xx-input.c b/drivers/media/usb/em28xx/em28xx-input.c
index 56ef49df4f8d..ed843bd221ea 100644
--- a/drivers/media/usb/em28xx/em28xx-input.c
+++ b/drivers/media/usb/em28xx/em28xx-input.c
@@ -27,6 +27,7 @@
 #include <linux/interrupt.h>
 #include <linux/usb.h>
 #include <linux/slab.h>
+#include <linux/bitrev.h>
 
 #include "em28xx.h"
 
@@ -53,6 +54,7 @@ struct em28xx_ir_poll_result {
         unsigned int toggle_bit:1;
         unsigned int read_count:7;
 
+        enum rc_type protocol;
         u32 scancode;
 };
 
@@ -72,7 +74,7 @@ struct em28xx_IR {
         /* i2c slave address of external device (if used) */
         u16 i2c_dev_addr;
 
-        int  (*get_key_i2c)(struct i2c_client *, u32 *);
+        int  (*get_key_i2c)(struct i2c_client *ir, enum rc_type *protocol, u32 *scancode);
         int  (*get_key)(struct em28xx_IR *, struct em28xx_ir_poll_result *);
 };
 
@@ -80,7 +82,8 @@ struct em28xx_IR {
  I2C IR based get keycodes - should be used with ir-kbd-i2c
  **********************************************************/
 
-static int em28xx_get_key_terratec(struct i2c_client *i2c_dev, u32 *ir_key)
+static int em28xx_get_key_terratec(struct i2c_client *i2c_dev,
+                                   enum rc_type *protocol, u32 *scancode)
 {
         unsigned char b;
 
@@ -98,14 +101,15 @@ static int em28xx_get_key_terratec(struct i2c_client *i2c_dev, u32 *ir_key)
                 /* keep old data */
                 return 1;
 
-        *ir_key = b;
+        *protocol = RC_TYPE_UNKNOWN;
+        *scancode = b;
         return 1;
 }
 
-static int em28xx_get_key_em_haup(struct i2c_client *i2c_dev, u32 *ir_key)
+static int em28xx_get_key_em_haup(struct i2c_client *i2c_dev,
+                                  enum rc_type *protocol, u32 *scancode)
 {
         unsigned char buf[2];
-        u16 code;
         int size;
 
         /* poll IR chip */
@@ -127,26 +131,13 @@ static int em28xx_get_key_em_haup(struct i2c_client *i2c_dev, u32 *ir_key)
          * So, the code translation is not complete. Yet, it is enough to
          * work with the provided RC5 IR.
          */
-        code =
-                 ((buf[0] & 0x01) ? 0x0020 : 0) | /*            0010 0000 */
-                 ((buf[0] & 0x02) ? 0x0010 : 0) | /*            0001 0000 */
-                 ((buf[0] & 0x04) ? 0x0008 : 0) | /*            0000 1000 */
-                 ((buf[0] & 0x08) ? 0x0004 : 0) | /*            0000 0100 */
-                 ((buf[0] & 0x10) ? 0x0002 : 0) | /*            0000 0010 */
-                 ((buf[0] & 0x20) ? 0x0001 : 0) | /*            0000 0001 */
-                 ((buf[1] & 0x08) ? 0x1000 : 0) | /* 0001 0000            */
-                 ((buf[1] & 0x10) ? 0x0800 : 0) | /* 0000 1000            */
-                 ((buf[1] & 0x20) ? 0x0400 : 0) | /* 0000 0100            */
-                 ((buf[1] & 0x40) ? 0x0200 : 0) | /* 0000 0010            */
-                 ((buf[1] & 0x80) ? 0x0100 : 0);  /* 0000 0001            */
-
-        /* return key */
-        *ir_key = code;
+        *protocol = RC_TYPE_RC5;
+        *scancode = (bitrev8(buf[1]) & 0x1f) << 8 | bitrev8(buf[0]) >> 2;
         return 1;
 }
 
 static int em28xx_get_key_pinnacle_usb_grey(struct i2c_client *i2c_dev,
-                                            u32 *ir_key)
+                                            enum rc_type *protocol, u32 *scancode)
 {
         unsigned char buf[3];
 
@@ -158,13 +149,13 @@ static int em28xx_get_key_pinnacle_usb_grey(struct i2c_client *i2c_dev,
         if (buf[0] != 0x00)
                 return 0;
 
-        *ir_key = buf[2]&0x3f;
-
+        *protocol = RC_TYPE_UNKNOWN;
+        *scancode = buf[2] & 0x3f;
         return 1;
 }
 
 static int em28xx_get_key_winfast_usbii_deluxe(struct i2c_client *i2c_dev,
-                                               u32 *ir_key)
+                                               enum rc_type *protocol, u32 *scancode)
 {
         unsigned char subaddr, keydetect, key;
 
@@ -184,7 +175,8 @@ static int em28xx_get_key_winfast_usbii_deluxe(struct i2c_client *i2c_dev,
         if (key == 0x00)
                 return 0;
 
-        *ir_key = key;
+        *protocol = RC_TYPE_UNKNOWN;
+        *scancode = key;
         return 1;
 }
 
@@ -215,7 +207,22 @@ static int default_polling_getkey(struct em28xx_IR *ir,
         poll_result->read_count = (msg[0] & 0x7f);
 
         /* Remote Control Address/Data (Regs 0x46/0x47) */
-        poll_result->scancode = msg[1] << 8 | msg[2];
+        switch (ir->rc_type) {
+        case RC_BIT_RC5:
+                poll_result->protocol = RC_TYPE_RC5;
+                poll_result->scancode = RC_SCANCODE_RC5(msg[1], msg[2]);
+                break;
+
+        case RC_BIT_NEC:
+                poll_result->protocol = RC_TYPE_NEC;
+                poll_result->scancode = RC_SCANCODE_NEC(msg[1], msg[2]);
+                break;
+
+        default:
+                poll_result->protocol = RC_TYPE_UNKNOWN;
+                poll_result->scancode = msg[1] << 8 | msg[2];
+                break;
+        }
 
         return 0;
 }
@@ -247,25 +254,32 @@ static int em2874_polling_getkey(struct em28xx_IR *ir,
          */
         switch (ir->rc_type) {
         case RC_BIT_RC5:
-                poll_result->scancode = msg[1] << 8 | msg[2];
+                poll_result->protocol = RC_TYPE_RC5;
+                poll_result->scancode = RC_SCANCODE_RC5(msg[1], msg[2]);
                 break;
+
         case RC_BIT_NEC:
+                poll_result->protocol = RC_TYPE_RC5;
+                poll_result->scancode = msg[1] << 8 | msg[2];
                 if ((msg[3] ^ msg[4]) != 0xff)          /* 32 bits NEC */
-                        poll_result->scancode = (msg[1] << 24) |
-                                                (msg[2] << 16) |
-                                                (msg[3] << 8)  |
-                                                 msg[4];
+                        poll_result->scancode = RC_SCANCODE_NEC32((msg[1] << 24) |
+                                                                  (msg[2] << 16) |
+                                                                  (msg[3] << 8)  |
+                                                                  (msg[4]));
                 else if ((msg[1] ^ msg[2]) != 0xff)     /* 24 bits NEC */
-                        poll_result->scancode = (msg[1] << 16) |
-                                                (msg[2] << 8)  |
-                                                 msg[3];
+                        poll_result->scancode = RC_SCANCODE_NECX(msg[1] << 8 |
+                                                                 msg[2], msg[3]);
                 else                                    /* Normal NEC */
-                        poll_result->scancode = msg[1] << 8 | msg[3];
+                        poll_result->scancode = RC_SCANCODE_NEC(msg[1], msg[3]);
                 break;
+
         case RC_BIT_RC6_0:
-                poll_result->scancode = msg[1] << 8 | msg[2];
+                poll_result->protocol = RC_TYPE_RC6_0;
+                poll_result->scancode = RC_SCANCODE_RC6_0(msg[1], msg[2]);
                 break;
+
         default:
+                poll_result->protocol = RC_TYPE_UNKNOWN;
                 poll_result->scancode = (msg[1] << 24) | (msg[2] << 16) |
                                         (msg[3] << 8)  | msg[4];
                 break;
@@ -281,22 +295,24 @@ static int em2874_polling_getkey(struct em28xx_IR *ir,
 static int em28xx_i2c_ir_handle_key(struct em28xx_IR *ir)
 {
         struct em28xx *dev = ir->dev;
-        static u32 ir_key;
+        static u32 scancode;
+        enum rc_type protocol;
         int rc;
         struct i2c_client client;
 
         client.adapter = &ir->dev->i2c_adap[dev->def_i2c_bus];
         client.addr = ir->i2c_dev_addr;
 
-        rc = ir->get_key_i2c(&client, &ir_key);
+        rc = ir->get_key_i2c(&client, &protocol, &scancode);
         if (rc < 0) {
                 dprintk("ir->get_key_i2c() failed: %d\n", rc);
                 return rc;
         }
 
         if (rc) {
-                dprintk("%s: keycode = 0x%04x\n", __func__, ir_key);
-                rc_keydown(ir->rc, ir_key, 0);
+                dprintk("%s: proto = 0x%04x, scancode = 0x%04x\n",
+                        __func__, protocol, scancode);
+                rc_keydown(ir->rc, protocol, scancode, 0);
         }
         return 0;
 }
@@ -319,10 +335,12 @@ static void em28xx_ir_handle_key(struct em28xx_IR *ir)
                         poll_result.scancode);
                 if (ir->full_code)
                         rc_keydown(ir->rc,
+                                   poll_result.protocol,
                                    poll_result.scancode,
                                    poll_result.toggle_bit);
                 else
                         rc_keydown(ir->rc,
+                                   RC_TYPE_UNKNOWN,
                                    poll_result.scancode & 0xff,
                                    poll_result.toggle_bit);
 
@@ -727,7 +745,7 @@ static int em28xx_ir_init(struct em28xx *dev)
                 case EM2820_BOARD_HAUPPAUGE_WINTV_USB_2:
                         rc->map_name = RC_MAP_HAUPPAUGE;
                         ir->get_key_i2c = em28xx_get_key_em_haup;
-                        rc_set_allowed_protocols(rc, RC_BIT_RC5);
+                        rc->allowed_protocols = RC_BIT_RC5;
                         break;
                 case EM2820_BOARD_LEADTEK_WINFAST_USBII_DELUXE:
                         rc->map_name = RC_MAP_WINFAST_USBII_DELUXE;
@@ -743,7 +761,7 @@ static int em28xx_ir_init(struct em28xx *dev)
                 switch (dev->chip_id) {
                 case CHIP_ID_EM2860:
                 case CHIP_ID_EM2883:
-                        rc_set_allowed_protocols(rc, RC_BIT_RC5 | RC_BIT_NEC);
+                        rc->allowed_protocols = RC_BIT_RC5 | RC_BIT_NEC;
                         ir->get_key = default_polling_getkey;
                         break;
                 case CHIP_ID_EM2884:
@@ -751,8 +769,8 @@ static int em28xx_ir_init(struct em28xx *dev)
                 case CHIP_ID_EM28174:
                 case CHIP_ID_EM28178:
                         ir->get_key = em2874_polling_getkey;
-                        rc_set_allowed_protocols(rc, RC_BIT_RC5 | RC_BIT_NEC |
-                                                 RC_BIT_RC6_0);
+                        rc->allowed_protocols = RC_BIT_RC5 | RC_BIT_NEC |
+                                             RC_BIT_RC6_0;
                         break;
                 default:
                         err = -ENODEV;
diff --git a/drivers/media/usb/em28xx/em28xx-video.c b/drivers/media/usb/em28xx/em28xx-video.c
index f6b49c98e2c9..90dec2955f1c 100644
--- a/drivers/media/usb/em28xx/em28xx-video.c
+++ b/drivers/media/usb/em28xx/em28xx-video.c
@@ -1227,8 +1227,7 @@ static void scale_to_size(struct em28xx *dev,
 static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
                                         struct v4l2_format *f)
 {
-        struct em28xx_fh      *fh  = priv;
-        struct em28xx         *dev = fh->dev;
+        struct em28xx         *dev = video_drvdata(file);
         struct em28xx_v4l2    *v4l2 = dev->v4l2;
 
         f->fmt.pix.width = v4l2->width;
@@ -1261,8 +1260,7 @@ static struct em28xx_fmt *format_by_fourcc(unsigned int fourcc)
 static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
                         struct v4l2_format *f)
 {
-        struct em28xx_fh      *fh    = priv;
-        struct em28xx         *dev   = fh->dev;
+        struct em28xx         *dev   = video_drvdata(file);
         struct em28xx_v4l2    *v4l2  = dev->v4l2;
         unsigned int          width  = f->fmt.pix.width;
         unsigned int          height = f->fmt.pix.height;
@@ -1355,8 +1353,7 @@ static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
 
 static int vidioc_g_std(struct file *file, void *priv, v4l2_std_id *norm)
 {
-        struct em28xx_fh   *fh  = priv;
-        struct em28xx      *dev = fh->dev;
+        struct em28xx *dev = video_drvdata(file);
 
         *norm = dev->v4l2->norm;
 
@@ -1365,8 +1362,7 @@ static int vidioc_g_std(struct file *file, void *priv, v4l2_std_id *norm)
 
 static int vidioc_querystd(struct file *file, void *priv, v4l2_std_id *norm)
 {
-        struct em28xx_fh   *fh  = priv;
-        struct em28xx      *dev = fh->dev;
+        struct em28xx *dev = video_drvdata(file);
 
         v4l2_device_call_all(&dev->v4l2->v4l2_dev, 0, video, querystd, norm);
 
@@ -1375,8 +1371,7 @@ static int vidioc_querystd(struct file *file, void *priv, v4l2_std_id *norm)
 
 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id norm)
 {
-        struct em28xx_fh   *fh   = priv;
-        struct em28xx      *dev  = fh->dev;
+        struct em28xx      *dev  = video_drvdata(file);
         struct em28xx_v4l2 *v4l2 = dev->v4l2;
         struct v4l2_format f;
 
@@ -1408,8 +1403,7 @@ static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id norm)
 static int vidioc_g_parm(struct file *file, void *priv,
                          struct v4l2_streamparm *p)
 {
-        struct em28xx_fh   *fh   = priv;
-        struct em28xx      *dev  = fh->dev;
+        struct em28xx      *dev  = video_drvdata(file);
         struct em28xx_v4l2 *v4l2 = dev->v4l2;
         int rc = 0;
 
@@ -1427,8 +1421,7 @@ static int vidioc_g_parm(struct file *file, void *priv,
 static int vidioc_s_parm(struct file *file, void *priv,
                          struct v4l2_streamparm *p)
 {
-        struct em28xx_fh   *fh  = priv;
-        struct em28xx      *dev = fh->dev;
+        struct em28xx *dev = video_drvdata(file);
 
         p->parm.capture.readbuffers = EM28XX_MIN_BUF;
         return v4l2_device_call_until_err(&dev->v4l2->v4l2_dev,
@@ -1450,8 +1443,7 @@ static const char *iname[] = {
 static int vidioc_enum_input(struct file *file, void *priv,
                                 struct v4l2_input *i)
 {
-        struct em28xx_fh   *fh  = priv;
-        struct em28xx      *dev = fh->dev;
+        struct em28xx *dev = video_drvdata(file);
         unsigned int       n;
 
         n = i->index;
@@ -1479,8 +1471,7 @@ static int vidioc_enum_input(struct file *file, void *priv,
 
 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
 {
-        struct em28xx_fh   *fh  = priv;
-        struct em28xx      *dev = fh->dev;
+        struct em28xx *dev = video_drvdata(file);
 
         *i = dev->ctl_input;
 
@@ -1489,8 +1480,7 @@ static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
 
 static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
 {
-        struct em28xx_fh   *fh  = priv;
-        struct em28xx      *dev = fh->dev;
+        struct em28xx *dev = video_drvdata(file);
 
         if (i >= MAX_EM28XX_INPUT)
                 return -EINVAL;
@@ -1503,8 +1493,7 @@ static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
 
 static int vidioc_g_audio(struct file *file, void *priv, struct v4l2_audio *a)
 {
-        struct em28xx_fh   *fh    = priv;
-        struct em28xx      *dev   = fh->dev;
+        struct em28xx *dev = video_drvdata(file);
 
         switch (a->index) {
         case EM28XX_AMUX_VIDEO:
@@ -1543,8 +1532,7 @@ static int vidioc_g_audio(struct file *file, void *priv, struct v4l2_audio *a)
 
 static int vidioc_s_audio(struct file *file, void *priv, const struct v4l2_audio *a)
 {
-        struct em28xx_fh   *fh  = priv;
-        struct em28xx      *dev = fh->dev;
+        struct em28xx *dev = video_drvdata(file);
 
         if (a->index >= MAX_EM28XX_INPUT)
                 return -EINVAL;
@@ -1563,8 +1551,7 @@ static int vidioc_s_audio(struct file *file, void *priv, const struct v4l2_audio
 static int vidioc_g_tuner(struct file *file, void *priv,
                                 struct v4l2_tuner *t)
 {
-        struct em28xx_fh      *fh  = priv;
-        struct em28xx         *dev = fh->dev;
+        struct em28xx *dev = video_drvdata(file);
 
         if (0 != t->index)
                 return -EINVAL;
@@ -1578,8 +1565,7 @@ static int vidioc_g_tuner(struct file *file, void *priv,
 static int vidioc_s_tuner(struct file *file, void *priv,
                                 const struct v4l2_tuner *t)
 {
-        struct em28xx_fh      *fh  = priv;
-        struct em28xx         *dev = fh->dev;
+        struct em28xx *dev = video_drvdata(file);
 
         if (0 != t->index)
                 return -EINVAL;
@@ -1591,8 +1577,7 @@ static int vidioc_s_tuner(struct file *file, void *priv,
 static int vidioc_g_frequency(struct file *file, void *priv,
                                 struct v4l2_frequency *f)
 {
-        struct em28xx_fh      *fh  = priv;
-        struct em28xx         *dev = fh->dev;
+        struct em28xx         *dev = video_drvdata(file);
         struct em28xx_v4l2    *v4l2 = dev->v4l2;
 
         if (0 != f->tuner)
@@ -1606,8 +1591,7 @@ static int vidioc_s_frequency(struct file *file, void *priv,
                                 const struct v4l2_frequency *f)
 {
         struct v4l2_frequency  new_freq = *f;
-        struct em28xx_fh          *fh   = priv;
-        struct em28xx             *dev  = fh->dev;
+        struct em28xx             *dev  = video_drvdata(file);
         struct em28xx_v4l2        *v4l2 = dev->v4l2;
 
         if (0 != f->tuner)
@@ -1624,8 +1608,7 @@ static int vidioc_s_frequency(struct file *file, void *priv,
 static int vidioc_g_chip_info(struct file *file, void *priv,
                struct v4l2_dbg_chip_info *chip)
 {
-        struct em28xx_fh      *fh  = priv;
-        struct em28xx         *dev = fh->dev;
+        struct em28xx *dev = video_drvdata(file);
 
         if (chip->match.addr > 1)
                 return -EINVAL;
@@ -1652,8 +1635,7 @@ static int em28xx_reg_len(int reg)
 static int vidioc_g_register(struct file *file, void *priv,
                              struct v4l2_dbg_register *reg)
 {
-        struct em28xx_fh      *fh  = priv;
-        struct em28xx         *dev = fh->dev;
+        struct em28xx *dev = video_drvdata(file);
         int ret;
 
         if (reg->match.addr > 1)
@@ -1693,8 +1675,7 @@ static int vidioc_g_register(struct file *file, void *priv,
 static int vidioc_s_register(struct file *file, void *priv,
                              const struct v4l2_dbg_register *reg)
 {
-        struct em28xx_fh      *fh  = priv;
-        struct em28xx         *dev = fh->dev;
+        struct em28xx *dev = video_drvdata(file);
         __le16 buf;
 
         if (reg->match.addr > 1)
@@ -1715,8 +1696,7 @@ static int vidioc_querycap(struct file *file, void  *priv,
                                         struct v4l2_capability *cap)
 {
         struct video_device   *vdev = video_devdata(file);
-        struct em28xx_fh      *fh   = priv;
-        struct em28xx         *dev  = fh->dev;
+        struct em28xx         *dev  = video_drvdata(file);
         struct em28xx_v4l2    *v4l2 = dev->v4l2;
 
         strlcpy(cap->driver, "em28xx", sizeof(cap->driver));
@@ -1761,8 +1741,7 @@ static int vidioc_enum_fmt_vid_cap(struct file *file, void  *priv,
 static int vidioc_enum_framesizes(struct file *file, void *priv,
                                   struct v4l2_frmsizeenum *fsize)
 {
-        struct em28xx_fh      *fh  = priv;
-        struct em28xx         *dev = fh->dev;
+        struct em28xx         *dev = video_drvdata(file);
         struct em28xx_fmt     *fmt;
         unsigned int          maxw = norm_maxw(dev);
         unsigned int          maxh = norm_maxh(dev);
@@ -1806,8 +1785,7 @@ static int vidioc_enum_framesizes(struct file *file, void *priv,
 static int vidioc_g_fmt_vbi_cap(struct file *file, void *priv,
                                 struct v4l2_format *format)
 {
-        struct em28xx_fh      *fh   = priv;
-        struct em28xx         *dev  = fh->dev;
+        struct em28xx         *dev  = video_drvdata(file);
         struct em28xx_v4l2    *v4l2 = dev->v4l2;
 
         format->fmt.vbi.samples_per_line = v4l2->vbi_width;
@@ -1840,7 +1818,7 @@ static int vidioc_g_fmt_vbi_cap(struct file *file, void *priv,
 static int radio_g_tuner(struct file *file, void *priv,
                          struct v4l2_tuner *t)
 {
-        struct em28xx *dev = ((struct em28xx_fh *)priv)->dev;
+        struct em28xx *dev = video_drvdata(file);
 
         if (unlikely(t->index > 0))
                 return -EINVAL;
@@ -1855,7 +1833,7 @@ static int radio_g_tuner(struct file *file, void *priv,
 static int radio_s_tuner(struct file *file, void *priv,
                          const struct v4l2_tuner *t)
 {
-        struct em28xx *dev = ((struct em28xx_fh *)priv)->dev;
+        struct em28xx *dev = video_drvdata(file);
 
         if (0 != t->index)
                 return -EINVAL;
@@ -1890,7 +1868,7 @@ static int em28xx_v4l2_open(struct file *filp)
         struct em28xx *dev = video_drvdata(filp);
         struct em28xx_v4l2 *v4l2 = dev->v4l2;
         enum v4l2_buf_type fh_type = 0;
-        struct em28xx_fh *fh;
+        int ret;
 
         switch (vdev->vfl_type) {
         case VFL_TYPE_GRABBER:
@@ -1905,24 +1883,23 @@ static int em28xx_v4l2_open(struct file *filp)
                 return -EINVAL;
         }
 
-        em28xx_videodbg("open dev=%s type=%s users=%d\n",
-                        video_device_node_name(vdev), v4l2_type_names[fh_type],
-                        v4l2->users);
+        em28xx_videodbg("open dev=%s type=%s\n",
+                        video_device_node_name(vdev), v4l2_type_names[fh_type]);
 
         if (mutex_lock_interruptible(&dev->lock))
                 return -ERESTARTSYS;
-        fh = kzalloc(sizeof(struct em28xx_fh), GFP_KERNEL);
-        if (!fh) {
-                em28xx_errdev("em28xx-video.c: Out of memory?!\n");
+
+        ret = v4l2_fh_open(filp);
+        if (ret) {
+                em28xx_errdev("%s: v4l2_fh_open() returned error %d\n",
+                              __func__, ret);
                 mutex_unlock(&dev->lock);
-                return -ENOMEM;
+                return ret;
         }
-        v4l2_fh_init(&fh->fh, vdev);
-        fh->dev = dev;
-        fh->type = fh_type;
-        filp->private_data = fh;
 
-        if (v4l2->users == 0) {
+        if (v4l2_fh_is_singular_file(filp)) {
+                em28xx_videodbg("first opened filehandle, initializing device\n");
+
                 em28xx_set_mode(dev, EM28XX_ANALOG_MODE);
 
                 if (vdev->vfl_type != VFL_TYPE_RADIO)
@@ -1933,6 +1910,8 @@ static int em28xx_v4l2_open(struct file *filp)
                  * of some i2c devices
                  */
                 em28xx_wake_i2c(dev);
+        } else {
+                em28xx_videodbg("further filehandles are already opened\n");
         }
 
         if (vdev->vfl_type == VFL_TYPE_RADIO) {
@@ -1942,10 +1921,8 @@ static int em28xx_v4l2_open(struct file *filp)
 
         kref_get(&dev->ref);
         kref_get(&v4l2->ref);
-        v4l2->users++;
 
         mutex_unlock(&dev->lock);
-        v4l2_fh_add(&fh->fh);
 
         return 0;
 }
@@ -2046,17 +2023,15 @@ static int em28xx_v4l2_resume(struct em28xx *dev)
  */
 static int em28xx_v4l2_close(struct file *filp)
 {
-        struct em28xx_fh      *fh   = filp->private_data;
-        struct em28xx         *dev  = fh->dev;
+        struct em28xx         *dev  = video_drvdata(filp);
         struct em28xx_v4l2    *v4l2 = dev->v4l2;
         int              errCode;
 
-        em28xx_videodbg("users=%d\n", v4l2->users);
-
-        vb2_fop_release(filp);
         mutex_lock(&dev->lock);
 
-        if (v4l2->users == 1) {
+        if (v4l2_fh_is_singular_file(filp)) {
+                em28xx_videodbg("last opened filehandle, shutting down device\n");
+
                 /* No sense to try to write to the device */
                 if (dev->disconnected)
                         goto exit;
@@ -2075,10 +2050,12 @@ static int em28xx_v4l2_close(struct file *filp)
                         em28xx_errdev("cannot change alternate number to "
                                         "0 (error=%i)\n", errCode);
                 }
+        } else {
+                em28xx_videodbg("further opened filehandles left\n");
         }
 
 exit:
-        v4l2->users--;
+        vb2_fop_release(filp);
         kref_put(&v4l2->ref, em28xx_free_v4l2);
         mutex_unlock(&dev->lock);
         kref_put(&dev->ref, em28xx_free_device);
@@ -2208,7 +2185,6 @@ static struct video_device *em28xx_vdev_init(struct em28xx *dev,
         vfd->v4l2_dev   = &dev->v4l2->v4l2_dev;
         vfd->debug      = video_debug;
         vfd->lock       = &dev->lock;
-        set_bit(V4L2_FL_USE_FH_PRIO, &vfd->flags);
         if (dev->board.is_webcam)
                 vfd->tvnorms = 0;
 
@@ -2552,7 +2528,7 @@ static int em28xx_v4l2_init(struct em28xx *dev)
                 v4l2->vbi_dev->queue->lock = &v4l2->vb_vbi_queue_lock;
 
                 /* disable inapplicable ioctls */
-                v4l2_disable_ioctl(v4l2->vdev, VIDIOC_S_PARM);
+                v4l2_disable_ioctl(v4l2->vbi_dev, VIDIOC_S_PARM);
                 if (dev->tuner_type == TUNER_ABSENT) {
                         v4l2_disable_ioctl(v4l2->vbi_dev, VIDIOC_G_TUNER);
                         v4l2_disable_ioctl(v4l2->vbi_dev, VIDIOC_S_TUNER);
diff --git a/drivers/media/usb/em28xx/em28xx.h b/drivers/media/usb/em28xx/em28xx.h
index b4c837d77e5d..84ef8efdb148 100644
--- a/drivers/media/usb/em28xx/em28xx.h
+++ b/drivers/media/usb/em28xx/em28xx.h
@@ -524,7 +524,6 @@ struct em28xx_v4l2 {
         int sensor_yres;
         int sensor_xtal;
 
-        int users;              /* user count for exclusive use */
         int streaming_users;    /* number of actively streaming users */
 
         u32 frequency;          /* selected tuner frequency */
@@ -576,13 +575,6 @@ struct em28xx_audio {
 
 struct em28xx;
 
-struct em28xx_fh {
-        struct v4l2_fh fh;
-        struct em28xx *dev;
-
-        enum v4l2_buf_type           type;
-};
-
 enum em28xx_i2c_algo_type {
         EM28XX_I2C_ALGO_EM28XX = 0,
         EM28XX_I2C_ALGO_EM2800,
diff --git a/drivers/media/usb/go7007/Kconfig b/drivers/media/usb/go7007/Kconfig
new file mode 100644
index 000000000000..95a3af644a92
--- /dev/null
+++ b/drivers/media/usb/go7007/Kconfig
@@ -0,0 +1,51 @@
+config VIDEO_GO7007
+        tristate "WIS GO7007 MPEG encoder support"
+        depends on VIDEO_DEV && I2C
+        depends on SND && USB
+        select VIDEOBUF2_VMALLOC
+        select VIDEO_TUNER
+        select CYPRESS_FIRMWARE
+        select SND_PCM
+        select VIDEO_SONY_BTF_MPX if MEDIA_SUBDRV_AUTOSELECT
+        select VIDEO_SAA711X if MEDIA_SUBDRV_AUTOSELECT
+        select VIDEO_TW2804 if MEDIA_SUBDRV_AUTOSELECT
+        select VIDEO_TW9903 if MEDIA_SUBDRV_AUTOSELECT
+        select VIDEO_TW9906 if MEDIA_SUBDRV_AUTOSELECT
+        select VIDEO_OV7640 if MEDIA_SUBDRV_AUTOSELECT
+        select VIDEO_UDA1342 if MEDIA_SUBDRV_AUTOSELECT
+        ---help---
+          This is a video4linux driver for the WIS GO7007 MPEG
+          encoder chip.
+
+          To compile this driver as a module, choose M here: the
+          module will be called go7007.
+
+config VIDEO_GO7007_USB
+        tristate "WIS GO7007 USB support"
+        depends on VIDEO_GO7007 && USB
+        ---help---
+          This is a video4linux driver for the WIS GO7007 MPEG
+          encoder chip over USB.
+
+          To compile this driver as a module, choose M here: the
+          module will be called go7007-usb.
+
+config VIDEO_GO7007_LOADER
+        tristate "WIS GO7007 Loader support"
+        depends on VIDEO_GO7007
+        default y
+        ---help---
+          This is a go7007 firmware loader driver for the WIS GO7007
+          MPEG encoder chip over USB.
+
+          To compile this driver as a module, choose M here: the
+          module will be called go7007-loader.
+
+config VIDEO_GO7007_USB_S2250_BOARD
+        tristate "Sensoray 2250/2251 support"
+        depends on VIDEO_GO7007_USB && USB
+        ---help---
+          This is a video4linux driver for the Sensoray 2250/2251 device.
+
+          To compile this driver as a module, choose M here: the
+          module will be called s2250.
diff --git a/drivers/media/usb/go7007/Makefile b/drivers/media/usb/go7007/Makefile
new file mode 100644
index 000000000000..e99287c3b828
--- /dev/null
+++ b/drivers/media/usb/go7007/Makefile
@@ -0,0 +1,11 @@
+obj-$(CONFIG_VIDEO_GO7007) += go7007.o
+obj-$(CONFIG_VIDEO_GO7007_USB) += go7007-usb.o
+obj-$(CONFIG_VIDEO_GO7007_LOADER) += go7007-loader.o
+obj-$(CONFIG_VIDEO_GO7007_USB_S2250_BOARD) += s2250.o
+
+go7007-y := go7007-v4l2.o go7007-driver.o go7007-i2c.o go7007-fw.o \
+                snd-go7007.o
+
+s2250-y := s2250-board.o
+
+ccflags-$(CONFIG_VIDEO_GO7007_LOADER:m=y) += -Idrivers/media/common
diff --git a/drivers/media/usb/go7007/go7007-driver.c b/drivers/media/usb/go7007/go7007-driver.c
new file mode 100644
index 000000000000..95cffb771a62
--- /dev/null
+++ b/drivers/media/usb/go7007/go7007-driver.c
@@ -0,0 +1,766 @@
+/*
+ * Copyright (C) 2005-2006 Micronas USA Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License (Version 2) as
+ * published by the Free Software Foundation.
+ *
+ * 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.
+ */
+
+#include <linux/module.h>
+#include <linux/delay.h>
+#include <linux/sched.h>
+#include <linux/spinlock.h>
+#include <linux/unistd.h>
+#include <linux/time.h>
+#include <linux/mm.h>
+#include <linux/vmalloc.h>
+#include <linux/device.h>
+#include <linux/i2c.h>
+#include <linux/firmware.h>
+#include <linux/mutex.h>
+#include <linux/uaccess.h>
+#include <linux/slab.h>
+#include <linux/videodev2.h>
+#include <media/tuner.h>
+#include <media/v4l2-common.h>
+#include <media/v4l2-event.h>
+
+#include "go7007-priv.h"
+
+/*
+ * Wait for an interrupt to be delivered from the GO7007SB and return
+ * the associated value and data.
+ *
+ * Must be called with the hw_lock held.
+ */
+int go7007_read_interrupt(struct go7007 *go, u16 *value, u16 *data)
+{
+        go->interrupt_available = 0;
+        go->hpi_ops->read_interrupt(go);
+        if (wait_event_timeout(go->interrupt_waitq,
+                                go->interrupt_available, 5*HZ) < 0) {
+                v4l2_err(&go->v4l2_dev, "timeout waiting for read interrupt\n");
+                return -1;
+        }
+        if (!go->interrupt_available)
+                return -1;
+        go->interrupt_available = 0;
+        *value = go->interrupt_value & 0xfffe;
+        *data = go->interrupt_data;
+        return 0;
+}
+EXPORT_SYMBOL(go7007_read_interrupt);
+
+/*
+ * Read a register/address on the GO7007SB.
+ *
+ * Must be called with the hw_lock held.
+ */
+int go7007_read_addr(struct go7007 *go, u16 addr, u16 *data)
+{
+        int count = 100;
+        u16 value;
+
+        if (go7007_write_interrupt(go, 0x0010, addr) < 0)
+                return -EIO;
+        while (count-- > 0) {
+                if (go7007_read_interrupt(go, &value, data) == 0 &&
+                                value == 0xa000)
+                        return 0;
+        }
+        return -EIO;
+}
+EXPORT_SYMBOL(go7007_read_addr);
+
+/*
+ * Send the boot firmware to the encoder, which just wakes it up and lets
+ * us talk to the GPIO pins and on-board I2C adapter.
+ *
+ * Must be called with the hw_lock held.
+ */
+static int go7007_load_encoder(struct go7007 *go)
+{
+        const struct firmware *fw_entry;
+        char fw_name[] = "go7007/go7007fw.bin";
+        void *bounce;
+        int fw_len, rv = 0;
+        u16 intr_val, intr_data;
+
+        if (go->boot_fw == NULL) {
+                if (request_firmware(&fw_entry, fw_name, go->dev)) {
+                        v4l2_err(go, "unable to load firmware from file \"%s\"\n", fw_name);
+                        return -1;
+                }
+                if (fw_entry->size < 16 || memcmp(fw_entry->data, "WISGO7007FW", 11)) {
+                        v4l2_err(go, "file \"%s\" does not appear to be go7007 firmware\n", fw_name);
+                        release_firmware(fw_entry);
+                        return -1;
+                }
+                fw_len = fw_entry->size - 16;
+                bounce = kmemdup(fw_entry->data + 16, fw_len, GFP_KERNEL);
+                if (bounce == NULL) {
+                        v4l2_err(go, "unable to allocate %d bytes for firmware transfer\n", fw_len);
+                        release_firmware(fw_entry);
+                        return -1;
+                }
+                release_firmware(fw_entry);
+                go->boot_fw_len = fw_len;
+                go->boot_fw = bounce;
+        }
+        if (go7007_interface_reset(go) < 0 ||
+            go7007_send_firmware(go, go->boot_fw, go->boot_fw_len) < 0 ||
+            go7007_read_interrupt(go, &intr_val, &intr_data) < 0 ||
+                        (intr_val & ~0x1) != 0x5a5a) {
+                v4l2_err(go, "error transferring firmware\n");
+                rv = -1;
+        }
+        return rv;
+}
+
+MODULE_FIRMWARE("go7007/go7007fw.bin");
+
+/*
+ * Boot the encoder and register the I2C adapter if requested.  Do the
+ * minimum initialization necessary, since the board-specific code may
+ * still need to probe the board ID.
+ *
+ * Must NOT be called with the hw_lock held.
+ */
+int go7007_boot_encoder(struct go7007 *go, int init_i2c)
+{
+        int ret;
+
+        mutex_lock(&go->hw_lock);
+        ret = go7007_load_encoder(go);
+        mutex_unlock(&go->hw_lock);
+        if (ret < 0)
+                return -1;
+        if (!init_i2c)
+                return 0;
+        if (go7007_i2c_init(go) < 0)
+                return -1;
+        go->i2c_adapter_online = 1;
+        return 0;
+}
+EXPORT_SYMBOL(go7007_boot_encoder);
+
+/*
+ * Configure any hardware-related registers in the GO7007, such as GPIO
+ * pins and bus parameters, which are board-specific.  This assumes
+ * the boot firmware has already been downloaded.
+ *
+ * Must be called with the hw_lock held.
+ */
+static int go7007_init_encoder(struct go7007 *go)
+{
+        if (go->board_info->audio_flags & GO7007_AUDIO_I2S_MASTER) {
+                go7007_write_addr(go, 0x1000, 0x0811);
+                go7007_write_addr(go, 0x1000, 0x0c11);
+        }
+        switch (go->board_id) {
+        case GO7007_BOARDID_MATRIX_REV:
+                /* Set GPIO pin 0 to be an output (audio clock control) */
+                go7007_write_addr(go, 0x3c82, 0x0001);
+                go7007_write_addr(go, 0x3c80, 0x00fe);
+                break;
+        case GO7007_BOARDID_ADLINK_MPG24:
+                /* set GPIO5 to be an output, currently low */
+                go7007_write_addr(go, 0x3c82, 0x0000);
+                go7007_write_addr(go, 0x3c80, 0x00df);
+                break;
+        case GO7007_BOARDID_ADS_USBAV_709:
+                /* GPIO pin 0: audio clock control */
+                /*      pin 2: TW9906 reset */
+                /*      pin 3: capture LED */
+                go7007_write_addr(go, 0x3c82, 0x000d);
+                go7007_write_addr(go, 0x3c80, 0x00f2);
+                break;
+        }
+        return 0;
+}
+
+/*
+ * Send the boot firmware to the GO7007 and configure the registers.  This
+ * is the only way to stop the encoder once it has started streaming video.
+ *
+ * Must be called with the hw_lock held.
+ */
+int go7007_reset_encoder(struct go7007 *go)
+{
+        if (go7007_load_encoder(go) < 0)
+                return -1;
+        return go7007_init_encoder(go);
+}
+
+/*
+ * Attempt to instantiate an I2C client by ID, probably loading a module.
+ */
+static int init_i2c_module(struct i2c_adapter *adapter, const struct go_i2c *const i2c)
+{
+        struct go7007 *go = i2c_get_adapdata(adapter);
+        struct v4l2_device *v4l2_dev = &go->v4l2_dev;
+        struct v4l2_subdev *sd;
+        struct i2c_board_info info;
+
+        memset(&info, 0, sizeof(info));
+        strlcpy(info.type, i2c->type, sizeof(info.type));
+        info.addr = i2c->addr;
+        info.flags = i2c->flags;
+
+        sd = v4l2_i2c_new_subdev_board(v4l2_dev, adapter, &info, NULL);
+        if (sd) {
+                if (i2c->is_video)
+                        go->sd_video = sd;
+                if (i2c->is_audio)
+                        go->sd_audio = sd;
+                return 0;
+        }
+
+        pr_info("go7007: probing for module i2c:%s failed\n", i2c->type);
+        return -EINVAL;
+}
+
+/*
+ * Detach and unregister the encoder.  The go7007 struct won't be freed
+ * until v4l2 finishes releasing its resources and all associated fds are
+ * closed by applications.
+ */
+static void go7007_remove(struct v4l2_device *v4l2_dev)
+{
+        struct go7007 *go = container_of(v4l2_dev, struct go7007, v4l2_dev);
+
+        v4l2_device_unregister(v4l2_dev);
+        if (go->hpi_ops->release)
+                go->hpi_ops->release(go);
+        if (go->i2c_adapter_online) {
+                i2c_del_adapter(&go->i2c_adapter);
+                go->i2c_adapter_online = 0;
+        }
+
+        kfree(go->boot_fw);
+        go7007_v4l2_remove(go);
+        kfree(go);
+}
+
+/*
+ * Finalize the GO7007 hardware setup, register the on-board I2C adapter
+ * (if used on this board), load the I2C client driver for the sensor
+ * (SAA7115 or whatever) and other devices, and register the ALSA and V4L2
+ * interfaces.
+ *
+ * Must NOT be called with the hw_lock held.
+ */
+int go7007_register_encoder(struct go7007 *go, unsigned num_i2c_devs)
+{
+        int i, ret;
+
+        dev_info(go->dev, "go7007: registering new %s\n", go->name);
+
+        go->v4l2_dev.release = go7007_remove;
+        ret = v4l2_device_register(go->dev, &go->v4l2_dev);
+        if (ret < 0)
+                return ret;
+
+        mutex_lock(&go->hw_lock);
+        ret = go7007_init_encoder(go);
+        mutex_unlock(&go->hw_lock);
+        if (ret < 0)
+                return ret;
+
+        ret = go7007_v4l2_ctrl_init(go);
+        if (ret < 0)
+                return ret;
+
+        if (!go->i2c_adapter_online &&
+                        go->board_info->flags & GO7007_BOARD_USE_ONBOARD_I2C) {
+                ret = go7007_i2c_init(go);
+                if (ret < 0)
+                        return ret;
+                go->i2c_adapter_online = 1;
+        }
+        if (go->i2c_adapter_online) {
+                if (go->board_id == GO7007_BOARDID_ADS_USBAV_709) {
+                        /* Reset the TW9906 */
+                        go7007_write_addr(go, 0x3c82, 0x0009);
+                        msleep(50);
+                        go7007_write_addr(go, 0x3c82, 0x000d);
+                }
+                for (i = 0; i < num_i2c_devs; ++i)
+                        init_i2c_module(&go->i2c_adapter, &go->board_info->i2c_devs[i]);
+
+                if (go->tuner_type >= 0) {
+                        struct tuner_setup setup = {
+                                .addr = ADDR_UNSET,
+                                .type = go->tuner_type,
+                                .mode_mask = T_ANALOG_TV,
+                        };
+
+                        v4l2_device_call_all(&go->v4l2_dev, 0, tuner,
+                                s_type_addr, &setup);
+                }
+                if (go->board_id == GO7007_BOARDID_ADLINK_MPG24)
+                        v4l2_subdev_call(go->sd_video, video, s_routing,
+                                        0, 0, go->channel_number + 1);
+        }
+
+        ret = go7007_v4l2_init(go);
+        if (ret < 0)
+                return ret;
+
+        if (go->board_info->flags & GO7007_BOARD_HAS_AUDIO) {
+                go->audio_enabled = 1;
+                go7007_snd_init(go);
+        }
+        return 0;
+}
+EXPORT_SYMBOL(go7007_register_encoder);
+
+/*
+ * Send the encode firmware to the encoder, which will cause it
+ * to immediately start delivering the video and audio streams.
+ *
+ * Must be called with the hw_lock held.
+ */
+int go7007_start_encoder(struct go7007 *go)
+{
+        u8 *fw;
+        int fw_len, rv = 0, i, x, y;
+        u16 intr_val, intr_data;
+
+        go->modet_enable = 0;
+        for (i = 0; i < 4; i++)
+                go->modet[i].enable = 0;
+
+        switch (v4l2_ctrl_g_ctrl(go->modet_mode)) {
+        case V4L2_DETECT_MD_MODE_GLOBAL:
+                memset(go->modet_map, 0, sizeof(go->modet_map));
+                go->modet[0].enable = 1;
+                go->modet_enable = 1;
+                break;
+        case V4L2_DETECT_MD_MODE_REGION_GRID:
+                for (y = 0; y < go->height / 16; y++) {
+                        for (x = 0; x < go->width / 16; x++) {
+                                int idx = y * go->width / 16 + x;
+
+                                go->modet[go->modet_map[idx]].enable = 1;
+                        }
+                }
+                go->modet_enable = 1;
+                break;
+        }
+
+        if (go->dvd_mode)
+                go->modet_enable = 0;
+
+        if (go7007_construct_fw_image(go, &fw, &fw_len) < 0)
+                return -1;
+
+        if (go7007_send_firmware(go, fw, fw_len) < 0 ||
+                        go7007_read_interrupt(go, &intr_val, &intr_data) < 0) {
+                v4l2_err(&go->v4l2_dev, "error transferring firmware\n");
+                rv = -1;
+                goto start_error;
+        }
+
+        go->state = STATE_DATA;
+        go->parse_length = 0;
+        go->seen_frame = 0;
+        if (go7007_stream_start(go) < 0) {
+                v4l2_err(&go->v4l2_dev, "error starting stream transfer\n");
+                rv = -1;
+                goto start_error;
+        }
+
+start_error:
+        kfree(fw);
+        return rv;
+}
+
+/*
+ * Store a byte in the current video buffer, if there is one.
+ */
+static inline void store_byte(struct go7007_buffer *vb, u8 byte)
+{
+        if (vb && vb->vb.v4l2_planes[0].bytesused < GO7007_BUF_SIZE) {
+                u8 *ptr = vb2_plane_vaddr(&vb->vb, 0);
+
+                ptr[vb->vb.v4l2_planes[0].bytesused++] = byte;
+        }
+}
+
+static void go7007_set_motion_regions(struct go7007 *go, struct go7007_buffer *vb,
+                u32 motion_regions)
+{
+        if (motion_regions != go->modet_event_status) {
+                struct v4l2_event ev = {
+                        .type = V4L2_EVENT_MOTION_DET,
+                        .u.motion_det = {
+                                .flags = V4L2_EVENT_MD_FL_HAVE_FRAME_SEQ,
+                                .frame_sequence = vb->vb.v4l2_buf.sequence,
+                                .region_mask = motion_regions,
+                        },
+                };
+
+                v4l2_event_queue(&go->vdev, &ev);
+                go->modet_event_status = motion_regions;
+        }
+}
+
+/*
+ * Determine regions with motion and send a motion detection event
+ * in case of changes.
+ */
+static void go7007_motion_regions(struct go7007 *go, struct go7007_buffer *vb)
+{
+        u32 *bytesused = &vb->vb.v4l2_planes[0].bytesused;
+        unsigned motion[4] = { 0, 0, 0, 0 };
+        u32 motion_regions = 0;
+        unsigned stride = (go->width + 7) >> 3;
+        unsigned x, y;
+        int i;
+
+        for (i = 0; i < 216; ++i)
+                store_byte(vb, go->active_map[i]);
+        for (y = 0; y < go->height / 16; y++) {
+                for (x = 0; x < go->width / 16; x++) {
+                        if (!(go->active_map[y * stride + (x >> 3)] & (1 << (x & 7))))
+                                continue;
+                        motion[go->modet_map[y * (go->width / 16) + x]]++;
+                }
+        }
+        motion_regions = ((motion[0] > 0) << 0) |
+                         ((motion[1] > 0) << 1) |
+                         ((motion[2] > 0) << 2) |
+                         ((motion[3] > 0) << 3);
+        *bytesused -= 216;
+        go7007_set_motion_regions(go, vb, motion_regions);
+}
+
+/*
+ * Deliver the last video buffer and get a new one to start writing to.
+ */
+static struct go7007_buffer *frame_boundary(struct go7007 *go, struct go7007_buffer *vb)
+{
+        u32 *bytesused = &vb->vb.v4l2_planes[0].bytesused;
+        struct go7007_buffer *vb_tmp = NULL;
+
+        if (vb == NULL) {
+                spin_lock(&go->spinlock);
+                if (!list_empty(&go->vidq_active))
+                        vb = go->active_buf =
+                                list_first_entry(&go->vidq_active, struct go7007_buffer, list);
+                spin_unlock(&go->spinlock);
+                go->next_seq++;
+                return vb;
+        }
+
+        vb->vb.v4l2_buf.sequence = go->next_seq++;
+        if (vb->modet_active && *bytesused + 216 < GO7007_BUF_SIZE)
+                go7007_motion_regions(go, vb);
+        else
+                go7007_set_motion_regions(go, vb, 0);
+
+        v4l2_get_timestamp(&vb->vb.v4l2_buf.timestamp);
+        vb_tmp = vb;
+        spin_lock(&go->spinlock);
+        list_del(&vb->list);
+        if (list_empty(&go->vidq_active))
+                vb = NULL;
+        else
+                vb = list_first_entry(&go->vidq_active, struct go7007_buffer, list);
+        go->active_buf = vb;
+        spin_unlock(&go->spinlock);
+        vb2_buffer_done(&vb_tmp->vb, VB2_BUF_STATE_DONE);
+        return vb;
+}
+
+static void write_bitmap_word(struct go7007 *go)
+{
+        int x, y, i, stride = ((go->width >> 4) + 7) >> 3;
+
+        for (i = 0; i < 16; ++i) {
+                y = (((go->parse_length - 1) << 3) + i) / (go->width >> 4);
+                x = (((go->parse_length - 1) << 3) + i) % (go->width >> 4);
+                if (stride * y + (x >> 3) < sizeof(go->active_map))
+                        go->active_map[stride * y + (x >> 3)] |=
+                                        (go->modet_word & 1) << (x & 0x7);
+                go->modet_word >>= 1;
+        }
+}
+
+/*
+ * Parse a chunk of the video stream into frames.  The frames are not
+ * delimited by the hardware, so we have to parse the frame boundaries
+ * based on the type of video stream we're receiving.
+ */
+void go7007_parse_video_stream(struct go7007 *go, u8 *buf, int length)
+{
+        struct go7007_buffer *vb = go->active_buf;
+        int i, seq_start_code = -1, gop_start_code = -1, frame_start_code = -1;
+
+        switch (go->format) {
+        case V4L2_PIX_FMT_MPEG4:
+                seq_start_code = 0xB0;
+                gop_start_code = 0xB3;
+                frame_start_code = 0xB6;
+                break;
+        case V4L2_PIX_FMT_MPEG1:
+        case V4L2_PIX_FMT_MPEG2:
+                seq_start_code = 0xB3;
+                gop_start_code = 0xB8;
+                frame_start_code = 0x00;
+                break;
+        }
+
+        for (i = 0; i < length; ++i) {
+                if (vb && vb->vb.v4l2_planes[0].bytesused >= GO7007_BUF_SIZE - 3) {
+                        v4l2_info(&go->v4l2_dev, "dropping oversized frame\n");
+                        vb->vb.v4l2_planes[0].bytesused = 0;
+                        vb->frame_offset = 0;
+                        vb->modet_active = 0;
+                        vb = go->active_buf = NULL;
+                }
+
+                switch (go->state) {
+                case STATE_DATA:
+                        switch (buf[i]) {
+                        case 0x00:
+                                go->state = STATE_00;
+                                break;
+                        case 0xFF:
+                                go->state = STATE_FF;
+                                break;
+                        default:
+                                store_byte(vb, buf[i]);
+                                break;
+                        }
+                        break;
+                case STATE_00:
+                        switch (buf[i]) {
+                        case 0x00:
+                                go->state = STATE_00_00;
+                                break;
+                        case 0xFF:
+                                store_byte(vb, 0x00);
+                                go->state = STATE_FF;
+                                break;
+                        default:
+                                store_byte(vb, 0x00);
+                                store_byte(vb, buf[i]);
+                                go->state = STATE_DATA;
+                                break;
+                        }
+                        break;
+                case STATE_00_00:
+                        switch (buf[i]) {
+                        case 0x00:
+                                store_byte(vb, 0x00);
+                                /* go->state remains STATE_00_00 */
+                                break;
+                        case 0x01:
+                                go->state = STATE_00_00_01;
+                                break;
+                        case 0xFF:
+                                store_byte(vb, 0x00);
+                                store_byte(vb, 0x00);
+                                go->state = STATE_FF;
+                                break;
+                        default:
+                                store_byte(vb, 0x00);
+                                store_byte(vb, 0x00);
+                                store_byte(vb, buf[i]);
+                                go->state = STATE_DATA;
+                                break;
+                        }
+                        break;
+                case STATE_00_00_01:
+                        if (buf[i] == 0xF8 && go->modet_enable == 0) {
+                                /* MODET start code, but MODET not enabled */
+                                store_byte(vb, 0x00);
+                                store_byte(vb, 0x00);
+                                store_byte(vb, 0x01);
+                                store_byte(vb, 0xF8);
+                                go->state = STATE_DATA;
+                                break;
+                        }
+                        /* If this is the start of a new MPEG frame,
+                         * get a new buffer */
+                        if ((go->format == V4L2_PIX_FMT_MPEG1 ||
+                             go->format == V4L2_PIX_FMT_MPEG2 ||
+                             go->format == V4L2_PIX_FMT_MPEG4) &&
+                            (buf[i] == seq_start_code ||
+                             buf[i] == gop_start_code ||
+                             buf[i] == frame_start_code)) {
+                                if (vb == NULL || go->seen_frame)
+                                        vb = frame_boundary(go, vb);
+                                go->seen_frame = buf[i] == frame_start_code;
+                                if (vb && go->seen_frame)
+                                        vb->frame_offset = vb->vb.v4l2_planes[0].bytesused;
+                        }
+                        /* Handle any special chunk types, or just write the
+                         * start code to the (potentially new) buffer */
+                        switch (buf[i]) {
+                        case 0xF5: /* timestamp */
+                                go->parse_length = 12;
+                                go->state = STATE_UNPARSED;
+                                break;
+                        case 0xF6: /* vbi */
+                                go->state = STATE_VBI_LEN_A;
+                                break;
+                        case 0xF8: /* MD map */
+                                go->parse_length = 0;
+                                memset(go->active_map, 0,
+                                                sizeof(go->active_map));
+                                go->state = STATE_MODET_MAP;
+                                break;
+                        case 0xFF: /* Potential JPEG start code */
+                                store_byte(vb, 0x00);
+                                store_byte(vb, 0x00);
+                                store_byte(vb, 0x01);
+                                go->state = STATE_FF;
+                                break;
+                        default:
+                                store_byte(vb, 0x00);
+                                store_byte(vb, 0x00);
+                                store_byte(vb, 0x01);
+                                store_byte(vb, buf[i]);
+                                go->state = STATE_DATA;
+                                break;
+                        }
+                        break;
+                case STATE_FF:
+                        switch (buf[i]) {
+                        case 0x00:
+                                store_byte(vb, 0xFF);
+                                go->state = STATE_00;
+                                break;
+                        case 0xFF:
+                                store_byte(vb, 0xFF);
+                                /* go->state remains STATE_FF */
+                                break;
+                        case 0xD8:
+                                if (go->format == V4L2_PIX_FMT_MJPEG)
+                                        vb = frame_boundary(go, vb);
+                                /* fall through */
+                        default:
+                                store_byte(vb, 0xFF);
+                                store_byte(vb, buf[i]);
+                                go->state = STATE_DATA;
+                                break;
+                        }
+                        break;
+                case STATE_VBI_LEN_A:
+                        go->parse_length = buf[i] << 8;
+                        go->state = STATE_VBI_LEN_B;
+                        break;
+                case STATE_VBI_LEN_B:
+                        go->parse_length |= buf[i];
+                        if (go->parse_length > 0)
+                                go->state = STATE_UNPARSED;
+                        else
+                                go->state = STATE_DATA;
+                        break;
+                case STATE_MODET_MAP:
+                        if (go->parse_length < 204) {
+                                if (go->parse_length & 1) {
+                                        go->modet_word |= buf[i];
+                                        write_bitmap_word(go);
+                                } else
+                                        go->modet_word = buf[i] << 8;
+                        } else if (go->parse_length == 207 && vb) {
+                                vb->modet_active = buf[i];
+                        }
+                        if (++go->parse_length == 208)
+                                go->state = STATE_DATA;
+                        break;
+                case STATE_UNPARSED:
+                        if (--go->parse_length == 0)
+                                go->state = STATE_DATA;
+                        break;
+                }
+        }
+}
+EXPORT_SYMBOL(go7007_parse_video_stream);
+
+/*
+ * Allocate a new go7007 struct.  Used by the hardware-specific probe.
+ */
+struct go7007 *go7007_alloc(const struct go7007_board_info *board,
+                                                struct device *dev)
+{
+        struct go7007 *go;
+        int i;
+
+        go = kzalloc(sizeof(struct go7007), GFP_KERNEL);
+        if (go == NULL)
+                return NULL;
+        go->dev = dev;
+        go->board_info = board;
+        go->board_id = 0;
+        go->tuner_type = -1;
+        go->channel_number = 0;
+        go->name[0] = 0;
+        mutex_init(&go->hw_lock);
+        init_waitqueue_head(&go->frame_waitq);
+        spin_lock_init(&go->spinlock);
+        go->status = STATUS_INIT;
+        memset(&go->i2c_adapter, 0, sizeof(go->i2c_adapter));
+        go->i2c_adapter_online = 0;
+        go->interrupt_available = 0;
+        init_waitqueue_head(&go->interrupt_waitq);
+        go->input = 0;
+        go7007_update_board(go);
+        go->encoder_h_halve = 0;
+        go->encoder_v_halve = 0;
+        go->encoder_subsample = 0;
+        go->format = V4L2_PIX_FMT_MJPEG;
+        go->bitrate = 1500000;
+        go->fps_scale = 1;
+        go->pali = 0;
+        go->aspect_ratio = GO7007_RATIO_1_1;
+        go->gop_size = 0;
+        go->ipb = 0;
+        go->closed_gop = 0;
+        go->repeat_seqhead = 0;
+        go->seq_header_enable = 0;
+        go->gop_header_enable = 0;
+        go->dvd_mode = 0;
+        go->interlace_coding = 0;
+        for (i = 0; i < 4; ++i)
+                go->modet[i].enable = 0;
+        for (i = 0; i < 1624; ++i)
+                go->modet_map[i] = 0;
+        go->audio_deliver = NULL;
+        go->audio_enabled = 0;
+
+        return go;
+}
+EXPORT_SYMBOL(go7007_alloc);
+
+void go7007_update_board(struct go7007 *go)
+{
+        const struct go7007_board_info *board = go->board_info;
+
+        if (board->sensor_flags & GO7007_SENSOR_TV) {
+                go->standard = GO7007_STD_NTSC;
+                go->std = V4L2_STD_NTSC_M;
+                go->width = 720;
+                go->height = 480;
+                go->sensor_framerate = 30000;
+        } else {
+                go->standard = GO7007_STD_OTHER;
+                go->width = board->sensor_width;
+                go->height = board->sensor_height;
+                go->sensor_framerate = board->sensor_framerate;
+        }
+        go->encoder_v_offset = board->sensor_v_offset;
+        go->encoder_h_offset = board->sensor_h_offset;
+}
+EXPORT_SYMBOL(go7007_update_board);
+
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/media/usb/go7007/go7007-fw.c b/drivers/media/usb/go7007/go7007-fw.c
new file mode 100644
index 000000000000..5f4c9b9e899a
--- /dev/null
+++ b/drivers/media/usb/go7007/go7007-fw.c
@@ -0,0 +1,1628 @@
+/*
+ * Copyright (C) 2005-2006 Micronas USA Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License (Version 2) as
+ * published by the Free Software Foundation.
+ *
+ * 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.
+ */
+
+/*
+ * This file contains code to generate a firmware image for the GO7007SB
+ * encoder.  Much of the firmware is read verbatim from a file, but some of
+ * it concerning bitrate control and other things that can be configured at
+ * run-time are generated dynamically.  Note that the format headers
+ * generated here do not affect the functioning of the encoder; they are
+ * merely parroted back to the host at the start of each frame.
+ */
+
+#include <linux/module.h>
+#include <linux/time.h>
+#include <linux/mm.h>
+#include <linux/device.h>
+#include <linux/i2c.h>
+#include <linux/firmware.h>
+#include <linux/slab.h>
+#include <asm/byteorder.h>
+
+#include "go7007-priv.h"
+
+#define GO7007_FW_NAME "go7007/go7007tv.bin"
+
+/* Constants used in the source firmware image to describe code segments */
+
+#define FLAG_MODE_MJPEG         (1)
+#define FLAG_MODE_MPEG1         (1<<1)
+#define FLAG_MODE_MPEG2         (1<<2)
+#define FLAG_MODE_MPEG4         (1<<3)
+#define FLAG_MODE_H263          (1<<4)
+#define FLAG_MODE_ALL           (FLAG_MODE_MJPEG | FLAG_MODE_MPEG1 | \
+                                        FLAG_MODE_MPEG2 | FLAG_MODE_MPEG4 | \
+                                        FLAG_MODE_H263)
+#define FLAG_SPECIAL            (1<<8)
+
+#define SPECIAL_FRM_HEAD        0
+#define SPECIAL_BRC_CTRL        1
+#define SPECIAL_CONFIG          2
+#define SPECIAL_SEQHEAD         3
+#define SPECIAL_AV_SYNC         4
+#define SPECIAL_FINAL           5
+#define SPECIAL_AUDIO           6
+#define SPECIAL_MODET           7
+
+/* Little data class for creating MPEG headers bit-by-bit */
+
+struct code_gen {
+        unsigned char *p; /* destination */
+        u32 a; /* collects bits at the top of the variable */
+        int b; /* bit position of most recently-written bit */
+        int len; /* written out so far */
+};
+
+#define CODE_GEN(name, dest) struct code_gen name = { dest, 0, 32, 0 }
+
+#define CODE_ADD(name, val, length) do { \
+        name.b -= (length); \
+        name.a |= (val) << name.b; \
+        while (name.b <= 24) { \
+                *name.p = name.a >> 24; \
+                ++name.p; \
+                name.a <<= 8; \
+                name.b += 8; \
+                name.len += 8; \
+        } \
+} while (0)
+
+#define CODE_LENGTH(name) (name.len + (32 - name.b))
+
+/* Tables for creating the bitrate control data */
+
+static const s16 converge_speed_ip[101] = {
+        1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+        1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+        1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+        1, 1, 1, 1, 1, 1, 1, 1, 1, 2,
+        2, 2, 2, 2, 2, 2, 2, 2, 2, 3,
+        3, 3, 3, 3, 3, 4, 4, 4, 4, 4,
+        5, 5, 5, 6, 6, 6, 7, 7, 8, 8,
+        9, 10, 10, 11, 12, 13, 14, 15, 16, 17,
+        19, 20, 22, 23, 25, 27, 30, 32, 35, 38,
+        41, 45, 49, 53, 58, 63, 69, 76, 83, 91,
+        100
+};
+
+static const s16 converge_speed_ipb[101] = {
+        3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+        3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+        3, 3, 3, 3, 3, 4, 4, 4, 4, 4,
+        4, 4, 4, 4, 5, 5, 5, 5, 5, 6,
+        6, 6, 6, 7, 7, 7, 7, 8, 8, 9,
+        9, 9, 10, 10, 11, 12, 12, 13, 14, 14,
+        15, 16, 17, 18, 19, 20, 22, 23, 25, 26,
+        28, 30, 32, 34, 37, 40, 42, 46, 49, 53,
+        57, 61, 66, 71, 77, 83, 90, 97, 106, 115,
+        125, 135, 147, 161, 175, 191, 209, 228, 249, 273,
+        300
+};
+
+static const s16 LAMBDA_table[4][101] = {
+        {       16, 16, 16, 16, 17, 17, 17, 18, 18, 18,
+                19, 19, 19, 20, 20, 20, 21, 21, 22, 22,
+                22, 23, 23, 24, 24, 25, 25, 25, 26, 26,
+                27, 27, 28, 28, 29, 29, 30, 31, 31, 32,
+                32, 33, 33, 34, 35, 35, 36, 37, 37, 38,
+                39, 39, 40, 41, 42, 42, 43, 44, 45, 46,
+                46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
+                56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
+                67, 68, 69, 70, 72, 73, 74, 76, 77, 78,
+                80, 81, 83, 84, 86, 87, 89, 90, 92, 94,
+                96
+        },
+        {
+                20, 20, 20, 21, 21, 21, 22, 22, 23, 23,
+                23, 24, 24, 25, 25, 26, 26, 27, 27, 28,
+                28, 29, 29, 30, 30, 31, 31, 32, 33, 33,
+                34, 34, 35, 36, 36, 37, 38, 38, 39, 40,
+                40, 41, 42, 43, 43, 44, 45, 46, 47, 48,
+                48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
+                58, 59, 60, 61, 62, 64, 65, 66, 67, 68,
+                70, 71, 72, 73, 75, 76, 78, 79, 80, 82,
+                83, 85, 86, 88, 90, 91, 93, 95, 96, 98,
+                100, 102, 103, 105, 107, 109, 111, 113, 115, 117,
+                120
+        },
+        {
+                24, 24, 24, 25, 25, 26, 26, 27, 27, 28,
+                28, 29, 29, 30, 30, 31, 31, 32, 33, 33,
+                34, 34, 35, 36, 36, 37, 38, 38, 39, 40,
+                41, 41, 42, 43, 44, 44, 45, 46, 47, 48,
+                49, 50, 50, 51, 52, 53, 54, 55, 56, 57,
+                58, 59, 60, 62, 63, 64, 65, 66, 67, 69,
+                70, 71, 72, 74, 75, 76, 78, 79, 81, 82,
+                84, 85, 87, 88, 90, 92, 93, 95, 97, 98,
+                100, 102, 104, 106, 108, 110, 112, 114, 116, 118,
+                120, 122, 124, 127, 129, 131, 134, 136, 138, 141,
+                144
+        },
+        {
+                32, 32, 33, 33, 34, 34, 35, 36, 36, 37,
+                38, 38, 39, 40, 41, 41, 42, 43, 44, 44,
+                45, 46, 47, 48, 49, 50, 50, 51, 52, 53,
+                54, 55, 56, 57, 58, 59, 60, 62, 63, 64,
+                65, 66, 67, 69, 70, 71, 72, 74, 75, 76,
+                78, 79, 81, 82, 84, 85, 87, 88, 90, 92,
+                93, 95, 97, 98, 100, 102, 104, 106, 108, 110,
+                112, 114, 116, 118, 120, 122, 124, 127, 129, 131,
+                134, 136, 139, 141, 144, 146, 149, 152, 154, 157,
+                160, 163, 166, 169, 172, 175, 178, 181, 185, 188,
+                192
+        }
+};
+
+/* MPEG blank frame generation tables */
+
+enum mpeg_frame_type {
+        PFRAME,
+        BFRAME_PRE,
+        BFRAME_POST,
+        BFRAME_BIDIR,
+        BFRAME_EMPTY
+};
+
+static const u32 addrinctab[33][2] = {
+        { 0x01, 1 },    { 0x03, 3 },    { 0x02, 3 },    { 0x03, 4 },
+        { 0x02, 4 },    { 0x03, 5 },    { 0x02, 5 },    { 0x07, 7 },
+        { 0x06, 7 },    { 0x0b, 8 },    { 0x0a, 8 },    { 0x09, 8 },
+        { 0x08, 8 },    { 0x07, 8 },    { 0x06, 8 },    { 0x17, 10 },
+        { 0x16, 10 },   { 0x15, 10 },   { 0x14, 10 },   { 0x13, 10 },
+        { 0x12, 10 },   { 0x23, 11 },   { 0x22, 11 },   { 0x21, 11 },
+        { 0x20, 11 },   { 0x1f, 11 },   { 0x1e, 11 },   { 0x1d, 11 },
+        { 0x1c, 11 },   { 0x1b, 11 },   { 0x1a, 11 },   { 0x19, 11 },
+        { 0x18, 11 }
+};
+
+/* Standard JPEG tables */
+
+static const u8 default_intra_quant_table[] = {
+         8, 16, 19, 22, 26, 27, 29, 34,
+        16, 16, 22, 24, 27, 29, 34, 37,
+        19, 22, 26, 27, 29, 34, 34, 38,
+        22, 22, 26, 27, 29, 34, 37, 40,
+        22, 26, 27, 29, 32, 35, 40, 48,
+        26, 27, 29, 32, 35, 40, 48, 58,
+        26, 27, 29, 34, 38, 46, 56, 69,
+        27, 29, 35, 38, 46, 56, 69, 83
+};
+
+static const u8 bits_dc_luminance[] = {
+        0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0
+};
+
+static const u8 val_dc_luminance[] = {
+        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
+};
+
+static const u8 bits_dc_chrominance[] = {
+        0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0
+};
+
+static const u8 val_dc_chrominance[] = {
+        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
+};
+
+static const u8 bits_ac_luminance[] = {
+        0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d
+};
+
+static const u8 val_ac_luminance[] = {
+        0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
+        0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
+        0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
+        0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
+        0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
+        0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
+        0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
+        0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
+        0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
+        0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
+        0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
+        0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
+        0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
+        0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
+        0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
+        0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
+        0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
+        0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
+        0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
+        0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
+        0xf9, 0xfa
+};
+
+static const u8 bits_ac_chrominance[] = {
+        0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77
+};
+
+static const u8 val_ac_chrominance[] = {
+        0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
+        0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
+        0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
+        0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
+        0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
+        0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
+        0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
+        0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
+        0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
+        0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
+        0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
+        0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
+        0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
+        0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
+        0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
+        0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
+        0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
+        0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
+        0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
+        0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
+        0xf9, 0xfa
+};
+
+/* Zig-zag mapping for quant table
+ *
+ * OK, let's do this mapping on the actual table above so it doesn't have
+ * to be done on the fly.
+ */
+static const int zz[64] = {
+        0,   1,  8, 16,  9,  2,  3, 10, 17, 24, 32, 25, 18, 11,  4,  5,
+        12, 19, 26, 33, 40, 48, 41, 34, 27, 20, 13,  6,  7, 14, 21, 28,
+        35, 42, 49, 56, 57, 50, 43, 36, 29, 22, 15, 23, 30, 37, 44, 51,
+        58, 59, 52, 45, 38, 31, 39, 46, 53, 60, 61, 54, 47, 55, 62, 63
+};
+
+static int copy_packages(__le16 *dest, u16 *src, int pkg_cnt, int space)
+{
+        int i, cnt = pkg_cnt * 32;
+
+        if (space < cnt)
+                return -1;
+
+        for (i = 0; i < cnt; ++i)
+                dest[i] = cpu_to_le16p(src + i);
+
+        return cnt;
+}
+
+static int mjpeg_frame_header(struct go7007 *go, unsigned char *buf, int q)
+{
+        int i, p = 0;
+
+        buf[p++] = 0xff;
+        buf[p++] = 0xd8;
+        buf[p++] = 0xff;
+        buf[p++] = 0xdb;
+        buf[p++] = 0;
+        buf[p++] = 2 + 65;
+        buf[p++] = 0;
+        buf[p++] = default_intra_quant_table[0];
+        for (i = 1; i < 64; ++i)
+                /* buf[p++] = (default_intra_quant_table[i] * q) >> 3; */
+                buf[p++] = (default_intra_quant_table[zz[i]] * q) >> 3;
+        buf[p++] = 0xff;
+        buf[p++] = 0xc0;
+        buf[p++] = 0;
+        buf[p++] = 17;
+        buf[p++] = 8;
+        buf[p++] = go->height >> 8;
+        buf[p++] = go->height & 0xff;
+        buf[p++] = go->width >> 8;
+        buf[p++] = go->width & 0xff;
+        buf[p++] = 3;
+        buf[p++] = 1;
+        buf[p++] = 0x22;
+        buf[p++] = 0;
+        buf[p++] = 2;
+        buf[p++] = 0x11;
+        buf[p++] = 0;
+        buf[p++] = 3;
+        buf[p++] = 0x11;
+        buf[p++] = 0;
+        buf[p++] = 0xff;
+        buf[p++] = 0xc4;
+        buf[p++] = 418 >> 8;
+        buf[p++] = 418 & 0xff;
+        buf[p++] = 0x00;
+        memcpy(buf + p, bits_dc_luminance + 1, 16);
+        p += 16;
+        memcpy(buf + p, val_dc_luminance, sizeof(val_dc_luminance));
+        p += sizeof(val_dc_luminance);
+        buf[p++] = 0x01;
+        memcpy(buf + p, bits_dc_chrominance + 1, 16);
+        p += 16;
+        memcpy(buf + p, val_dc_chrominance, sizeof(val_dc_chrominance));
+        p += sizeof(val_dc_chrominance);
+        buf[p++] = 0x10;
+        memcpy(buf + p, bits_ac_luminance + 1, 16);
+        p += 16;
+        memcpy(buf + p, val_ac_luminance, sizeof(val_ac_luminance));
+        p += sizeof(val_ac_luminance);
+        buf[p++] = 0x11;
+        memcpy(buf + p, bits_ac_chrominance + 1, 16);
+        p += 16;
+        memcpy(buf + p, val_ac_chrominance, sizeof(val_ac_chrominance));
+        p += sizeof(val_ac_chrominance);
+        buf[p++] = 0xff;
+        buf[p++] = 0xda;
+        buf[p++] = 0;
+        buf[p++] = 12;
+        buf[p++] = 3;
+        buf[p++] = 1;
+        buf[p++] = 0x00;
+        buf[p++] = 2;
+        buf[p++] = 0x11;
+        buf[p++] = 3;
+        buf[p++] = 0x11;
+        buf[p++] = 0;
+        buf[p++] = 63;
+        buf[p++] = 0;
+        return p;
+}
+
+static int gen_mjpeghdr_to_package(struct go7007 *go, __le16 *code, int space)
+{
+        u8 *buf;
+        u16 mem = 0x3e00;
+        unsigned int addr = 0x19;
+        int size = 0, i, off = 0, chunk;
+
+        buf = kzalloc(4096, GFP_KERNEL);
+        if (buf == NULL)
+                return -1;
+
+        for (i = 1; i < 32; ++i) {
+                mjpeg_frame_header(go, buf + size, i);
+                size += 80;
+        }
+        chunk = mjpeg_frame_header(go, buf + size, 1);
+        memmove(buf + size, buf + size + 80, chunk - 80);
+        size += chunk - 80;
+
+        for (i = 0; i < size; i += chunk * 2) {
+                if (space - off < 32) {
+                        off = -1;
+                        goto done;
+                }
+
+                code[off + 1] = __cpu_to_le16(0x8000 | mem);
+
+                chunk = 28;
+                if (mem + chunk > 0x4000)
+                        chunk = 0x4000 - mem;
+                if (i + 2 * chunk > size)
+                        chunk = (size - i) / 2;
+
+                if (chunk < 28) {
+                        code[off] = __cpu_to_le16(0x4000 | chunk);
+                        code[off + 31] = __cpu_to_le16(addr++);
+                        mem = 0x3e00;
+                } else {
+                        code[off] = __cpu_to_le16(0x1000 | 28);
+                        code[off + 31] = 0;
+                        mem += 28;
+                }
+
+                memcpy(&code[off + 2], buf + i, chunk * 2);
+                off += 32;
+        }
+done:
+        kfree(buf);
+        return off;
+}
+
+static int mpeg1_frame_header(struct go7007 *go, unsigned char *buf,
+                int modulo, int pict_struct, enum mpeg_frame_type frame)
+{
+        int i, j, mb_code, mb_len;
+        int rows = go->interlace_coding ? go->height / 32 : go->height / 16;
+        CODE_GEN(c, buf + 6);
+
+        switch (frame) {
+        case PFRAME:
+                mb_code = 0x1;
+                mb_len = 3;
+                break;
+        case BFRAME_PRE:
+                mb_code = 0x2;
+                mb_len = 4;
+                break;
+        case BFRAME_POST:
+                mb_code = 0x2;
+                mb_len = 3;
+                break;
+        case BFRAME_BIDIR:
+                mb_code = 0x2;
+                mb_len = 2;
+                break;
+        default: /* keep the compiler happy */
+                mb_code = mb_len = 0;
+                break;
+        }
+
+        CODE_ADD(c, frame == PFRAME ? 0x2 : 0x3, 13);
+        CODE_ADD(c, 0xffff, 16);
+        CODE_ADD(c, go->format == V4L2_PIX_FMT_MPEG2 ? 0x7 : 0x4, 4);
+        if (frame != PFRAME)
+                CODE_ADD(c, go->format == V4L2_PIX_FMT_MPEG2 ? 0x7 : 0x4, 4);
+        else
+                CODE_ADD(c, 0, 4); /* Is this supposed to be here?? */
+        CODE_ADD(c, 0, 3); /* What is this?? */
+        /* Byte-align with zeros */
+        j = 8 - (CODE_LENGTH(c) % 8);
+        if (j != 8)
+                CODE_ADD(c, 0, j);
+
+        if (go->format == V4L2_PIX_FMT_MPEG2) {
+                CODE_ADD(c, 0x1, 24);
+                CODE_ADD(c, 0xb5, 8);
+                CODE_ADD(c, 0x844, 12);
+                CODE_ADD(c, frame == PFRAME ? 0xff : 0x44, 8);
+                if (go->interlace_coding) {
+                        CODE_ADD(c, pict_struct, 4);
+                        if (go->dvd_mode)
+                                CODE_ADD(c, 0x000, 11);
+                        else
+                                CODE_ADD(c, 0x200, 11);
+                } else {
+                        CODE_ADD(c, 0x3, 4);
+                        CODE_ADD(c, 0x20c, 11);
+                }
+                /* Byte-align with zeros */
+                j = 8 - (CODE_LENGTH(c) % 8);
+                if (j != 8)
+                        CODE_ADD(c, 0, j);
+        }
+
+        for (i = 0; i < rows; ++i) {
+                CODE_ADD(c, 1, 24);
+                CODE_ADD(c, i + 1, 8);
+                CODE_ADD(c, 0x2, 6);
+                CODE_ADD(c, 0x1, 1);
+                CODE_ADD(c, mb_code, mb_len);
+                if (go->interlace_coding) {
+                        CODE_ADD(c, 0x1, 2);
+                        CODE_ADD(c, pict_struct == 1 ? 0x0 : 0x1, 1);
+                }
+                if (frame == BFRAME_BIDIR) {
+                        CODE_ADD(c, 0x3, 2);
+                        if (go->interlace_coding)
+                                CODE_ADD(c, pict_struct == 1 ? 0x0 : 0x1, 1);
+                }
+                CODE_ADD(c, 0x3, 2);
+                for (j = (go->width >> 4) - 2; j >= 33; j -= 33)
+                        CODE_ADD(c, 0x8, 11);
+                CODE_ADD(c, addrinctab[j][0], addrinctab[j][1]);
+                CODE_ADD(c, mb_code, mb_len);
+                if (go->interlace_coding) {
+                        CODE_ADD(c, 0x1, 2);
+                        CODE_ADD(c, pict_struct == 1 ? 0x0 : 0x1, 1);
+                }
+                if (frame == BFRAME_BIDIR) {
+                        CODE_ADD(c, 0x3, 2);
+                        if (go->interlace_coding)
+                                CODE_ADD(c, pict_struct == 1 ? 0x0 : 0x1, 1);
+                }
+                CODE_ADD(c, 0x3, 2);
+
+                /* Byte-align with zeros */
+                j = 8 - (CODE_LENGTH(c) % 8);
+                if (j != 8)
+                        CODE_ADD(c, 0, j);
+        }
+
+        i = CODE_LENGTH(c) + 4 * 8;
+        buf[2] = 0x00;
+        buf[3] = 0x00;
+        buf[4] = 0x01;
+        buf[5] = 0x00;
+        return i;
+}
+
+static int mpeg1_sequence_header(struct go7007 *go, unsigned char *buf, int ext)
+{
+        int i, aspect_ratio, picture_rate;
+        CODE_GEN(c, buf + 6);
+
+        if (go->format == V4L2_PIX_FMT_MPEG1) {
+                switch (go->aspect_ratio) {
+                case GO7007_RATIO_4_3:
+                        aspect_ratio = go->standard == GO7007_STD_NTSC ? 3 : 2;
+                        break;
+                case GO7007_RATIO_16_9:
+                        aspect_ratio = go->standard == GO7007_STD_NTSC ? 5 : 4;
+                        break;
+                default:
+                        aspect_ratio = 1;
+                        break;
+                }
+        } else {
+                switch (go->aspect_ratio) {
+                case GO7007_RATIO_4_3:
+                        aspect_ratio = 2;
+                        break;
+                case GO7007_RATIO_16_9:
+                        aspect_ratio = 3;
+                        break;
+                default:
+                        aspect_ratio = 1;
+                        break;
+                }
+        }
+        switch (go->sensor_framerate) {
+        case 24000:
+                picture_rate = 1;
+                break;
+        case 24024:
+                picture_rate = 2;
+                break;
+        case 25025:
+                picture_rate = go->interlace_coding ? 6 : 3;
+                break;
+        case 30000:
+                picture_rate = go->interlace_coding ? 7 : 4;
+                break;
+        case 30030:
+                picture_rate = go->interlace_coding ? 8 : 5;
+                break;
+        default:
+                picture_rate = 5; /* 30 fps seems like a reasonable default */
+                break;
+        }
+
+        CODE_ADD(c, go->width, 12);
+        CODE_ADD(c, go->height, 12);
+        CODE_ADD(c, aspect_ratio, 4);
+        CODE_ADD(c, picture_rate, 4);
+        CODE_ADD(c, go->format == V4L2_PIX_FMT_MPEG2 ? 20000 : 0x3ffff, 18);
+        CODE_ADD(c, 1, 1);
+        CODE_ADD(c, go->format == V4L2_PIX_FMT_MPEG2 ? 112 : 20, 10);
+        CODE_ADD(c, 0, 3);
+
+        /* Byte-align with zeros */
+        i = 8 - (CODE_LENGTH(c) % 8);
+        if (i != 8)
+                CODE_ADD(c, 0, i);
+
+        if (go->format == V4L2_PIX_FMT_MPEG2) {
+                CODE_ADD(c, 0x1, 24);
+                CODE_ADD(c, 0xb5, 8);
+                CODE_ADD(c, 0x148, 12);
+                if (go->interlace_coding)
+                        CODE_ADD(c, 0x20001, 20);
+                else
+                        CODE_ADD(c, 0xa0001, 20);
+                CODE_ADD(c, 0, 16);
+
+                /* Byte-align with zeros */
+                i = 8 - (CODE_LENGTH(c) % 8);
+                if (i != 8)
+                        CODE_ADD(c, 0, i);
+
+                if (ext) {
+                        CODE_ADD(c, 0x1, 24);
+                        CODE_ADD(c, 0xb52, 12);
+                        CODE_ADD(c, go->standard == GO7007_STD_NTSC ? 2 : 1, 3);
+                        CODE_ADD(c, 0x105, 9);
+                        CODE_ADD(c, 0x505, 16);
+                        CODE_ADD(c, go->width, 14);
+                        CODE_ADD(c, 1, 1);
+                        CODE_ADD(c, go->height, 14);
+
+                        /* Byte-align with zeros */
+                        i = 8 - (CODE_LENGTH(c) % 8);
+                        if (i != 8)
+                                CODE_ADD(c, 0, i);
+                }
+        }
+
+        i = CODE_LENGTH(c) + 4 * 8;
+        buf[0] = i & 0xff;
+        buf[1] = i >> 8;
+        buf[2] = 0x00;
+        buf[3] = 0x00;
+        buf[4] = 0x01;
+        buf[5] = 0xb3;
+        return i;
+}
+
+static int gen_mpeg1hdr_to_package(struct go7007 *go,
+                                        __le16 *code, int space, int *framelen)
+{
+        u8 *buf;
+        u16 mem = 0x3e00;
+        unsigned int addr = 0x19;
+        int i, off = 0, chunk;
+
+        buf = kzalloc(5120, GFP_KERNEL);
+        if (buf == NULL)
+                return -1;
+
+        framelen[0] = mpeg1_frame_header(go, buf, 0, 1, PFRAME);
+        if (go->interlace_coding)
+                framelen[0] += mpeg1_frame_header(go, buf + framelen[0] / 8,
+                                                        0, 2, PFRAME);
+        buf[0] = framelen[0] & 0xff;
+        buf[1] = framelen[0] >> 8;
+        i = 368;
+        framelen[1] = mpeg1_frame_header(go, buf + i, 0, 1, BFRAME_PRE);
+        if (go->interlace_coding)
+                framelen[1] += mpeg1_frame_header(go, buf + i + framelen[1] / 8,
+                                                        0, 2, BFRAME_PRE);
+        buf[i] = framelen[1] & 0xff;
+        buf[i + 1] = framelen[1] >> 8;
+        i += 1632;
+        framelen[2] = mpeg1_frame_header(go, buf + i, 0, 1, BFRAME_POST);
+        if (go->interlace_coding)
+                framelen[2] += mpeg1_frame_header(go, buf + i + framelen[2] / 8,
+                                                        0, 2, BFRAME_POST);
+        buf[i] = framelen[2] & 0xff;
+        buf[i + 1] = framelen[2] >> 8;
+        i += 1432;
+        framelen[3] = mpeg1_frame_header(go, buf + i, 0, 1, BFRAME_BIDIR);
+        if (go->interlace_coding)
+                framelen[3] += mpeg1_frame_header(go, buf + i + framelen[3] / 8,
+                                                        0, 2, BFRAME_BIDIR);
+        buf[i] = framelen[3] & 0xff;
+        buf[i + 1] = framelen[3] >> 8;
+        i += 1632 + 16;
+        mpeg1_sequence_header(go, buf + i, 0);
+        i += 40;
+        for (i = 0; i < 5120; i += chunk * 2) {
+                if (space - off < 32) {
+                        off = -1;
+                        goto done;
+                }
+
+                code[off + 1] = __cpu_to_le16(0x8000 | mem);
+
+                chunk = 28;
+                if (mem + chunk > 0x4000)
+                        chunk = 0x4000 - mem;
+                if (i + 2 * chunk > 5120)
+                        chunk = (5120 - i) / 2;
+
+                if (chunk < 28) {
+                        code[off] = __cpu_to_le16(0x4000 | chunk);
+                        code[off + 31] = __cpu_to_le16(addr);
+                        if (mem + chunk == 0x4000) {
+                                mem = 0x3e00;
+                                ++addr;
+                        }
+                } else {
+                        code[off] = __cpu_to_le16(0x1000 | 28);
+                        code[off + 31] = 0;
+                        mem += 28;
+                }
+
+                memcpy(&code[off + 2], buf + i, chunk * 2);
+                off += 32;
+        }
+done:
+        kfree(buf);
+        return off;
+}
+
+static int vti_bitlen(struct go7007 *go)
+{
+        unsigned int i, max_time_incr = go->sensor_framerate / go->fps_scale;
+
+        for (i = 31; (max_time_incr & ((1 << i) - 1)) == max_time_incr; --i)
+                ;
+        return i + 1;
+}
+
+static int mpeg4_frame_header(struct go7007 *go, unsigned char *buf,
+                int modulo, enum mpeg_frame_type frame)
+{
+        int i;
+        CODE_GEN(c, buf + 6);
+        int mb_count = (go->width >> 4) * (go->height >> 4);
+
+        CODE_ADD(c, frame == PFRAME ? 0x1 : 0x2, 2);
+        if (modulo)
+                CODE_ADD(c, 0x1, 1);
+        CODE_ADD(c, 0x1, 2);
+        CODE_ADD(c, 0, vti_bitlen(go));
+        CODE_ADD(c, 0x3, 2);
+        if (frame == PFRAME)
+                CODE_ADD(c, 0, 1);
+        CODE_ADD(c, 0xc, 11);
+        if (frame != PFRAME)
+                CODE_ADD(c, 0x4, 3);
+        if (frame != BFRAME_EMPTY) {
+                for (i = 0; i < mb_count; ++i) {
+                        switch (frame) {
+                        case PFRAME:
+                                CODE_ADD(c, 0x1, 1);
+                                break;
+                        case BFRAME_PRE:
+                                CODE_ADD(c, 0x47, 8);
+                                break;
+                        case BFRAME_POST:
+                                CODE_ADD(c, 0x27, 7);
+                                break;
+                        case BFRAME_BIDIR:
+                                CODE_ADD(c, 0x5f, 8);
+                                break;
+                        case BFRAME_EMPTY: /* keep compiler quiet */
+                                break;
+                        }
+                }
+        }
+
+        /* Byte-align with a zero followed by ones */
+        i = 8 - (CODE_LENGTH(c) % 8);
+        CODE_ADD(c, 0, 1);
+        CODE_ADD(c, (1 << (i - 1)) - 1, i - 1);
+
+        i = CODE_LENGTH(c) + 4 * 8;
+        buf[0] = i & 0xff;
+        buf[1] = i >> 8;
+        buf[2] = 0x00;
+        buf[3] = 0x00;
+        buf[4] = 0x01;
+        buf[5] = 0xb6;
+        return i;
+}
+
+static int mpeg4_sequence_header(struct go7007 *go, unsigned char *buf, int ext)
+{
+        const unsigned char head[] = { 0x00, 0x00, 0x01, 0xb0, go->pali,
+                0x00, 0x00, 0x01, 0xb5, 0x09,
+                0x00, 0x00, 0x01, 0x00,
+                0x00, 0x00, 0x01, 0x20, };
+        int i, aspect_ratio;
+        int fps = go->sensor_framerate / go->fps_scale;
+        CODE_GEN(c, buf + 2 + sizeof(head));
+
+        switch (go->aspect_ratio) {
+        case GO7007_RATIO_4_3:
+                aspect_ratio = go->standard == GO7007_STD_NTSC ? 3 : 2;
+                break;
+        case GO7007_RATIO_16_9:
+                aspect_ratio = go->standard == GO7007_STD_NTSC ? 5 : 4;
+                break;
+        default:
+                aspect_ratio = 1;
+                break;
+        }
+
+        memcpy(buf + 2, head, sizeof(head));
+        CODE_ADD(c, 0x191, 17);
+        CODE_ADD(c, aspect_ratio, 4);
+        CODE_ADD(c, 0x1, 4);
+        CODE_ADD(c, fps, 16);
+        CODE_ADD(c, 0x3, 2);
+        CODE_ADD(c, 1001, vti_bitlen(go));
+        CODE_ADD(c, 1, 1);
+        CODE_ADD(c, go->width, 13);
+        CODE_ADD(c, 1, 1);
+        CODE_ADD(c, go->height, 13);
+        CODE_ADD(c, 0x2830, 14);
+
+        /* Byte-align */
+        i = 8 - (CODE_LENGTH(c) % 8);
+        CODE_ADD(c, 0, 1);
+        CODE_ADD(c, (1 << (i - 1)) - 1, i - 1);
+
+        i = CODE_LENGTH(c) + sizeof(head) * 8;
+        buf[0] = i & 0xff;
+        buf[1] = i >> 8;
+        return i;
+}
+
+static int gen_mpeg4hdr_to_package(struct go7007 *go,
+                                        __le16 *code, int space, int *framelen)
+{
+        u8 *buf;
+        u16 mem = 0x3e00;
+        unsigned int addr = 0x19;
+        int i, off = 0, chunk;
+
+        buf = kzalloc(5120, GFP_KERNEL);
+        if (buf == NULL)
+                return -1;
+
+        framelen[0] = mpeg4_frame_header(go, buf, 0, PFRAME);
+        i = 368;
+        framelen[1] = mpeg4_frame_header(go, buf + i, 0, BFRAME_PRE);
+        i += 1632;
+        framelen[2] = mpeg4_frame_header(go, buf + i, 0, BFRAME_POST);
+        i += 1432;
+        framelen[3] = mpeg4_frame_header(go, buf + i, 0, BFRAME_BIDIR);
+        i += 1632;
+        mpeg4_frame_header(go, buf + i, 0, BFRAME_EMPTY);
+        i += 16;
+        mpeg4_sequence_header(go, buf + i, 0);
+        i += 40;
+        for (i = 0; i < 5120; i += chunk * 2) {
+                if (space - off < 32) {
+                        off = -1;
+                        goto done;
+                }
+
+                code[off + 1] = __cpu_to_le16(0x8000 | mem);
+
+                chunk = 28;
+                if (mem + chunk > 0x4000)
+                        chunk = 0x4000 - mem;
+                if (i + 2 * chunk > 5120)
+                        chunk = (5120 - i) / 2;
+
+                if (chunk < 28) {
+                        code[off] = __cpu_to_le16(0x4000 | chunk);
+                        code[off + 31] = __cpu_to_le16(addr);
+                        if (mem + chunk == 0x4000) {
+                                mem = 0x3e00;
+                                ++addr;
+                        }
+                } else {
+                        code[off] = __cpu_to_le16(0x1000 | 28);
+                        code[off + 31] = 0;
+                        mem += 28;
+                }
+
+                memcpy(&code[off + 2], buf + i, chunk * 2);
+                off += 32;
+        }
+        mem = 0x3e00;
+        addr = go->ipb ? 0x14f9 : 0x0af9;
+        memset(buf, 0, 5120);
+        framelen[4] = mpeg4_frame_header(go, buf, 1, PFRAME);
+        i = 368;
+        framelen[5] = mpeg4_frame_header(go, buf + i, 1, BFRAME_PRE);
+        i += 1632;
+        framelen[6] = mpeg4_frame_header(go, buf + i, 1, BFRAME_POST);
+        i += 1432;
+        framelen[7] = mpeg4_frame_header(go, buf + i, 1, BFRAME_BIDIR);
+        i += 1632;
+        mpeg4_frame_header(go, buf + i, 1, BFRAME_EMPTY);
+        i += 16;
+        for (i = 0; i < 5120; i += chunk * 2) {
+                if (space - off < 32) {
+                        off = -1;
+                        goto done;
+                }
+
+                code[off + 1] = __cpu_to_le16(0x8000 | mem);
+
+                chunk = 28;
+                if (mem + chunk > 0x4000)
+                        chunk = 0x4000 - mem;
+                if (i + 2 * chunk > 5120)
+                        chunk = (5120 - i) / 2;
+
+                if (chunk < 28) {
+                        code[off] = __cpu_to_le16(0x4000 | chunk);
+                        code[off + 31] = __cpu_to_le16(addr);
+                        if (mem + chunk == 0x4000) {
+                                mem = 0x3e00;
+                                ++addr;
+                        }
+                } else {
+                        code[off] = __cpu_to_le16(0x1000 | 28);
+                        code[off + 31] = 0;
+                        mem += 28;
+                }
+
+                memcpy(&code[off + 2], buf + i, chunk * 2);
+                off += 32;
+        }
+done:
+        kfree(buf);
+        return off;
+}
+
+static int brctrl_to_package(struct go7007 *go,
+                                        __le16 *code, int space, int *framelen)
+{
+        int converge_speed = 0;
+        int lambda = (go->format == V4L2_PIX_FMT_MJPEG || go->dvd_mode) ?
+                                100 : 0;
+        int peak_rate = 6 * go->bitrate / 5;
+        int vbv_buffer = go->format == V4L2_PIX_FMT_MJPEG ?
+                                go->bitrate :
+                                (go->dvd_mode ? 900000 : peak_rate);
+        int fps = go->sensor_framerate / go->fps_scale;
+        int q = 0;
+        /* Bizarre math below depends on rounding errors in division */
+        u32 sgop_expt_addr = go->bitrate / 32 * (go->ipb ? 3 : 1) * 1001 / fps;
+        u32 sgop_peak_addr = peak_rate / 32 * 1001 / fps;
+        u32 total_expt_addr = go->bitrate / 32 * 1000 / fps * (fps / 1000);
+        u32 vbv_alert_addr = vbv_buffer * 3 / (4 * 32);
+        u32 cplx[] = {
+                q > 0 ? sgop_expt_addr * q :
+                        2 * go->width * go->height * (go->ipb ? 6 : 4) / 32,
+                q > 0 ? sgop_expt_addr * q :
+                        2 * go->width * go->height * (go->ipb ? 6 : 4) / 32,
+                q > 0 ? sgop_expt_addr * q :
+                        2 * go->width * go->height * (go->ipb ? 6 : 4) / 32,
+                q > 0 ? sgop_expt_addr * q :
+                        2 * go->width * go->height * (go->ipb ? 6 : 4) / 32,
+        };
+        u32 calc_q = q > 0 ? q : cplx[0] / sgop_expt_addr;
+        u16 pack[] = {
+                0x200e,         0x0000,
+                0xBF20,         go->ipb ? converge_speed_ipb[converge_speed]
+                                        : converge_speed_ip[converge_speed],
+                0xBF21,         go->ipb ? 2 : 0,
+                0xBF22,         go->ipb ? LAMBDA_table[0][lambda / 2 + 50]
+                                        : 32767,
+                0xBF23,         go->ipb ? LAMBDA_table[1][lambda] : 32767,
+                0xBF24,         32767,
+                0xBF25,         lambda > 99 ? 32767 : LAMBDA_table[3][lambda],
+                0xBF26,         sgop_expt_addr & 0x0000FFFF,
+                0xBF27,         sgop_expt_addr >> 16,
+                0xBF28,         sgop_peak_addr & 0x0000FFFF,
+                0xBF29,         sgop_peak_addr >> 16,
+                0xBF2A,         vbv_alert_addr & 0x0000FFFF,
+                0xBF2B,         vbv_alert_addr >> 16,
+                0xBF2C,         0,
+                0xBF2D,         0,
+                0,              0,
+
+                0x200e,         0x0000,
+                0xBF2E,         vbv_alert_addr & 0x0000FFFF,
+                0xBF2F,         vbv_alert_addr >> 16,
+                0xBF30,         cplx[0] & 0x0000FFFF,
+                0xBF31,         cplx[0] >> 16,
+                0xBF32,         cplx[1] & 0x0000FFFF,
+                0xBF33,         cplx[1] >> 16,
+                0xBF34,         cplx[2] & 0x0000FFFF,
+                0xBF35,         cplx[2] >> 16,
+                0xBF36,         cplx[3] & 0x0000FFFF,
+                0xBF37,         cplx[3] >> 16,
+                0xBF38,         0,
+                0xBF39,         0,
+                0xBF3A,         total_expt_addr & 0x0000FFFF,
+                0xBF3B,         total_expt_addr >> 16,
+                0,              0,
+
+                0x200e,         0x0000,
+                0xBF3C,         total_expt_addr & 0x0000FFFF,
+                0xBF3D,         total_expt_addr >> 16,
+                0xBF3E,         0,
+                0xBF3F,         0,
+                0xBF48,         0,
+                0xBF49,         0,
+                0xBF4A,         calc_q < 4 ? 4 : (calc_q > 124 ? 124 : calc_q),
+                0xBF4B,         4,
+                0xBF4C,         0,
+                0xBF4D,         0,
+                0xBF4E,         0,
+                0xBF4F,         0,
+                0xBF50,         0,
+                0xBF51,         0,
+                0,              0,
+
+                0x200e,         0x0000,
+                0xBF40,         sgop_expt_addr & 0x0000FFFF,
+                0xBF41,         sgop_expt_addr >> 16,
+                0xBF42,         0,
+                0xBF43,         0,
+                0xBF44,         0,
+                0xBF45,         0,
+                0xBF46,         (go->width >> 4) * (go->height >> 4),
+                0xBF47,         0,
+                0xBF64,         0,
+                0xBF65,         0,
+                0xBF18,         framelen[4],
+                0xBF19,         framelen[5],
+                0xBF1A,         framelen[6],
+                0xBF1B,         framelen[7],
+                0,              0,
+
+#if 0
+                /* Remove once we don't care about matching */
+                0x200e,         0x0000,
+                0xBF56,         4,
+                0xBF57,         0,
+                0xBF58,         5,
+                0xBF59,         0,
+                0xBF5A,         6,
+                0xBF5B,         0,
+                0xBF5C,         8,
+                0xBF5D,         0,
+                0xBF5E,         1,
+                0xBF5F,         0,
+                0xBF60,         1,
+                0xBF61,         0,
+                0xBF62,         0,
+                0xBF63,         0,
+                0,              0,
+#else
+                0x2008,         0x0000,
+                0xBF56,         4,
+                0xBF57,         0,
+                0xBF58,         5,
+                0xBF59,         0,
+                0xBF5A,         6,
+                0xBF5B,         0,
+                0xBF5C,         8,
+                0xBF5D,         0,
+                0,              0,
+                0,              0,
+                0,              0,
+                0,              0,
+                0,              0,
+                0,              0,
+                0,              0,
+#endif
+
+                0x200e,         0x0000,
+                0xBF10,         0,
+                0xBF11,         0,
+                0xBF12,         0,
+                0xBF13,         0,
+                0xBF14,         0,
+                0xBF15,         0,
+                0xBF16,         0,
+                0xBF17,         0,
+                0xBF7E,         0,
+                0xBF7F,         1,
+                0xBF52,         framelen[0],
+                0xBF53,         framelen[1],
+                0xBF54,         framelen[2],
+                0xBF55,         framelen[3],
+                0,              0,
+        };
+
+        return copy_packages(code, pack, 6, space);
+}
+
+static int config_package(struct go7007 *go, __le16 *code, int space)
+{
+        int fps = go->sensor_framerate / go->fps_scale / 1000;
+        int rows = go->interlace_coding ? go->height / 32 : go->height / 16;
+        int brc_window_size = fps;
+        int q_min = 2, q_max = 31;
+        int THACCoeffSet0 = 0;
+        u16 pack[] = {
+                0x200e,         0x0000,
+                0xc002,         0x14b4,
+                0xc003,         0x28b4,
+                0xc004,         0x3c5a,
+                0xdc05,         0x2a77,
+                0xc6c3,         go->format == V4L2_PIX_FMT_MPEG4 ? 0 :
+                                (go->format == V4L2_PIX_FMT_H263 ? 0 : 1),
+                0xc680,         go->format == V4L2_PIX_FMT_MPEG4 ? 0xf1 :
+                                (go->format == V4L2_PIX_FMT_H263 ? 0x61 :
+                                                                        0xd3),
+                0xc780,         0x0140,
+                0xe009,         0x0001,
+                0xc60f,         0x0008,
+                0xd4ff,         0x0002,
+                0xe403,         2340,
+                0xe406,         75,
+                0xd411,         0x0001,
+                0xd410,         0xa1d6,
+                0x0001,         0x2801,
+
+                0x200d,         0x0000,
+                0xe402,         0x018b,
+                0xe401,         0x8b01,
+                0xd472,         (go->board_info->sensor_flags &
+                                                        GO7007_SENSOR_TV) &&
+                                                (!go->interlace_coding) ?
+                                        0x01b0 : 0x0170,
+                0xd475,         (go->board_info->sensor_flags &
+                                                        GO7007_SENSOR_TV) &&
+                                                (!go->interlace_coding) ?
+                                        0x0008 : 0x0009,
+                0xc404,         go->interlace_coding ? 0x44 :
+                                (go->format == V4L2_PIX_FMT_MPEG4 ? 0x11 :
+                                (go->format == V4L2_PIX_FMT_MPEG1 ? 0x02 :
+                                (go->format == V4L2_PIX_FMT_MPEG2 ? 0x04 :
+                                (go->format == V4L2_PIX_FMT_H263  ? 0x08 :
+                                                                     0x20)))),
+                0xbf0a,         (go->format == V4L2_PIX_FMT_MPEG4 ? 8 :
+                                (go->format == V4L2_PIX_FMT_MPEG1 ? 1 :
+                                (go->format == V4L2_PIX_FMT_MPEG2 ? 2 :
+                                (go->format == V4L2_PIX_FMT_H263 ? 4 : 16)))) |
+                                ((go->repeat_seqhead ? 1 : 0) << 6) |
+                                ((go->dvd_mode ? 1 : 0) << 9) |
+                                ((go->gop_header_enable ? 1 : 0) << 10),
+                0xbf0b,         0,
+                0xdd5a,         go->ipb ? 0x14 : 0x0a,
+                0xbf0c,         0,
+                0xbf0d,         0,
+                0xc683,         THACCoeffSet0,
+                0xc40a,         (go->width << 4) | rows,
+                0xe01a,         go->board_info->hpi_buffer_cap,
+                0,              0,
+                0,              0,
+
+                0x2008,         0,
+                0xe402,         0x88,
+                0xe401,         0x8f01,
+                0xbf6a,         0,
+                0xbf6b,         0,
+                0xbf6c,         0,
+                0xbf6d,         0,
+                0xbf6e,         0,
+                0xbf6f,         0,
+                0,              0,
+                0,              0,
+                0,              0,
+                0,              0,
+                0,              0,
+                0,              0,
+                0,              0,
+
+                0x200e,         0,
+                0xbf66,         brc_window_size,
+                0xbf67,         0,
+                0xbf68,         q_min,
+                0xbf69,         q_max,
+                0xbfe0,         0,
+                0xbfe1,         0,
+                0xbfe2,         0,
+                0xbfe3,         go->ipb ? 3 : 1,
+                0xc031,         go->board_info->sensor_flags &
+                                        GO7007_SENSOR_VBI ? 1 : 0,
+                0xc01c,         0x1f,
+                0xdd8c,         0x15,
+                0xdd94,         0x15,
+                0xdd88,         go->ipb ? 0x1401 : 0x0a01,
+                0xdd90,         go->ipb ? 0x1401 : 0x0a01,
+                0,              0,
+
+                0x200e,         0,
+                0xbfe4,         0,
+                0xbfe5,         0,
+                0xbfe6,         0,
+                0xbfe7,         fps << 8,
+                0xbfe8,         0x3a00,
+                0xbfe9,         0,
+                0xbfea,         0,
+                0xbfeb,         0,
+                0xbfec,         (go->interlace_coding ? 1 << 15 : 0) |
+                                        (go->modet_enable ? 0xa : 0) |
+                                        (go->board_info->sensor_flags &
+                                                GO7007_SENSOR_VBI ? 1 : 0),
+                0xbfed,         0,
+                0xbfee,         0,
+                0xbfef,         0,
+                0xbff0,         go->board_info->sensor_flags &
+                                        GO7007_SENSOR_TV ? 0xf060 : 0xb060,
+                0xbff1,         0,
+                0,              0,
+        };
+
+        return copy_packages(code, pack, 5, space);
+}
+
+static int seqhead_to_package(struct go7007 *go, __le16 *code, int space,
+        int (*sequence_header_func)(struct go7007 *go,
+                unsigned char *buf, int ext))
+{
+        int vop_time_increment_bitlength = vti_bitlen(go);
+        int fps = go->sensor_framerate / go->fps_scale *
+                                        (go->interlace_coding ? 2 : 1);
+        unsigned char buf[40] = { };
+        int len = sequence_header_func(go, buf, 1);
+        u16 pack[] = {
+                0x2006,         0,
+                0xbf08,         fps,
+                0xbf09,         0,
+                0xbff2,         vop_time_increment_bitlength,
+                0xbff3,         (1 << vop_time_increment_bitlength) - 1,
+                0xbfe6,         0,
+                0xbfe7,         (fps / 1000) << 8,
+                0,              0,
+                0,              0,
+                0,              0,
+                0,              0,
+                0,              0,
+                0,              0,
+                0,              0,
+                0,              0,
+                0,              0,
+
+                0x2007,         0,
+                0xc800,         buf[2] << 8 | buf[3],
+                0xc801,         buf[4] << 8 | buf[5],
+                0xc802,         buf[6] << 8 | buf[7],
+                0xc803,         buf[8] << 8 | buf[9],
+                0xc406,         64,
+                0xc407,         len - 64,
+                0xc61b,         1,
+                0,              0,
+                0,              0,
+                0,              0,
+                0,              0,
+                0,              0,
+                0,              0,
+                0,              0,
+                0,              0,
+
+                0x200e,         0,
+                0xc808,         buf[10] << 8 | buf[11],
+                0xc809,         buf[12] << 8 | buf[13],
+                0xc80a,         buf[14] << 8 | buf[15],
+                0xc80b,         buf[16] << 8 | buf[17],
+                0xc80c,         buf[18] << 8 | buf[19],
+                0xc80d,         buf[20] << 8 | buf[21],
+                0xc80e,         buf[22] << 8 | buf[23],
+                0xc80f,         buf[24] << 8 | buf[25],
+                0xc810,         buf[26] << 8 | buf[27],
+                0xc811,         buf[28] << 8 | buf[29],
+                0xc812,         buf[30] << 8 | buf[31],
+                0xc813,         buf[32] << 8 | buf[33],
+                0xc814,         buf[34] << 8 | buf[35],
+                0xc815,         buf[36] << 8 | buf[37],
+                0,              0,
+                0,              0,
+                0,              0,
+        };
+
+        return copy_packages(code, pack, 3, space);
+}
+
+static int relative_prime(int big, int little)
+{
+        int remainder;
+
+        while (little != 0) {
+                remainder = big % little;
+                big = little;
+                little = remainder;
+        }
+        return big;
+}
+
+static int avsync_to_package(struct go7007 *go, __le16 *code, int space)
+{
+        int arate = go->board_info->audio_rate * 1001 * go->fps_scale;
+        int ratio = arate / go->sensor_framerate;
+        int adjratio = ratio * 215 / 100;
+        int rprime = relative_prime(go->sensor_framerate,
+                                        arate % go->sensor_framerate);
+        int f1 = (arate % go->sensor_framerate) / rprime;
+        int f2 = (go->sensor_framerate - arate % go->sensor_framerate) / rprime;
+        u16 pack[] = {
+                0x200e,         0,
+                0xbf98,         (u16)((-adjratio) & 0xffff),
+                0xbf99,         (u16)((-adjratio) >> 16),
+                0xbf92,         0,
+                0xbf93,         0,
+                0xbff4,         f1 > f2 ? f1 : f2,
+                0xbff5,         f1 < f2 ? f1 : f2,
+                0xbff6,         f1 < f2 ? ratio : ratio + 1,
+                0xbff7,         f1 > f2 ? ratio : ratio + 1,
+                0xbff8,         0,
+                0xbff9,         0,
+                0xbffa,         adjratio & 0xffff,
+                0xbffb,         adjratio >> 16,
+                0xbf94,         0,
+                0xbf95,         0,
+                0,              0,
+        };
+
+        return copy_packages(code, pack, 1, space);
+}
+
+static int final_package(struct go7007 *go, __le16 *code, int space)
+{
+        int rows = go->interlace_coding ? go->height / 32 : go->height / 16;
+        u16 pack[] = {
+                0x8000,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                2,
+                ((go->board_info->sensor_flags & GO7007_SENSOR_TV) &&
+                                                (!go->interlace_coding) ?
+                                        (1 << 14) | (1 << 9) : 0) |
+                        ((go->encoder_subsample ? 1 : 0) << 8) |
+                        (go->board_info->sensor_flags &
+                                GO7007_SENSOR_CONFIG_MASK),
+                ((go->encoder_v_halve ? 1 : 0) << 14) |
+                        (go->encoder_v_halve ? rows << 9 : rows << 8) |
+                        (go->encoder_h_halve ? 1 << 6 : 0) |
+                        (go->encoder_h_halve ? go->width >> 3 : go->width >> 4),
+                (1 << 15) | (go->encoder_v_offset << 6) |
+                        (1 << 7) | (go->encoder_h_offset >> 2),
+                (1 << 6),
+                0,
+                0,
+                ((go->fps_scale - 1) << 8) |
+                        (go->board_info->sensor_flags & GO7007_SENSOR_TV ?
+                                                (1 << 7) : 0) |
+                        0x41,
+                go->ipb ? 0xd4c : 0x36b,
+                (rows << 8) | (go->width >> 4),
+                go->format == V4L2_PIX_FMT_MPEG4 ? 0x0404 : 0,
+                (1 << 15) | ((go->interlace_coding ? 1 : 0) << 13) |
+                        ((go->closed_gop ? 1 : 0) << 12) |
+                        ((go->format == V4L2_PIX_FMT_MPEG4 ? 1 : 0) << 11) |
+                /*      (1 << 9) |   */
+                        ((go->ipb ? 3 : 0) << 7) |
+                        ((go->modet_enable ? 1 : 0) << 2) |
+                        ((go->dvd_mode ? 1 : 0) << 1) | 1,
+                (go->format == V4L2_PIX_FMT_MPEG1 ? 0x89a0 :
+                        (go->format == V4L2_PIX_FMT_MPEG2 ? 0x89a0 :
+                        (go->format == V4L2_PIX_FMT_MJPEG ? 0x89a0 :
+                        (go->format == V4L2_PIX_FMT_MPEG4 ? 0x8920 :
+                        (go->format == V4L2_PIX_FMT_H263 ? 0x8920 : 0))))),
+                go->ipb ? 0x1f15 : 0x1f0b,
+                go->ipb ? 0x0015 : 0x000b,
+                go->ipb ? 0xa800 : 0x5800,
+                0xffff,
+                0x0020 + 0x034b * 0,
+                0x0020 + 0x034b * 1,
+                0x0020 + 0x034b * 2,
+                0x0020 + 0x034b * 3,
+                0x0020 + 0x034b * 4,
+                0x0020 + 0x034b * 5,
+                go->ipb ? (go->gop_size / 3) : go->gop_size,
+                (go->height >> 4) * (go->width >> 4) * 110 / 100,
+        };
+
+        return copy_packages(code, pack, 1, space);
+}
+
+static int audio_to_package(struct go7007 *go, __le16 *code, int space)
+{
+        int clock_config = ((go->board_info->audio_flags &
+                                GO7007_AUDIO_I2S_MASTER ? 1 : 0) << 11) |
+                        ((go->board_info->audio_flags &
+                                GO7007_AUDIO_OKI_MODE ? 1 : 0) << 8) |
+                        (((go->board_info->audio_bclk_div / 4) - 1) << 4) |
+                        (go->board_info->audio_main_div - 1);
+        u16 pack[] = {
+                0x200d,         0,
+                0x9002,         0,
+                0x9002,         0,
+                0x9031,         0,
+                0x9032,         0,
+                0x9033,         0,
+                0x9034,         0,
+                0x9035,         0,
+                0x9036,         0,
+                0x9037,         0,
+                0x9040,         0,
+                0x9000,         clock_config,
+                0x9001,         (go->board_info->audio_flags & 0xffff) |
+                                        (1 << 9),
+                0x9000,         ((go->board_info->audio_flags &
+                                                GO7007_AUDIO_I2S_MASTER ?
+                                                1 : 0) << 10) |
+                                        clock_config,
+                0,              0,
+                0,              0,
+                0x2005,         0,
+                0x9041,         0,
+                0x9042,         256,
+                0x9043,         0,
+                0x9044,         16,
+                0x9045,         16,
+                0,              0,
+                0,              0,
+                0,              0,
+                0,              0,
+                0,              0,
+                0,              0,
+                0,              0,
+                0,              0,
+                0,              0,
+                0,              0,
+        };
+
+        return copy_packages(code, pack, 2, space);
+}
+
+static int modet_to_package(struct go7007 *go, __le16 *code, int space)
+{
+        bool has_modet0 = go->modet[0].enable;
+        bool has_modet1 = go->modet[1].enable;
+        bool has_modet2 = go->modet[2].enable;
+        bool has_modet3 = go->modet[3].enable;
+        int ret, mb, i, addr, cnt = 0;
+        u16 pack[32];
+        u16 thresholds[] = {
+                0x200e,         0,
+                0xbf82,         has_modet0 ? go->modet[0].pixel_threshold : 32767,
+                0xbf83,         has_modet1 ? go->modet[1].pixel_threshold : 32767,
+                0xbf84,         has_modet2 ? go->modet[2].pixel_threshold : 32767,
+                0xbf85,         has_modet3 ? go->modet[3].pixel_threshold : 32767,
+                0xbf86,         has_modet0 ? go->modet[0].motion_threshold : 32767,
+                0xbf87,         has_modet1 ? go->modet[1].motion_threshold : 32767,
+                0xbf88,         has_modet2 ? go->modet[2].motion_threshold : 32767,
+                0xbf89,         has_modet3 ? go->modet[3].motion_threshold : 32767,
+                0xbf8a,         has_modet0 ? go->modet[0].mb_threshold : 32767,
+                0xbf8b,         has_modet1 ? go->modet[1].mb_threshold : 32767,
+                0xbf8c,         has_modet2 ? go->modet[2].mb_threshold : 32767,
+                0xbf8d,         has_modet3 ? go->modet[3].mb_threshold : 32767,
+                0xbf8e,         0,
+                0xbf8f,         0,
+                0,              0,
+        };
+
+        ret = copy_packages(code, thresholds, 1, space);
+        if (ret < 0)
+                return -1;
+        cnt += ret;
+
+        addr = 0xbac0;
+        memset(pack, 0, 64);
+        i = 0;
+        for (mb = 0; mb < 1624; ++mb) {
+                pack[i * 2 + 3] <<= 2;
+                pack[i * 2 + 3] |= go->modet_map[mb];
+                if (mb % 8 != 7)
+                        continue;
+                pack[i * 2 + 2] = addr++;
+                ++i;
+                if (i == 10 || mb == 1623) {
+                        pack[0] = 0x2000 | i;
+                        ret = copy_packages(code + cnt, pack, 1, space - cnt);
+                        if (ret < 0)
+                                return -1;
+                        cnt += ret;
+                        i = 0;
+                        memset(pack, 0, 64);
+                }
+                pack[i * 2 + 3] = 0;
+        }
+
+        memset(pack, 0, 64);
+        i = 0;
+        for (addr = 0xbb90; addr < 0xbbfa; ++addr) {
+                pack[i * 2 + 2] = addr;
+                pack[i * 2 + 3] = 0;
+                ++i;
+                if (i == 10 || addr == 0xbbf9) {
+                        pack[0] = 0x2000 | i;
+                        ret = copy_packages(code + cnt, pack, 1, space - cnt);
+                        if (ret < 0)
+                                return -1;
+                        cnt += ret;
+                        i = 0;
+                        memset(pack, 0, 64);
+                }
+        }
+        return cnt;
+}
+
+static int do_special(struct go7007 *go, u16 type, __le16 *code, int space,
+                        int *framelen)
+{
+        switch (type) {
+        case SPECIAL_FRM_HEAD:
+                switch (go->format) {
+                case V4L2_PIX_FMT_MJPEG:
+                        return gen_mjpeghdr_to_package(go, code, space);
+                case V4L2_PIX_FMT_MPEG1:
+                case V4L2_PIX_FMT_MPEG2:
+                        return gen_mpeg1hdr_to_package(go, code, space,
+                                                                framelen);
+                case V4L2_PIX_FMT_MPEG4:
+                        return gen_mpeg4hdr_to_package(go, code, space,
+                                                                framelen);
+                }
+        case SPECIAL_BRC_CTRL:
+                return brctrl_to_package(go, code, space, framelen);
+        case SPECIAL_CONFIG:
+                return config_package(go, code, space);
+        case SPECIAL_SEQHEAD:
+                switch (go->format) {
+                case V4L2_PIX_FMT_MPEG1:
+                case V4L2_PIX_FMT_MPEG2:
+                        return seqhead_to_package(go, code, space,
+                                        mpeg1_sequence_header);
+                case V4L2_PIX_FMT_MPEG4:
+                        return seqhead_to_package(go, code, space,
+                                        mpeg4_sequence_header);
+                default:
+                        return 0;
+                }
+        case SPECIAL_AV_SYNC:
+                return avsync_to_package(go, code, space);
+        case SPECIAL_FINAL:
+                return final_package(go, code, space);
+        case SPECIAL_AUDIO:
+                return audio_to_package(go, code, space);
+        case SPECIAL_MODET:
+                return modet_to_package(go, code, space);
+        }
+        dev_err(go->dev,
+                "firmware file contains unsupported feature %04x\n", type);
+        return -1;
+}
+
+int go7007_construct_fw_image(struct go7007 *go, u8 **fw, int *fwlen)
+{
+        const struct firmware *fw_entry;
+        __le16 *code, *src;
+        int framelen[8] = { }; /* holds the lengths of empty frame templates */
+        int codespace = 64 * 1024, i = 0, srclen, chunk_len, chunk_flags;
+        int mode_flag;
+        int ret;
+
+        switch (go->format) {
+        case V4L2_PIX_FMT_MJPEG:
+                mode_flag = FLAG_MODE_MJPEG;
+                break;
+        case V4L2_PIX_FMT_MPEG1:
+                mode_flag = FLAG_MODE_MPEG1;
+                break;
+        case V4L2_PIX_FMT_MPEG2:
+                mode_flag = FLAG_MODE_MPEG2;
+                break;
+        case V4L2_PIX_FMT_MPEG4:
+                mode_flag = FLAG_MODE_MPEG4;
+                break;
+        default:
+                return -1;
+        }
+        if (request_firmware(&fw_entry, GO7007_FW_NAME, go->dev)) {
+                dev_err(go->dev,
+                        "unable to load firmware from file \"%s\"\n",
+                        GO7007_FW_NAME);
+                return -1;
+        }
+        code = kzalloc(codespace * 2, GFP_KERNEL);
+        if (code == NULL)
+                goto fw_failed;
+
+        src = (__le16 *)fw_entry->data;
+        srclen = fw_entry->size / 2;
+        while (srclen >= 2) {
+                chunk_flags = __le16_to_cpu(src[0]);
+                chunk_len = __le16_to_cpu(src[1]);
+                if (chunk_len + 2 > srclen) {
+                        dev_err(go->dev,
+                                "firmware file \"%s\" appears to be corrupted\n",
+                                GO7007_FW_NAME);
+                        goto fw_failed;
+                }
+                if (chunk_flags & mode_flag) {
+                        if (chunk_flags & FLAG_SPECIAL) {
+                                ret = do_special(go, __le16_to_cpu(src[2]),
+                                        &code[i], codespace - i, framelen);
+                                if (ret < 0) {
+                                        dev_err(go->dev,
+                                                "insufficient memory for firmware construction\n");
+                                        goto fw_failed;
+                                }
+                                i += ret;
+                        } else {
+                                if (codespace - i < chunk_len) {
+                                        dev_err(go->dev,
+                                                "insufficient memory for firmware construction\n");
+                                        goto fw_failed;
+                                }
+                                memcpy(&code[i], &src[2], chunk_len * 2);
+                                i += chunk_len;
+                        }
+                }
+                srclen -= chunk_len + 2;
+                src += chunk_len + 2;
+        }
+        release_firmware(fw_entry);
+        *fw = (u8 *)code;
+        *fwlen = i * 2;
+        return 0;
+
+fw_failed:
+        kfree(code);
+        release_firmware(fw_entry);
+        return -1;
+}
+
+MODULE_FIRMWARE(GO7007_FW_NAME);
diff --git a/drivers/media/usb/go7007/go7007-i2c.c b/drivers/media/usb/go7007/go7007-i2c.c
new file mode 100644
index 000000000000..55addfa855d4
--- /dev/null
+++ b/drivers/media/usb/go7007/go7007-i2c.c
@@ -0,0 +1,218 @@
+/*
+ * Copyright (C) 2005-2006 Micronas USA Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License (Version 2) as
+ * published by the Free Software Foundation.
+ *
+ * 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.
+ */
+
+#include <linux/module.h>
+#include <linux/delay.h>
+#include <linux/sched.h>
+#include <linux/list.h>
+#include <linux/unistd.h>
+#include <linux/time.h>
+#include <linux/device.h>
+#include <linux/i2c.h>
+#include <linux/mutex.h>
+#include <linux/uaccess.h>
+
+#include "go7007-priv.h"
+
+/********************* Driver for on-board I2C adapter *********************/
+
+/* #define GO7007_I2C_DEBUG */
+
+#define SPI_I2C_ADDR_BASE               0x1400
+#define STATUS_REG_ADDR                 (SPI_I2C_ADDR_BASE + 0x2)
+#define I2C_CTRL_REG_ADDR               (SPI_I2C_ADDR_BASE + 0x6)
+#define I2C_DEV_UP_ADDR_REG_ADDR        (SPI_I2C_ADDR_BASE + 0x7)
+#define I2C_LO_ADDR_REG_ADDR            (SPI_I2C_ADDR_BASE + 0x8)
+#define I2C_DATA_REG_ADDR               (SPI_I2C_ADDR_BASE + 0x9)
+#define I2C_CLKFREQ_REG_ADDR            (SPI_I2C_ADDR_BASE + 0xa)
+
+#define I2C_STATE_MASK                  0x0007
+#define I2C_READ_READY_MASK             0x0008
+
+/* There is only one I2C port on the TW2804 that feeds all four GO7007 VIPs
+ * on the Adlink PCI-MPG24, so access is shared between all of them. */
+static DEFINE_MUTEX(adlink_mpg24_i2c_lock);
+
+static int go7007_i2c_xfer(struct go7007 *go, u16 addr, int read,
+                u16 command, int flags, u8 *data)
+{
+        int i, ret = -EIO;
+        u16 val;
+
+        if (go->status == STATUS_SHUTDOWN)
+                return -ENODEV;
+
+#ifdef GO7007_I2C_DEBUG
+        if (read)
+                dev_dbg(go->dev, "go7007-i2c: reading 0x%02x on 0x%02x\n",
+                        command, addr);
+        else
+                dev_dbg(go->dev,
+                        "go7007-i2c: writing 0x%02x to 0x%02x on 0x%02x\n",
+                        *data, command, addr);
+#endif
+
+        mutex_lock(&go->hw_lock);
+
+        if (go->board_id == GO7007_BOARDID_ADLINK_MPG24) {
+                /* Bridge the I2C port on this GO7007 to the shared bus */
+                mutex_lock(&adlink_mpg24_i2c_lock);
+                go7007_write_addr(go, 0x3c82, 0x0020);
+        }
+
+        /* Wait for I2C adapter to be ready */
+        for (i = 0; i < 10; ++i) {
+                if (go7007_read_addr(go, STATUS_REG_ADDR, &val) < 0)
+                        goto i2c_done;
+                if (!(val & I2C_STATE_MASK))
+                        break;
+                msleep(100);
+        }
+        if (i == 10) {
+                dev_err(go->dev, "go7007-i2c: I2C adapter is hung\n");
+                goto i2c_done;
+        }
+
+        /* Set target register (command) */
+        go7007_write_addr(go, I2C_CTRL_REG_ADDR, flags);
+        go7007_write_addr(go, I2C_LO_ADDR_REG_ADDR, command);
+
+        /* If we're writing, send the data and target address and we're done */
+        if (!read) {
+                go7007_write_addr(go, I2C_DATA_REG_ADDR, *data);
+                go7007_write_addr(go, I2C_DEV_UP_ADDR_REG_ADDR,
+                                        (addr << 9) | (command >> 8));
+                ret = 0;
+                goto i2c_done;
+        }
+
+        /* Otherwise, we're reading.  First clear i2c_rx_data_rdy. */
+        if (go7007_read_addr(go, I2C_DATA_REG_ADDR, &val) < 0)
+                goto i2c_done;
+
+        /* Send the target address plus read flag */
+        go7007_write_addr(go, I2C_DEV_UP_ADDR_REG_ADDR,
+                        (addr << 9) | 0x0100 | (command >> 8));
+
+        /* Wait for i2c_rx_data_rdy */
+        for (i = 0; i < 10; ++i) {
+                if (go7007_read_addr(go, STATUS_REG_ADDR, &val) < 0)
+                        goto i2c_done;
+                if (val & I2C_READ_READY_MASK)
+                        break;
+                msleep(100);
+        }
+        if (i == 10) {
+                dev_err(go->dev, "go7007-i2c: I2C adapter is hung\n");
+                goto i2c_done;
+        }
+
+        /* Retrieve the read byte */
+        if (go7007_read_addr(go, I2C_DATA_REG_ADDR, &val) < 0)
+                goto i2c_done;
+        *data = val;
+        ret = 0;
+
+i2c_done:
+        if (go->board_id == GO7007_BOARDID_ADLINK_MPG24) {
+                /* Isolate the I2C port on this GO7007 from the shared bus */
+                go7007_write_addr(go, 0x3c82, 0x0000);
+                mutex_unlock(&adlink_mpg24_i2c_lock);
+        }
+        mutex_unlock(&go->hw_lock);
+        return ret;
+}
+
+static int go7007_smbus_xfer(struct i2c_adapter *adapter, u16 addr,
+                unsigned short flags, char read_write,
+                u8 command, int size, union i2c_smbus_data *data)
+{
+        struct go7007 *go = i2c_get_adapdata(adapter);
+
+        if (size != I2C_SMBUS_BYTE_DATA)
+                return -EIO;
+        return go7007_i2c_xfer(go, addr, read_write == I2C_SMBUS_READ, command,
+                        flags & I2C_CLIENT_SCCB ? 0x10 : 0x00, &data->byte);
+}
+
+/* VERY LIMITED I2C master xfer function -- only needed because the
+ * SMBus functions only support 8-bit commands and the SAA7135 uses
+ * 16-bit commands.  The I2C interface on the GO7007, as limited as
+ * it is, does support this mode. */
+
+static int go7007_i2c_master_xfer(struct i2c_adapter *adapter,
+                                        struct i2c_msg msgs[], int num)
+{
+        struct go7007 *go = i2c_get_adapdata(adapter);
+        int i;
+
+        for (i = 0; i < num; ++i) {
+                /* We can only do two things here -- write three bytes, or
+                 * write two bytes and read one byte. */
+                if (msgs[i].len == 2) {
+                        if (i + 1 == num || msgs[i].addr != msgs[i + 1].addr ||
+                                        (msgs[i].flags & I2C_M_RD) ||
+                                        !(msgs[i + 1].flags & I2C_M_RD) ||
+                                        msgs[i + 1].len != 1)
+                                return -EIO;
+                        if (go7007_i2c_xfer(go, msgs[i].addr, 1,
+                                        (msgs[i].buf[0] << 8) | msgs[i].buf[1],
+                                        0x01, &msgs[i + 1].buf[0]) < 0)
+                                return -EIO;
+                        ++i;
+                } else if (msgs[i].len == 3) {
+                        if (msgs[i].flags & I2C_M_RD)
+                                return -EIO;
+                        if (msgs[i].len != 3)
+                                return -EIO;
+                        if (go7007_i2c_xfer(go, msgs[i].addr, 0,
+                                        (msgs[i].buf[0] << 8) | msgs[i].buf[1],
+                                        0x01, &msgs[i].buf[2]) < 0)
+                                return -EIO;
+                } else
+                        return -EIO;
+        }
+
+        return num;
+}
+
+static u32 go7007_functionality(struct i2c_adapter *adapter)
+{
+        return I2C_FUNC_SMBUS_BYTE_DATA;
+}
+
+static struct i2c_algorithm go7007_algo = {
+        .smbus_xfer     = go7007_smbus_xfer,
+        .master_xfer    = go7007_i2c_master_xfer,
+        .functionality  = go7007_functionality,
+};
+
+static struct i2c_adapter go7007_adap_templ = {
+        .owner                  = THIS_MODULE,
+        .name                   = "WIS GO7007SB",
+        .algo                   = &go7007_algo,
+};
+
+int go7007_i2c_init(struct go7007 *go)
+{
+        memcpy(&go->i2c_adapter, &go7007_adap_templ,
+                        sizeof(go7007_adap_templ));
+        go->i2c_adapter.dev.parent = go->dev;
+        i2c_set_adapdata(&go->i2c_adapter, go);
+        if (i2c_add_adapter(&go->i2c_adapter) < 0) {
+                dev_err(go->dev,
+                        "go7007-i2c: error: i2c_add_adapter failed\n");
+                return -1;
+        }
+        return 0;
+}
diff --git a/drivers/media/usb/go7007/go7007-loader.c b/drivers/media/usb/go7007/go7007-loader.c
new file mode 100644
index 000000000000..042f78a31283
--- /dev/null
+++ b/drivers/media/usb/go7007/go7007-loader.c
@@ -0,0 +1,141 @@
+/*
+ * Copyright (C) 2008 Sensoray Company Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License (Version 2) as
+ * published by the Free Software Foundation.
+ *
+ * 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.
+ */
+
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/usb.h>
+#include <linux/firmware.h>
+#include <cypress_firmware.h>
+
+struct fw_config {
+        u16 vendor;
+        u16 product;
+        const char * const fw_name1;
+        const char * const fw_name2;
+};
+
+static struct fw_config fw_configs[] = {
+        { 0x1943, 0xa250, "go7007/s2250-1.fw", "go7007/s2250-2.fw" },
+        { 0x093b, 0xa002, "go7007/px-m402u.fw", NULL },
+        { 0x093b, 0xa004, "go7007/px-tv402u.fw", NULL },
+        { 0x0eb1, 0x6666, "go7007/lr192.fw", NULL },
+        { 0x0eb1, 0x6668, "go7007/wis-startrek.fw", NULL },
+        { 0, 0, NULL, NULL }
+};
+MODULE_FIRMWARE("go7007/s2250-1.fw");
+MODULE_FIRMWARE("go7007/s2250-2.fw");
+MODULE_FIRMWARE("go7007/px-m402u.fw");
+MODULE_FIRMWARE("go7007/px-tv402u.fw");
+MODULE_FIRMWARE("go7007/lr192.fw");
+MODULE_FIRMWARE("go7007/wis-startrek.fw");
+
+static int go7007_loader_probe(struct usb_interface *interface,
+                                const struct usb_device_id *id)
+{
+        struct usb_device *usbdev;
+        const struct firmware *fw;
+        u16 vendor, product;
+        const char *fw1, *fw2;
+        int ret;
+        int i;
+
+        usbdev = usb_get_dev(interface_to_usbdev(interface));
+        if (!usbdev)
+                goto failed2;
+
+        if (usbdev->descriptor.bNumConfigurations != 1) {
+                dev_err(&interface->dev, "can't handle multiple config\n");
+                goto failed2;
+        }
+
+        vendor = le16_to_cpu(usbdev->descriptor.idVendor);
+        product = le16_to_cpu(usbdev->descriptor.idProduct);
+
+        for (i = 0; fw_configs[i].fw_name1; i++)
+                if (fw_configs[i].vendor == vendor &&
+                    fw_configs[i].product == product)
+                        break;
+
+        /* Should never happen */
+        if (fw_configs[i].fw_name1 == NULL)
+                goto failed2;
+
+        fw1 = fw_configs[i].fw_name1;
+        fw2 = fw_configs[i].fw_name2;
+
+        dev_info(&interface->dev, "loading firmware %s\n", fw1);
+
+        if (request_firmware(&fw, fw1, &usbdev->dev)) {
+                dev_err(&interface->dev,
+                        "unable to load firmware from file \"%s\"\n", fw1);
+                goto failed2;
+        }
+        ret = cypress_load_firmware(usbdev, fw, CYPRESS_FX2);
+        release_firmware(fw);
+        if (0 != ret) {
+                dev_err(&interface->dev, "loader download failed\n");
+                goto failed2;
+        }
+
+        if (fw2 == NULL)
+                return 0;
+
+        if (request_firmware(&fw, fw2, &usbdev->dev)) {
+                dev_err(&interface->dev,
+                        "unable to load firmware from file \"%s\"\n", fw2);
+                goto failed2;
+        }
+        ret = cypress_load_firmware(usbdev, fw, CYPRESS_FX2);
+        release_firmware(fw);
+        if (0 != ret) {
+                dev_err(&interface->dev, "firmware download failed\n");
+                goto failed2;
+        }
+        return 0;
+
+failed2:
+        usb_put_dev(usbdev);
+        dev_err(&interface->dev, "probe failed\n");
+        return -ENODEV;
+}
+
+static void go7007_loader_disconnect(struct usb_interface *interface)
+{
+        dev_info(&interface->dev, "disconnect\n");
+        usb_put_dev(interface_to_usbdev(interface));
+        usb_set_intfdata(interface, NULL);
+}
+
+static const struct usb_device_id go7007_loader_ids[] = {
+        { USB_DEVICE(0x1943, 0xa250) },
+        { USB_DEVICE(0x093b, 0xa002) },
+        { USB_DEVICE(0x093b, 0xa004) },
+        { USB_DEVICE(0x0eb1, 0x6666) },
+        { USB_DEVICE(0x0eb1, 0x6668) },
+        {}                          /* Terminating entry */
+};
+
+MODULE_DEVICE_TABLE(usb, go7007_loader_ids);
+
+static struct usb_driver go7007_loader_driver = {
+        .name           = "go7007-loader",
+        .probe          = go7007_loader_probe,
+        .disconnect     = go7007_loader_disconnect,
+        .id_table       = go7007_loader_ids,
+};
+
+module_usb_driver(go7007_loader_driver);
+
+MODULE_AUTHOR("");
+MODULE_DESCRIPTION("firmware loader for go7007-usb");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/media/usb/go7007/go7007-priv.h b/drivers/media/usb/go7007/go7007-priv.h
new file mode 100644
index 000000000000..2251c3f99d1d
--- /dev/null
+++ b/drivers/media/usb/go7007/go7007-priv.h
@@ -0,0 +1,306 @@
+/*
+ * Copyright (C) 2005-2006 Micronas USA Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License (Version 2) as
+ * published by the Free Software Foundation.
+ *
+ * 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.
+ */
+
+/*
+ * This is the private include file for the go7007 driver.  It should not
+ * be included by anybody but the driver itself, and especially not by
+ * user-space applications.
+ */
+
+#include <media/v4l2-device.h>
+#include <media/v4l2-ctrls.h>
+#include <media/v4l2-fh.h>
+#include <media/videobuf2-core.h>
+
+struct go7007;
+
+/* IDs to activate board-specific support code */
+#define GO7007_BOARDID_MATRIX_II        0
+#define GO7007_BOARDID_MATRIX_RELOAD    1
+#define GO7007_BOARDID_STAR_TREK        2
+#define GO7007_BOARDID_PCI_VOYAGER      3
+#define GO7007_BOARDID_XMEN             4
+#define GO7007_BOARDID_XMEN_II          5
+#define GO7007_BOARDID_XMEN_III         6
+#define GO7007_BOARDID_MATRIX_REV       7
+#define GO7007_BOARDID_PX_M402U         8
+#define GO7007_BOARDID_PX_TV402U        9
+#define GO7007_BOARDID_LIFEVIEW_LR192   10 /* TV Walker Ultra */
+#define GO7007_BOARDID_ENDURA           11
+#define GO7007_BOARDID_ADLINK_MPG24     12
+#define GO7007_BOARDID_SENSORAY_2250    13 /* Sensoray 2250/2251 */
+#define GO7007_BOARDID_ADS_USBAV_709    14
+
+/* Various characteristics of each board */
+#define GO7007_BOARD_HAS_AUDIO          (1<<0)
+#define GO7007_BOARD_USE_ONBOARD_I2C    (1<<1)
+#define GO7007_BOARD_HAS_TUNER          (1<<2)
+
+/* Characteristics of sensor devices */
+#define GO7007_SENSOR_VALID_POLAR       (1<<0)
+#define GO7007_SENSOR_HREF_POLAR        (1<<1)
+#define GO7007_SENSOR_VREF_POLAR        (1<<2)
+#define GO7007_SENSOR_FIELD_ID_POLAR    (1<<3)
+#define GO7007_SENSOR_BIT_WIDTH         (1<<4)
+#define GO7007_SENSOR_VALID_ENABLE      (1<<5)
+#define GO7007_SENSOR_656               (1<<6)
+#define GO7007_SENSOR_CONFIG_MASK       0x7f
+#define GO7007_SENSOR_TV                (1<<7)
+#define GO7007_SENSOR_VBI               (1<<8)
+#define GO7007_SENSOR_SCALING           (1<<9)
+#define GO7007_SENSOR_SAA7115           (1<<10)
+
+/* Characteristics of audio sensor devices */
+#define GO7007_AUDIO_I2S_MODE_1         (1)
+#define GO7007_AUDIO_I2S_MODE_2         (2)
+#define GO7007_AUDIO_I2S_MODE_3         (3)
+#define GO7007_AUDIO_BCLK_POLAR         (1<<2)
+#define GO7007_AUDIO_WORD_14            (14<<4)
+#define GO7007_AUDIO_WORD_16            (16<<4)
+#define GO7007_AUDIO_ONE_CHANNEL        (1<<11)
+#define GO7007_AUDIO_I2S_MASTER         (1<<16)
+#define GO7007_AUDIO_OKI_MODE           (1<<17)
+
+#define GO7007_CID_CUSTOM_BASE          (V4L2_CID_DETECT_CLASS_BASE + 0x1000)
+#define V4L2_CID_PIXEL_THRESHOLD0       (GO7007_CID_CUSTOM_BASE+1)
+#define V4L2_CID_MOTION_THRESHOLD0      (GO7007_CID_CUSTOM_BASE+2)
+#define V4L2_CID_MB_THRESHOLD0          (GO7007_CID_CUSTOM_BASE+3)
+#define V4L2_CID_PIXEL_THRESHOLD1       (GO7007_CID_CUSTOM_BASE+4)
+#define V4L2_CID_MOTION_THRESHOLD1      (GO7007_CID_CUSTOM_BASE+5)
+#define V4L2_CID_MB_THRESHOLD1          (GO7007_CID_CUSTOM_BASE+6)
+#define V4L2_CID_PIXEL_THRESHOLD2       (GO7007_CID_CUSTOM_BASE+7)
+#define V4L2_CID_MOTION_THRESHOLD2      (GO7007_CID_CUSTOM_BASE+8)
+#define V4L2_CID_MB_THRESHOLD2          (GO7007_CID_CUSTOM_BASE+9)
+#define V4L2_CID_PIXEL_THRESHOLD3       (GO7007_CID_CUSTOM_BASE+10)
+#define V4L2_CID_MOTION_THRESHOLD3      (GO7007_CID_CUSTOM_BASE+11)
+#define V4L2_CID_MB_THRESHOLD3          (GO7007_CID_CUSTOM_BASE+12)
+
+struct go7007_board_info {
+        unsigned int flags;
+        int hpi_buffer_cap;
+        unsigned int sensor_flags;
+        int sensor_width;
+        int sensor_height;
+        int sensor_framerate;
+        int sensor_h_offset;
+        int sensor_v_offset;
+        unsigned int audio_flags;
+        int audio_rate;
+        int audio_bclk_div;
+        int audio_main_div;
+        int num_i2c_devs;
+        struct go_i2c {
+                const char *type;
+                unsigned int is_video:1;
+                unsigned int is_audio:1;
+                int addr;
+                u32 flags;
+        } i2c_devs[5];
+        int num_inputs;
+        struct {
+                int video_input;
+                int audio_index;
+                char *name;
+        } inputs[4];
+        int video_config;
+        int num_aud_inputs;
+        struct {
+                int audio_input;
+                char *name;
+        } aud_inputs[3];
+};
+
+struct go7007_hpi_ops {
+        int (*interface_reset)(struct go7007 *go);
+        int (*write_interrupt)(struct go7007 *go, int addr, int data);
+        int (*read_interrupt)(struct go7007 *go);
+        int (*stream_start)(struct go7007 *go);
+        int (*stream_stop)(struct go7007 *go);
+        int (*send_firmware)(struct go7007 *go, u8 *data, int len);
+        int (*send_command)(struct go7007 *go, unsigned int cmd, void *arg);
+        void (*release)(struct go7007 *go);
+};
+
+/* The video buffer size must be a multiple of PAGE_SIZE */
+#define GO7007_BUF_PAGES        (128 * 1024 / PAGE_SIZE)
+#define GO7007_BUF_SIZE         (GO7007_BUF_PAGES << PAGE_SHIFT)
+
+struct go7007_buffer {
+        struct vb2_buffer vb;
+        struct list_head list;
+        unsigned int frame_offset;
+        u32 modet_active;
+};
+
+#define GO7007_RATIO_1_1        0
+#define GO7007_RATIO_4_3        1
+#define GO7007_RATIO_16_9       2
+
+enum go7007_parser_state {
+        STATE_DATA,
+        STATE_00,
+        STATE_00_00,
+        STATE_00_00_01,
+        STATE_FF,
+        STATE_VBI_LEN_A,
+        STATE_VBI_LEN_B,
+        STATE_MODET_MAP,
+        STATE_UNPARSED,
+};
+
+struct go7007 {
+        struct device *dev;
+        u8 bus_info[32];
+        const struct go7007_board_info *board_info;
+        unsigned int board_id;
+        int tuner_type;
+        int channel_number; /* for multi-channel boards like Adlink PCI-MPG24 */
+        char name[64];
+        struct video_device vdev;
+        void *boot_fw;
+        unsigned boot_fw_len;
+        struct v4l2_device v4l2_dev;
+        struct v4l2_ctrl_handler hdl;
+        struct v4l2_ctrl *mpeg_video_encoding;
+        struct v4l2_ctrl *mpeg_video_gop_size;
+        struct v4l2_ctrl *mpeg_video_gop_closure;
+        struct v4l2_ctrl *mpeg_video_bitrate;
+        struct v4l2_ctrl *mpeg_video_aspect_ratio;
+        struct v4l2_ctrl *mpeg_video_b_frames;
+        struct v4l2_ctrl *mpeg_video_rep_seqheader;
+        struct v4l2_ctrl *modet_mode;
+        enum { STATUS_INIT, STATUS_ONLINE, STATUS_SHUTDOWN } status;
+        spinlock_t spinlock;
+        struct mutex hw_lock;
+        struct mutex serialize_lock;
+        int audio_enabled;
+        struct v4l2_subdev *sd_video;
+        struct v4l2_subdev *sd_audio;
+        u8 usb_buf[16];
+
+        /* Video input */
+        int input;
+        int aud_input;
+        enum { GO7007_STD_NTSC, GO7007_STD_PAL, GO7007_STD_OTHER } standard;
+        v4l2_std_id std;
+        int sensor_framerate;
+        int width;
+        int height;
+        int encoder_h_offset;
+        int encoder_v_offset;
+        unsigned int encoder_h_halve:1;
+        unsigned int encoder_v_halve:1;
+        unsigned int encoder_subsample:1;
+
+        /* Encoder config */
+        u32 format;
+        int bitrate;
+        int fps_scale;
+        int pali;
+        int aspect_ratio;
+        int gop_size;
+        unsigned int ipb:1;
+        unsigned int closed_gop:1;
+        unsigned int repeat_seqhead:1;
+        unsigned int seq_header_enable:1;
+        unsigned int gop_header_enable:1;
+        unsigned int dvd_mode:1;
+        unsigned int interlace_coding:1;
+
+        /* Motion detection */
+        unsigned int modet_enable:1;
+        struct {
+                unsigned int enable:1;
+                int pixel_threshold;
+                int motion_threshold;
+                int mb_threshold;
+        } modet[4];
+        unsigned char modet_map[1624];
+        unsigned char active_map[216];
+        u32 modet_event_status;
+
+        /* Video streaming */
+        struct mutex queue_lock;
+        struct vb2_queue vidq;
+        enum go7007_parser_state state;
+        int parse_length;
+        u16 modet_word;
+        int seen_frame;
+        u32 next_seq;
+        struct list_head vidq_active;
+        wait_queue_head_t frame_waitq;
+        struct go7007_buffer *active_buf;
+
+        /* Audio streaming */
+        void (*audio_deliver)(struct go7007 *go, u8 *buf, int length);
+        void *snd_context;
+
+        /* I2C */
+        int i2c_adapter_online;
+        struct i2c_adapter i2c_adapter;
+
+        /* HPI driver */
+        struct go7007_hpi_ops *hpi_ops;
+        void *hpi_context;
+        int interrupt_available;
+        wait_queue_head_t interrupt_waitq;
+        unsigned short interrupt_value;
+        unsigned short interrupt_data;
+};
+
+static inline struct go7007 *to_go7007(struct v4l2_device *v4l2_dev)
+{
+        return container_of(v4l2_dev, struct go7007, v4l2_dev);
+}
+
+/* All of these must be called with the hpi_lock mutex held! */
+#define go7007_interface_reset(go) \
+                        ((go)->hpi_ops->interface_reset(go))
+#define go7007_write_interrupt(go, x, y) \
+                        ((go)->hpi_ops->write_interrupt)((go), (x), (y))
+#define go7007_stream_start(go) \
+                        ((go)->hpi_ops->stream_start(go))
+#define go7007_stream_stop(go) \
+                        ((go)->hpi_ops->stream_stop(go))
+#define go7007_send_firmware(go, x, y) \
+                        ((go)->hpi_ops->send_firmware)((go), (x), (y))
+#define go7007_write_addr(go, x, y) \
+                        ((go)->hpi_ops->write_interrupt)((go), (x)|0x8000, (y))
+
+/* go7007-driver.c */
+int go7007_read_addr(struct go7007 *go, u16 addr, u16 *data);
+int go7007_read_interrupt(struct go7007 *go, u16 *value, u16 *data);
+int go7007_boot_encoder(struct go7007 *go, int init_i2c);
+int go7007_reset_encoder(struct go7007 *go);
+int go7007_register_encoder(struct go7007 *go, unsigned num_i2c_devs);
+int go7007_start_encoder(struct go7007 *go);
+void go7007_parse_video_stream(struct go7007 *go, u8 *buf, int length);
+struct go7007 *go7007_alloc(const struct go7007_board_info *board,
+                                        struct device *dev);
+void go7007_update_board(struct go7007 *go);
+
+/* go7007-fw.c */
+int go7007_construct_fw_image(struct go7007 *go, u8 **fw, int *fwlen);
+
+/* go7007-i2c.c */
+int go7007_i2c_init(struct go7007 *go);
+int go7007_i2c_remove(struct go7007 *go);
+
+/* go7007-v4l2.c */
+int go7007_v4l2_init(struct go7007 *go);
+int go7007_v4l2_ctrl_init(struct go7007 *go);
+void go7007_v4l2_remove(struct go7007 *go);
+
+/* snd-go7007.c */
+int go7007_snd_init(struct go7007 *go);
+int go7007_snd_remove(struct go7007 *go);
diff --git a/drivers/media/usb/go7007/go7007-usb.c b/drivers/media/usb/go7007/go7007-usb.c
new file mode 100644
index 000000000000..ece27ece8115
--- /dev/null
+++ b/drivers/media/usb/go7007/go7007-usb.c
@@ -0,0 +1,1345 @@
+/*
+ * Copyright (C) 2005-2006 Micronas USA Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License (Version 2) as
+ * published by the Free Software Foundation.
+ *
+ * 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.
+ */
+
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/wait.h>
+#include <linux/list.h>
+#include <linux/slab.h>
+#include <linux/time.h>
+#include <linux/mm.h>
+#include <linux/usb.h>
+#include <linux/i2c.h>
+#include <asm/byteorder.h>
+#include <media/saa7115.h>
+#include <media/tuner.h>
+#include <media/uda1342.h>
+
+#include "go7007-priv.h"
+
+static unsigned int assume_endura;
+module_param(assume_endura, int, 0644);
+MODULE_PARM_DESC(assume_endura,
+                        "when probing fails, hardware is a Pelco Endura");
+
+/* #define GO7007_I2C_DEBUG */ /* for debugging the EZ-USB I2C adapter */
+
+#define HPI_STATUS_ADDR 0xFFF4
+#define INT_PARAM_ADDR  0xFFF6
+#define INT_INDEX_ADDR  0xFFF8
+
+/*
+ * Pipes on EZ-USB interface:
+ *      0 snd - Control
+ *      0 rcv - Control
+ *      2 snd - Download firmware (control)
+ *      4 rcv - Read Interrupt (interrupt)
+ *      6 rcv - Read Video (bulk)
+ *      8 rcv - Read Audio (bulk)
+ */
+
+#define GO7007_USB_EZUSB                (1<<0)
+#define GO7007_USB_EZUSB_I2C            (1<<1)
+
+struct go7007_usb_board {
+        unsigned int flags;
+        struct go7007_board_info main_info;
+};
+
+struct go7007_usb {
+        const struct go7007_usb_board *board;
+        struct mutex i2c_lock;
+        struct usb_device *usbdev;
+        struct urb *video_urbs[8];
+        struct urb *audio_urbs[8];
+        struct urb *intr_urb;
+};
+
+/*********************** Product specification data ***********************/
+
+static const struct go7007_usb_board board_matrix_ii = {
+        .flags          = GO7007_USB_EZUSB,
+        .main_info      = {
+                .flags           = GO7007_BOARD_HAS_AUDIO |
+                                        GO7007_BOARD_USE_ONBOARD_I2C,
+                .audio_flags     = GO7007_AUDIO_I2S_MODE_1 |
+                                        GO7007_AUDIO_WORD_16,
+                .audio_rate      = 48000,
+                .audio_bclk_div  = 8,
+                .audio_main_div  = 2,
+                .hpi_buffer_cap  = 7,
+                .sensor_flags    = GO7007_SENSOR_656 |
+                                        GO7007_SENSOR_VALID_ENABLE |
+                                        GO7007_SENSOR_TV |
+                                        GO7007_SENSOR_SAA7115 |
+                                        GO7007_SENSOR_VBI |
+                                        GO7007_SENSOR_SCALING,
+                .num_i2c_devs    = 1,
+                .i2c_devs        = {
+                        {
+                                .type   = "saa7115",
+                                .addr   = 0x20,
+                                .is_video = 1,
+                        },
+                },
+                .num_inputs      = 2,
+                .inputs          = {
+                        {
+                                .video_input    = 0,
+                                .name           = "Composite",
+                        },
+                        {
+                                .video_input    = 9,
+                                .name           = "S-Video",
+                        },
+                },
+                .video_config   = SAA7115_IDQ_IS_DEFAULT,
+        },
+};
+
+static const struct go7007_usb_board board_matrix_reload = {
+        .flags          = GO7007_USB_EZUSB,
+        .main_info      = {
+                .flags           = GO7007_BOARD_HAS_AUDIO |
+                                        GO7007_BOARD_USE_ONBOARD_I2C,
+                .audio_flags     = GO7007_AUDIO_I2S_MODE_1 |
+                                        GO7007_AUDIO_I2S_MASTER |
+                                        GO7007_AUDIO_WORD_16,
+                .audio_rate      = 48000,
+                .audio_bclk_div  = 8,
+                .audio_main_div  = 2,
+                .hpi_buffer_cap  = 7,
+                .sensor_flags    = GO7007_SENSOR_656 |
+                                        GO7007_SENSOR_TV,
+                .num_i2c_devs    = 1,
+                .i2c_devs        = {
+                        {
+                                .type   = "saa7113",
+                                .addr   = 0x25,
+                                .is_video = 1,
+                        },
+                },
+                .num_inputs      = 2,
+                .inputs          = {
+                        {
+                                .video_input    = 0,
+                                .name           = "Composite",
+                        },
+                        {
+                                .video_input    = 9,
+                                .name           = "S-Video",
+                        },
+                },
+                .video_config   = SAA7115_IDQ_IS_DEFAULT,
+        },
+};
+
+static const struct go7007_usb_board board_star_trek = {
+        .flags          = GO7007_USB_EZUSB | GO7007_USB_EZUSB_I2C,
+        .main_info      = {
+                .flags           = GO7007_BOARD_HAS_AUDIO, /* |
+                                        GO7007_BOARD_HAS_TUNER, */
+                .sensor_flags    = GO7007_SENSOR_656 |
+                                        GO7007_SENSOR_VALID_ENABLE |
+                                        GO7007_SENSOR_TV |
+                                        GO7007_SENSOR_SAA7115 |
+                                        GO7007_SENSOR_VBI |
+                                        GO7007_SENSOR_SCALING,
+                .audio_flags     = GO7007_AUDIO_I2S_MODE_1 |
+                                        GO7007_AUDIO_WORD_16,
+                .audio_bclk_div  = 8,
+                .audio_main_div  = 2,
+                .hpi_buffer_cap  = 7,
+                .num_i2c_devs    = 1,
+                .i2c_devs        = {
+                        {
+                                .type   = "saa7115",
+                                .addr   = 0x20,
+                                .is_video = 1,
+                        },
+                },
+                .num_inputs      = 2,
+                .inputs          = {
+                /*      {
+                 *              .video_input    = 3,
+                 *              .audio_index    = AUDIO_TUNER,
+                 *              .name           = "Tuner",
+                 *      },
+                 */
+                        {
+                                .video_input    = 1,
+                        /*      .audio_index    = AUDIO_EXTERN, */
+                                .name           = "Composite",
+                        },
+                        {
+                                .video_input    = 8,
+                        /*      .audio_index    = AUDIO_EXTERN, */
+                                .name           = "S-Video",
+                        },
+                },
+                .video_config   = SAA7115_IDQ_IS_DEFAULT,
+        },
+};
+
+static const struct go7007_usb_board board_px_tv402u = {
+        .flags          = GO7007_USB_EZUSB | GO7007_USB_EZUSB_I2C,
+        .main_info      = {
+                .flags           = GO7007_BOARD_HAS_AUDIO |
+                                        GO7007_BOARD_HAS_TUNER,
+                .sensor_flags    = GO7007_SENSOR_656 |
+                                        GO7007_SENSOR_VALID_ENABLE |
+                                        GO7007_SENSOR_TV |
+                                        GO7007_SENSOR_SAA7115 |
+                                        GO7007_SENSOR_VBI |
+                                        GO7007_SENSOR_SCALING,
+                .audio_flags     = GO7007_AUDIO_I2S_MODE_1 |
+                                        GO7007_AUDIO_WORD_16,
+                .audio_bclk_div  = 8,
+                .audio_main_div  = 2,
+                .hpi_buffer_cap  = 7,
+                .num_i2c_devs    = 5,
+                .i2c_devs        = {
+                        {
+                                .type   = "saa7115",
+                                .addr   = 0x20,
+                                .is_video = 1,
+                        },
+                        {
+                                .type   = "uda1342",
+                                .addr   = 0x1a,
+                                .is_audio = 1,
+                        },
+                        {
+                                .type   = "tuner",
+                                .addr   = 0x60,
+                        },
+                        {
+                                .type   = "tuner",
+                                .addr   = 0x43,
+                        },
+                        {
+                                .type   = "sony-btf-mpx",
+                                .addr   = 0x44,
+                        },
+                },
+                .num_inputs      = 3,
+                .inputs          = {
+                        {
+                                .video_input    = 3,
+                                .audio_index    = 0,
+                                .name           = "Tuner",
+                        },
+                        {
+                                .video_input    = 1,
+                                .audio_index    = 1,
+                                .name           = "Composite",
+                        },
+                        {
+                                .video_input    = 8,
+                                .audio_index    = 1,
+                                .name           = "S-Video",
+                        },
+                },
+                .video_config   = SAA7115_IDQ_IS_DEFAULT,
+                .num_aud_inputs  = 2,
+                .aud_inputs      = {
+                        {
+                                .audio_input    = UDA1342_IN2,
+                                .name           = "Tuner",
+                        },
+                        {
+                                .audio_input    = UDA1342_IN1,
+                                .name           = "Line In",
+                        },
+                },
+        },
+};
+
+static const struct go7007_usb_board board_xmen = {
+        .flags          = 0,
+        .main_info      = {
+                .flags            = GO7007_BOARD_USE_ONBOARD_I2C,
+                .hpi_buffer_cap   = 0,
+                .sensor_flags     = GO7007_SENSOR_VREF_POLAR,
+                .sensor_width     = 320,
+                .sensor_height    = 240,
+                .sensor_framerate = 30030,
+                .audio_flags      = GO7007_AUDIO_ONE_CHANNEL |
+                                        GO7007_AUDIO_I2S_MODE_3 |
+                                        GO7007_AUDIO_WORD_14 |
+                                        GO7007_AUDIO_I2S_MASTER |
+                                        GO7007_AUDIO_BCLK_POLAR |
+                                        GO7007_AUDIO_OKI_MODE,
+                .audio_rate       = 8000,
+                .audio_bclk_div   = 48,
+                .audio_main_div   = 1,
+                .num_i2c_devs     = 1,
+                .i2c_devs         = {
+                        {
+                                .type   = "ov7640",
+                                .addr   = 0x21,
+                        },
+                },
+                .num_inputs       = 1,
+                .inputs           = {
+                        {
+                                .name           = "Camera",
+                        },
+                },
+        },
+};
+
+static const struct go7007_usb_board board_matrix_revolution = {
+        .flags          = GO7007_USB_EZUSB,
+        .main_info      = {
+                .flags           = GO7007_BOARD_HAS_AUDIO |
+                                        GO7007_BOARD_USE_ONBOARD_I2C,
+                .audio_flags     = GO7007_AUDIO_I2S_MODE_1 |
+                                        GO7007_AUDIO_I2S_MASTER |
+                                        GO7007_AUDIO_WORD_16,
+                .audio_rate      = 48000,
+                .audio_bclk_div  = 8,
+                .audio_main_div  = 2,
+                .hpi_buffer_cap  = 7,
+                .sensor_flags    = GO7007_SENSOR_656 |
+                                        GO7007_SENSOR_TV |
+                                        GO7007_SENSOR_VBI,
+                .num_i2c_devs    = 1,
+                .i2c_devs        = {
+                        {
+                                .type   = "tw9903",
+                                .is_video = 1,
+                                .addr   = 0x44,
+                        },
+                },
+                .num_inputs      = 2,
+                .inputs          = {
+                        {
+                                .video_input    = 2,
+                                .name           = "Composite",
+                        },
+                        {
+                                .video_input    = 8,
+                                .name           = "S-Video",
+                        },
+                },
+        },
+};
+
+static const struct go7007_usb_board board_lifeview_lr192 = {
+        .flags          = GO7007_USB_EZUSB,
+        .main_info      = {
+                .flags           = GO7007_BOARD_HAS_AUDIO |
+                                        GO7007_BOARD_USE_ONBOARD_I2C,
+                .audio_flags     = GO7007_AUDIO_I2S_MODE_1 |
+                                        GO7007_AUDIO_WORD_16,
+                .audio_rate      = 48000,
+                .audio_bclk_div  = 8,
+                .audio_main_div  = 2,
+                .hpi_buffer_cap  = 7,
+                .sensor_flags    = GO7007_SENSOR_656 |
+                                        GO7007_SENSOR_VALID_ENABLE |
+                                        GO7007_SENSOR_TV |
+                                        GO7007_SENSOR_VBI |
+                                        GO7007_SENSOR_SCALING,
+                .num_i2c_devs    = 0,
+                .num_inputs      = 1,
+                .inputs          = {
+                        {
+                                .video_input    = 0,
+                                .name           = "Composite",
+                        },
+                },
+        },
+};
+
+static const struct go7007_usb_board board_endura = {
+        .flags          = 0,
+        .main_info      = {
+                .flags           = 0,
+                .audio_flags     = GO7007_AUDIO_I2S_MODE_1 |
+                                        GO7007_AUDIO_I2S_MASTER |
+                                        GO7007_AUDIO_WORD_16,
+                .audio_rate      = 8000,
+                .audio_bclk_div  = 48,
+                .audio_main_div  = 8,
+                .hpi_buffer_cap  = 0,
+                .sensor_flags    = GO7007_SENSOR_656 |
+                                        GO7007_SENSOR_TV,
+                .sensor_h_offset = 8,
+                .num_i2c_devs    = 0,
+                .num_inputs      = 1,
+                .inputs          = {
+                        {
+                                .name           = "Camera",
+                        },
+                },
+        },
+};
+
+static const struct go7007_usb_board board_adlink_mpg24 = {
+        .flags          = 0,
+        .main_info      = {
+                .flags           = GO7007_BOARD_USE_ONBOARD_I2C,
+                .audio_flags     = GO7007_AUDIO_I2S_MODE_1 |
+                                        GO7007_AUDIO_I2S_MASTER |
+                                        GO7007_AUDIO_WORD_16,
+                .audio_rate      = 48000,
+                .audio_bclk_div  = 8,
+                .audio_main_div  = 2,
+                .hpi_buffer_cap  = 0,
+                .sensor_flags    = GO7007_SENSOR_656 |
+                                        GO7007_SENSOR_TV |
+                                        GO7007_SENSOR_VBI,
+                .num_i2c_devs    = 1,
+                .i2c_devs        = {
+                        {
+                                .type   = "tw2804",
+                                .addr   = 0x00, /* yes, really */
+                                .flags  = I2C_CLIENT_TEN,
+                                .is_video = 1,
+                        },
+                },
+                .num_inputs      = 1,
+                .inputs          = {
+                        {
+                                .name           = "Composite",
+                        },
+                },
+        },
+};
+
+static const struct go7007_usb_board board_sensoray_2250 = {
+        .flags          = GO7007_USB_EZUSB | GO7007_USB_EZUSB_I2C,
+        .main_info      = {
+                .audio_flags     = GO7007_AUDIO_I2S_MODE_1 |
+                                        GO7007_AUDIO_I2S_MASTER |
+                                        GO7007_AUDIO_WORD_16,
+                .flags           = GO7007_BOARD_HAS_AUDIO,
+                .audio_rate      = 48000,
+                .audio_bclk_div  = 8,
+                .audio_main_div  = 2,
+                .hpi_buffer_cap  = 7,
+                .sensor_flags    = GO7007_SENSOR_656 |
+                                        GO7007_SENSOR_TV,
+                .num_i2c_devs    = 1,
+                .i2c_devs        = {
+                        {
+                                .type   = "s2250",
+                                .addr   = 0x43,
+                                .is_video = 1,
+                                .is_audio = 1,
+                        },
+                },
+                .num_inputs      = 2,
+                .inputs          = {
+                        {
+                                .video_input    = 0,
+                                .name           = "Composite",
+                        },
+                        {
+                                .video_input    = 1,
+                                .name           = "S-Video",
+                        },
+                },
+                .num_aud_inputs  = 3,
+                .aud_inputs      = {
+                        {
+                                .audio_input    = 0,
+                                .name           = "Line In",
+                        },
+                        {
+                                .audio_input    = 1,
+                                .name           = "Mic",
+                        },
+                        {
+                                .audio_input    = 2,
+                                .name           = "Mic Boost",
+                        },
+                },
+        },
+};
+
+static const struct go7007_usb_board board_ads_usbav_709 = {
+        .flags          = GO7007_USB_EZUSB,
+        .main_info      = {
+                .flags           = GO7007_BOARD_HAS_AUDIO |
+                                        GO7007_BOARD_USE_ONBOARD_I2C,
+                .audio_flags     = GO7007_AUDIO_I2S_MODE_1 |
+                                        GO7007_AUDIO_I2S_MASTER |
+                                        GO7007_AUDIO_WORD_16,
+                .audio_rate      = 48000,
+                .audio_bclk_div  = 8,
+                .audio_main_div  = 2,
+                .hpi_buffer_cap  = 7,
+                .sensor_flags    = GO7007_SENSOR_656 |
+                                        GO7007_SENSOR_TV |
+                                        GO7007_SENSOR_VBI,
+                .num_i2c_devs    = 1,
+                .i2c_devs        = {
+                        {
+                                .type   = "tw9906",
+                                .is_video = 1,
+                                .addr   = 0x44,
+                        },
+                },
+                .num_inputs      = 2,
+                .inputs          = {
+                        {
+                                .video_input    = 0,
+                                .name           = "Composite",
+                        },
+                        {
+                                .video_input    = 10,
+                                .name           = "S-Video",
+                        },
+                },
+        },
+};
+
+static const struct usb_device_id go7007_usb_id_table[] = {
+        {
+                .match_flags    = USB_DEVICE_ID_MATCH_DEVICE_AND_VERSION |
+                                        USB_DEVICE_ID_MATCH_INT_INFO,
+                .idVendor       = 0x0eb1,  /* Vendor ID of WIS Technologies */
+                .idProduct      = 0x7007,  /* Product ID of GO7007SB chip */
+                .bcdDevice_lo   = 0x200,   /* Revision number of XMen */
+                .bcdDevice_hi   = 0x200,
+                .bInterfaceClass        = 255,
+                .bInterfaceSubClass     = 0,
+                .bInterfaceProtocol     = 255,
+                .driver_info    = (kernel_ulong_t)GO7007_BOARDID_XMEN,
+        },
+        {
+                .match_flags    = USB_DEVICE_ID_MATCH_DEVICE_AND_VERSION,
+                .idVendor       = 0x0eb1,  /* Vendor ID of WIS Technologies */
+                .idProduct      = 0x7007,  /* Product ID of GO7007SB chip */
+                .bcdDevice_lo   = 0x202,   /* Revision number of Matrix II */
+                .bcdDevice_hi   = 0x202,
+                .driver_info    = (kernel_ulong_t)GO7007_BOARDID_MATRIX_II,
+        },
+        {
+                .match_flags    = USB_DEVICE_ID_MATCH_DEVICE_AND_VERSION,
+                .idVendor       = 0x0eb1,  /* Vendor ID of WIS Technologies */
+                .idProduct      = 0x7007,  /* Product ID of GO7007SB chip */
+                .bcdDevice_lo   = 0x204,   /* Revision number of Matrix */
+                .bcdDevice_hi   = 0x204,   /*     Reloaded */
+                .driver_info    = (kernel_ulong_t)GO7007_BOARDID_MATRIX_RELOAD,
+        },
+        {
+                .match_flags    = USB_DEVICE_ID_MATCH_DEVICE_AND_VERSION |
+                                        USB_DEVICE_ID_MATCH_INT_INFO,
+                .idVendor       = 0x0eb1,  /* Vendor ID of WIS Technologies */
+                .idProduct      = 0x7007,  /* Product ID of GO7007SB chip */
+                .bcdDevice_lo   = 0x205,   /* Revision number of XMen-II */
+                .bcdDevice_hi   = 0x205,
+                .bInterfaceClass        = 255,
+                .bInterfaceSubClass     = 0,
+                .bInterfaceProtocol     = 255,
+                .driver_info    = (kernel_ulong_t)GO7007_BOARDID_XMEN_II,
+        },
+        {
+                .match_flags    = USB_DEVICE_ID_MATCH_DEVICE_AND_VERSION,
+                .idVendor       = 0x0eb1,  /* Vendor ID of WIS Technologies */
+                .idProduct      = 0x7007,  /* Product ID of GO7007SB chip */
+                .bcdDevice_lo   = 0x208,   /* Revision number of Star Trek */
+                .bcdDevice_hi   = 0x208,
+                .driver_info    = (kernel_ulong_t)GO7007_BOARDID_STAR_TREK,
+        },
+        {
+                .match_flags    = USB_DEVICE_ID_MATCH_DEVICE_AND_VERSION |
+                                        USB_DEVICE_ID_MATCH_INT_INFO,
+                .idVendor       = 0x0eb1,  /* Vendor ID of WIS Technologies */
+                .idProduct      = 0x7007,  /* Product ID of GO7007SB chip */
+                .bcdDevice_lo   = 0x209,   /* Revision number of XMen-III */
+                .bcdDevice_hi   = 0x209,
+                .bInterfaceClass        = 255,
+                .bInterfaceSubClass     = 0,
+                .bInterfaceProtocol     = 255,
+                .driver_info    = (kernel_ulong_t)GO7007_BOARDID_XMEN_III,
+        },
+        {
+                .match_flags    = USB_DEVICE_ID_MATCH_DEVICE_AND_VERSION,
+                .idVendor       = 0x0eb1,  /* Vendor ID of WIS Technologies */
+                .idProduct      = 0x7007,  /* Product ID of GO7007SB chip */
+                .bcdDevice_lo   = 0x210,   /* Revision number of Matrix */
+                .bcdDevice_hi   = 0x210,   /*     Revolution */
+                .driver_info    = (kernel_ulong_t)GO7007_BOARDID_MATRIX_REV,
+        },
+        {
+                .match_flags    = USB_DEVICE_ID_MATCH_DEVICE_AND_VERSION,
+                .idVendor       = 0x093b,  /* Vendor ID of Plextor */
+                .idProduct      = 0xa102,  /* Product ID of M402U */
+                .bcdDevice_lo   = 0x1,     /* revision number of Blueberry */
+                .bcdDevice_hi   = 0x1,
+                .driver_info    = (kernel_ulong_t)GO7007_BOARDID_PX_M402U,
+        },
+        {
+                .match_flags    = USB_DEVICE_ID_MATCH_DEVICE_AND_VERSION,
+                .idVendor       = 0x093b,  /* Vendor ID of Plextor */
+                .idProduct      = 0xa104,  /* Product ID of TV402U */
+                .bcdDevice_lo   = 0x1,
+                .bcdDevice_hi   = 0x1,
+                .driver_info    = (kernel_ulong_t)GO7007_BOARDID_PX_TV402U,
+        },
+        {
+                .match_flags    = USB_DEVICE_ID_MATCH_DEVICE_AND_VERSION,
+                .idVendor       = 0x10fd,  /* Vendor ID of Anubis Electronics */
+                .idProduct      = 0xde00,  /* Product ID of Lifeview LR192 */
+                .bcdDevice_lo   = 0x1,
+                .bcdDevice_hi   = 0x1,
+                .driver_info    = (kernel_ulong_t)GO7007_BOARDID_LIFEVIEW_LR192,
+        },
+        {
+                .match_flags    = USB_DEVICE_ID_MATCH_DEVICE_AND_VERSION,
+                .idVendor       = 0x1943,  /* Vendor ID Sensoray */
+                .idProduct      = 0x2250,  /* Product ID of 2250/2251 */
+                .bcdDevice_lo   = 0x1,
+                .bcdDevice_hi   = 0x1,
+                .driver_info    = (kernel_ulong_t)GO7007_BOARDID_SENSORAY_2250,
+        },
+        {
+                .match_flags    = USB_DEVICE_ID_MATCH_DEVICE_AND_VERSION,
+                .idVendor       = 0x06e1,  /* Vendor ID of ADS Technologies */
+                .idProduct      = 0x0709,  /* Product ID of DVD Xpress DX2 */
+                .bcdDevice_lo   = 0x204,
+                .bcdDevice_hi   = 0x204,
+                .driver_info    = (kernel_ulong_t)GO7007_BOARDID_ADS_USBAV_709,
+        },
+        { }                                     /* Terminating entry */
+};
+
+MODULE_DEVICE_TABLE(usb, go7007_usb_id_table);
+
+/********************* Driver for EZ-USB HPI interface *********************/
+
+static int go7007_usb_vendor_request(struct go7007 *go, int request,
+                int value, int index, void *transfer_buffer, int length, int in)
+{
+        struct go7007_usb *usb = go->hpi_context;
+        int timeout = 5000;
+
+        if (in) {
+                return usb_control_msg(usb->usbdev,
+                                usb_rcvctrlpipe(usb->usbdev, 0), request,
+                                USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
+                                value, index, transfer_buffer, length, timeout);
+        } else {
+                return usb_control_msg(usb->usbdev,
+                                usb_sndctrlpipe(usb->usbdev, 0), request,
+                                USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+                                value, index, transfer_buffer, length, timeout);
+        }
+}
+
+static int go7007_usb_interface_reset(struct go7007 *go)
+{
+        struct go7007_usb *usb = go->hpi_context;
+        u16 intr_val, intr_data;
+
+        if (go->status == STATUS_SHUTDOWN)
+                return -1;
+        /* Reset encoder */
+        if (go7007_write_interrupt(go, 0x0001, 0x0001) < 0)
+                return -1;
+        msleep(100);
+
+        if (usb->board->flags & GO7007_USB_EZUSB) {
+                /* Reset buffer in EZ-USB */
+                pr_debug("resetting EZ-USB buffers\n");
+                if (go7007_usb_vendor_request(go, 0x10, 0, 0, NULL, 0, 0) < 0 ||
+                    go7007_usb_vendor_request(go, 0x10, 0, 0, NULL, 0, 0) < 0)
+                        return -1;
+
+                /* Reset encoder again */
+                if (go7007_write_interrupt(go, 0x0001, 0x0001) < 0)
+                        return -1;
+                msleep(100);
+        }
+
+        /* Wait for an interrupt to indicate successful hardware reset */
+        if (go7007_read_interrupt(go, &intr_val, &intr_data) < 0 ||
+                        (intr_val & ~0x1) != 0x55aa) {
+                dev_err(go->dev, "unable to reset the USB interface\n");
+                return -1;
+        }
+        return 0;
+}
+
+static int go7007_usb_ezusb_write_interrupt(struct go7007 *go,
+                                                int addr, int data)
+{
+        struct go7007_usb *usb = go->hpi_context;
+        int i, r;
+        u16 status_reg = 0;
+        int timeout = 500;
+
+        pr_debug("WriteInterrupt: %04x %04x\n", addr, data);
+
+        for (i = 0; i < 100; ++i) {
+                r = usb_control_msg(usb->usbdev,
+                                usb_rcvctrlpipe(usb->usbdev, 0), 0x14,
+                                USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
+                                0, HPI_STATUS_ADDR, go->usb_buf,
+                                sizeof(status_reg), timeout);
+                if (r < 0)
+                        break;
+                status_reg = le16_to_cpu(*((u16 *)go->usb_buf));
+                if (!(status_reg & 0x0010))
+                        break;
+                msleep(10);
+        }
+        if (r < 0)
+                goto write_int_error;
+        if (i == 100) {
+                dev_err(go->dev, "device is hung, status reg = 0x%04x\n", status_reg);
+                return -1;
+        }
+        r = usb_control_msg(usb->usbdev, usb_sndctrlpipe(usb->usbdev, 0), 0x12,
+                        USB_TYPE_VENDOR | USB_RECIP_DEVICE, data,
+                        INT_PARAM_ADDR, NULL, 0, timeout);
+        if (r < 0)
+                goto write_int_error;
+        r = usb_control_msg(usb->usbdev, usb_sndctrlpipe(usb->usbdev, 0),
+                        0x12, USB_TYPE_VENDOR | USB_RECIP_DEVICE, addr,
+                        INT_INDEX_ADDR, NULL, 0, timeout);
+        if (r < 0)
+                goto write_int_error;
+        return 0;
+
+write_int_error:
+        dev_err(go->dev, "error in WriteInterrupt: %d\n", r);
+        return r;
+}
+
+static int go7007_usb_onboard_write_interrupt(struct go7007 *go,
+                                                int addr, int data)
+{
+        struct go7007_usb *usb = go->hpi_context;
+        int r;
+        int timeout = 500;
+
+        pr_debug("WriteInterrupt: %04x %04x\n", addr, data);
+
+        go->usb_buf[0] = data & 0xff;
+        go->usb_buf[1] = data >> 8;
+        go->usb_buf[2] = addr & 0xff;
+        go->usb_buf[3] = addr >> 8;
+        go->usb_buf[4] = go->usb_buf[5] = go->usb_buf[6] = go->usb_buf[7] = 0;
+        r = usb_control_msg(usb->usbdev, usb_sndctrlpipe(usb->usbdev, 2), 0x00,
+                        USB_TYPE_VENDOR | USB_RECIP_ENDPOINT, 0x55aa,
+                        0xf0f0, go->usb_buf, 8, timeout);
+        if (r < 0) {
+                dev_err(go->dev, "error in WriteInterrupt: %d\n", r);
+                return r;
+        }
+        return 0;
+}
+
+static void go7007_usb_readinterrupt_complete(struct urb *urb)
+{
+        struct go7007 *go = (struct go7007 *)urb->context;
+        u16 *regs = (u16 *)urb->transfer_buffer;
+        int status = urb->status;
+
+        if (status) {
+                if (status != -ESHUTDOWN &&
+                                go->status != STATUS_SHUTDOWN) {
+                        dev_err(go->dev, "error in read interrupt: %d\n", urb->status);
+                } else {
+                        wake_up(&go->interrupt_waitq);
+                        return;
+                }
+        } else if (urb->actual_length != urb->transfer_buffer_length) {
+                dev_err(go->dev, "short read in interrupt pipe!\n");
+        } else {
+                go->interrupt_available = 1;
+                go->interrupt_data = __le16_to_cpu(regs[0]);
+                go->interrupt_value = __le16_to_cpu(regs[1]);
+                pr_debug("ReadInterrupt: %04x %04x\n",
+                                go->interrupt_value, go->interrupt_data);
+        }
+
+        wake_up(&go->interrupt_waitq);
+}
+
+static int go7007_usb_read_interrupt(struct go7007 *go)
+{
+        struct go7007_usb *usb = go->hpi_context;
+        int r;
+
+        r = usb_submit_urb(usb->intr_urb, GFP_KERNEL);
+        if (r < 0) {
+                dev_err(go->dev, "unable to submit interrupt urb: %d\n", r);
+                return r;
+        }
+        return 0;
+}
+
+static void go7007_usb_read_video_pipe_complete(struct urb *urb)
+{
+        struct go7007 *go = (struct go7007 *)urb->context;
+        int r, status = urb->status;
+
+        if (!vb2_is_streaming(&go->vidq)) {
+                wake_up_interruptible(&go->frame_waitq);
+                return;
+        }
+        if (status) {
+                dev_err(go->dev, "error in video pipe: %d\n", status);
+                return;
+        }
+        if (urb->actual_length != urb->transfer_buffer_length) {
+                dev_err(go->dev, "short read in video pipe!\n");
+                return;
+        }
+        go7007_parse_video_stream(go, urb->transfer_buffer, urb->actual_length);
+        r = usb_submit_urb(urb, GFP_ATOMIC);
+        if (r < 0)
+                dev_err(go->dev, "error in video pipe: %d\n", r);
+}
+
+static void go7007_usb_read_audio_pipe_complete(struct urb *urb)
+{
+        struct go7007 *go = (struct go7007 *)urb->context;
+        int r, status = urb->status;
+
+        if (!vb2_is_streaming(&go->vidq))
+                return;
+        if (status) {
+                dev_err(go->dev, "error in audio pipe: %d\n",
+                        status);
+                return;
+        }
+        if (urb->actual_length != urb->transfer_buffer_length) {
+                dev_err(go->dev, "short read in audio pipe!\n");
+                return;
+        }
+        if (go->audio_deliver != NULL)
+                go->audio_deliver(go, urb->transfer_buffer, urb->actual_length);
+        r = usb_submit_urb(urb, GFP_ATOMIC);
+        if (r < 0)
+                dev_err(go->dev, "error in audio pipe: %d\n", r);
+}
+
+static int go7007_usb_stream_start(struct go7007 *go)
+{
+        struct go7007_usb *usb = go->hpi_context;
+        int i, r;
+
+        for (i = 0; i < 8; ++i) {
+                r = usb_submit_urb(usb->video_urbs[i], GFP_KERNEL);
+                if (r < 0) {
+                        dev_err(go->dev, "error submitting video urb %d: %d\n", i, r);
+                        goto video_submit_failed;
+                }
+        }
+        if (!go->audio_enabled)
+                return 0;
+
+        for (i = 0; i < 8; ++i) {
+                r = usb_submit_urb(usb->audio_urbs[i], GFP_KERNEL);
+                if (r < 0) {
+                        dev_err(go->dev, "error submitting audio urb %d: %d\n", i, r);
+                        goto audio_submit_failed;
+                }
+        }
+        return 0;
+
+audio_submit_failed:
+        for (i = 0; i < 7; ++i)
+                usb_kill_urb(usb->audio_urbs[i]);
+video_submit_failed:
+        for (i = 0; i < 8; ++i)
+                usb_kill_urb(usb->video_urbs[i]);
+        return -1;
+}
+
+static int go7007_usb_stream_stop(struct go7007 *go)
+{
+        struct go7007_usb *usb = go->hpi_context;
+        int i;
+
+        if (go->status == STATUS_SHUTDOWN)
+                return 0;
+        for (i = 0; i < 8; ++i)
+                usb_kill_urb(usb->video_urbs[i]);
+        if (go->audio_enabled)
+                for (i = 0; i < 8; ++i)
+                        usb_kill_urb(usb->audio_urbs[i]);
+        return 0;
+}
+
+static int go7007_usb_send_firmware(struct go7007 *go, u8 *data, int len)
+{
+        struct go7007_usb *usb = go->hpi_context;
+        int transferred, pipe;
+        int timeout = 500;
+
+        pr_debug("DownloadBuffer sending %d bytes\n", len);
+
+        if (usb->board->flags & GO7007_USB_EZUSB)
+                pipe = usb_sndbulkpipe(usb->usbdev, 2);
+        else
+                pipe = usb_sndbulkpipe(usb->usbdev, 3);
+
+        return usb_bulk_msg(usb->usbdev, pipe, data, len,
+                                        &transferred, timeout);
+}
+
+static void go7007_usb_release(struct go7007 *go)
+{
+        struct go7007_usb *usb = go->hpi_context;
+        struct urb *vurb, *aurb;
+        int i;
+
+        if (usb->intr_urb) {
+                usb_kill_urb(usb->intr_urb);
+                kfree(usb->intr_urb->transfer_buffer);
+                usb_free_urb(usb->intr_urb);
+        }
+
+        /* Free USB-related structs */
+        for (i = 0; i < 8; ++i) {
+                vurb = usb->video_urbs[i];
+                if (vurb) {
+                        usb_kill_urb(vurb);
+                        kfree(vurb->transfer_buffer);
+                        usb_free_urb(vurb);
+                }
+                aurb = usb->audio_urbs[i];
+                if (aurb) {
+                        usb_kill_urb(aurb);
+                        kfree(aurb->transfer_buffer);
+                        usb_free_urb(aurb);
+                }
+        }
+
+        kfree(go->hpi_context);
+}
+
+static struct go7007_hpi_ops go7007_usb_ezusb_hpi_ops = {
+        .interface_reset        = go7007_usb_interface_reset,
+        .write_interrupt        = go7007_usb_ezusb_write_interrupt,
+        .read_interrupt         = go7007_usb_read_interrupt,
+        .stream_start           = go7007_usb_stream_start,
+        .stream_stop            = go7007_usb_stream_stop,
+        .send_firmware          = go7007_usb_send_firmware,
+        .release                = go7007_usb_release,
+};
+
+static struct go7007_hpi_ops go7007_usb_onboard_hpi_ops = {
+        .interface_reset        = go7007_usb_interface_reset,
+        .write_interrupt        = go7007_usb_onboard_write_interrupt,
+        .read_interrupt         = go7007_usb_read_interrupt,
+        .stream_start           = go7007_usb_stream_start,
+        .stream_stop            = go7007_usb_stream_stop,
+        .send_firmware          = go7007_usb_send_firmware,
+        .release                = go7007_usb_release,
+};
+
+/********************* Driver for EZ-USB I2C adapter *********************/
+
+static int go7007_usb_i2c_master_xfer(struct i2c_adapter *adapter,
+                                        struct i2c_msg msgs[], int num)
+{
+        struct go7007 *go = i2c_get_adapdata(adapter);
+        struct go7007_usb *usb = go->hpi_context;
+        u8 *buf = go->usb_buf;
+        int buf_len, i;
+        int ret = -EIO;
+
+        if (go->status == STATUS_SHUTDOWN)
+                return -ENODEV;
+
+        mutex_lock(&usb->i2c_lock);
+
+        for (i = 0; i < num; ++i) {
+                /* The hardware command is "write some bytes then read some
+                 * bytes", so we try to coalesce a write followed by a read
+                 * into a single USB transaction */
+                if (i + 1 < num && msgs[i].addr == msgs[i + 1].addr &&
+                                !(msgs[i].flags & I2C_M_RD) &&
+                                (msgs[i + 1].flags & I2C_M_RD)) {
+#ifdef GO7007_I2C_DEBUG
+                        pr_debug("i2c write/read %d/%d bytes on %02x\n",
+                                msgs[i].len, msgs[i + 1].len, msgs[i].addr);
+#endif
+                        buf[0] = 0x01;
+                        buf[1] = msgs[i].len + 1;
+                        buf[2] = msgs[i].addr << 1;
+                        memcpy(&buf[3], msgs[i].buf, msgs[i].len);
+                        buf_len = msgs[i].len + 3;
+                        buf[buf_len++] = msgs[++i].len;
+                } else if (msgs[i].flags & I2C_M_RD) {
+#ifdef GO7007_I2C_DEBUG
+                        pr_debug("i2c read %d bytes on %02x\n",
+                                        msgs[i].len, msgs[i].addr);
+#endif
+                        buf[0] = 0x01;
+                        buf[1] = 1;
+                        buf[2] = msgs[i].addr << 1;
+                        buf[3] = msgs[i].len;
+                        buf_len = 4;
+                } else {
+#ifdef GO7007_I2C_DEBUG
+                        pr_debug("i2c write %d bytes on %02x\n",
+                                        msgs[i].len, msgs[i].addr);
+#endif
+                        buf[0] = 0x00;
+                        buf[1] = msgs[i].len + 1;
+                        buf[2] = msgs[i].addr << 1;
+                        memcpy(&buf[3], msgs[i].buf, msgs[i].len);
+                        buf_len = msgs[i].len + 3;
+                        buf[buf_len++] = 0;
+                }
+                if (go7007_usb_vendor_request(go, 0x24, 0, 0,
+                                                buf, buf_len, 0) < 0)
+                        goto i2c_done;
+                if (msgs[i].flags & I2C_M_RD) {
+                        memset(buf, 0, msgs[i].len + 1);
+                        if (go7007_usb_vendor_request(go, 0x25, 0, 0, buf,
+                                                msgs[i].len + 1, 1) < 0)
+                                goto i2c_done;
+                        memcpy(msgs[i].buf, buf + 1, msgs[i].len);
+                }
+        }
+        ret = num;
+
+i2c_done:
+        mutex_unlock(&usb->i2c_lock);
+        return ret;
+}
+
+static u32 go7007_usb_functionality(struct i2c_adapter *adapter)
+{
+        /* No errors are reported by the hardware, so we don't bother
+         * supporting quick writes to avoid confusing probing */
+        return (I2C_FUNC_SMBUS_EMUL) & ~I2C_FUNC_SMBUS_QUICK;
+}
+
+static struct i2c_algorithm go7007_usb_algo = {
+        .master_xfer    = go7007_usb_i2c_master_xfer,
+        .functionality  = go7007_usb_functionality,
+};
+
+static struct i2c_adapter go7007_usb_adap_templ = {
+        .owner                  = THIS_MODULE,
+        .name                   = "WIS GO7007SB EZ-USB",
+        .algo                   = &go7007_usb_algo,
+};
+
+/********************* USB add/remove functions *********************/
+
+static int go7007_usb_probe(struct usb_interface *intf,
+                const struct usb_device_id *id)
+{
+        struct go7007 *go;
+        struct go7007_usb *usb;
+        const struct go7007_usb_board *board;
+        struct usb_device *usbdev = interface_to_usbdev(intf);
+        unsigned num_i2c_devs;
+        char *name;
+        int video_pipe, i, v_urb_len;
+
+        pr_debug("probing new GO7007 USB board\n");
+
+        switch (id->driver_info) {
+        case GO7007_BOARDID_MATRIX_II:
+                name = "WIS Matrix II or compatible";
+                board = &board_matrix_ii;
+                break;
+        case GO7007_BOARDID_MATRIX_RELOAD:
+                name = "WIS Matrix Reloaded or compatible";
+                board = &board_matrix_reload;
+                break;
+        case GO7007_BOARDID_MATRIX_REV:
+                name = "WIS Matrix Revolution or compatible";
+                board = &board_matrix_revolution;
+                break;
+        case GO7007_BOARDID_STAR_TREK:
+                name = "WIS Star Trek or compatible";
+                board = &board_star_trek;
+                break;
+        case GO7007_BOARDID_XMEN:
+                name = "WIS XMen or compatible";
+                board = &board_xmen;
+                break;
+        case GO7007_BOARDID_XMEN_II:
+                name = "WIS XMen II or compatible";
+                board = &board_xmen;
+                break;
+        case GO7007_BOARDID_XMEN_III:
+                name = "WIS XMen III or compatible";
+                board = &board_xmen;
+                break;
+        case GO7007_BOARDID_PX_M402U:
+                name = "Plextor PX-M402U";
+                board = &board_matrix_ii;
+                break;
+        case GO7007_BOARDID_PX_TV402U:
+                name = "Plextor PX-TV402U (unknown tuner)";
+                board = &board_px_tv402u;
+                break;
+        case GO7007_BOARDID_LIFEVIEW_LR192:
+                dev_err(&intf->dev, "The Lifeview TV Walker Ultra is not supported. Sorry!\n");
+                return -ENODEV;
+                name = "Lifeview TV Walker Ultra";
+                board = &board_lifeview_lr192;
+                break;
+        case GO7007_BOARDID_SENSORAY_2250:
+                dev_info(&intf->dev, "Sensoray 2250 found\n");
+                name = "Sensoray 2250/2251";
+                board = &board_sensoray_2250;
+                break;
+        case GO7007_BOARDID_ADS_USBAV_709:
+                name = "ADS Tech DVD Xpress DX2";
+                board = &board_ads_usbav_709;
+                break;
+        default:
+                dev_err(&intf->dev, "unknown board ID %d!\n",
+                                (unsigned int)id->driver_info);
+                return -ENODEV;
+        }
+
+        go = go7007_alloc(&board->main_info, &intf->dev);
+        if (go == NULL)
+                return -ENOMEM;
+
+        usb = kzalloc(sizeof(struct go7007_usb), GFP_KERNEL);
+        if (usb == NULL) {
+                kfree(go);
+                return -ENOMEM;
+        }
+
+        usb->board = board;
+        usb->usbdev = usbdev;
+        usb_make_path(usbdev, go->bus_info, sizeof(go->bus_info));
+        go->board_id = id->driver_info;
+        strncpy(go->name, name, sizeof(go->name));
+        if (board->flags & GO7007_USB_EZUSB)
+                go->hpi_ops = &go7007_usb_ezusb_hpi_ops;
+        else
+                go->hpi_ops = &go7007_usb_onboard_hpi_ops;
+        go->hpi_context = usb;
+
+        /* Allocate the URB and buffer for receiving incoming interrupts */
+        usb->intr_urb = usb_alloc_urb(0, GFP_KERNEL);
+        if (usb->intr_urb == NULL)
+                goto allocfail;
+        usb->intr_urb->transfer_buffer = kmalloc(2*sizeof(u16), GFP_KERNEL);
+        if (usb->intr_urb->transfer_buffer == NULL)
+                goto allocfail;
+
+        if (go->board_id == GO7007_BOARDID_SENSORAY_2250)
+                usb_fill_bulk_urb(usb->intr_urb, usb->usbdev,
+                        usb_rcvbulkpipe(usb->usbdev, 4),
+                        usb->intr_urb->transfer_buffer, 2*sizeof(u16),
+                        go7007_usb_readinterrupt_complete, go);
+        else
+                usb_fill_int_urb(usb->intr_urb, usb->usbdev,
+                        usb_rcvintpipe(usb->usbdev, 4),
+                        usb->intr_urb->transfer_buffer, 2*sizeof(u16),
+                        go7007_usb_readinterrupt_complete, go, 8);
+        usb_set_intfdata(intf, &go->v4l2_dev);
+
+        /* Boot the GO7007 */
+        if (go7007_boot_encoder(go, go->board_info->flags &
+                                        GO7007_BOARD_USE_ONBOARD_I2C) < 0)
+                goto allocfail;
+
+        /* Register the EZ-USB I2C adapter, if we're using it */
+        if (board->flags & GO7007_USB_EZUSB_I2C) {
+                memcpy(&go->i2c_adapter, &go7007_usb_adap_templ,
+                                sizeof(go7007_usb_adap_templ));
+                mutex_init(&usb->i2c_lock);
+                go->i2c_adapter.dev.parent = go->dev;
+                i2c_set_adapdata(&go->i2c_adapter, go);
+                if (i2c_add_adapter(&go->i2c_adapter) < 0) {
+                        dev_err(go->dev, "error: i2c_add_adapter failed\n");
+                        goto allocfail;
+                }
+                go->i2c_adapter_online = 1;
+        }
+
+        /* Pelco and Adlink reused the XMen and XMen-III vendor and product
+         * IDs for their own incompatible designs.  We can detect XMen boards
+         * by probing the sensor, but there is no way to probe the sensors on
+         * the Pelco and Adlink designs so we default to the Adlink.  If it
+         * is actually a Pelco, the user must set the assume_endura module
+         * parameter. */
+        if ((go->board_id == GO7007_BOARDID_XMEN ||
+                                go->board_id == GO7007_BOARDID_XMEN_III) &&
+                        go->i2c_adapter_online) {
+                union i2c_smbus_data data;
+
+                /* Check to see if register 0x0A is 0x76 */
+                i2c_smbus_xfer(&go->i2c_adapter, 0x21, I2C_CLIENT_SCCB,
+                        I2C_SMBUS_READ, 0x0A, I2C_SMBUS_BYTE_DATA, &data);
+                if (data.byte != 0x76) {
+                        if (assume_endura) {
+                                go->board_id = GO7007_BOARDID_ENDURA;
+                                usb->board = board = &board_endura;
+                                go->board_info = &board->main_info;
+                                strncpy(go->name, "Pelco Endura",
+                                        sizeof(go->name));
+                        } else {
+                                u16 channel;
+
+                                /* read channel number from GPIO[1:0] */
+                                go7007_read_addr(go, 0x3c81, &channel);
+                                channel &= 0x3;
+                                go->board_id = GO7007_BOARDID_ADLINK_MPG24;
+                                usb->board = board = &board_adlink_mpg24;
+                                go->board_info = &board->main_info;
+                                go->channel_number = channel;
+                                snprintf(go->name, sizeof(go->name),
+                                        "Adlink PCI-MPG24, channel #%d",
+                                        channel);
+                        }
+                        go7007_update_board(go);
+                }
+        }
+
+        num_i2c_devs = go->board_info->num_i2c_devs;
+
+        /* Probe the tuner model on the TV402U */
+        if (go->board_id == GO7007_BOARDID_PX_TV402U) {
+                /* Board strapping indicates tuner model */
+                if (go7007_usb_vendor_request(go, 0x41, 0, 0, go->usb_buf, 3,
+                                        1) < 0) {
+                        dev_err(go->dev, "GPIO read failed!\n");
+                        goto allocfail;
+                }
+                switch (go->usb_buf[0] >> 6) {
+                case 1:
+                        go->tuner_type = TUNER_SONY_BTF_PG472Z;
+                        go->std = V4L2_STD_PAL;
+                        strncpy(go->name, "Plextor PX-TV402U-EU",
+                                        sizeof(go->name));
+                        break;
+                case 2:
+                        go->tuner_type = TUNER_SONY_BTF_PK467Z;
+                        go->std = V4L2_STD_NTSC_M_JP;
+                        num_i2c_devs -= 2;
+                        strncpy(go->name, "Plextor PX-TV402U-JP",
+                                        sizeof(go->name));
+                        break;
+                case 3:
+                        go->tuner_type = TUNER_SONY_BTF_PB463Z;
+                        num_i2c_devs -= 2;
+                        strncpy(go->name, "Plextor PX-TV402U-NA",
+                                        sizeof(go->name));
+                        break;
+                default:
+                        pr_debug("unable to detect tuner type!\n");
+                        break;
+                }
+                /* Configure tuner mode selection inputs connected
+                 * to the EZ-USB GPIO output pins */
+                if (go7007_usb_vendor_request(go, 0x40, 0x7f02, 0,
+                                        NULL, 0, 0) < 0) {
+                        dev_err(go->dev, "GPIO write failed!\n");
+                        goto allocfail;
+                }
+        }
+
+        /* Print a nasty message if the user attempts to use a USB2.0 device in
+         * a USB1.1 port.  There will be silent corruption of the stream. */
+        if ((board->flags & GO7007_USB_EZUSB) &&
+                        usbdev->speed != USB_SPEED_HIGH)
+                dev_err(go->dev, "*** WARNING ***  This device must be connected to a USB 2.0 port! Attempting to capture video through a USB 1.1 port will result in stream corruption, even at low bitrates!\n");
+
+        /* Allocate the URBs and buffers for receiving the video stream */
+        if (board->flags & GO7007_USB_EZUSB) {
+                v_urb_len = 1024;
+                video_pipe = usb_rcvbulkpipe(usb->usbdev, 6);
+        } else {
+                v_urb_len = 512;
+                video_pipe = usb_rcvbulkpipe(usb->usbdev, 1);
+        }
+        for (i = 0; i < 8; ++i) {
+                usb->video_urbs[i] = usb_alloc_urb(0, GFP_KERNEL);
+                if (usb->video_urbs[i] == NULL)
+                        goto allocfail;
+                usb->video_urbs[i]->transfer_buffer =
+                                                kmalloc(v_urb_len, GFP_KERNEL);
+                if (usb->video_urbs[i]->transfer_buffer == NULL)
+                        goto allocfail;
+                usb_fill_bulk_urb(usb->video_urbs[i], usb->usbdev, video_pipe,
+                                usb->video_urbs[i]->transfer_buffer, v_urb_len,
+                                go7007_usb_read_video_pipe_complete, go);
+        }
+
+        /* Allocate the URBs and buffers for receiving the audio stream */
+        if ((board->flags & GO7007_USB_EZUSB) &&
+            (board->flags & GO7007_BOARD_HAS_AUDIO)) {
+                for (i = 0; i < 8; ++i) {
+                        usb->audio_urbs[i] = usb_alloc_urb(0, GFP_KERNEL);
+                        if (usb->audio_urbs[i] == NULL)
+                                goto allocfail;
+                        usb->audio_urbs[i]->transfer_buffer = kmalloc(4096,
+                                                                GFP_KERNEL);
+                        if (usb->audio_urbs[i]->transfer_buffer == NULL)
+                                goto allocfail;
+                        usb_fill_bulk_urb(usb->audio_urbs[i], usb->usbdev,
+                                usb_rcvbulkpipe(usb->usbdev, 8),
+                                usb->audio_urbs[i]->transfer_buffer, 4096,
+                                go7007_usb_read_audio_pipe_complete, go);
+                }
+        }
+
+        /* Do any final GO7007 initialization, then register the
+         * V4L2 and ALSA interfaces */
+        if (go7007_register_encoder(go, num_i2c_devs) < 0)
+                goto allocfail;
+
+        go->status = STATUS_ONLINE;
+        return 0;
+
+allocfail:
+        go7007_usb_release(go);
+        kfree(go);
+        return -ENOMEM;
+}
+
+static void go7007_usb_disconnect(struct usb_interface *intf)
+{
+        struct go7007 *go = to_go7007(usb_get_intfdata(intf));
+
+        mutex_lock(&go->queue_lock);
+        mutex_lock(&go->serialize_lock);
+
+        if (go->audio_enabled)
+                go7007_snd_remove(go);
+
+        go->status = STATUS_SHUTDOWN;
+        v4l2_device_disconnect(&go->v4l2_dev);
+        video_unregister_device(&go->vdev);
+        mutex_unlock(&go->serialize_lock);
+        mutex_unlock(&go->queue_lock);
+
+        v4l2_device_put(&go->v4l2_dev);
+}
+
+static struct usb_driver go7007_usb_driver = {
+        .name           = "go7007",
+        .probe          = go7007_usb_probe,
+        .disconnect     = go7007_usb_disconnect,
+        .id_table       = go7007_usb_id_table,
+};
+
+module_usb_driver(go7007_usb_driver);
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/media/usb/go7007/go7007-v4l2.c b/drivers/media/usb/go7007/go7007-v4l2.c
new file mode 100644
index 000000000000..ec799b4d88be
--- /dev/null
+++ b/drivers/media/usb/go7007/go7007-v4l2.c
@@ -0,0 +1,1173 @@
+/*
+ * Copyright (C) 2005-2006 Micronas USA Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License (Version 2) as
+ * published by the Free Software Foundation.
+ *
+ * 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.
+ */
+
+#include <linux/module.h>
+#include <linux/delay.h>
+#include <linux/sched.h>
+#include <linux/spinlock.h>
+#include <linux/slab.h>
+#include <linux/fs.h>
+#include <linux/unistd.h>
+#include <linux/time.h>
+#include <linux/vmalloc.h>
+#include <linux/pagemap.h>
+#include <linux/i2c.h>
+#include <linux/mutex.h>
+#include <linux/uaccess.h>
+#include <linux/videodev2.h>
+#include <media/v4l2-common.h>
+#include <media/v4l2-ioctl.h>
+#include <media/v4l2-subdev.h>
+#include <media/v4l2-event.h>
+#include <media/videobuf2-vmalloc.h>
+#include <media/saa7115.h>
+
+#include "go7007-priv.h"
+
+#define call_all(dev, o, f, args...) \
+        v4l2_device_call_until_err(dev, 0, o, f, ##args)
+
+static bool valid_pixelformat(u32 pixelformat)
+{
+        switch (pixelformat) {
+        case V4L2_PIX_FMT_MJPEG:
+        case V4L2_PIX_FMT_MPEG1:
+        case V4L2_PIX_FMT_MPEG2:
+        case V4L2_PIX_FMT_MPEG4:
+                return true;
+        default:
+                return false;
+        }
+}
+
+static u32 get_frame_type_flag(struct go7007_buffer *vb, int format)
+{
+        u8 *ptr = vb2_plane_vaddr(&vb->vb, 0);
+
+        switch (format) {
+        case V4L2_PIX_FMT_MJPEG:
+                return V4L2_BUF_FLAG_KEYFRAME;
+        case V4L2_PIX_FMT_MPEG4:
+                switch ((ptr[vb->frame_offset + 4] >> 6) & 0x3) {
+                case 0:
+                        return V4L2_BUF_FLAG_KEYFRAME;
+                case 1:
+                        return V4L2_BUF_FLAG_PFRAME;
+                case 2:
+                        return V4L2_BUF_FLAG_BFRAME;
+                default:
+                        return 0;
+                }
+        case V4L2_PIX_FMT_MPEG1:
+        case V4L2_PIX_FMT_MPEG2:
+                switch ((ptr[vb->frame_offset + 5] >> 3) & 0x7) {
+                case 1:
+                        return V4L2_BUF_FLAG_KEYFRAME;
+                case 2:
+                        return V4L2_BUF_FLAG_PFRAME;
+                case 3:
+                        return V4L2_BUF_FLAG_BFRAME;
+                default:
+                        return 0;
+                }
+        }
+
+        return 0;
+}
+
+static void get_resolution(struct go7007 *go, int *width, int *height)
+{
+        switch (go->standard) {
+        case GO7007_STD_NTSC:
+                *width = 720;
+                *height = 480;
+                break;
+        case GO7007_STD_PAL:
+                *width = 720;
+                *height = 576;
+                break;
+        case GO7007_STD_OTHER:
+        default:
+                *width = go->board_info->sensor_width;
+                *height = go->board_info->sensor_height;
+                break;
+        }
+}
+
+static void set_formatting(struct go7007 *go)
+{
+        if (go->format == V4L2_PIX_FMT_MJPEG) {
+                go->pali = 0;
+                go->aspect_ratio = GO7007_RATIO_1_1;
+                go->gop_size = 0;
+                go->ipb = 0;
+                go->closed_gop = 0;
+                go->repeat_seqhead = 0;
+                go->seq_header_enable = 0;
+                go->gop_header_enable = 0;
+                go->dvd_mode = 0;
+                return;
+        }
+
+        switch (go->format) {
+        case V4L2_PIX_FMT_MPEG1:
+                go->pali = 0;
+                break;
+        default:
+        case V4L2_PIX_FMT_MPEG2:
+                go->pali = 0x48;
+                break;
+        case V4L2_PIX_FMT_MPEG4:
+                /* For future reference: this is the list of MPEG4
+                 * profiles that are available, although they are
+                 * untested:
+                 *
+                 * Profile              pali
+                 * --------------       ----
+                 * PROFILE_S_L0         0x08
+                 * PROFILE_S_L1         0x01
+                 * PROFILE_S_L2         0x02
+                 * PROFILE_S_L3         0x03
+                 * PROFILE_ARTS_L1      0x91
+                 * PROFILE_ARTS_L2      0x92
+                 * PROFILE_ARTS_L3      0x93
+                 * PROFILE_ARTS_L4      0x94
+                 * PROFILE_AS_L0        0xf0
+                 * PROFILE_AS_L1        0xf1
+                 * PROFILE_AS_L2        0xf2
+                 * PROFILE_AS_L3        0xf3
+                 * PROFILE_AS_L4        0xf4
+                 * PROFILE_AS_L5        0xf5
+                 */
+                go->pali = 0xf5;
+                break;
+        }
+        go->gop_size = v4l2_ctrl_g_ctrl(go->mpeg_video_gop_size);
+        go->closed_gop = v4l2_ctrl_g_ctrl(go->mpeg_video_gop_closure);
+        go->ipb = v4l2_ctrl_g_ctrl(go->mpeg_video_b_frames) != 0;
+        go->bitrate = v4l2_ctrl_g_ctrl(go->mpeg_video_bitrate);
+        go->repeat_seqhead = v4l2_ctrl_g_ctrl(go->mpeg_video_rep_seqheader);
+        go->gop_header_enable = 1;
+        go->dvd_mode = 0;
+        if (go->format == V4L2_PIX_FMT_MPEG2)
+                go->dvd_mode =
+                        go->bitrate == 9800000 &&
+                        go->gop_size == 15 &&
+                        go->ipb == 0 &&
+                        go->repeat_seqhead == 1 &&
+                        go->closed_gop;
+
+        switch (v4l2_ctrl_g_ctrl(go->mpeg_video_aspect_ratio)) {
+        default:
+        case V4L2_MPEG_VIDEO_ASPECT_1x1:
+                go->aspect_ratio = GO7007_RATIO_1_1;
+                break;
+        case V4L2_MPEG_VIDEO_ASPECT_4x3:
+                go->aspect_ratio = GO7007_RATIO_4_3;
+                break;
+        case V4L2_MPEG_VIDEO_ASPECT_16x9:
+                go->aspect_ratio = GO7007_RATIO_16_9;
+                break;
+        }
+}
+
+static int set_capture_size(struct go7007 *go, struct v4l2_format *fmt, int try)
+{
+        int sensor_height = 0, sensor_width = 0;
+        int width, height;
+
+        if (fmt != NULL && !valid_pixelformat(fmt->fmt.pix.pixelformat))
+                return -EINVAL;
+
+        get_resolution(go, &sensor_width, &sensor_height);
+
+        if (fmt == NULL) {
+                width = sensor_width;
+                height = sensor_height;
+        } else if (go->board_info->sensor_flags & GO7007_SENSOR_SCALING) {
+                if (fmt->fmt.pix.width > sensor_width)
+                        width = sensor_width;
+                else if (fmt->fmt.pix.width < 144)
+                        width = 144;
+                else
+                        width = fmt->fmt.pix.width & ~0x0f;
+
+                if (fmt->fmt.pix.height > sensor_height)
+                        height = sensor_height;
+                else if (fmt->fmt.pix.height < 96)
+                        height = 96;
+                else
+                        height = fmt->fmt.pix.height & ~0x0f;
+        } else {
+                width = fmt->fmt.pix.width;
+
+                if (width <= sensor_width / 4) {
+                        width = sensor_width / 4;
+                        height = sensor_height / 4;
+                } else if (width <= sensor_width / 2) {
+                        width = sensor_width / 2;
+                        height = sensor_height / 2;
+                } else {
+                        width = sensor_width;
+                        height = sensor_height;
+                }
+                width &= ~0xf;
+                height &= ~0xf;
+        }
+
+        if (fmt != NULL) {
+                u32 pixelformat = fmt->fmt.pix.pixelformat;
+
+                memset(fmt, 0, sizeof(*fmt));
+                fmt->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+                fmt->fmt.pix.width = width;
+                fmt->fmt.pix.height = height;
+                fmt->fmt.pix.pixelformat = pixelformat;
+                fmt->fmt.pix.field = V4L2_FIELD_NONE;
+                fmt->fmt.pix.bytesperline = 0;
+                fmt->fmt.pix.sizeimage = GO7007_BUF_SIZE;
+                fmt->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
+        }
+
+        if (try)
+                return 0;
+
+        if (fmt)
+                go->format = fmt->fmt.pix.pixelformat;
+        go->width = width;
+        go->height = height;
+        go->encoder_h_offset = go->board_info->sensor_h_offset;
+        go->encoder_v_offset = go->board_info->sensor_v_offset;
+
+        if (go->board_info->sensor_flags & GO7007_SENSOR_SCALING) {
+                struct v4l2_mbus_framefmt mbus_fmt;
+
+                mbus_fmt.code = V4L2_MBUS_FMT_FIXED;
+                mbus_fmt.width = fmt ? fmt->fmt.pix.width : width;
+                mbus_fmt.height = height;
+                go->encoder_h_halve = 0;
+                go->encoder_v_halve = 0;
+                go->encoder_subsample = 0;
+                call_all(&go->v4l2_dev, video, s_mbus_fmt, &mbus_fmt);
+        } else {
+                if (width <= sensor_width / 4) {
+                        go->encoder_h_halve = 1;
+                        go->encoder_v_halve = 1;
+                        go->encoder_subsample = 1;
+                } else if (width <= sensor_width / 2) {
+                        go->encoder_h_halve = 1;
+                        go->encoder_v_halve = 1;
+                        go->encoder_subsample = 0;
+                } else {
+                        go->encoder_h_halve = 0;
+                        go->encoder_v_halve = 0;
+                        go->encoder_subsample = 0;
+                }
+        }
+        return 0;
+}
+
+static int vidioc_querycap(struct file *file, void  *priv,
+                                        struct v4l2_capability *cap)
+{
+        struct go7007 *go = video_drvdata(file);
+
+        strlcpy(cap->driver, "go7007", sizeof(cap->driver));
+        strlcpy(cap->card, go->name, sizeof(cap->card));
+        strlcpy(cap->bus_info, go->bus_info, sizeof(cap->bus_info));
+
+        cap->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE |
+                                V4L2_CAP_STREAMING;
+
+        if (go->board_info->num_aud_inputs)
+                cap->device_caps |= V4L2_CAP_AUDIO;
+        if (go->board_info->flags & GO7007_BOARD_HAS_TUNER)
+                cap->device_caps |= V4L2_CAP_TUNER;
+        cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
+        return 0;
+}
+
+static int vidioc_enum_fmt_vid_cap(struct file *file, void  *priv,
+                                        struct v4l2_fmtdesc *fmt)
+{
+        char *desc = NULL;
+
+        switch (fmt->index) {
+        case 0:
+                fmt->pixelformat = V4L2_PIX_FMT_MJPEG;
+                desc = "Motion JPEG";
+                break;
+        case 1:
+                fmt->pixelformat = V4L2_PIX_FMT_MPEG1;
+                desc = "MPEG-1 ES";
+                break;
+        case 2:
+                fmt->pixelformat = V4L2_PIX_FMT_MPEG2;
+                desc = "MPEG-2 ES";
+                break;
+        case 3:
+                fmt->pixelformat = V4L2_PIX_FMT_MPEG4;
+                desc = "MPEG-4 ES";
+                break;
+        default:
+                return -EINVAL;
+        }
+        fmt->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+        fmt->flags = V4L2_FMT_FLAG_COMPRESSED;
+
+        strncpy(fmt->description, desc, sizeof(fmt->description));
+
+        return 0;
+}
+
+static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
+                                        struct v4l2_format *fmt)
+{
+        struct go7007 *go = video_drvdata(file);
+
+        fmt->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+        fmt->fmt.pix.width = go->width;
+        fmt->fmt.pix.height = go->height;
+        fmt->fmt.pix.pixelformat = go->format;
+        fmt->fmt.pix.field = V4L2_FIELD_NONE;
+        fmt->fmt.pix.bytesperline = 0;
+        fmt->fmt.pix.sizeimage = GO7007_BUF_SIZE;
+        fmt->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
+
+        return 0;
+}
+
+static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
+                        struct v4l2_format *fmt)
+{
+        struct go7007 *go = video_drvdata(file);
+
+        return set_capture_size(go, fmt, 1);
+}
+
+static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
+                        struct v4l2_format *fmt)
+{
+        struct go7007 *go = video_drvdata(file);
+
+        if (vb2_is_busy(&go->vidq))
+                return -EBUSY;
+
+        return set_capture_size(go, fmt, 0);
+}
+
+static int go7007_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[])
+{
+        sizes[0] = GO7007_BUF_SIZE;
+        *num_planes = 1;
+
+        if (*num_buffers < 2)
+                *num_buffers = 2;
+
+        return 0;
+}
+
+static void go7007_buf_queue(struct vb2_buffer *vb)
+{
+        struct vb2_queue *vq = vb->vb2_queue;
+        struct go7007 *go = vb2_get_drv_priv(vq);
+        struct go7007_buffer *go7007_vb =
+                container_of(vb, struct go7007_buffer, vb);
+        unsigned long flags;
+
+        spin_lock_irqsave(&go->spinlock, flags);
+        list_add_tail(&go7007_vb->list, &go->vidq_active);
+        spin_unlock_irqrestore(&go->spinlock, flags);
+}
+
+static int go7007_buf_prepare(struct vb2_buffer *vb)
+{
+        struct go7007_buffer *go7007_vb =
+                container_of(vb, struct go7007_buffer, vb);
+
+        go7007_vb->modet_active = 0;
+        go7007_vb->frame_offset = 0;
+        vb->v4l2_planes[0].bytesused = 0;
+        return 0;
+}
+
+static void go7007_buf_finish(struct vb2_buffer *vb)
+{
+        struct vb2_queue *vq = vb->vb2_queue;
+        struct go7007 *go = vb2_get_drv_priv(vq);
+        struct go7007_buffer *go7007_vb =
+                container_of(vb, struct go7007_buffer, vb);
+        u32 frame_type_flag = get_frame_type_flag(go7007_vb, go->format);
+        struct v4l2_buffer *buf = &vb->v4l2_buf;
+
+        buf->flags &= ~(V4L2_BUF_FLAG_KEYFRAME | V4L2_BUF_FLAG_BFRAME |
+                        V4L2_BUF_FLAG_PFRAME);
+        buf->flags |= frame_type_flag;
+        buf->field = V4L2_FIELD_NONE;
+}
+
+static int go7007_start_streaming(struct vb2_queue *q, unsigned int count)
+{
+        struct go7007 *go = vb2_get_drv_priv(q);
+        int ret;
+
+        set_formatting(go);
+        mutex_lock(&go->hw_lock);
+        go->next_seq = 0;
+        go->active_buf = NULL;
+        go->modet_event_status = 0;
+        q->streaming = 1;
+        if (go7007_start_encoder(go) < 0)
+                ret = -EIO;
+        else
+                ret = 0;
+        mutex_unlock(&go->hw_lock);
+        if (ret) {
+                q->streaming = 0;
+                return ret;
+        }
+        call_all(&go->v4l2_dev, video, s_stream, 1);
+        v4l2_ctrl_grab(go->mpeg_video_gop_size, true);
+        v4l2_ctrl_grab(go->mpeg_video_gop_closure, true);
+        v4l2_ctrl_grab(go->mpeg_video_bitrate, true);
+        v4l2_ctrl_grab(go->mpeg_video_aspect_ratio, true);
+        /* Turn on Capture LED */
+        if (go->board_id == GO7007_BOARDID_ADS_USBAV_709)
+                go7007_write_addr(go, 0x3c82, 0x0005);
+        return ret;
+}
+
+static void go7007_stop_streaming(struct vb2_queue *q)
+{
+        struct go7007 *go = vb2_get_drv_priv(q);
+        unsigned long flags;
+
+        q->streaming = 0;
+        go7007_stream_stop(go);
+        mutex_lock(&go->hw_lock);
+        go7007_reset_encoder(go);
+        mutex_unlock(&go->hw_lock);
+        call_all(&go->v4l2_dev, video, s_stream, 0);
+
+        spin_lock_irqsave(&go->spinlock, flags);
+        INIT_LIST_HEAD(&go->vidq_active);
+        spin_unlock_irqrestore(&go->spinlock, flags);
+        v4l2_ctrl_grab(go->mpeg_video_gop_size, false);
+        v4l2_ctrl_grab(go->mpeg_video_gop_closure, false);
+        v4l2_ctrl_grab(go->mpeg_video_bitrate, false);
+        v4l2_ctrl_grab(go->mpeg_video_aspect_ratio, false);
+        /* Turn on Capture LED */
+        if (go->board_id == GO7007_BOARDID_ADS_USBAV_709)
+                go7007_write_addr(go, 0x3c82, 0x000d);
+}
+
+static struct vb2_ops go7007_video_qops = {
+        .queue_setup    = go7007_queue_setup,
+        .buf_queue      = go7007_buf_queue,
+        .buf_prepare    = go7007_buf_prepare,
+        .buf_finish     = go7007_buf_finish,
+        .start_streaming = go7007_start_streaming,
+        .stop_streaming = go7007_stop_streaming,
+        .wait_prepare   = vb2_ops_wait_prepare,
+        .wait_finish    = vb2_ops_wait_finish,
+};
+
+static int vidioc_g_parm(struct file *filp, void *priv,
+                struct v4l2_streamparm *parm)
+{
+        struct go7007 *go = video_drvdata(filp);
+        struct v4l2_fract timeperframe = {
+                .numerator = 1001 *  go->fps_scale,
+                .denominator = go->sensor_framerate,
+        };
+
+        if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
+                return -EINVAL;
+
+        parm->parm.capture.readbuffers = 2;
+        parm->parm.capture.capability = V4L2_CAP_TIMEPERFRAME;
+        parm->parm.capture.timeperframe = timeperframe;
+
+        return 0;
+}
+
+static int vidioc_s_parm(struct file *filp, void *priv,
+                struct v4l2_streamparm *parm)
+{
+        struct go7007 *go = video_drvdata(filp);
+        unsigned int n, d;
+
+        if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
+                return -EINVAL;
+
+        n = go->sensor_framerate *
+                parm->parm.capture.timeperframe.numerator;
+        d = 1001 * parm->parm.capture.timeperframe.denominator;
+        if (n != 0 && d != 0 && n > d)
+                go->fps_scale = (n + d/2) / d;
+        else
+                go->fps_scale = 1;
+
+        return vidioc_g_parm(filp, priv, parm);
+}
+
+/* VIDIOC_ENUMSTD on go7007 were used for enumerating the supported fps and
+   its resolution, when the device is not connected to TV.
+   This is were an API abuse, probably used by the lack of specific IOCTL's to
+   enumerate it, by the time the driver was written.
+
+   However, since kernel 2.6.19, two new ioctls (VIDIOC_ENUM_FRAMEINTERVALS
+   and VIDIOC_ENUM_FRAMESIZES) were added for this purpose.
+
+   The two functions below implement the newer ioctls
+*/
+static int vidioc_enum_framesizes(struct file *filp, void *priv,
+                                  struct v4l2_frmsizeenum *fsize)
+{
+        struct go7007 *go = video_drvdata(filp);
+        int width, height;
+
+        if (fsize->index > 2)
+                return -EINVAL;
+
+        if (!valid_pixelformat(fsize->pixel_format))
+                return -EINVAL;
+
+        get_resolution(go, &width, &height);
+        fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE;
+        fsize->discrete.width = (width >> fsize->index) & ~0xf;
+        fsize->discrete.height = (height >> fsize->index) & ~0xf;
+        return 0;
+}
+
+static int vidioc_enum_frameintervals(struct file *filp, void *priv,
+                                      struct v4l2_frmivalenum *fival)
+{
+        struct go7007 *go = video_drvdata(filp);
+        int width, height;
+        int i;
+
+        if (fival->index > 4)
+                return -EINVAL;
+
+        if (!valid_pixelformat(fival->pixel_format))
+                return -EINVAL;
+
+        if (!(go->board_info->sensor_flags & GO7007_SENSOR_SCALING)) {
+                get_resolution(go, &width, &height);
+                for (i = 0; i <= 2; i++)
+                        if (fival->width == ((width >> i) & ~0xf) &&
+                            fival->height == ((height >> i) & ~0xf))
+                                break;
+                if (i > 2)
+                        return -EINVAL;
+        }
+        fival->type = V4L2_FRMIVAL_TYPE_DISCRETE;
+        fival->discrete.numerator = 1001 * (fival->index + 1);
+        fival->discrete.denominator = go->sensor_framerate;
+        return 0;
+}
+
+static int vidioc_g_std(struct file *file, void *priv, v4l2_std_id *std)
+{
+        struct go7007 *go = video_drvdata(file);
+
+        *std = go->std;
+        return 0;
+}
+
+static int go7007_s_std(struct go7007 *go)
+{
+        if (go->std & V4L2_STD_625_50) {
+                go->standard = GO7007_STD_PAL;
+                go->sensor_framerate = 25025;
+        } else {
+                go->standard = GO7007_STD_NTSC;
+                go->sensor_framerate = 30000;
+        }
+
+        call_all(&go->v4l2_dev, video, s_std, go->std);
+        set_capture_size(go, NULL, 0);
+        return 0;
+}
+
+static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id std)
+{
+        struct go7007 *go = video_drvdata(file);
+
+        if (vb2_is_busy(&go->vidq))
+                return -EBUSY;
+
+        go->std = std;
+
+        return go7007_s_std(go);
+}
+
+static int vidioc_querystd(struct file *file, void *priv, v4l2_std_id *std)
+{
+        struct go7007 *go = video_drvdata(file);
+
+        return call_all(&go->v4l2_dev, video, querystd, std);
+}
+
+static int vidioc_enum_input(struct file *file, void *priv,
+                                struct v4l2_input *inp)
+{
+        struct go7007 *go = video_drvdata(file);
+
+        if (inp->index >= go->board_info->num_inputs)
+                return -EINVAL;
+
+        strncpy(inp->name, go->board_info->inputs[inp->index].name,
+                        sizeof(inp->name));
+
+        /* If this board has a tuner, it will be the first input */
+        if ((go->board_info->flags & GO7007_BOARD_HAS_TUNER) &&
+                        inp->index == 0)
+                inp->type = V4L2_INPUT_TYPE_TUNER;
+        else
+                inp->type = V4L2_INPUT_TYPE_CAMERA;
+
+        if (go->board_info->num_aud_inputs)
+                inp->audioset = (1 << go->board_info->num_aud_inputs) - 1;
+        else
+                inp->audioset = 0;
+        inp->tuner = 0;
+        if (go->board_info->sensor_flags & GO7007_SENSOR_TV)
+                inp->std = video_devdata(file)->tvnorms;
+        else
+                inp->std = 0;
+
+        return 0;
+}
+
+
+static int vidioc_g_input(struct file *file, void *priv, unsigned int *input)
+{
+        struct go7007 *go = video_drvdata(file);
+
+        *input = go->input;
+
+        return 0;
+}
+
+static int vidioc_enumaudio(struct file *file, void *fh, struct v4l2_audio *a)
+{
+        struct go7007 *go = video_drvdata(file);
+
+        if (a->index >= go->board_info->num_aud_inputs)
+                return -EINVAL;
+        strlcpy(a->name, go->board_info->aud_inputs[a->index].name,
+                sizeof(a->name));
+        a->capability = V4L2_AUDCAP_STEREO;
+        return 0;
+}
+
+static int vidioc_g_audio(struct file *file, void *fh, struct v4l2_audio *a)
+{
+        struct go7007 *go = video_drvdata(file);
+
+        a->index = go->aud_input;
+        strlcpy(a->name, go->board_info->aud_inputs[go->aud_input].name,
+                sizeof(a->name));
+        a->capability = V4L2_AUDCAP_STEREO;
+        return 0;
+}
+
+static int vidioc_s_audio(struct file *file, void *fh,
+        const struct v4l2_audio *a)
+{
+        struct go7007 *go = video_drvdata(file);
+
+        if (a->index >= go->board_info->num_aud_inputs)
+                return -EINVAL;
+        go->aud_input = a->index;
+        v4l2_subdev_call(go->sd_audio, audio, s_routing,
+                go->board_info->aud_inputs[go->aud_input].audio_input, 0, 0);
+        return 0;
+}
+
+static void go7007_s_input(struct go7007 *go)
+{
+        unsigned int input = go->input;
+
+        v4l2_subdev_call(go->sd_video, video, s_routing,
+                        go->board_info->inputs[input].video_input, 0,
+                        go->board_info->video_config);
+        if (go->board_info->num_aud_inputs) {
+                int aud_input = go->board_info->inputs[input].audio_index;
+
+                v4l2_subdev_call(go->sd_audio, audio, s_routing,
+                        go->board_info->aud_inputs[aud_input].audio_input, 0, 0);
+                go->aud_input = aud_input;
+        }
+}
+
+static int vidioc_s_input(struct file *file, void *priv, unsigned int input)
+{
+        struct go7007 *go = video_drvdata(file);
+
+        if (input >= go->board_info->num_inputs)
+                return -EINVAL;
+        if (vb2_is_busy(&go->vidq))
+                return -EBUSY;
+
+        go->input = input;
+        go7007_s_input(go);
+
+        return 0;
+}
+
+static int vidioc_g_tuner(struct file *file, void *priv,
+                                struct v4l2_tuner *t)
+{
+        struct go7007 *go = video_drvdata(file);
+
+        if (t->index != 0)
+                return -EINVAL;
+
+        strlcpy(t->name, "Tuner", sizeof(t->name));
+        return call_all(&go->v4l2_dev, tuner, g_tuner, t);
+}
+
+static int vidioc_s_tuner(struct file *file, void *priv,
+                                const struct v4l2_tuner *t)
+{
+        struct go7007 *go = video_drvdata(file);
+
+        if (t->index != 0)
+                return -EINVAL;
+
+        return call_all(&go->v4l2_dev, tuner, s_tuner, t);
+}
+
+static int vidioc_g_frequency(struct file *file, void *priv,
+                                struct v4l2_frequency *f)
+{
+        struct go7007 *go = video_drvdata(file);
+
+        if (f->tuner)
+                return -EINVAL;
+
+        return call_all(&go->v4l2_dev, tuner, g_frequency, f);
+}
+
+static int vidioc_s_frequency(struct file *file, void *priv,
+                                const struct v4l2_frequency *f)
+{
+        struct go7007 *go = video_drvdata(file);
+
+        if (f->tuner)
+                return -EINVAL;
+
+        return call_all(&go->v4l2_dev, tuner, s_frequency, f);
+}
+
+static int vidioc_log_status(struct file *file, void *priv)
+{
+        struct go7007 *go = video_drvdata(file);
+
+        v4l2_ctrl_log_status(file, priv);
+        return call_all(&go->v4l2_dev, core, log_status);
+}
+
+static int vidioc_subscribe_event(struct v4l2_fh *fh,
+                                const struct v4l2_event_subscription *sub)
+{
+
+        switch (sub->type) {
+        case V4L2_EVENT_CTRL:
+                return v4l2_ctrl_subscribe_event(fh, sub);
+        case V4L2_EVENT_MOTION_DET:
+                /* Allow for up to 30 events (1 second for NTSC) to be
+                 * stored. */
+                return v4l2_event_subscribe(fh, sub, 30, NULL);
+        }
+        return -EINVAL;
+}
+
+
+static int go7007_s_ctrl(struct v4l2_ctrl *ctrl)
+{
+        struct go7007 *go =
+                container_of(ctrl->handler, struct go7007, hdl);
+        unsigned y;
+        u8 *mt;
+
+        switch (ctrl->id) {
+        case V4L2_CID_PIXEL_THRESHOLD0:
+                go->modet[0].pixel_threshold = ctrl->val;
+                break;
+        case V4L2_CID_MOTION_THRESHOLD0:
+                go->modet[0].motion_threshold = ctrl->val;
+                break;
+        case V4L2_CID_MB_THRESHOLD0:
+                go->modet[0].mb_threshold = ctrl->val;
+                break;
+        case V4L2_CID_PIXEL_THRESHOLD1:
+                go->modet[1].pixel_threshold = ctrl->val;
+                break;
+        case V4L2_CID_MOTION_THRESHOLD1:
+                go->modet[1].motion_threshold = ctrl->val;
+                break;
+        case V4L2_CID_MB_THRESHOLD1:
+                go->modet[1].mb_threshold = ctrl->val;
+                break;
+        case V4L2_CID_PIXEL_THRESHOLD2:
+                go->modet[2].pixel_threshold = ctrl->val;
+                break;
+        case V4L2_CID_MOTION_THRESHOLD2:
+                go->modet[2].motion_threshold = ctrl->val;
+                break;
+        case V4L2_CID_MB_THRESHOLD2:
+                go->modet[2].mb_threshold = ctrl->val;
+                break;
+        case V4L2_CID_PIXEL_THRESHOLD3:
+                go->modet[3].pixel_threshold = ctrl->val;
+                break;
+        case V4L2_CID_MOTION_THRESHOLD3:
+                go->modet[3].motion_threshold = ctrl->val;
+                break;
+        case V4L2_CID_MB_THRESHOLD3:
+                go->modet[3].mb_threshold = ctrl->val;
+                break;
+        case V4L2_CID_DETECT_MD_REGION_GRID:
+                mt = go->modet_map;
+                for (y = 0; y < go->height / 16; y++, mt += go->width / 16)
+                        memcpy(mt, ctrl->p_new.p_u8 + y * (720 / 16), go->width / 16);
+                break;
+        default:
+                return -EINVAL;
+        }
+        return 0;
+}
+
+static struct v4l2_file_operations go7007_fops = {
+        .owner          = THIS_MODULE,
+        .open           = v4l2_fh_open,
+        .release        = vb2_fop_release,
+        .unlocked_ioctl = video_ioctl2,
+        .read           = vb2_fop_read,
+        .mmap           = vb2_fop_mmap,
+        .poll           = vb2_fop_poll,
+};
+
+static const struct v4l2_ioctl_ops video_ioctl_ops = {
+        .vidioc_querycap          = vidioc_querycap,
+        .vidioc_enum_fmt_vid_cap  = vidioc_enum_fmt_vid_cap,
+        .vidioc_g_fmt_vid_cap     = vidioc_g_fmt_vid_cap,
+        .vidioc_try_fmt_vid_cap   = vidioc_try_fmt_vid_cap,
+        .vidioc_s_fmt_vid_cap     = vidioc_s_fmt_vid_cap,
+        .vidioc_reqbufs           = vb2_ioctl_reqbufs,
+        .vidioc_querybuf          = vb2_ioctl_querybuf,
+        .vidioc_qbuf              = vb2_ioctl_qbuf,
+        .vidioc_dqbuf             = vb2_ioctl_dqbuf,
+        .vidioc_g_std             = vidioc_g_std,
+        .vidioc_s_std             = vidioc_s_std,
+        .vidioc_querystd          = vidioc_querystd,
+        .vidioc_enum_input        = vidioc_enum_input,
+        .vidioc_g_input           = vidioc_g_input,
+        .vidioc_s_input           = vidioc_s_input,
+        .vidioc_enumaudio         = vidioc_enumaudio,
+        .vidioc_g_audio           = vidioc_g_audio,
+        .vidioc_s_audio           = vidioc_s_audio,
+        .vidioc_streamon          = vb2_ioctl_streamon,
+        .vidioc_streamoff         = vb2_ioctl_streamoff,
+        .vidioc_g_tuner           = vidioc_g_tuner,
+        .vidioc_s_tuner           = vidioc_s_tuner,
+        .vidioc_g_frequency       = vidioc_g_frequency,
+        .vidioc_s_frequency       = vidioc_s_frequency,
+        .vidioc_g_parm            = vidioc_g_parm,
+        .vidioc_s_parm            = vidioc_s_parm,
+        .vidioc_enum_framesizes   = vidioc_enum_framesizes,
+        .vidioc_enum_frameintervals = vidioc_enum_frameintervals,
+        .vidioc_log_status        = vidioc_log_status,
+        .vidioc_subscribe_event   = vidioc_subscribe_event,
+        .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
+};
+
+static struct video_device go7007_template = {
+        .name           = "go7007",
+        .fops           = &go7007_fops,
+        .release        = video_device_release_empty,
+        .ioctl_ops      = &video_ioctl_ops,
+        .tvnorms        = V4L2_STD_ALL,
+};
+
+static const struct v4l2_ctrl_ops go7007_ctrl_ops = {
+        .s_ctrl = go7007_s_ctrl,
+};
+
+static const struct v4l2_ctrl_config go7007_pixel_threshold0_ctrl = {
+        .ops = &go7007_ctrl_ops,
+        .id = V4L2_CID_PIXEL_THRESHOLD0,
+        .name = "Pixel Threshold Region 0",
+        .type = V4L2_CTRL_TYPE_INTEGER,
+        .def = 20,
+        .max = 32767,
+        .step = 1,
+};
+
+static const struct v4l2_ctrl_config go7007_motion_threshold0_ctrl = {
+        .ops = &go7007_ctrl_ops,
+        .id = V4L2_CID_MOTION_THRESHOLD0,
+        .name = "Motion Threshold Region 0",
+        .type = V4L2_CTRL_TYPE_INTEGER,
+        .def = 80,
+        .max = 32767,
+        .step = 1,
+};
+
+static const struct v4l2_ctrl_config go7007_mb_threshold0_ctrl = {
+        .ops = &go7007_ctrl_ops,
+        .id = V4L2_CID_MB_THRESHOLD0,
+        .name = "MB Threshold Region 0",
+        .type = V4L2_CTRL_TYPE_INTEGER,
+        .def = 200,
+        .max = 32767,
+        .step = 1,
+};
+
+static const struct v4l2_ctrl_config go7007_pixel_threshold1_ctrl = {
+        .ops = &go7007_ctrl_ops,
+        .id = V4L2_CID_PIXEL_THRESHOLD1,
+        .name = "Pixel Threshold Region 1",
+        .type = V4L2_CTRL_TYPE_INTEGER,
+        .def = 20,
+        .max = 32767,
+        .step = 1,
+};
+
+static const struct v4l2_ctrl_config go7007_motion_threshold1_ctrl = {
+        .ops = &go7007_ctrl_ops,
+        .id = V4L2_CID_MOTION_THRESHOLD1,
+        .name = "Motion Threshold Region 1",
+        .type = V4L2_CTRL_TYPE_INTEGER,
+        .def = 80,
+        .max = 32767,
+        .step = 1,
+};
+
+static const struct v4l2_ctrl_config go7007_mb_threshold1_ctrl = {
+        .ops = &go7007_ctrl_ops,
+        .id = V4L2_CID_MB_THRESHOLD1,
+        .name = "MB Threshold Region 1",
+        .type = V4L2_CTRL_TYPE_INTEGER,
+        .def = 200,
+        .max = 32767,
+        .step = 1,
+};
+
+static const struct v4l2_ctrl_config go7007_pixel_threshold2_ctrl = {
+        .ops = &go7007_ctrl_ops,
+        .id = V4L2_CID_PIXEL_THRESHOLD2,
+        .name = "Pixel Threshold Region 2",
+        .type = V4L2_CTRL_TYPE_INTEGER,
+        .def = 20,
+        .max = 32767,
+        .step = 1,
+};
+
+static const struct v4l2_ctrl_config go7007_motion_threshold2_ctrl = {
+        .ops = &go7007_ctrl_ops,
+        .id = V4L2_CID_MOTION_THRESHOLD2,
+        .name = "Motion Threshold Region 2",
+        .type = V4L2_CTRL_TYPE_INTEGER,
+        .def = 80,
+        .max = 32767,
+        .step = 1,
+};
+
+static const struct v4l2_ctrl_config go7007_mb_threshold2_ctrl = {
+        .ops = &go7007_ctrl_ops,
+        .id = V4L2_CID_MB_THRESHOLD2,
+        .name = "MB Threshold Region 2",
+        .type = V4L2_CTRL_TYPE_INTEGER,
+        .def = 200,
+        .max = 32767,
+        .step = 1,
+};
+
+static const struct v4l2_ctrl_config go7007_pixel_threshold3_ctrl = {
+        .ops = &go7007_ctrl_ops,
+        .id = V4L2_CID_PIXEL_THRESHOLD3,
+        .name = "Pixel Threshold Region 3",
+        .type = V4L2_CTRL_TYPE_INTEGER,
+        .def = 20,
+        .max = 32767,
+        .step = 1,
+};
+
+static const struct v4l2_ctrl_config go7007_motion_threshold3_ctrl = {
+        .ops = &go7007_ctrl_ops,
+        .id = V4L2_CID_MOTION_THRESHOLD3,
+        .name = "Motion Threshold Region 3",
+        .type = V4L2_CTRL_TYPE_INTEGER,
+        .def = 80,
+        .max = 32767,
+        .step = 1,
+};
+
+static const struct v4l2_ctrl_config go7007_mb_threshold3_ctrl = {
+        .ops = &go7007_ctrl_ops,
+        .id = V4L2_CID_MB_THRESHOLD3,
+        .name = "MB Threshold Region 3",
+        .type = V4L2_CTRL_TYPE_INTEGER,
+        .def = 200,
+        .max = 32767,
+        .step = 1,
+};
+
+static const struct v4l2_ctrl_config go7007_mb_regions_ctrl = {
+        .ops = &go7007_ctrl_ops,
+        .id = V4L2_CID_DETECT_MD_REGION_GRID,
+        .dims = { 576 / 16, 720 / 16 },
+        .max = 3,
+        .step = 1,
+};
+
+int go7007_v4l2_ctrl_init(struct go7007 *go)
+{
+        struct v4l2_ctrl_handler *hdl = &go->hdl;
+        struct v4l2_ctrl *ctrl;
+
+        v4l2_ctrl_handler_init(hdl, 22);
+        go->mpeg_video_gop_size = v4l2_ctrl_new_std(hdl, NULL,
+                        V4L2_CID_MPEG_VIDEO_GOP_SIZE, 0, 34, 1, 15);
+        go->mpeg_video_gop_closure = v4l2_ctrl_new_std(hdl, NULL,
+                        V4L2_CID_MPEG_VIDEO_GOP_CLOSURE, 0, 1, 1, 1);
+        go->mpeg_video_bitrate = v4l2_ctrl_new_std(hdl, NULL,
+                        V4L2_CID_MPEG_VIDEO_BITRATE,
+                        64000, 10000000, 1, 9800000);
+        go->mpeg_video_b_frames = v4l2_ctrl_new_std(hdl, NULL,
+                        V4L2_CID_MPEG_VIDEO_B_FRAMES, 0, 2, 2, 0);
+        go->mpeg_video_rep_seqheader = v4l2_ctrl_new_std(hdl, NULL,
+                        V4L2_CID_MPEG_VIDEO_REPEAT_SEQ_HEADER, 0, 1, 1, 1);
+
+        go->mpeg_video_aspect_ratio = v4l2_ctrl_new_std_menu(hdl, NULL,
+                        V4L2_CID_MPEG_VIDEO_ASPECT,
+                        V4L2_MPEG_VIDEO_ASPECT_16x9, 0,
+                        V4L2_MPEG_VIDEO_ASPECT_1x1);
+        ctrl = v4l2_ctrl_new_std(hdl, NULL,
+                        V4L2_CID_JPEG_ACTIVE_MARKER, 0,
+                        V4L2_JPEG_ACTIVE_MARKER_DQT |
+                        V4L2_JPEG_ACTIVE_MARKER_DHT, 0,
+                        V4L2_JPEG_ACTIVE_MARKER_DQT |
+                        V4L2_JPEG_ACTIVE_MARKER_DHT);
+        if (ctrl)
+                ctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY;
+        v4l2_ctrl_new_custom(hdl, &go7007_pixel_threshold0_ctrl, NULL);
+        v4l2_ctrl_new_custom(hdl, &go7007_motion_threshold0_ctrl, NULL);
+        v4l2_ctrl_new_custom(hdl, &go7007_mb_threshold0_ctrl, NULL);
+        v4l2_ctrl_new_custom(hdl, &go7007_pixel_threshold1_ctrl, NULL);
+        v4l2_ctrl_new_custom(hdl, &go7007_motion_threshold1_ctrl, NULL);
+        v4l2_ctrl_new_custom(hdl, &go7007_mb_threshold1_ctrl, NULL);
+        v4l2_ctrl_new_custom(hdl, &go7007_pixel_threshold2_ctrl, NULL);
+        v4l2_ctrl_new_custom(hdl, &go7007_motion_threshold2_ctrl, NULL);
+        v4l2_ctrl_new_custom(hdl, &go7007_mb_threshold2_ctrl, NULL);
+        v4l2_ctrl_new_custom(hdl, &go7007_pixel_threshold3_ctrl, NULL);
+        v4l2_ctrl_new_custom(hdl, &go7007_motion_threshold3_ctrl, NULL);
+        v4l2_ctrl_new_custom(hdl, &go7007_mb_threshold3_ctrl, NULL);
+        v4l2_ctrl_new_custom(hdl, &go7007_mb_regions_ctrl, NULL);
+        go->modet_mode = v4l2_ctrl_new_std_menu(hdl, NULL,
+                        V4L2_CID_DETECT_MD_MODE,
+                        V4L2_DETECT_MD_MODE_REGION_GRID,
+                        1 << V4L2_DETECT_MD_MODE_THRESHOLD_GRID,
+                        V4L2_DETECT_MD_MODE_DISABLED);
+        if (hdl->error) {
+                int rv = hdl->error;
+
+                v4l2_err(&go->v4l2_dev, "Could not register controls\n");
+                return rv;
+        }
+        go->v4l2_dev.ctrl_handler = hdl;
+        return 0;
+}
+
+int go7007_v4l2_init(struct go7007 *go)
+{
+        struct video_device *vdev = &go->vdev;
+        int rv;
+
+        mutex_init(&go->serialize_lock);
+        mutex_init(&go->queue_lock);
+
+        INIT_LIST_HEAD(&go->vidq_active);
+        go->vidq.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+        go->vidq.io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ;
+        go->vidq.ops = &go7007_video_qops;
+        go->vidq.mem_ops = &vb2_vmalloc_memops;
+        go->vidq.drv_priv = go;
+        go->vidq.buf_struct_size = sizeof(struct go7007_buffer);
+        go->vidq.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
+        go->vidq.lock = &go->queue_lock;
+        rv = vb2_queue_init(&go->vidq);
+        if (rv)
+                return rv;
+        *vdev = go7007_template;
+        vdev->lock = &go->serialize_lock;
+        vdev->queue = &go->vidq;
+        video_set_drvdata(vdev, go);
+        vdev->v4l2_dev = &go->v4l2_dev;
+        if (!v4l2_device_has_op(&go->v4l2_dev, video, querystd))
+                v4l2_disable_ioctl(vdev, VIDIOC_QUERYSTD);
+        if (!(go->board_info->flags & GO7007_BOARD_HAS_TUNER)) {
+                v4l2_disable_ioctl(vdev, VIDIOC_S_FREQUENCY);
+                v4l2_disable_ioctl(vdev, VIDIOC_G_FREQUENCY);
+                v4l2_disable_ioctl(vdev, VIDIOC_S_TUNER);
+                v4l2_disable_ioctl(vdev, VIDIOC_G_TUNER);
+        } else {
+                struct v4l2_frequency f = {
+                        .type = V4L2_TUNER_ANALOG_TV,
+                        .frequency = 980,
+                };
+
+                call_all(&go->v4l2_dev, tuner, s_frequency, &f);
+        }
+        if (!(go->board_info->sensor_flags & GO7007_SENSOR_TV)) {
+                v4l2_disable_ioctl(vdev, VIDIOC_G_STD);
+                v4l2_disable_ioctl(vdev, VIDIOC_S_STD);
+                vdev->tvnorms = 0;
+        }
+        if (go->board_info->sensor_flags & GO7007_SENSOR_SCALING)
+                v4l2_disable_ioctl(vdev, VIDIOC_ENUM_FRAMESIZES);
+        if (go->board_info->num_aud_inputs == 0) {
+                v4l2_disable_ioctl(vdev, VIDIOC_G_AUDIO);
+                v4l2_disable_ioctl(vdev, VIDIOC_S_AUDIO);
+                v4l2_disable_ioctl(vdev, VIDIOC_ENUMAUDIO);
+        }
+        /* Setup correct crystal frequency on this board */
+        if (go->board_info->sensor_flags & GO7007_SENSOR_SAA7115)
+                v4l2_subdev_call(go->sd_video, video, s_crystal_freq,
+                                SAA7115_FREQ_24_576_MHZ,
+                                SAA7115_FREQ_FL_APLL | SAA7115_FREQ_FL_UCGC |
+                                SAA7115_FREQ_FL_DOUBLE_ASCLK);
+        go7007_s_input(go);
+        if (go->board_info->sensor_flags & GO7007_SENSOR_TV)
+                go7007_s_std(go);
+        rv = video_register_device(vdev, VFL_TYPE_GRABBER, -1);
+        if (rv < 0)
+                return rv;
+        dev_info(go->dev, "registered device %s [v4l2]\n",
+                 video_device_node_name(vdev));
+
+        return 0;
+}
+
+void go7007_v4l2_remove(struct go7007 *go)
+{
+        v4l2_ctrl_handler_free(&go->hdl);
+}
diff --git a/drivers/media/usb/go7007/s2250-board.c b/drivers/media/usb/go7007/s2250-board.c
new file mode 100644
index 000000000000..bb846680bcd4
--- /dev/null
+++ b/drivers/media/usb/go7007/s2250-board.c
@@ -0,0 +1,628 @@
+/*
+ * Copyright (C) 2008 Sensoray Company Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License (Version 2) as
+ * published by the Free Software Foundation.
+ *
+ * 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.
+ */
+
+#include <linux/module.h>
+#include <linux/usb.h>
+#include <linux/i2c.h>
+#include <linux/videodev2.h>
+#include <linux/slab.h>
+#include <media/v4l2-device.h>
+#include <media/v4l2-common.h>
+#include <media/v4l2-subdev.h>
+#include "go7007-priv.h"
+
+MODULE_DESCRIPTION("Sensoray 2250/2251 i2c v4l2 subdev driver");
+MODULE_LICENSE("GPL v2");
+
+/*
+ * Note: this board has two i2c devices: a vpx3226f and a tlv320aic23b.
+ * Due to the unusual way these are accessed on this device we do not
+ * reuse the i2c drivers, but instead they are implemented in this
+ * driver. It would be nice to improve on this, though.
+ */
+
+#define TLV320_ADDRESS      0x34
+#define VPX322_ADDR_ANALOGCONTROL1      0x02
+#define VPX322_ADDR_BRIGHTNESS0         0x0127
+#define VPX322_ADDR_BRIGHTNESS1         0x0131
+#define VPX322_ADDR_CONTRAST0           0x0128
+#define VPX322_ADDR_CONTRAST1           0x0132
+#define VPX322_ADDR_HUE                 0x00dc
+#define VPX322_ADDR_SAT                 0x0030
+
+struct go7007_usb_board {
+        unsigned int flags;
+        struct go7007_board_info main_info;
+};
+
+struct go7007_usb {
+        struct go7007_usb_board *board;
+        struct mutex i2c_lock;
+        struct usb_device *usbdev;
+        struct urb *video_urbs[8];
+        struct urb *audio_urbs[8];
+        struct urb *intr_urb;
+};
+
+static unsigned char aud_regs[] = {
+        0x1e, 0x00,
+        0x00, 0x17,
+        0x02, 0x17,
+        0x04, 0xf9,
+        0x06, 0xf9,
+        0x08, 0x02,
+        0x0a, 0x00,
+        0x0c, 0x00,
+        0x0a, 0x00,
+        0x0c, 0x00,
+        0x0e, 0x02,
+        0x10, 0x00,
+        0x12, 0x01,
+        0x00, 0x00,
+};
+
+
+static unsigned char vid_regs[] = {
+        0xF2, 0x0f,
+        0xAA, 0x00,
+        0xF8, 0xff,
+        0x00, 0x00,
+};
+
+static u16 vid_regs_fp[] = {
+        0x028, 0x067,
+        0x120, 0x016,
+        0x121, 0xcF2,
+        0x122, 0x0F2,
+        0x123, 0x00c,
+        0x124, 0x2d0,
+        0x125, 0x2e0,
+        0x126, 0x004,
+        0x128, 0x1E0,
+        0x12A, 0x016,
+        0x12B, 0x0F2,
+        0x12C, 0x0F2,
+        0x12D, 0x00c,
+        0x12E, 0x2d0,
+        0x12F, 0x2e0,
+        0x130, 0x004,
+        0x132, 0x1E0,
+        0x140, 0x060,
+        0x153, 0x00C,
+        0x154, 0x200,
+        0x150, 0x801,
+        0x000, 0x000
+};
+
+/* PAL specific values */
+static u16 vid_regs_fp_pal[] = {
+        0x120, 0x017,
+        0x121, 0xd22,
+        0x122, 0x122,
+        0x12A, 0x017,
+        0x12B, 0x122,
+        0x12C, 0x122,
+        0x140, 0x060,
+        0x000, 0x000,
+};
+
+struct s2250 {
+        struct v4l2_subdev sd;
+        struct v4l2_ctrl_handler hdl;
+        v4l2_std_id std;
+        int input;
+        int brightness;
+        int contrast;
+        int saturation;
+        int hue;
+        int reg12b_val;
+        int audio_input;
+        struct i2c_client *audio;
+};
+
+static inline struct s2250 *to_state(struct v4l2_subdev *sd)
+{
+        return container_of(sd, struct s2250, sd);
+}
+
+/* from go7007-usb.c which is Copyright (C) 2005-2006 Micronas USA Inc.*/
+static int go7007_usb_vendor_request(struct go7007 *go, u16 request,
+        u16 value, u16 index, void *transfer_buffer, int length, int in)
+{
+        struct go7007_usb *usb = go->hpi_context;
+        int timeout = 5000;
+
+        if (in) {
+                return usb_control_msg(usb->usbdev,
+                                usb_rcvctrlpipe(usb->usbdev, 0), request,
+                                USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
+                                value, index, transfer_buffer, length, timeout);
+        } else {
+                return usb_control_msg(usb->usbdev,
+                                usb_sndctrlpipe(usb->usbdev, 0), request,
+                                USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+                                value, index, transfer_buffer, length, timeout);
+        }
+}
+/* end from go7007-usb.c which is Copyright (C) 2005-2006 Micronas USA Inc.*/
+
+static int write_reg(struct i2c_client *client, u8 reg, u8 value)
+{
+        struct go7007 *go = i2c_get_adapdata(client->adapter);
+        struct go7007_usb *usb;
+        int rc;
+        int dev_addr = client->addr << 1;  /* firmware wants 8-bit address */
+        u8 *buf;
+
+        if (go == NULL)
+                return -ENODEV;
+
+        if (go->status == STATUS_SHUTDOWN)
+                return -EBUSY;
+
+        buf = kzalloc(16, GFP_KERNEL);
+        if (buf == NULL)
+                return -ENOMEM;
+
+        usb = go->hpi_context;
+        if (mutex_lock_interruptible(&usb->i2c_lock) != 0) {
+                dev_info(&client->dev, "i2c lock failed\n");
+                kfree(buf);
+                return -EINTR;
+        }
+        rc = go7007_usb_vendor_request(go, 0x55, dev_addr,
+                                       (reg<<8 | value),
+                                       buf,
+                                       16, 1);
+
+        mutex_unlock(&usb->i2c_lock);
+        kfree(buf);
+        return rc;
+}
+
+static int write_reg_fp(struct i2c_client *client, u16 addr, u16 val)
+{
+        struct go7007 *go = i2c_get_adapdata(client->adapter);
+        struct go7007_usb *usb;
+        int rc;
+        u8 *buf;
+        struct s2250 *dec = i2c_get_clientdata(client);
+
+        if (go == NULL)
+                return -ENODEV;
+
+        if (go->status == STATUS_SHUTDOWN)
+                return -EBUSY;
+
+        buf = kzalloc(16, GFP_KERNEL);
+
+        if (buf == NULL)
+                return -ENOMEM;
+
+
+
+        memset(buf, 0xcd, 6);
+
+        usb = go->hpi_context;
+        if (mutex_lock_interruptible(&usb->i2c_lock) != 0) {
+                dev_info(&client->dev, "i2c lock failed\n");
+                kfree(buf);
+                return -EINTR;
+        }
+        rc = go7007_usb_vendor_request(go, 0x57, addr, val, buf, 16, 1);
+        mutex_unlock(&usb->i2c_lock);
+        if (rc < 0) {
+                kfree(buf);
+                return rc;
+        }
+
+        if (buf[0] == 0) {
+                unsigned int subaddr, val_read;
+
+                subaddr = (buf[4] << 8) + buf[5];
+                val_read = (buf[2] << 8) + buf[3];
+                kfree(buf);
+                if (val_read != val) {
+                        dev_info(&client->dev, "invalid fp write %x %x\n",
+                                 val_read, val);
+                        return -EFAULT;
+                }
+                if (subaddr != addr) {
+                        dev_info(&client->dev, "invalid fp write addr %x %x\n",
+                                 subaddr, addr);
+                        return -EFAULT;
+                }
+        } else {
+                kfree(buf);
+                return -EFAULT;
+        }
+
+        /* save last 12b value */
+        if (addr == 0x12b)
+                dec->reg12b_val = val;
+
+        return 0;
+}
+
+static int read_reg_fp(struct i2c_client *client, u16 addr, u16 *val)
+{
+        struct go7007 *go = i2c_get_adapdata(client->adapter);
+        struct go7007_usb *usb;
+        int rc;
+        u8 *buf;
+
+        if (go == NULL)
+                return -ENODEV;
+
+        if (go->status == STATUS_SHUTDOWN)
+                return -EBUSY;
+
+        buf = kzalloc(16, GFP_KERNEL);
+
+        if (buf == NULL)
+                return -ENOMEM;
+
+
+
+        memset(buf, 0xcd, 6);
+        usb = go->hpi_context;
+        if (mutex_lock_interruptible(&usb->i2c_lock) != 0) {
+                dev_info(&client->dev, "i2c lock failed\n");
+                kfree(buf);
+                return -EINTR;
+        }
+        rc = go7007_usb_vendor_request(go, 0x58, addr, 0, buf, 16, 1);
+        mutex_unlock(&usb->i2c_lock);
+        if (rc < 0) {
+                kfree(buf);
+                return rc;
+        }
+
+        *val = (buf[0] << 8) | buf[1];
+        kfree(buf);
+
+        return 0;
+}
+
+
+static int write_regs(struct i2c_client *client, u8 *regs)
+{
+        int i;
+
+        for (i = 0; !((regs[i] == 0x00) && (regs[i+1] == 0x00)); i += 2) {
+                if (write_reg(client, regs[i], regs[i+1]) < 0) {
+                        dev_info(&client->dev, "failed\n");
+                        return -1;
+                }
+        }
+        return 0;
+}
+
+static int write_regs_fp(struct i2c_client *client, u16 *regs)
+{
+        int i;
+
+        for (i = 0; !((regs[i] == 0x00) && (regs[i+1] == 0x00)); i += 2) {
+                if (write_reg_fp(client, regs[i], regs[i+1]) < 0) {
+                        dev_info(&client->dev, "failed fp\n");
+                        return -1;
+                }
+        }
+        return 0;
+}
+
+
+/* ------------------------------------------------------------------------- */
+
+static int s2250_s_video_routing(struct v4l2_subdev *sd, u32 input, u32 output,
+                                 u32 config)
+{
+        struct s2250 *state = to_state(sd);
+        struct i2c_client *client = v4l2_get_subdevdata(sd);
+        int vidsys;
+
+        vidsys = (state->std == V4L2_STD_NTSC) ? 0x01 : 0x00;
+        if (input == 0) {
+                /* composite */
+                write_reg_fp(client, 0x20, 0x020 | vidsys);
+                write_reg_fp(client, 0x21, 0x662);
+                write_reg_fp(client, 0x140, 0x060);
+        } else if (input == 1) {
+                /* S-Video */
+                write_reg_fp(client, 0x20, 0x040 | vidsys);
+                write_reg_fp(client, 0x21, 0x666);
+                write_reg_fp(client, 0x140, 0x060);
+        } else {
+                return -EINVAL;
+        }
+        state->input = input;
+        return 0;
+}
+
+static int s2250_s_std(struct v4l2_subdev *sd, v4l2_std_id norm)
+{
+        struct s2250 *state = to_state(sd);
+        struct i2c_client *client = v4l2_get_subdevdata(sd);
+        u16 vidsource;
+
+        vidsource = (state->input == 1) ? 0x040 : 0x020;
+        if (norm & V4L2_STD_625_50) {
+                write_regs_fp(client, vid_regs_fp);
+                write_regs_fp(client, vid_regs_fp_pal);
+                write_reg_fp(client, 0x20, vidsource);
+        } else {
+                write_regs_fp(client, vid_regs_fp);
+                write_reg_fp(client, 0x20, vidsource | 1);
+        }
+        state->std = norm;
+        return 0;
+}
+
+static int s2250_s_ctrl(struct v4l2_ctrl *ctrl)
+{
+        struct s2250 *state = container_of(ctrl->handler, struct s2250, hdl);
+        struct i2c_client *client = v4l2_get_subdevdata(&state->sd);
+        u16 oldvalue;
+
+        switch (ctrl->id) {
+        case V4L2_CID_BRIGHTNESS:
+                read_reg_fp(client, VPX322_ADDR_BRIGHTNESS0, &oldvalue);
+                write_reg_fp(client, VPX322_ADDR_BRIGHTNESS0,
+                             ctrl->val | (oldvalue & ~0xff));
+                read_reg_fp(client, VPX322_ADDR_BRIGHTNESS1, &oldvalue);
+                write_reg_fp(client, VPX322_ADDR_BRIGHTNESS1,
+                             ctrl->val | (oldvalue & ~0xff));
+                write_reg_fp(client, 0x140, 0x60);
+                break;
+        case V4L2_CID_CONTRAST:
+                read_reg_fp(client, VPX322_ADDR_CONTRAST0, &oldvalue);
+                write_reg_fp(client, VPX322_ADDR_CONTRAST0,
+                             ctrl->val | (oldvalue & ~0x3f));
+                read_reg_fp(client, VPX322_ADDR_CONTRAST1, &oldvalue);
+                write_reg_fp(client, VPX322_ADDR_CONTRAST1,
+                             ctrl->val | (oldvalue & ~0x3f));
+                write_reg_fp(client, 0x140, 0x60);
+                break;
+        case V4L2_CID_SATURATION:
+                write_reg_fp(client, VPX322_ADDR_SAT, ctrl->val);
+                break;
+        case V4L2_CID_HUE:
+                write_reg_fp(client, VPX322_ADDR_HUE, ctrl->val);
+                break;
+        default:
+                return -EINVAL;
+        }
+        return 0;
+}
+
+static int s2250_s_mbus_fmt(struct v4l2_subdev *sd,
+                        struct v4l2_mbus_framefmt *fmt)
+{
+        struct s2250 *state = to_state(sd);
+        struct i2c_client *client = v4l2_get_subdevdata(sd);
+
+        if (fmt->height < 640) {
+                write_reg_fp(client, 0x12b, state->reg12b_val | 0x400);
+                write_reg_fp(client, 0x140, 0x060);
+        } else {
+                write_reg_fp(client, 0x12b, state->reg12b_val & ~0x400);
+                write_reg_fp(client, 0x140, 0x060);
+        }
+        return 0;
+}
+
+static int s2250_s_audio_routing(struct v4l2_subdev *sd, u32 input, u32 output,
+                                 u32 config)
+{
+        struct s2250 *state = to_state(sd);
+
+        switch (input) {
+        case 0:
+                write_reg(state->audio, 0x08, 0x02); /* Line In */
+                break;
+        case 1:
+                write_reg(state->audio, 0x08, 0x04); /* Mic */
+                break;
+        case 2:
+                write_reg(state->audio, 0x08, 0x05); /* Mic Boost */
+                break;
+        default:
+                return -EINVAL;
+        }
+        state->audio_input = input;
+        return 0;
+}
+
+
+static int s2250_log_status(struct v4l2_subdev *sd)
+{
+        struct s2250 *state = to_state(sd);
+
+        v4l2_info(sd, "Standard: %s\n", state->std == V4L2_STD_NTSC ? "NTSC" :
+                                        state->std == V4L2_STD_PAL ? "PAL" :
+                                        state->std == V4L2_STD_SECAM ? "SECAM" :
+                                        "unknown");
+        v4l2_info(sd, "Input: %s\n", state->input == 0 ? "Composite" :
+                                        state->input == 1 ? "S-video" :
+                                        "error");
+        v4l2_info(sd, "Audio input: %s\n", state->audio_input == 0 ? "Line In" :
+                                        state->audio_input == 1 ? "Mic" :
+                                        state->audio_input == 2 ? "Mic Boost" :
+                                        "error");
+        return v4l2_ctrl_subdev_log_status(sd);
+}
+
+/* --------------------------------------------------------------------------*/
+
+static const struct v4l2_ctrl_ops s2250_ctrl_ops = {
+        .s_ctrl = s2250_s_ctrl,
+};
+
+static const struct v4l2_subdev_core_ops s2250_core_ops = {
+        .log_status = s2250_log_status,
+};
+
+static const struct v4l2_subdev_audio_ops s2250_audio_ops = {
+        .s_routing = s2250_s_audio_routing,
+};
+
+static const struct v4l2_subdev_video_ops s2250_video_ops = {
+        .s_std = s2250_s_std,
+        .s_routing = s2250_s_video_routing,
+        .s_mbus_fmt = s2250_s_mbus_fmt,
+};
+
+static const struct v4l2_subdev_ops s2250_ops = {
+        .core = &s2250_core_ops,
+        .audio = &s2250_audio_ops,
+        .video = &s2250_video_ops,
+};
+
+/* --------------------------------------------------------------------------*/
+
+static int s2250_probe(struct i2c_client *client,
+                       const struct i2c_device_id *id)
+{
+        struct i2c_client *audio;
+        struct i2c_adapter *adapter = client->adapter;
+        struct s2250 *state;
+        struct v4l2_subdev *sd;
+        u8 *data;
+        struct go7007 *go = i2c_get_adapdata(adapter);
+        struct go7007_usb *usb = go->hpi_context;
+
+        audio = i2c_new_dummy(adapter, TLV320_ADDRESS >> 1);
+        if (audio == NULL)
+                return -ENOMEM;
+
+        state = kzalloc(sizeof(struct s2250), GFP_KERNEL);
+        if (state == NULL) {
+                i2c_unregister_device(audio);
+                return -ENOMEM;
+        }
+
+        sd = &state->sd;
+        v4l2_i2c_subdev_init(sd, client, &s2250_ops);
+
+        v4l2_info(sd, "initializing %s at address 0x%x on %s\n",
+               "Sensoray 2250/2251", client->addr, client->adapter->name);
+
+        v4l2_ctrl_handler_init(&state->hdl, 4);
+        v4l2_ctrl_new_std(&state->hdl, &s2250_ctrl_ops,
+                V4L2_CID_BRIGHTNESS, -128, 127, 1, 0);
+        v4l2_ctrl_new_std(&state->hdl, &s2250_ctrl_ops,
+                V4L2_CID_CONTRAST, 0, 0x3f, 1, 0x32);
+        v4l2_ctrl_new_std(&state->hdl, &s2250_ctrl_ops,
+                V4L2_CID_SATURATION, 0, 4094, 1, 2070);
+        v4l2_ctrl_new_std(&state->hdl, &s2250_ctrl_ops,
+                V4L2_CID_HUE, -512, 511, 1, 0);
+        sd->ctrl_handler = &state->hdl;
+        if (state->hdl.error) {
+                int err = state->hdl.error;
+
+                v4l2_ctrl_handler_free(&state->hdl);
+                kfree(state);
+                return err;
+        }
+
+        state->std = V4L2_STD_NTSC;
+        state->brightness = 50;
+        state->contrast = 50;
+        state->saturation = 50;
+        state->hue = 0;
+        state->audio = audio;
+
+        /* initialize the audio */
+        if (write_regs(audio, aud_regs) < 0) {
+                dev_err(&client->dev, "error initializing audio\n");
+                goto fail;
+        }
+
+        if (write_regs(client, vid_regs) < 0) {
+                dev_err(&client->dev, "error initializing decoder\n");
+                goto fail;
+        }
+        if (write_regs_fp(client, vid_regs_fp) < 0) {
+                dev_err(&client->dev, "error initializing decoder\n");
+                goto fail;
+        }
+        /* set default channel */
+        /* composite */
+        write_reg_fp(client, 0x20, 0x020 | 1);
+        write_reg_fp(client, 0x21, 0x662);
+        write_reg_fp(client, 0x140, 0x060);
+
+        /* set default audio input */
+        state->audio_input = 0;
+        write_reg(client, 0x08, 0x02); /* Line In */
+
+        if (mutex_lock_interruptible(&usb->i2c_lock) == 0) {
+                data = kzalloc(16, GFP_KERNEL);
+                if (data != NULL) {
+                        int rc = go7007_usb_vendor_request(go, 0x41, 0, 0,
+                                                       data, 16, 1);
+
+                        if (rc > 0) {
+                                u8 mask;
+
+                                data[0] = 0;
+                                mask = 1<<5;
+                                data[0] &= ~mask;
+                                data[1] |= mask;
+                                go7007_usb_vendor_request(go, 0x40, 0,
+                                                          (data[1]<<8)
+                                                          + data[1],
+                                                          data, 16, 0);
+                        }
+                        kfree(data);
+                }
+                mutex_unlock(&usb->i2c_lock);
+        }
+
+        v4l2_info(sd, "initialized successfully\n");
+        return 0;
+
+fail:
+        i2c_unregister_device(audio);
+        v4l2_ctrl_handler_free(&state->hdl);
+        kfree(state);
+        return -EIO;
+}
+
+static int s2250_remove(struct i2c_client *client)
+{
+        struct s2250 *state = to_state(i2c_get_clientdata(client));
+
+        v4l2_device_unregister_subdev(&state->sd);
+        v4l2_ctrl_handler_free(&state->hdl);
+        kfree(state);
+        return 0;
+}
+
+static const struct i2c_device_id s2250_id[] = {
+        { "s2250", 0 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, s2250_id);
+
+static struct i2c_driver s2250_driver = {
+        .driver = {
+                .owner  = THIS_MODULE,
+                .name   = "s2250",
+        },
+        .probe          = s2250_probe,
+        .remove         = s2250_remove,
+        .id_table       = s2250_id,
+};
+
+module_i2c_driver(s2250_driver);
diff --git a/drivers/media/usb/go7007/snd-go7007.c b/drivers/media/usb/go7007/snd-go7007.c
new file mode 100644
index 000000000000..d22d7d574672
--- /dev/null
+++ b/drivers/media/usb/go7007/snd-go7007.c
@@ -0,0 +1,298 @@
+/*
+ * Copyright (C) 2005-2006 Micronas USA Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License (Version 2) as
+ * published by the Free Software Foundation.
+ *
+ * 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.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/spinlock.h>
+#include <linux/delay.h>
+#include <linux/sched.h>
+#include <linux/vmalloc.h>
+#include <linux/time.h>
+#include <linux/mm.h>
+#include <linux/i2c.h>
+#include <linux/mutex.h>
+#include <linux/uaccess.h>
+#include <linux/slab.h>
+#include <sound/core.h>
+#include <sound/pcm.h>
+#include <sound/initval.h>
+
+#include "go7007-priv.h"
+
+static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;
+static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;
+static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;
+
+module_param_array(index, int, NULL, 0444);
+module_param_array(id, charp, NULL, 0444);
+module_param_array(enable, bool, NULL, 0444);
+MODULE_PARM_DESC(index, "Index value for the go7007 audio driver");
+MODULE_PARM_DESC(id, "ID string for the go7007 audio driver");
+MODULE_PARM_DESC(enable, "Enable for the go7007 audio driver");
+
+struct go7007_snd {
+        struct snd_card *card;
+        struct snd_pcm *pcm;
+        struct snd_pcm_substream *substream;
+        spinlock_t lock;
+        int w_idx;
+        int hw_ptr;
+        int avail;
+        int capturing;
+};
+
+static struct snd_pcm_hardware go7007_snd_capture_hw = {
+        .info                   = (SNDRV_PCM_INFO_MMAP |
+                                        SNDRV_PCM_INFO_INTERLEAVED |
+                                        SNDRV_PCM_INFO_BLOCK_TRANSFER |
+                                        SNDRV_PCM_INFO_MMAP_VALID),
+        .formats                = SNDRV_PCM_FMTBIT_S16_LE,
+        .rates                  = SNDRV_PCM_RATE_48000,
+        .rate_min               = 48000,
+        .rate_max               = 48000,
+        .channels_min           = 2,
+        .channels_max           = 2,
+        .buffer_bytes_max       = (128*1024),
+        .period_bytes_min       = 4096,
+        .period_bytes_max       = (128*1024),
+        .periods_min            = 1,
+        .periods_max            = 32,
+};
+
+static void parse_audio_stream_data(struct go7007 *go, u8 *buf, int length)
+{
+        struct go7007_snd *gosnd = go->snd_context;
+        struct snd_pcm_runtime *runtime = gosnd->substream->runtime;
+        int frames = bytes_to_frames(runtime, length);
+
+        spin_lock(&gosnd->lock);
+        gosnd->hw_ptr += frames;
+        if (gosnd->hw_ptr >= runtime->buffer_size)
+                gosnd->hw_ptr -= runtime->buffer_size;
+        gosnd->avail += frames;
+        spin_unlock(&gosnd->lock);
+        if (gosnd->w_idx + length > runtime->dma_bytes) {
+                int cpy = runtime->dma_bytes - gosnd->w_idx;
+
+                memcpy(runtime->dma_area + gosnd->w_idx, buf, cpy);
+                length -= cpy;
+                buf += cpy;
+                gosnd->w_idx = 0;
+        }
+        memcpy(runtime->dma_area + gosnd->w_idx, buf, length);
+        gosnd->w_idx += length;
+        spin_lock(&gosnd->lock);
+        if (gosnd->avail < runtime->period_size) {
+                spin_unlock(&gosnd->lock);
+                return;
+        }
+        gosnd->avail -= runtime->period_size;
+        spin_unlock(&gosnd->lock);
+        if (gosnd->capturing)
+                snd_pcm_period_elapsed(gosnd->substream);
+}
+
+static int go7007_snd_hw_params(struct snd_pcm_substream *substream,
+                                struct snd_pcm_hw_params *hw_params)
+{
+        struct go7007 *go = snd_pcm_substream_chip(substream);
+        unsigned int bytes;
+
+        bytes = params_buffer_bytes(hw_params);
+        if (substream->runtime->dma_bytes > 0)
+                vfree(substream->runtime->dma_area);
+        substream->runtime->dma_bytes = 0;
+        substream->runtime->dma_area = vmalloc(bytes);
+        if (substream->runtime->dma_area == NULL)
+                return -ENOMEM;
+        substream->runtime->dma_bytes = bytes;
+        go->audio_deliver = parse_audio_stream_data;
+        return 0;
+}
+
+static int go7007_snd_hw_free(struct snd_pcm_substream *substream)
+{
+        struct go7007 *go = snd_pcm_substream_chip(substream);
+
+        go->audio_deliver = NULL;
+        if (substream->runtime->dma_bytes > 0)
+                vfree(substream->runtime->dma_area);
+        substream->runtime->dma_bytes = 0;
+        return 0;
+}
+
+static int go7007_snd_capture_open(struct snd_pcm_substream *substream)
+{
+        struct go7007 *go = snd_pcm_substream_chip(substream);
+        struct go7007_snd *gosnd = go->snd_context;
+        unsigned long flags;
+        int r;
+
+        spin_lock_irqsave(&gosnd->lock, flags);
+        if (gosnd->substream == NULL) {
+                gosnd->substream = substream;
+                substream->runtime->hw = go7007_snd_capture_hw;
+                r = 0;
+        } else
+                r = -EBUSY;
+        spin_unlock_irqrestore(&gosnd->lock, flags);
+        return r;
+}
+
+static int go7007_snd_capture_close(struct snd_pcm_substream *substream)
+{
+        struct go7007 *go = snd_pcm_substream_chip(substream);
+        struct go7007_snd *gosnd = go->snd_context;
+
+        gosnd->substream = NULL;
+        return 0;
+}
+
+static int go7007_snd_pcm_prepare(struct snd_pcm_substream *substream)
+{
+        return 0;
+}
+
+static int go7007_snd_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
+{
+        struct go7007 *go = snd_pcm_substream_chip(substream);
+        struct go7007_snd *gosnd = go->snd_context;
+
+        switch (cmd) {
+        case SNDRV_PCM_TRIGGER_START:
+                /* Just set a flag to indicate we should signal ALSA when
+                 * sound comes in */
+                gosnd->capturing = 1;
+                return 0;
+        case SNDRV_PCM_TRIGGER_STOP:
+                gosnd->hw_ptr = gosnd->w_idx = gosnd->avail = 0;
+                gosnd->capturing = 0;
+                return 0;
+        default:
+                return -EINVAL;
+        }
+}
+
+static snd_pcm_uframes_t go7007_snd_pcm_pointer(struct snd_pcm_substream *substream)
+{
+        struct go7007 *go = snd_pcm_substream_chip(substream);
+        struct go7007_snd *gosnd = go->snd_context;
+
+        return gosnd->hw_ptr;
+}
+
+static struct page *go7007_snd_pcm_page(struct snd_pcm_substream *substream,
+                                        unsigned long offset)
+{
+        return vmalloc_to_page(substream->runtime->dma_area + offset);
+}
+
+static struct snd_pcm_ops go7007_snd_capture_ops = {
+        .open           = go7007_snd_capture_open,
+        .close          = go7007_snd_capture_close,
+        .ioctl          = snd_pcm_lib_ioctl,
+        .hw_params      = go7007_snd_hw_params,
+        .hw_free        = go7007_snd_hw_free,
+        .prepare        = go7007_snd_pcm_prepare,
+        .trigger        = go7007_snd_pcm_trigger,
+        .pointer        = go7007_snd_pcm_pointer,
+        .page           = go7007_snd_pcm_page,
+};
+
+static int go7007_snd_free(struct snd_device *device)
+{
+        struct go7007 *go = device->device_data;
+
+        kfree(go->snd_context);
+        go->snd_context = NULL;
+        return 0;
+}
+
+static struct snd_device_ops go7007_snd_device_ops = {
+        .dev_free       = go7007_snd_free,
+};
+
+int go7007_snd_init(struct go7007 *go)
+{
+        static int dev;
+        struct go7007_snd *gosnd;
+        int ret = 0;
+
+        if (dev >= SNDRV_CARDS)
+                return -ENODEV;
+        if (!enable[dev]) {
+                dev++;
+                return -ENOENT;
+        }
+        gosnd = kmalloc(sizeof(struct go7007_snd), GFP_KERNEL);
+        if (gosnd == NULL)
+                return -ENOMEM;
+        spin_lock_init(&gosnd->lock);
+        gosnd->hw_ptr = gosnd->w_idx = gosnd->avail = 0;
+        gosnd->capturing = 0;
+        ret = snd_card_new(go->dev, index[dev], id[dev], THIS_MODULE, 0,
+                           &gosnd->card);
+        if (ret < 0) {
+                kfree(gosnd);
+                return ret;
+        }
+        ret = snd_device_new(gosnd->card, SNDRV_DEV_LOWLEVEL, go,
+                        &go7007_snd_device_ops);
+        if (ret < 0) {
+                kfree(gosnd);
+                return ret;
+        }
+        ret = snd_pcm_new(gosnd->card, "go7007", 0, 0, 1, &gosnd->pcm);
+        if (ret < 0) {
+                snd_card_free(gosnd->card);
+                kfree(gosnd);
+                return ret;
+        }
+        strlcpy(gosnd->card->driver, "go7007", sizeof(gosnd->card->driver));
+        strlcpy(gosnd->card->shortname, go->name, sizeof(gosnd->card->driver));
+        strlcpy(gosnd->card->longname, gosnd->card->shortname,
+                        sizeof(gosnd->card->longname));
+
+        gosnd->pcm->private_data = go;
+        snd_pcm_set_ops(gosnd->pcm, SNDRV_PCM_STREAM_CAPTURE,
+                        &go7007_snd_capture_ops);
+
+        ret = snd_card_register(gosnd->card);
+        if (ret < 0) {
+                snd_card_free(gosnd->card);
+                kfree(gosnd);
+                return ret;
+        }
+
+        gosnd->substream = NULL;
+        go->snd_context = gosnd;
+        v4l2_device_get(&go->v4l2_dev);
+        ++dev;
+
+        return 0;
+}
+EXPORT_SYMBOL(go7007_snd_init);
+
+int go7007_snd_remove(struct go7007 *go)
+{
+        struct go7007_snd *gosnd = go->snd_context;
+
+        snd_card_disconnect(gosnd->card);
+        snd_card_free_when_closed(gosnd->card);
+        v4l2_device_put(&go->v4l2_dev);
+        return 0;
+}
+EXPORT_SYMBOL(go7007_snd_remove);
+
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/media/usb/gspca/autogain_functions.c b/drivers/media/usb/gspca/autogain_functions.c
index 67db674bb044..0e9ee8b50bb7 100644
--- a/drivers/media/usb/gspca/autogain_functions.c
+++ b/drivers/media/usb/gspca/autogain_functions.c
@@ -121,9 +121,9 @@ int gspca_coarse_grained_expo_autogain(
         orig_gain = gain = v4l2_ctrl_g_ctrl(gspca_dev->gain);
         orig_exposure = exposure = v4l2_ctrl_g_ctrl(gspca_dev->exposure);
 
-        gain_low  = (gspca_dev->gain->maximum - gspca_dev->gain->minimum) /
+        gain_low  = (s32)(gspca_dev->gain->maximum - gspca_dev->gain->minimum) /
                     5 * 2 + gspca_dev->gain->minimum;
-        gain_high = (gspca_dev->gain->maximum - gspca_dev->gain->minimum) /
+        gain_high = (s32)(gspca_dev->gain->maximum - gspca_dev->gain->minimum) /
                     5 * 4 + gspca_dev->gain->minimum;
 
         /* If we are of a multiple of deadzone, do multiple steps to reach the
diff --git a/drivers/media/usb/gspca/gspca.c b/drivers/media/usb/gspca/gspca.c
index f3a7ace0fac9..e8cf23c91cef 100644
--- a/drivers/media/usb/gspca/gspca.c
+++ b/drivers/media/usb/gspca/gspca.c
@@ -603,10 +603,13 @@ static void gspca_stream_off(struct gspca_dev *gspca_dev)
 }
 
 /*
- * look for an input transfer endpoint in an alternate setting
+ * look for an input transfer endpoint in an alternate setting.
+ *
+ * If xfer_ep is invalid, return the first valid ep found, otherwise
+ * look for exactly the ep with address equal to xfer_ep.
  */
 static struct usb_host_endpoint *alt_xfer(struct usb_host_interface *alt,
-                                          int xfer)
+                                          int xfer, int xfer_ep)
 {
         struct usb_host_endpoint *ep;
         int i, attr;
@@ -616,7 +619,8 @@ static struct usb_host_endpoint *alt_xfer(struct usb_host_interface *alt,
                 attr = ep->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK;
                 if (attr == xfer
                     && ep->desc.wMaxPacketSize != 0
-                    && usb_endpoint_dir_in(&ep->desc))
+                    && usb_endpoint_dir_in(&ep->desc)
+                    && (xfer_ep < 0 || ep->desc.bEndpointAddress == xfer_ep))
                         return ep;
         }
         return NULL;
@@ -689,7 +693,8 @@ static int build_isoc_ep_tb(struct gspca_dev *gspca_dev,
                 found = 0;
                 for (j = 0; j < nbalt; j++) {
                         ep = alt_xfer(&intf->altsetting[j],
-                                      USB_ENDPOINT_XFER_ISOC);
+                                      USB_ENDPOINT_XFER_ISOC,
+                                      gspca_dev->xfer_ep);
                         if (ep == NULL)
                                 continue;
                         if (ep->desc.bInterval == 0) {
@@ -862,7 +867,8 @@ static int gspca_init_transfer(struct gspca_dev *gspca_dev)
         /* if bulk or the subdriver forced an altsetting, get the endpoint */
         if (gspca_dev->alt != 0) {
                 gspca_dev->alt--;       /* (previous version compatibility) */
-                ep = alt_xfer(&intf->altsetting[gspca_dev->alt], xfer);
+                ep = alt_xfer(&intf->altsetting[gspca_dev->alt], xfer,
+                              gspca_dev->xfer_ep);
                 if (ep == NULL) {
                         pr_err("bad altsetting %d\n", gspca_dev->alt);
                         return -EIO;
@@ -904,7 +910,8 @@ static int gspca_init_transfer(struct gspca_dev *gspca_dev)
                 if (!gspca_dev->cam.no_urb_create) {
                         PDEBUG(D_STREAM, "init transfer alt %d", alt);
                         ret = create_urbs(gspca_dev,
-                                alt_xfer(&intf->altsetting[alt], xfer));
+                                alt_xfer(&intf->altsetting[alt], xfer,
+                                         gspca_dev->xfer_ep));
                         if (ret < 0) {
                                 destroy_urbs(gspca_dev);
                                 goto out;
@@ -1102,8 +1109,8 @@ static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
         struct gspca_dev *gspca_dev = video_drvdata(file);
 
         fmt->fmt.pix = gspca_dev->pixfmt;
-        /* some drivers use priv internally, zero it before giving it to
-           userspace */
+        /* some drivers use priv internally, zero it before giving it back to
+           the core */
         fmt->fmt.pix.priv = 0;
         return 0;
 }
@@ -1139,8 +1146,8 @@ static int try_fmt_vid_cap(struct gspca_dev *gspca_dev,
                 fmt->fmt.pix.height = h;
                 gspca_dev->sd_desc->try_fmt(gspca_dev, fmt);
         }
-        /* some drivers use priv internally, zero it before giving it to
-           userspace */
+        /* some drivers use priv internally, zero it before giving it back to
+           the core */
         fmt->fmt.pix.priv = 0;
         return mode;                    /* used when s_fmt */
 }
@@ -2030,6 +2037,7 @@ int gspca_dev_probe2(struct usb_interface *intf,
         }
         gspca_dev->dev = dev;
         gspca_dev->iface = intf->cur_altsetting->desc.bInterfaceNumber;
+        gspca_dev->xfer_ep = -1;
 
         /* check if any audio device */
         if (dev->actconfig->desc.bNumInterfaces != 1) {
@@ -2058,7 +2066,6 @@ int gspca_dev_probe2(struct usb_interface *intf,
         gspca_dev->vdev = gspca_template;
         gspca_dev->vdev.v4l2_dev = &gspca_dev->v4l2_dev;
         video_set_drvdata(&gspca_dev->vdev, gspca_dev);
-        set_bit(V4L2_FL_USE_FH_PRIO, &gspca_dev->vdev.flags);
         gspca_dev->module = module;
         gspca_dev->present = 1;
 
diff --git a/drivers/media/usb/gspca/gspca.h b/drivers/media/usb/gspca/gspca.h
index 300642dc1a17..f06253cd7469 100644
--- a/drivers/media/usb/gspca/gspca.h
+++ b/drivers/media/usb/gspca/gspca.h
@@ -205,6 +205,7 @@ struct gspca_dev {
         char memory;                    /* memory type (V4L2_MEMORY_xxx) */
         __u8 iface;                     /* USB interface number */
         __u8 alt;                       /* USB alternate setting */
+        int xfer_ep;                    /* USB transfer endpoint address */
         u8 audio;                       /* presence of audio device */
 
         /* (*) These variables are proteced by both usb_lock and queue_lock,
diff --git a/drivers/media/usb/gspca/kinect.c b/drivers/media/usb/gspca/kinect.c
index 081f05162809..45bc1f51c5d8 100644
--- a/drivers/media/usb/gspca/kinect.c
+++ b/drivers/media/usb/gspca/kinect.c
@@ -36,6 +36,8 @@ MODULE_AUTHOR("Antonio Ospite <ospite@studenti.unina.it>");
 MODULE_DESCRIPTION("GSPCA/Kinect Sensor Device USB Camera Driver");
 MODULE_LICENSE("GPL");
 
+static bool depth_mode;
+
 struct pkt_hdr {
         uint8_t magic[2];
         uint8_t pad;
@@ -73,6 +75,14 @@ struct sd {
 
 #define FPS_HIGH       0x0100
 
+static const struct v4l2_pix_format depth_camera_mode[] = {
+        {640, 480, V4L2_PIX_FMT_Y10BPACK, V4L2_FIELD_NONE,
+         .bytesperline = 640 * 10 / 8,
+         .sizeimage =  640 * 480 * 10 / 8,
+         .colorspace = V4L2_COLORSPACE_SRGB,
+         .priv = MODE_640x488 | FORMAT_Y10B},
+};
+
 static const struct v4l2_pix_format video_camera_mode[] = {
         {640, 480, V4L2_PIX_FMT_SGRBG8, V4L2_FIELD_NONE,
          .bytesperline = 640,
@@ -219,7 +229,7 @@ static int write_register(struct gspca_dev *gspca_dev, uint16_t reg,
 }
 
 /* this function is called at probe time */
-static int sd_config(struct gspca_dev *gspca_dev,
+static int sd_config_video(struct gspca_dev *gspca_dev,
                      const struct usb_device_id *id)
 {
         struct sd *sd = (struct sd *) gspca_dev;
@@ -227,8 +237,6 @@ static int sd_config(struct gspca_dev *gspca_dev,
 
         sd->cam_tag = 0;
 
-        /* Only video stream is supported for now,
-         * which has stream flag = 0x80 */
         sd->stream_flag = 0x80;
 
         cam = &gspca_dev->cam;
@@ -236,6 +244,8 @@ static int sd_config(struct gspca_dev *gspca_dev,
         cam->cam_mode = video_camera_mode;
         cam->nmodes = ARRAY_SIZE(video_camera_mode);
 
+        gspca_dev->xfer_ep = 0x81;
+
 #if 0
         /* Setting those values is not needed for video stream */
         cam->npkt = 15;
@@ -245,6 +255,26 @@ static int sd_config(struct gspca_dev *gspca_dev,
         return 0;
 }
 
+static int sd_config_depth(struct gspca_dev *gspca_dev,
+                     const struct usb_device_id *id)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        struct cam *cam;
+
+        sd->cam_tag = 0;
+
+        sd->stream_flag = 0x70;
+
+        cam = &gspca_dev->cam;
+
+        cam->cam_mode = depth_camera_mode;
+        cam->nmodes = ARRAY_SIZE(depth_camera_mode);
+
+        gspca_dev->xfer_ep = 0x82;
+
+        return 0;
+}
+
 /* this function is called at probe and resume time */
 static int sd_init(struct gspca_dev *gspca_dev)
 {
@@ -253,7 +283,7 @@ static int sd_init(struct gspca_dev *gspca_dev)
         return 0;
 }
 
-static int sd_start(struct gspca_dev *gspca_dev)
+static int sd_start_video(struct gspca_dev *gspca_dev)
 {
         int mode;
         uint8_t fmt_reg, fmt_val;
@@ -325,12 +355,39 @@ static int sd_start(struct gspca_dev *gspca_dev)
         return 0;
 }
 
-static void sd_stopN(struct gspca_dev *gspca_dev)
+static int sd_start_depth(struct gspca_dev *gspca_dev)
+{
+        /* turn off IR-reset function */
+        write_register(gspca_dev, 0x105, 0x00);
+
+        /* reset depth stream */
+        write_register(gspca_dev, 0x06, 0x00);
+        /* Depth Stream Format 0x03: 11 bit stream | 0x02: 10 bit */
+        write_register(gspca_dev, 0x12, 0x02);
+        /* Depth Stream Resolution 1: standard (640x480) */
+        write_register(gspca_dev, 0x13, 0x01);
+        /* Depth Framerate / 0x1e (30): 30 fps */
+        write_register(gspca_dev, 0x14, 0x1e);
+        /* Depth Stream Control  / 2: Open Depth Stream */
+        write_register(gspca_dev, 0x06, 0x02);
+        /* disable depth hflip / LSB = 0: Smoothing Disabled */
+        write_register(gspca_dev, 0x17, 0x00);
+
+        return 0;
+}
+
+static void sd_stopN_video(struct gspca_dev *gspca_dev)
 {
         /* reset video stream */
         write_register(gspca_dev, 0x05, 0x00);
 }
 
+static void sd_stopN_depth(struct gspca_dev *gspca_dev)
+{
+        /* reset depth stream */
+        write_register(gspca_dev, 0x06, 0x00);
+}
+
 static void sd_pkt_scan(struct gspca_dev *gspca_dev, u8 *__data, int len)
 {
         struct sd *sd = (struct sd *) gspca_dev;
@@ -366,12 +423,24 @@ static void sd_pkt_scan(struct gspca_dev *gspca_dev, u8 *__data, int len)
 }
 
 /* sub-driver description */
-static const struct sd_desc sd_desc = {
+static const struct sd_desc sd_desc_video = {
         .name      = MODULE_NAME,
-        .config    = sd_config,
+        .config    = sd_config_video,
         .init      = sd_init,
-        .start     = sd_start,
-        .stopN     = sd_stopN,
+        .start     = sd_start_video,
+        .stopN     = sd_stopN_video,
+        .pkt_scan  = sd_pkt_scan,
+        /*
+        .get_streamparm = sd_get_streamparm,
+        .set_streamparm = sd_set_streamparm,
+        */
+};
+static const struct sd_desc sd_desc_depth = {
+        .name      = MODULE_NAME,
+        .config    = sd_config_depth,
+        .init      = sd_init,
+        .start     = sd_start_depth,
+        .stopN     = sd_stopN_depth,
         .pkt_scan  = sd_pkt_scan,
         /*
         .get_streamparm = sd_get_streamparm,
@@ -391,8 +460,12 @@ MODULE_DEVICE_TABLE(usb, device_table);
 /* -- device connect -- */
 static int sd_probe(struct usb_interface *intf, const struct usb_device_id *id)
 {
-        return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
-                                THIS_MODULE);
+        if (depth_mode)
+                return gspca_dev_probe(intf, id, &sd_desc_depth,
+                                       sizeof(struct sd), THIS_MODULE);
+        else
+                return gspca_dev_probe(intf, id, &sd_desc_video,
+                                       sizeof(struct sd), THIS_MODULE);
 }
 
 static struct usb_driver sd_driver = {
@@ -408,3 +481,6 @@ static struct usb_driver sd_driver = {
 };
 
 module_usb_driver(sd_driver);
+
+module_param(depth_mode, bool, 0644);
+MODULE_PARM_DESC(depth_mode, "0=video 1=depth");
diff --git a/drivers/media/usb/gspca/pac7302.c b/drivers/media/usb/gspca/pac7302.c
index 339adce7c7a5..8b08bd0172f4 100644
--- a/drivers/media/usb/gspca/pac7302.c
+++ b/drivers/media/usb/gspca/pac7302.c
@@ -394,9 +394,9 @@ static void setbrightcont(struct gspca_dev *gspca_dev)
         reg_w(gspca_dev, 0xff, 0x00);           /* page 0 */
         for (i = 0; i < 10; i++) {
                 v = max[i];
-                v += (sd->brightness->val - sd->brightness->maximum)
-                        * 150 / sd->brightness->maximum; /* 200 ? */
-                v -= delta[i] * sd->contrast->val / sd->contrast->maximum;
+                v += (sd->brightness->val - (s32)sd->brightness->maximum)
+                        * 150 / (s32)sd->brightness->maximum; /* 200 ? */
+                v -= delta[i] * sd->contrast->val / (s32)sd->contrast->maximum;
                 if (v < 0)
                         v = 0;
                 else if (v > 0xff)
@@ -419,7 +419,7 @@ static void setcolors(struct gspca_dev *gspca_dev)
         reg_w(gspca_dev, 0x11, 0x01);
         reg_w(gspca_dev, 0xff, 0x00);                   /* page 0 */
         for (i = 0; i < 9; i++) {
-                v = a[i] * sd->saturation->val / sd->saturation->maximum;
+                v = a[i] * sd->saturation->val / (s32)sd->saturation->maximum;
                 v += b[i];
                 reg_w(gspca_dev, 0x0f + 2 * i, (v >> 8) & 0x07);
                 reg_w(gspca_dev, 0x0f + 2 * i + 1, v);
diff --git a/drivers/media/usb/gspca/sonixb.c b/drivers/media/usb/gspca/sonixb.c
index ecbcb39feb71..6696b2ec34e9 100644
--- a/drivers/media/usb/gspca/sonixb.c
+++ b/drivers/media/usb/gspca/sonixb.c
@@ -913,7 +913,7 @@ static void do_autogain(struct gspca_dev *gspca_dev)
                                 desired_avg_lum, deadzone))
                         sd->autogain_ignore_frames = AUTOGAIN_IGNORE_FRAMES;
         } else {
-                int gain_knee = gspca_dev->gain->maximum * 9 / 10;
+                int gain_knee = (s32)gspca_dev->gain->maximum * 9 / 10;
                 if (gspca_expo_autogain(gspca_dev, avg_lum, desired_avg_lum,
                                 deadzone, gain_knee, sd->exposure_knee))
                         sd->autogain_ignore_frames = AUTOGAIN_IGNORE_FRAMES;
diff --git a/drivers/media/usb/hdpvr/hdpvr-video.c b/drivers/media/usb/hdpvr/hdpvr-video.c
index 6bce01a674f9..59d15fd242ba 100644
--- a/drivers/media/usb/hdpvr/hdpvr-video.c
+++ b/drivers/media/usb/hdpvr/hdpvr-video.c
@@ -1022,14 +1022,13 @@ static int vidioc_g_fmt_vid_cap(struct file *file, void *_fh,
         f->fmt.pix.pixelformat  = V4L2_PIX_FMT_MPEG;
         f->fmt.pix.sizeimage    = dev->bulk_in_size;
         f->fmt.pix.bytesperline = 0;
-        f->fmt.pix.priv         = 0;
         if (f->fmt.pix.width == 720) {
                 /* SDTV formats */
                 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
                 f->fmt.pix.field = V4L2_FIELD_INTERLACED;
         } else {
                 /* HDTV formats */
-                f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE240M;
+                f->fmt.pix.colorspace = V4L2_COLORSPACE_REC709;
                 f->fmt.pix.field = V4L2_FIELD_NONE;
         }
         return 0;
@@ -1240,7 +1239,6 @@ int hdpvr_register_videodev(struct hdpvr_device *dev, struct device *parent,
         strcpy(dev->video_dev->name, "Hauppauge HD PVR");
         dev->video_dev->v4l2_dev = &dev->v4l2_dev;
         video_set_drvdata(dev->video_dev, dev);
-        set_bit(V4L2_FL_USE_FH_PRIO, &dev->video_dev->flags);
 
         res = video_register_device(dev->video_dev, VFL_TYPE_GRABBER, devnum);
         if (res < 0) {
diff --git a/drivers/media/usb/msi2500/Kconfig b/drivers/media/usb/msi2500/Kconfig
new file mode 100644
index 000000000000..9eff8a76ff0e
--- /dev/null
+++ b/drivers/media/usb/msi2500/Kconfig
@@ -0,0 +1,5 @@
+config USB_MSI2500
+        tristate "Mirics MSi2500"
+        depends on VIDEO_V4L2 && SPI
+        select VIDEOBUF2_VMALLOC
+        select MEDIA_TUNER_MSI001
diff --git a/drivers/media/usb/msi2500/Makefile b/drivers/media/usb/msi2500/Makefile
new file mode 100644
index 000000000000..b3bc2e53707f
--- /dev/null
+++ b/drivers/media/usb/msi2500/Makefile
@@ -0,0 +1 @@
+obj-$(CONFIG_USB_MSI2500)             += msi2500.o
diff --git a/drivers/media/usb/msi2500/msi2500.c b/drivers/media/usb/msi2500/msi2500.c
new file mode 100644
index 000000000000..26b133414032
--- /dev/null
+++ b/drivers/media/usb/msi2500/msi2500.c
@@ -0,0 +1,1336 @@
+/*
+ * Mirics MSi3101 SDR Dongle driver
+ *
+ * Copyright (C) 2013 Antti Palosaari <crope@iki.fi>
+ *
+ *    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.
+ *
+ * That driver is somehow based of pwc driver:
+ *  (C) 1999-2004 Nemosoft Unv.
+ *  (C) 2004-2006 Luc Saillard (luc@saillard.org)
+ *  (C) 2011 Hans de Goede <hdegoede@redhat.com>
+ */
+
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <asm/div64.h>
+#include <media/v4l2-device.h>
+#include <media/v4l2-ioctl.h>
+#include <media/v4l2-ctrls.h>
+#include <media/v4l2-event.h>
+#include <linux/usb.h>
+#include <media/videobuf2-vmalloc.h>
+#include <linux/spi/spi.h>
+
+static bool msi2500_emulated_fmt;
+module_param_named(emulated_formats, msi2500_emulated_fmt, bool, 0644);
+MODULE_PARM_DESC(emulated_formats, "enable emulated formats (disappears in future)");
+
+/*
+ *   iConfiguration          0
+ *     bInterfaceNumber        0
+ *     bAlternateSetting       1
+ *     bNumEndpoints           1
+ *       bEndpointAddress     0x81  EP 1 IN
+ *       bmAttributes            1
+ *         Transfer Type            Isochronous
+ *       wMaxPacketSize     0x1400  3x 1024 bytes
+ *       bInterval               1
+ */
+#define MAX_ISO_BUFS            (8)
+#define ISO_FRAMES_PER_DESC     (8)
+#define ISO_MAX_FRAME_SIZE      (3 * 1024)
+#define ISO_BUFFER_SIZE         (ISO_FRAMES_PER_DESC * ISO_MAX_FRAME_SIZE)
+#define MAX_ISOC_ERRORS         20
+
+/*
+ * TODO: These formats should be moved to V4L2 API. Formats are currently
+ * disabled from formats[] table, not visible to userspace.
+ */
+ /* signed 12-bit */
+#define MSI2500_PIX_FMT_SDR_S12         v4l2_fourcc('D', 'S', '1', '2')
+/* Mirics MSi2500 format 384 */
+#define MSI2500_PIX_FMT_SDR_MSI2500_384 v4l2_fourcc('M', '3', '8', '4')
+
+static const struct v4l2_frequency_band bands[] = {
+        {
+                .tuner = 0,
+                .type = V4L2_TUNER_ADC,
+                .index = 0,
+                .capability = V4L2_TUNER_CAP_1HZ | V4L2_TUNER_CAP_FREQ_BANDS,
+                .rangelow   =  1200000,
+                .rangehigh  = 15000000,
+        },
+};
+
+/* stream formats */
+struct msi2500_format {
+        char    *name;
+        u32     pixelformat;
+        u32     buffersize;
+};
+
+/* format descriptions for capture and preview */
+static struct msi2500_format formats[] = {
+        {
+                .name           = "Complex S8",
+                .pixelformat    = V4L2_SDR_FMT_CS8,
+                .buffersize     = 3 * 1008,
+#if 0
+        }, {
+                .name           = "10+2-bit signed",
+                .pixelformat    = MSI2500_PIX_FMT_SDR_MSI2500_384,
+        }, {
+                .name           = "12-bit signed",
+                .pixelformat    = MSI2500_PIX_FMT_SDR_S12,
+#endif
+        }, {
+                .name           = "Complex S14LE",
+                .pixelformat    = V4L2_SDR_FMT_CS14LE,
+                .buffersize     = 3 * 1008,
+        }, {
+                .name           = "Complex U8 (emulated)",
+                .pixelformat    = V4L2_SDR_FMT_CU8,
+                .buffersize     = 3 * 1008,
+        }, {
+                .name           = "Complex U16LE (emulated)",
+                .pixelformat    =  V4L2_SDR_FMT_CU16LE,
+                .buffersize     = 3 * 1008,
+        },
+};
+
+static const unsigned int NUM_FORMATS = ARRAY_SIZE(formats);
+
+/* intermediate buffers with raw data from the USB device */
+struct msi2500_frame_buf {
+        struct vb2_buffer vb;   /* common v4l buffer stuff -- must be first */
+        struct list_head list;
+};
+
+struct msi2500_state {
+        struct video_device vdev;
+        struct v4l2_device v4l2_dev;
+        struct v4l2_subdev *v4l2_subdev;
+        struct spi_master *master;
+
+        /* videobuf2 queue and queued buffers list */
+        struct vb2_queue vb_queue;
+        struct list_head queued_bufs;
+        spinlock_t queued_bufs_lock; /* Protects queued_bufs */
+
+        /* Note if taking both locks v4l2_lock must always be locked first! */
+        struct mutex v4l2_lock;      /* Protects everything else */
+        struct mutex vb_queue_lock;  /* Protects vb_queue and capt_file */
+
+        /* Pointer to our usb_device, will be NULL after unplug */
+        struct usb_device *udev; /* Both mutexes most be hold when setting! */
+
+        unsigned int f_adc;
+        u32 pixelformat;
+        u32 buffersize;
+        unsigned int num_formats;
+
+        unsigned int isoc_errors; /* number of contiguous ISOC errors */
+        unsigned int vb_full; /* vb is full and packets dropped */
+
+        struct urb *urbs[MAX_ISO_BUFS];
+
+        /* Controls */
+        struct v4l2_ctrl_handler hdl;
+
+        u32 next_sample; /* for track lost packets */
+        u32 sample; /* for sample rate calc */
+        unsigned long jiffies_next;
+        unsigned int sample_ctrl_bit[4];
+};
+
+/* Private functions */
+static struct msi2500_frame_buf *msi2500_get_next_fill_buf(
+                struct msi2500_state *s)
+{
+        unsigned long flags = 0;
+        struct msi2500_frame_buf *buf = NULL;
+
+        spin_lock_irqsave(&s->queued_bufs_lock, flags);
+        if (list_empty(&s->queued_bufs))
+                goto leave;
+
+        buf = list_entry(s->queued_bufs.next, struct msi2500_frame_buf, list);
+        list_del(&buf->list);
+leave:
+        spin_unlock_irqrestore(&s->queued_bufs_lock, flags);
+        return buf;
+}
+
+/*
+ * +===========================================================================
+ * |   00-1023 | USB packet type '504'
+ * +===========================================================================
+ * |   00-  03 | sequence number of first sample in that USB packet
+ * +---------------------------------------------------------------------------
+ * |   04-  15 | garbage
+ * +---------------------------------------------------------------------------
+ * |   16-1023 | samples
+ * +---------------------------------------------------------------------------
+ * signed 8-bit sample
+ * 504 * 2 = 1008 samples
+ *
+ *
+ * +===========================================================================
+ * |   00-1023 | USB packet type '384'
+ * +===========================================================================
+ * |   00-  03 | sequence number of first sample in that USB packet
+ * +---------------------------------------------------------------------------
+ * |   04-  15 | garbage
+ * +---------------------------------------------------------------------------
+ * |   16- 175 | samples
+ * +---------------------------------------------------------------------------
+ * |  176- 179 | control bits for previous samples
+ * +---------------------------------------------------------------------------
+ * |  180- 339 | samples
+ * +---------------------------------------------------------------------------
+ * |  340- 343 | control bits for previous samples
+ * +---------------------------------------------------------------------------
+ * |  344- 503 | samples
+ * +---------------------------------------------------------------------------
+ * |  504- 507 | control bits for previous samples
+ * +---------------------------------------------------------------------------
+ * |  508- 667 | samples
+ * +---------------------------------------------------------------------------
+ * |  668- 671 | control bits for previous samples
+ * +---------------------------------------------------------------------------
+ * |  672- 831 | samples
+ * +---------------------------------------------------------------------------
+ * |  832- 835 | control bits for previous samples
+ * +---------------------------------------------------------------------------
+ * |  836- 995 | samples
+ * +---------------------------------------------------------------------------
+ * |  996- 999 | control bits for previous samples
+ * +---------------------------------------------------------------------------
+ * | 1000-1023 | garbage
+ * +---------------------------------------------------------------------------
+ *
+ * Bytes 4 - 7 could have some meaning?
+ *
+ * Control bits for previous samples is 32-bit field, containing 16 x 2-bit
+ * numbers. This results one 2-bit number for 8 samples. It is likely used for
+ * for bit shifting sample by given bits, increasing actual sampling resolution.
+ * Number 2 (0b10) was never seen.
+ *
+ * 6 * 16 * 2 * 4 = 768 samples. 768 * 4 = 3072 bytes
+ *
+ *
+ * +===========================================================================
+ * |   00-1023 | USB packet type '336'
+ * +===========================================================================
+ * |   00-  03 | sequence number of first sample in that USB packet
+ * +---------------------------------------------------------------------------
+ * |   04-  15 | garbage
+ * +---------------------------------------------------------------------------
+ * |   16-1023 | samples
+ * +---------------------------------------------------------------------------
+ * signed 12-bit sample
+ *
+ *
+ * +===========================================================================
+ * |   00-1023 | USB packet type '252'
+ * +===========================================================================
+ * |   00-  03 | sequence number of first sample in that USB packet
+ * +---------------------------------------------------------------------------
+ * |   04-  15 | garbage
+ * +---------------------------------------------------------------------------
+ * |   16-1023 | samples
+ * +---------------------------------------------------------------------------
+ * signed 14-bit sample
+ */
+
+static int msi2500_convert_stream(struct msi2500_state *s, u8 *dst, u8 *src,
+                unsigned int src_len)
+{
+        unsigned int i, j, transactions, dst_len = 0;
+        u32 sample[3];
+
+        /* There could be 1-3 1024 byte transactions per packet */
+        transactions = src_len / 1024;
+
+        for (i = 0; i < transactions; i++) {
+                sample[i] = src[3] << 24 | src[2] << 16 | src[1] << 8 |
+                                src[0] << 0;
+                if (i == 0 && s->next_sample != sample[0]) {
+                        dev_dbg_ratelimited(&s->udev->dev,
+                                        "%d samples lost, %d %08x:%08x\n",
+                                        sample[0] - s->next_sample,
+                                        src_len, s->next_sample, sample[0]);
+                }
+
+                /*
+                 * Dump all unknown 'garbage' data - maybe we will discover
+                 * someday if there is something rational...
+                 */
+                dev_dbg_ratelimited(&s->udev->dev, "%*ph\n", 12, &src[4]);
+
+                src += 16; /* skip header */
+
+                switch (s->pixelformat) {
+                case V4L2_SDR_FMT_CU8: /* 504 x IQ samples */
+                {
+                        s8 *s8src = (s8 *) src;
+                        u8 *u8dst = (u8 *) dst;
+
+                        for (j = 0; j < 1008; j++)
+                                *u8dst++ = *s8src++ + 128;
+
+                        src += 1008;
+                        dst += 1008;
+                        dst_len += 1008;
+                        s->next_sample = sample[i] + 504;
+                        break;
+                }
+                case  V4L2_SDR_FMT_CU16LE: /* 252 x IQ samples */
+                {
+                        s16 *s16src = (s16 *) src;
+                        u16 *u16dst = (u16 *) dst;
+                        struct {signed int x:14; } se; /* sign extension */
+                        unsigned int utmp;
+
+                        for (j = 0; j < 1008; j += 2) {
+                                /* sign extension from 14-bit to signed int */
+                                se.x = *s16src++;
+                                /* from signed int to unsigned int */
+                                utmp = se.x + 8192;
+                                /* from 14-bit to 16-bit */
+                                *u16dst++ = utmp << 2 | utmp >> 12;
+                        }
+
+                        src += 1008;
+                        dst += 1008;
+                        dst_len += 1008;
+                        s->next_sample = sample[i] + 252;
+                        break;
+                }
+                case MSI2500_PIX_FMT_SDR_MSI2500_384: /* 384 x IQ samples */
+                        /* Dump unknown 'garbage' data */
+                        dev_dbg_ratelimited(&s->udev->dev,
+                                        "%*ph\n", 24, &src[1000]);
+                        memcpy(dst, src, 984);
+                        src += 984 + 24;
+                        dst += 984;
+                        dst_len += 984;
+                        s->next_sample = sample[i] + 384;
+                        break;
+                case V4L2_SDR_FMT_CS8:         /* 504 x IQ samples */
+                        memcpy(dst, src, 1008);
+                        src += 1008;
+                        dst += 1008;
+                        dst_len += 1008;
+                        s->next_sample = sample[i] + 504;
+                        break;
+                case MSI2500_PIX_FMT_SDR_S12:  /* 336 x IQ samples */
+                        memcpy(dst, src, 1008);
+                        src += 1008;
+                        dst += 1008;
+                        dst_len += 1008;
+                        s->next_sample = sample[i] + 336;
+                        break;
+                case V4L2_SDR_FMT_CS14LE:      /* 252 x IQ samples */
+                        memcpy(dst, src, 1008);
+                        src += 1008;
+                        dst += 1008;
+                        dst_len += 1008;
+                        s->next_sample = sample[i] + 252;
+                        break;
+                default:
+                        break;
+                }
+        }
+
+        /* calculate sample rate and output it in 10 seconds intervals */
+        if (unlikely(time_is_before_jiffies(s->jiffies_next))) {
+                #define MSECS 10000UL
+                unsigned int msecs = jiffies_to_msecs(jiffies -
+                                s->jiffies_next + msecs_to_jiffies(MSECS));
+                unsigned int samples = s->next_sample - s->sample;
+
+                s->jiffies_next = jiffies + msecs_to_jiffies(MSECS);
+                s->sample = s->next_sample;
+                dev_dbg(&s->udev->dev,
+                                "size=%u samples=%u msecs=%u sample rate=%lu\n",
+                                src_len, samples, msecs,
+                                samples * 1000UL / msecs);
+        }
+
+        return dst_len;
+}
+
+/*
+ * This gets called for the Isochronous pipe (stream). This is done in interrupt
+ * time, so it has to be fast, not crash, and not stall. Neat.
+ */
+static void msi2500_isoc_handler(struct urb *urb)
+{
+        struct msi2500_state *s = (struct msi2500_state *)urb->context;
+        int i, flen, fstatus;
+        unsigned char *iso_buf = NULL;
+        struct msi2500_frame_buf *fbuf;
+
+        if (unlikely(urb->status == -ENOENT || urb->status == -ECONNRESET ||
+                        urb->status == -ESHUTDOWN)) {
+                dev_dbg(&s->udev->dev, "URB (%p) unlinked %ssynchronuously\n",
+                                urb, urb->status == -ENOENT ? "" : "a");
+                return;
+        }
+
+        if (unlikely(urb->status != 0)) {
+                dev_dbg(&s->udev->dev,
+                                "msi2500_isoc_handler() called with status %d\n",
+                                urb->status);
+                /* Give up after a number of contiguous errors */
+                if (++s->isoc_errors > MAX_ISOC_ERRORS)
+                        dev_dbg(&s->udev->dev,
+                                        "Too many ISOC errors, bailing out\n");
+                goto handler_end;
+        } else {
+                /* Reset ISOC error counter. We did get here, after all. */
+                s->isoc_errors = 0;
+        }
+
+        /* Compact data */
+        for (i = 0; i < urb->number_of_packets; i++) {
+                void *ptr;
+
+                /* Check frame error */
+                fstatus = urb->iso_frame_desc[i].status;
+                if (unlikely(fstatus)) {
+                        dev_dbg_ratelimited(&s->udev->dev,
+                                        "frame=%d/%d has error %d skipping\n",
+                                        i, urb->number_of_packets, fstatus);
+                        continue;
+                }
+
+                /* Check if that frame contains data */
+                flen = urb->iso_frame_desc[i].actual_length;
+                if (unlikely(flen == 0))
+                        continue;
+
+                iso_buf = urb->transfer_buffer + urb->iso_frame_desc[i].offset;
+
+                /* Get free framebuffer */
+                fbuf = msi2500_get_next_fill_buf(s);
+                if (unlikely(fbuf == NULL)) {
+                        s->vb_full++;
+                        dev_dbg_ratelimited(&s->udev->dev,
+                                        "videobuf is full, %d packets dropped\n",
+                                        s->vb_full);
+                        continue;
+                }
+
+                /* fill framebuffer */
+                ptr = vb2_plane_vaddr(&fbuf->vb, 0);
+                flen = msi2500_convert_stream(s, ptr, iso_buf, flen);
+                vb2_set_plane_payload(&fbuf->vb, 0, flen);
+                vb2_buffer_done(&fbuf->vb, VB2_BUF_STATE_DONE);
+        }
+
+handler_end:
+        i = usb_submit_urb(urb, GFP_ATOMIC);
+        if (unlikely(i != 0))
+                dev_dbg(&s->udev->dev,
+                                "Error (%d) re-submitting urb in msi2500_isoc_handler\n",
+                                i);
+}
+
+static void msi2500_iso_stop(struct msi2500_state *s)
+{
+        int i;
+
+        dev_dbg(&s->udev->dev, "%s:\n", __func__);
+
+        /* Unlinking ISOC buffers one by one */
+        for (i = 0; i < MAX_ISO_BUFS; i++) {
+                if (s->urbs[i]) {
+                        dev_dbg(&s->udev->dev, "Unlinking URB %p\n",
+                                        s->urbs[i]);
+                        usb_kill_urb(s->urbs[i]);
+                }
+        }
+}
+
+static void msi2500_iso_free(struct msi2500_state *s)
+{
+        int i;
+
+        dev_dbg(&s->udev->dev, "%s:\n", __func__);
+
+        /* Freeing ISOC buffers one by one */
+        for (i = 0; i < MAX_ISO_BUFS; i++) {
+                if (s->urbs[i]) {
+                        dev_dbg(&s->udev->dev, "Freeing URB\n");
+                        if (s->urbs[i]->transfer_buffer) {
+                                usb_free_coherent(s->udev,
+                                        s->urbs[i]->transfer_buffer_length,
+                                        s->urbs[i]->transfer_buffer,
+                                        s->urbs[i]->transfer_dma);
+                        }
+                        usb_free_urb(s->urbs[i]);
+                        s->urbs[i] = NULL;
+                }
+        }
+}
+
+/* Both v4l2_lock and vb_queue_lock should be locked when calling this */
+static void msi2500_isoc_cleanup(struct msi2500_state *s)
+{
+        dev_dbg(&s->udev->dev, "%s:\n", __func__);
+
+        msi2500_iso_stop(s);
+        msi2500_iso_free(s);
+}
+
+/* Both v4l2_lock and vb_queue_lock should be locked when calling this */
+static int msi2500_isoc_init(struct msi2500_state *s)
+{
+        struct usb_device *udev;
+        struct urb *urb;
+        int i, j, ret;
+
+        dev_dbg(&s->udev->dev, "%s:\n", __func__);
+
+        s->isoc_errors = 0;
+        udev = s->udev;
+
+        ret = usb_set_interface(s->udev, 0, 1);
+        if (ret)
+                return ret;
+
+        /* Allocate and init Isochronuous urbs */
+        for (i = 0; i < MAX_ISO_BUFS; i++) {
+                urb = usb_alloc_urb(ISO_FRAMES_PER_DESC, GFP_KERNEL);
+                if (urb == NULL) {
+                        dev_err(&s->udev->dev,
+                                        "Failed to allocate urb %d\n", i);
+                        msi2500_isoc_cleanup(s);
+                        return -ENOMEM;
+                }
+                s->urbs[i] = urb;
+                dev_dbg(&s->udev->dev, "Allocated URB at 0x%p\n", urb);
+
+                urb->interval = 1;
+                urb->dev = udev;
+                urb->pipe = usb_rcvisocpipe(udev, 0x81);
+                urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
+                urb->transfer_buffer = usb_alloc_coherent(udev, ISO_BUFFER_SIZE,
+                                GFP_KERNEL, &urb->transfer_dma);
+                if (urb->transfer_buffer == NULL) {
+                        dev_err(&s->udev->dev,
+                                        "Failed to allocate urb buffer %d\n",
+                                        i);
+                        msi2500_isoc_cleanup(s);
+                        return -ENOMEM;
+                }
+                urb->transfer_buffer_length = ISO_BUFFER_SIZE;
+                urb->complete = msi2500_isoc_handler;
+                urb->context = s;
+                urb->start_frame = 0;
+                urb->number_of_packets = ISO_FRAMES_PER_DESC;
+                for (j = 0; j < ISO_FRAMES_PER_DESC; j++) {
+                        urb->iso_frame_desc[j].offset = j * ISO_MAX_FRAME_SIZE;
+                        urb->iso_frame_desc[j].length = ISO_MAX_FRAME_SIZE;
+                }
+        }
+
+        /* link */
+        for (i = 0; i < MAX_ISO_BUFS; i++) {
+                ret = usb_submit_urb(s->urbs[i], GFP_KERNEL);
+                if (ret) {
+                        dev_err(&s->udev->dev,
+                                        "isoc_init() submit_urb %d failed with error %d\n",
+                                        i, ret);
+                        msi2500_isoc_cleanup(s);
+                        return ret;
+                }
+                dev_dbg(&s->udev->dev, "URB 0x%p submitted.\n", s->urbs[i]);
+        }
+
+        /* All is done... */
+        return 0;
+}
+
+/* Must be called with vb_queue_lock hold */
+static void msi2500_cleanup_queued_bufs(struct msi2500_state *s)
+{
+        unsigned long flags = 0;
+
+        dev_dbg(&s->udev->dev, "%s:\n", __func__);
+
+        spin_lock_irqsave(&s->queued_bufs_lock, flags);
+        while (!list_empty(&s->queued_bufs)) {
+                struct msi2500_frame_buf *buf;
+
+                buf = list_entry(s->queued_bufs.next, struct msi2500_frame_buf,
+                                 list);
+                list_del(&buf->list);
+                vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
+        }
+        spin_unlock_irqrestore(&s->queued_bufs_lock, flags);
+}
+
+/* The user yanked out the cable... */
+static void msi2500_disconnect(struct usb_interface *intf)
+{
+        struct v4l2_device *v = usb_get_intfdata(intf);
+        struct msi2500_state *s =
+                        container_of(v, struct msi2500_state, v4l2_dev);
+
+        dev_dbg(&s->udev->dev, "%s:\n", __func__);
+
+        mutex_lock(&s->vb_queue_lock);
+        mutex_lock(&s->v4l2_lock);
+        /* No need to keep the urbs around after disconnection */
+        s->udev = NULL;
+        v4l2_device_disconnect(&s->v4l2_dev);
+        video_unregister_device(&s->vdev);
+        spi_unregister_master(s->master);
+        mutex_unlock(&s->v4l2_lock);
+        mutex_unlock(&s->vb_queue_lock);
+
+        v4l2_device_put(&s->v4l2_dev);
+}
+
+static int msi2500_querycap(struct file *file, void *fh,
+                struct v4l2_capability *cap)
+{
+        struct msi2500_state *s = video_drvdata(file);
+
+        dev_dbg(&s->udev->dev, "%s:\n", __func__);
+
+        strlcpy(cap->driver, KBUILD_MODNAME, sizeof(cap->driver));
+        strlcpy(cap->card, s->vdev.name, sizeof(cap->card));
+        usb_make_path(s->udev, cap->bus_info, sizeof(cap->bus_info));
+        cap->device_caps = V4L2_CAP_SDR_CAPTURE | V4L2_CAP_STREAMING |
+                        V4L2_CAP_READWRITE | V4L2_CAP_TUNER;
+        cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
+        return 0;
+}
+
+/* Videobuf2 operations */
+static int msi2500_queue_setup(struct vb2_queue *vq,
+                const struct v4l2_format *fmt, unsigned int *nbuffers,
+                unsigned int *nplanes, unsigned int sizes[], void *alloc_ctxs[])
+{
+        struct msi2500_state *s = vb2_get_drv_priv(vq);
+
+        dev_dbg(&s->udev->dev, "%s: *nbuffers=%d\n", __func__, *nbuffers);
+
+        /* Absolute min and max number of buffers available for mmap() */
+        *nbuffers = clamp_t(unsigned int, *nbuffers, 8, 32);
+        *nplanes = 1;
+        sizes[0] = PAGE_ALIGN(s->buffersize);
+        dev_dbg(&s->udev->dev, "%s: nbuffers=%d sizes[0]=%d\n",
+                        __func__, *nbuffers, sizes[0]);
+        return 0;
+}
+
+static void msi2500_buf_queue(struct vb2_buffer *vb)
+{
+        struct msi2500_state *s = vb2_get_drv_priv(vb->vb2_queue);
+        struct msi2500_frame_buf *buf =
+                        container_of(vb, struct msi2500_frame_buf, vb);
+        unsigned long flags = 0;
+
+        /* Check the device has not disconnected between prep and queuing */
+        if (unlikely(!s->udev)) {
+                vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
+                return;
+        }
+
+        spin_lock_irqsave(&s->queued_bufs_lock, flags);
+        list_add_tail(&buf->list, &s->queued_bufs);
+        spin_unlock_irqrestore(&s->queued_bufs_lock, flags);
+}
+
+#define CMD_WREG               0x41
+#define CMD_START_STREAMING    0x43
+#define CMD_STOP_STREAMING     0x45
+#define CMD_READ_UNKNOW        0x48
+
+#define msi2500_dbg_usb_control_msg(_udev, _r, _t, _v, _i, _b, _l) { \
+        char *_direction; \
+        if (_t & USB_DIR_IN) \
+                _direction = "<<<"; \
+        else \
+                _direction = ">>>"; \
+        dev_dbg(&_udev->dev, "%s: %02x %02x %02x %02x %02x %02x %02x %02x " \
+                        "%s %*ph\n",  __func__, _t, _r, _v & 0xff, _v >> 8, \
+                        _i & 0xff, _i >> 8, _l & 0xff, _l >> 8, _direction, \
+                        _l, _b); \
+}
+
+static int msi2500_ctrl_msg(struct msi2500_state *s, u8 cmd, u32 data)
+{
+        int ret;
+        u8 request = cmd;
+        u8 requesttype = USB_DIR_OUT | USB_TYPE_VENDOR;
+        u16 value = (data >> 0) & 0xffff;
+        u16 index = (data >> 16) & 0xffff;
+
+        msi2500_dbg_usb_control_msg(s->udev,
+                        request, requesttype, value, index, NULL, 0);
+
+        ret = usb_control_msg(s->udev, usb_sndctrlpipe(s->udev, 0),
+                        request, requesttype, value, index, NULL, 0, 2000);
+
+        if (ret)
+                dev_err(&s->udev->dev, "%s: failed %d, cmd %02x, data %04x\n",
+                                __func__, ret, cmd, data);
+
+        return ret;
+};
+
+#define F_REF 24000000
+#define DIV_R_IN 2
+static int msi2500_set_usb_adc(struct msi2500_state *s)
+{
+        int ret, div_n, div_m, div_r_out, f_sr, f_vco, fract;
+        u32 reg3, reg4, reg7;
+        struct v4l2_ctrl *bandwidth_auto;
+        struct v4l2_ctrl *bandwidth;
+
+        f_sr = s->f_adc;
+
+        /* set tuner, subdev, filters according to sampling rate */
+        bandwidth_auto = v4l2_ctrl_find(&s->hdl,
+                        V4L2_CID_RF_TUNER_BANDWIDTH_AUTO);
+        if (v4l2_ctrl_g_ctrl(bandwidth_auto)) {
+                bandwidth = v4l2_ctrl_find(&s->hdl,
+                                V4L2_CID_RF_TUNER_BANDWIDTH);
+                v4l2_ctrl_s_ctrl(bandwidth, s->f_adc);
+        }
+
+        /* select stream format */
+        switch (s->pixelformat) {
+        case V4L2_SDR_FMT_CU8:
+                reg7 = 0x000c9407; /* 504 */
+                break;
+        case  V4L2_SDR_FMT_CU16LE:
+                reg7 = 0x00009407; /* 252 */
+                break;
+        case V4L2_SDR_FMT_CS8:
+                reg7 = 0x000c9407; /* 504 */
+                break;
+        case MSI2500_PIX_FMT_SDR_MSI2500_384:
+                reg7 = 0x0000a507; /* 384 */
+                break;
+        case MSI2500_PIX_FMT_SDR_S12:
+                reg7 = 0x00008507; /* 336 */
+                break;
+        case V4L2_SDR_FMT_CS14LE:
+                reg7 = 0x00009407; /* 252 */
+                break;
+        default:
+                reg7 = 0x000c9407; /* 504 */
+                break;
+        }
+
+        /*
+         * Synthesizer config is just a educated guess...
+         *
+         * [7:0]   0x03, register address
+         * [8]     1, power control
+         * [9]     ?, power control
+         * [12:10] output divider
+         * [13]    0 ?
+         * [14]    0 ?
+         * [15]    fractional MSB, bit 20
+         * [16:19] N
+         * [23:20] ?
+         * [24:31] 0x01
+         *
+         * output divider
+         * val   div
+         *   0     - (invalid)
+         *   1     4
+         *   2     6
+         *   3     8
+         *   4    10
+         *   5    12
+         *   6    14
+         *   7    16
+         *
+         * VCO 202000000 - 720000000++
+         */
+        reg3 = 0x01000303;
+        reg4 = 0x00000004;
+
+        /* XXX: Filters? AGC? */
+        if (f_sr < 6000000)
+                reg3 |= 0x1 << 20;
+        else if (f_sr < 7000000)
+                reg3 |= 0x5 << 20;
+        else if (f_sr < 8500000)
+                reg3 |= 0x9 << 20;
+        else
+                reg3 |= 0xd << 20;
+
+        for (div_r_out = 4; div_r_out < 16; div_r_out += 2) {
+                f_vco = f_sr * div_r_out * 12;
+                dev_dbg(&s->udev->dev, "%s: div_r_out=%d f_vco=%d\n",
+                                __func__, div_r_out, f_vco);
+                if (f_vco >= 202000000)
+                        break;
+        }
+
+        div_n = f_vco / (F_REF * DIV_R_IN);
+        div_m = f_vco % (F_REF * DIV_R_IN);
+        fract = 0x200000ul * div_m / (F_REF * DIV_R_IN);
+
+        reg3 |= div_n << 16;
+        reg3 |= (div_r_out / 2 - 1) << 10;
+        reg3 |= ((fract >> 20) & 0x000001) << 15; /* [20] */
+        reg4 |= ((fract >>  0) & 0x0fffff) <<  8; /* [19:0] */
+
+        dev_dbg(&s->udev->dev,
+                        "%s: f_sr=%d f_vco=%d div_n=%d div_m=%d div_r_out=%d reg3=%08x reg4=%08x\n",
+                        __func__, f_sr, f_vco, div_n, div_m, div_r_out, reg3,
+                        reg4);
+
+        ret = msi2500_ctrl_msg(s, CMD_WREG, 0x00608008);
+        if (ret)
+                goto err;
+
+        ret = msi2500_ctrl_msg(s, CMD_WREG, 0x00000c05);
+        if (ret)
+                goto err;
+
+        ret = msi2500_ctrl_msg(s, CMD_WREG, 0x00020000);
+        if (ret)
+                goto err;
+
+        ret = msi2500_ctrl_msg(s, CMD_WREG, 0x00480102);
+        if (ret)
+                goto err;
+
+        ret = msi2500_ctrl_msg(s, CMD_WREG, 0x00f38008);
+        if (ret)
+                goto err;
+
+        ret = msi2500_ctrl_msg(s, CMD_WREG, reg7);
+        if (ret)
+                goto err;
+
+        ret = msi2500_ctrl_msg(s, CMD_WREG, reg4);
+        if (ret)
+                goto err;
+
+        ret = msi2500_ctrl_msg(s, CMD_WREG, reg3);
+        if (ret)
+                goto err;
+err:
+        return ret;
+};
+
+static int msi2500_start_streaming(struct vb2_queue *vq, unsigned int count)
+{
+        struct msi2500_state *s = vb2_get_drv_priv(vq);
+        int ret;
+
+        dev_dbg(&s->udev->dev, "%s:\n", __func__);
+
+        if (!s->udev)
+                return -ENODEV;
+
+        if (mutex_lock_interruptible(&s->v4l2_lock))
+                return -ERESTARTSYS;
+
+        /* wake-up tuner */
+        v4l2_subdev_call(s->v4l2_subdev, core, s_power, 1);
+
+        ret = msi2500_set_usb_adc(s);
+
+        ret = msi2500_isoc_init(s);
+        if (ret)
+                msi2500_cleanup_queued_bufs(s);
+
+        ret = msi2500_ctrl_msg(s, CMD_START_STREAMING, 0);
+
+        mutex_unlock(&s->v4l2_lock);
+
+        return ret;
+}
+
+static void msi2500_stop_streaming(struct vb2_queue *vq)
+{
+        struct msi2500_state *s = vb2_get_drv_priv(vq);
+
+        dev_dbg(&s->udev->dev, "%s:\n", __func__);
+
+        mutex_lock(&s->v4l2_lock);
+
+        if (s->udev)
+                msi2500_isoc_cleanup(s);
+
+        msi2500_cleanup_queued_bufs(s);
+
+        /* according to tests, at least 700us delay is required  */
+        msleep(20);
+        if (!msi2500_ctrl_msg(s, CMD_STOP_STREAMING, 0)) {
+                /* sleep USB IF / ADC */
+                msi2500_ctrl_msg(s, CMD_WREG, 0x01000003);
+        }
+
+        /* sleep tuner */
+        v4l2_subdev_call(s->v4l2_subdev, core, s_power, 0);
+
+        mutex_unlock(&s->v4l2_lock);
+}
+
+static struct vb2_ops msi2500_vb2_ops = {
+        .queue_setup            = msi2500_queue_setup,
+        .buf_queue              = msi2500_buf_queue,
+        .start_streaming        = msi2500_start_streaming,
+        .stop_streaming         = msi2500_stop_streaming,
+        .wait_prepare           = vb2_ops_wait_prepare,
+        .wait_finish            = vb2_ops_wait_finish,
+};
+
+static int msi2500_enum_fmt_sdr_cap(struct file *file, void *priv,
+                struct v4l2_fmtdesc *f)
+{
+        struct msi2500_state *s = video_drvdata(file);
+
+        dev_dbg(&s->udev->dev, "%s: index=%d\n", __func__, f->index);
+
+        if (f->index >= s->num_formats)
+                return -EINVAL;
+
+        strlcpy(f->description, formats[f->index].name, sizeof(f->description));
+        f->pixelformat = formats[f->index].pixelformat;
+
+        return 0;
+}
+
+static int msi2500_g_fmt_sdr_cap(struct file *file, void *priv,
+                struct v4l2_format *f)
+{
+        struct msi2500_state *s = video_drvdata(file);
+
+        dev_dbg(&s->udev->dev, "%s: pixelformat fourcc %4.4s\n", __func__,
+                        (char *)&s->pixelformat);
+
+        f->fmt.sdr.pixelformat = s->pixelformat;
+        f->fmt.sdr.buffersize = s->buffersize;
+        memset(f->fmt.sdr.reserved, 0, sizeof(f->fmt.sdr.reserved));
+
+        return 0;
+}
+
+static int msi2500_s_fmt_sdr_cap(struct file *file, void *priv,
+                struct v4l2_format *f)
+{
+        struct msi2500_state *s = video_drvdata(file);
+        struct vb2_queue *q = &s->vb_queue;
+        int i;
+
+        dev_dbg(&s->udev->dev, "%s: pixelformat fourcc %4.4s\n", __func__,
+                        (char *)&f->fmt.sdr.pixelformat);
+
+        if (vb2_is_busy(q))
+                return -EBUSY;
+
+        memset(f->fmt.sdr.reserved, 0, sizeof(f->fmt.sdr.reserved));
+        for (i = 0; i < s->num_formats; i++) {
+                if (formats[i].pixelformat == f->fmt.sdr.pixelformat) {
+                        s->pixelformat = formats[i].pixelformat;
+                        s->buffersize = formats[i].buffersize;
+                        f->fmt.sdr.buffersize = formats[i].buffersize;
+                        return 0;
+                }
+        }
+
+        s->pixelformat = formats[0].pixelformat;
+        s->buffersize = formats[0].buffersize;
+        f->fmt.sdr.pixelformat = formats[0].pixelformat;
+        f->fmt.sdr.buffersize = formats[0].buffersize;
+
+        return 0;
+}
+
+static int msi2500_try_fmt_sdr_cap(struct file *file, void *priv,
+                struct v4l2_format *f)
+{
+        struct msi2500_state *s = video_drvdata(file);
+        int i;
+
+        dev_dbg(&s->udev->dev, "%s: pixelformat fourcc %4.4s\n", __func__,
+                        (char *)&f->fmt.sdr.pixelformat);
+
+        memset(f->fmt.sdr.reserved, 0, sizeof(f->fmt.sdr.reserved));
+        for (i = 0; i < s->num_formats; i++) {
+                if (formats[i].pixelformat == f->fmt.sdr.pixelformat) {
+                        f->fmt.sdr.buffersize = formats[i].buffersize;
+                        return 0;
+                }
+        }
+
+        f->fmt.sdr.pixelformat = formats[0].pixelformat;
+        f->fmt.sdr.buffersize = formats[0].buffersize;
+
+        return 0;
+}
+
+static int msi2500_s_tuner(struct file *file, void *priv,
+                const struct v4l2_tuner *v)
+{
+        struct msi2500_state *s = video_drvdata(file);
+        int ret;
+
+        dev_dbg(&s->udev->dev, "%s: index=%d\n", __func__, v->index);
+
+        if (v->index == 0)
+                ret = 0;
+        else if (v->index == 1)
+                ret = v4l2_subdev_call(s->v4l2_subdev, tuner, s_tuner, v);
+        else
+                ret = -EINVAL;
+
+        return ret;
+}
+
+static int msi2500_g_tuner(struct file *file, void *priv, struct v4l2_tuner *v)
+{
+        struct msi2500_state *s = video_drvdata(file);
+        int ret;
+
+        dev_dbg(&s->udev->dev, "%s: index=%d\n", __func__, v->index);
+
+        if (v->index == 0) {
+                strlcpy(v->name, "Mirics MSi2500", sizeof(v->name));
+                v->type = V4L2_TUNER_ADC;
+                v->capability = V4L2_TUNER_CAP_1HZ | V4L2_TUNER_CAP_FREQ_BANDS;
+                v->rangelow =   1200000;
+                v->rangehigh = 15000000;
+                ret = 0;
+        } else if (v->index == 1) {
+                ret = v4l2_subdev_call(s->v4l2_subdev, tuner, g_tuner, v);
+        } else {
+                ret = -EINVAL;
+        }
+
+        return ret;
+}
+
+static int msi2500_g_frequency(struct file *file, void *priv,
+                struct v4l2_frequency *f)
+{
+        struct msi2500_state *s = video_drvdata(file);
+        int ret  = 0;
+
+        dev_dbg(&s->udev->dev, "%s: tuner=%d type=%d\n",
+                        __func__, f->tuner, f->type);
+
+        if (f->tuner == 0) {
+                f->frequency = s->f_adc;
+                ret = 0;
+        } else if (f->tuner == 1) {
+                f->type = V4L2_TUNER_RF;
+                ret = v4l2_subdev_call(s->v4l2_subdev, tuner, g_frequency, f);
+        } else {
+                ret = -EINVAL;
+        }
+
+        return ret;
+}
+
+static int msi2500_s_frequency(struct file *file, void *priv,
+                const struct v4l2_frequency *f)
+{
+        struct msi2500_state *s = video_drvdata(file);
+        int ret;
+
+        dev_dbg(&s->udev->dev, "%s: tuner=%d type=%d frequency=%u\n",
+                        __func__, f->tuner, f->type, f->frequency);
+
+        if (f->tuner == 0) {
+                s->f_adc = clamp_t(unsigned int, f->frequency,
+                                bands[0].rangelow,
+                                bands[0].rangehigh);
+                dev_dbg(&s->udev->dev, "%s: ADC frequency=%u Hz\n",
+                                __func__, s->f_adc);
+                ret = msi2500_set_usb_adc(s);
+        } else if (f->tuner == 1) {
+                ret = v4l2_subdev_call(s->v4l2_subdev, tuner, s_frequency, f);
+        } else {
+                ret = -EINVAL;
+        }
+
+        return ret;
+}
+
+static int msi2500_enum_freq_bands(struct file *file, void *priv,
+                struct v4l2_frequency_band *band)
+{
+        struct msi2500_state *s = video_drvdata(file);
+        int ret;
+
+        dev_dbg(&s->udev->dev, "%s: tuner=%d type=%d index=%d\n",
+                        __func__, band->tuner, band->type, band->index);
+
+        if (band->tuner == 0) {
+                if (band->index >= ARRAY_SIZE(bands)) {
+                        ret = -EINVAL;
+                } else {
+                        *band = bands[band->index];
+                        ret = 0;
+                }
+        } else if (band->tuner == 1) {
+                ret = v4l2_subdev_call(s->v4l2_subdev, tuner,
+                                enum_freq_bands, band);
+        } else {
+                ret = -EINVAL;
+        }
+
+        return ret;
+}
+
+static const struct v4l2_ioctl_ops msi2500_ioctl_ops = {
+        .vidioc_querycap          = msi2500_querycap,
+
+        .vidioc_enum_fmt_sdr_cap  = msi2500_enum_fmt_sdr_cap,
+        .vidioc_g_fmt_sdr_cap     = msi2500_g_fmt_sdr_cap,
+        .vidioc_s_fmt_sdr_cap     = msi2500_s_fmt_sdr_cap,
+        .vidioc_try_fmt_sdr_cap   = msi2500_try_fmt_sdr_cap,
+
+        .vidioc_reqbufs           = vb2_ioctl_reqbufs,
+        .vidioc_create_bufs       = vb2_ioctl_create_bufs,
+        .vidioc_prepare_buf       = vb2_ioctl_prepare_buf,
+        .vidioc_querybuf          = vb2_ioctl_querybuf,
+        .vidioc_qbuf              = vb2_ioctl_qbuf,
+        .vidioc_dqbuf             = vb2_ioctl_dqbuf,
+
+        .vidioc_streamon          = vb2_ioctl_streamon,
+        .vidioc_streamoff         = vb2_ioctl_streamoff,
+
+        .vidioc_g_tuner           = msi2500_g_tuner,
+        .vidioc_s_tuner           = msi2500_s_tuner,
+
+        .vidioc_g_frequency       = msi2500_g_frequency,
+        .vidioc_s_frequency       = msi2500_s_frequency,
+        .vidioc_enum_freq_bands   = msi2500_enum_freq_bands,
+
+        .vidioc_subscribe_event   = v4l2_ctrl_subscribe_event,
+        .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
+        .vidioc_log_status        = v4l2_ctrl_log_status,
+};
+
+static const struct v4l2_file_operations msi2500_fops = {
+        .owner                    = THIS_MODULE,
+        .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 struct video_device msi2500_template = {
+        .name                     = "Mirics MSi3101 SDR Dongle",
+        .release                  = video_device_release_empty,
+        .fops                     = &msi2500_fops,
+        .ioctl_ops                = &msi2500_ioctl_ops,
+};
+
+static void msi2500_video_release(struct v4l2_device *v)
+{
+        struct msi2500_state *s =
+                        container_of(v, struct msi2500_state, v4l2_dev);
+
+        v4l2_ctrl_handler_free(&s->hdl);
+        v4l2_device_unregister(&s->v4l2_dev);
+        kfree(s);
+}
+
+static int msi2500_transfer_one_message(struct spi_master *master,
+                struct spi_message *m)
+{
+        struct msi2500_state *s = spi_master_get_devdata(master);
+        struct spi_transfer *t;
+        int ret = 0;
+        u32 data;
+
+        list_for_each_entry(t, &m->transfers, transfer_list) {
+                dev_dbg(&s->udev->dev, "%s: msg=%*ph\n",
+                                __func__, t->len, t->tx_buf);
+                data = 0x09; /* reg 9 is SPI adapter */
+                data |= ((u8 *)t->tx_buf)[0] << 8;
+                data |= ((u8 *)t->tx_buf)[1] << 16;
+                data |= ((u8 *)t->tx_buf)[2] << 24;
+                ret = msi2500_ctrl_msg(s, CMD_WREG, data);
+        }
+
+        m->status = ret;
+        spi_finalize_current_message(master);
+        return ret;
+}
+
+static int msi2500_probe(struct usb_interface *intf,
+                const struct usb_device_id *id)
+{
+        struct usb_device *udev = interface_to_usbdev(intf);
+        struct msi2500_state *s = NULL;
+        struct v4l2_subdev *sd;
+        struct spi_master *master;
+        int ret;
+        static struct spi_board_info board_info = {
+                .modalias               = "msi001",
+                .bus_num                = 0,
+                .chip_select            = 0,
+                .max_speed_hz           = 12000000,
+        };
+
+        s = kzalloc(sizeof(struct msi2500_state), GFP_KERNEL);
+        if (s == NULL) {
+                pr_err("Could not allocate memory for msi2500_state\n");
+                return -ENOMEM;
+        }
+
+        mutex_init(&s->v4l2_lock);
+        mutex_init(&s->vb_queue_lock);
+        spin_lock_init(&s->queued_bufs_lock);
+        INIT_LIST_HEAD(&s->queued_bufs);
+        s->udev = udev;
+        s->f_adc = bands[0].rangelow;
+        s->pixelformat = formats[0].pixelformat;
+        s->buffersize = formats[0].buffersize;
+        s->num_formats = NUM_FORMATS;
+        if (msi2500_emulated_fmt == false)
+                s->num_formats -= 2;
+
+        /* Init videobuf2 queue structure */
+        s->vb_queue.type = V4L2_BUF_TYPE_SDR_CAPTURE;
+        s->vb_queue.io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ;
+        s->vb_queue.drv_priv = s;
+        s->vb_queue.buf_struct_size = sizeof(struct msi2500_frame_buf);
+        s->vb_queue.ops = &msi2500_vb2_ops;
+        s->vb_queue.mem_ops = &vb2_vmalloc_memops;
+        s->vb_queue.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
+        ret = vb2_queue_init(&s->vb_queue);
+        if (ret) {
+                dev_err(&s->udev->dev, "Could not initialize vb2 queue\n");
+                goto err_free_mem;
+        }
+
+        /* Init video_device structure */
+        s->vdev = msi2500_template;
+        s->vdev.queue = &s->vb_queue;
+        s->vdev.queue->lock = &s->vb_queue_lock;
+        video_set_drvdata(&s->vdev, s);
+
+        /* Register the v4l2_device structure */
+        s->v4l2_dev.release = msi2500_video_release;
+        ret = v4l2_device_register(&intf->dev, &s->v4l2_dev);
+        if (ret) {
+                dev_err(&s->udev->dev,
+                                "Failed to register v4l2-device (%d)\n", ret);
+                goto err_free_mem;
+        }
+
+        /* SPI master adapter */
+        master = spi_alloc_master(&s->udev->dev, 0);
+        if (master == NULL) {
+                ret = -ENOMEM;
+                goto err_unregister_v4l2_dev;
+        }
+
+        s->master = master;
+        master->bus_num = 0;
+        master->num_chipselect = 1;
+        master->transfer_one_message = msi2500_transfer_one_message;
+        spi_master_set_devdata(master, s);
+        ret = spi_register_master(master);
+        if (ret) {
+                spi_master_put(master);
+                goto err_unregister_v4l2_dev;
+        }
+
+        /* load v4l2 subdevice */
+        sd = v4l2_spi_new_subdev(&s->v4l2_dev, master, &board_info);
+        s->v4l2_subdev = sd;
+        if (sd == NULL) {
+                dev_err(&s->udev->dev, "cannot get v4l2 subdevice\n");
+                ret = -ENODEV;
+                goto err_unregister_master;
+        }
+
+        /* Register controls */
+        v4l2_ctrl_handler_init(&s->hdl, 0);
+        if (s->hdl.error) {
+                ret = s->hdl.error;
+                dev_err(&s->udev->dev, "Could not initialize controls\n");
+                goto err_free_controls;
+        }
+
+        /* currently all controls are from subdev */
+        v4l2_ctrl_add_handler(&s->hdl, sd->ctrl_handler, NULL);
+
+        s->v4l2_dev.ctrl_handler = &s->hdl;
+        s->vdev.v4l2_dev = &s->v4l2_dev;
+        s->vdev.lock = &s->v4l2_lock;
+
+        ret = video_register_device(&s->vdev, VFL_TYPE_SDR, -1);
+        if (ret) {
+                dev_err(&s->udev->dev,
+                                "Failed to register as video device (%d)\n",
+                                ret);
+                goto err_unregister_v4l2_dev;
+        }
+        dev_info(&s->udev->dev, "Registered as %s\n",
+                        video_device_node_name(&s->vdev));
+        dev_notice(&s->udev->dev,
+                        "%s: SDR API is still slightly experimental and functionality changes may follow\n",
+                        KBUILD_MODNAME);
+
+        return 0;
+
+err_free_controls:
+        v4l2_ctrl_handler_free(&s->hdl);
+err_unregister_master:
+        spi_unregister_master(s->master);
+err_unregister_v4l2_dev:
+        v4l2_device_unregister(&s->v4l2_dev);
+err_free_mem:
+        kfree(s);
+        return ret;
+}
+
+/* USB device ID list */
+static struct usb_device_id msi2500_id_table[] = {
+        { USB_DEVICE(0x1df7, 0x2500) }, /* Mirics MSi3101 SDR Dongle */
+        { USB_DEVICE(0x2040, 0xd300) }, /* Hauppauge WinTV 133559 LF */
+        { }
+};
+MODULE_DEVICE_TABLE(usb, msi2500_id_table);
+
+/* USB subsystem interface */
+static struct usb_driver msi2500_driver = {
+        .name                     = KBUILD_MODNAME,
+        .probe                    = msi2500_probe,
+        .disconnect               = msi2500_disconnect,
+        .id_table                 = msi2500_id_table,
+};
+
+module_usb_driver(msi2500_driver);
+
+MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
+MODULE_DESCRIPTION("Mirics MSi3101 SDR Dongle");
+MODULE_LICENSE("GPL");
diff --git a/drivers/media/usb/pvrusb2/pvrusb2-v4l2.c b/drivers/media/usb/pvrusb2/pvrusb2-v4l2.c
index 7c280f35eea9..1b158f1167ed 100644
--- a/drivers/media/usb/pvrusb2/pvrusb2-v4l2.c
+++ b/drivers/media/usb/pvrusb2/pvrusb2-v4l2.c
@@ -951,15 +951,9 @@ static long pvr2_v4l2_ioctl(struct file *file,
         if (ret < 0) {
                 if (pvrusb2_debug & PVR2_TRACE_V4LIOCTL) {
                         pvr2_trace(PVR2_TRACE_V4LIOCTL,
-                                   "pvr2_v4l2_do_ioctl failure, ret=%ld", ret);
-                } else {
-                        if (pvrusb2_debug & PVR2_TRACE_V4LIOCTL) {
-                                pvr2_trace(PVR2_TRACE_V4LIOCTL,
-                                           "pvr2_v4l2_do_ioctl failure, ret=%ld"
-                                           " command was:", ret);
-                                v4l_printk_ioctl(pvr2_hdw_get_driver_name(hdw),
-                                                cmd);
-                        }
+                                   "pvr2_v4l2_do_ioctl failure, ret=%ld"
+                                   " command was:", ret);
+                        v4l_printk_ioctl(pvr2_hdw_get_driver_name(hdw), cmd);
                 }
         } else {
                 pvr2_trace(PVR2_TRACE_V4LIOCTL,
diff --git a/drivers/media/usb/pwc/pwc-if.c b/drivers/media/usb/pwc/pwc-if.c
index a73b0bced96f..15b754da4a2c 100644
--- a/drivers/media/usb/pwc/pwc-if.c
+++ b/drivers/media/usb/pwc/pwc-if.c
@@ -1013,7 +1013,6 @@ static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id
         strcpy(pdev->vdev.name, name);
         pdev->vdev.queue = &pdev->vb_queue;
         pdev->vdev.queue->lock = &pdev->vb_queue_lock;
-        set_bit(V4L2_FL_USE_FH_PRIO, &pdev->vdev.flags);
         video_set_drvdata(&pdev->vdev, pdev);
 
         pdev->release = le16_to_cpu(udev->descriptor.bcdDevice);
diff --git a/drivers/media/usb/s2255/s2255drv.c b/drivers/media/usb/s2255/s2255drv.c
index a44466bc7b86..2c901861034a 100644
--- a/drivers/media/usb/s2255/s2255drv.c
+++ b/drivers/media/usb/s2255/s2255drv.c
@@ -1676,7 +1676,6 @@ static int s2255_probe_v4l(struct s2255_dev *dev)
                 vc->vdev.ctrl_handler = &vc->hdl;
                 vc->vdev.lock = &dev->lock;
                 vc->vdev.v4l2_dev = &dev->v4l2_dev;
-                set_bit(V4L2_FL_USE_FH_PRIO, &vc->vdev.flags);
                 video_set_drvdata(&vc->vdev, vc);
                 if (video_nr == -1)
                         ret = video_register_device(&vc->vdev,
diff --git a/drivers/media/usb/stk1160/stk1160-v4l.c b/drivers/media/usb/stk1160/stk1160-v4l.c
index 5461341a31cb..233054311a62 100644
--- a/drivers/media/usb/stk1160/stk1160-v4l.c
+++ b/drivers/media/usb/stk1160/stk1160-v4l.c
@@ -671,7 +671,6 @@ int stk1160_video_register(struct stk1160 *dev)
 
         /* This will be used to set video_device parent */
         dev->vdev.v4l2_dev = &dev->v4l2_dev;
-        set_bit(V4L2_FL_USE_FH_PRIO, &dev->vdev.flags);
 
         /* NTSC is default */
         dev->norm = V4L2_STD_NTSC_M;
diff --git a/drivers/media/usb/stkwebcam/stk-webcam.c b/drivers/media/usb/stkwebcam/stk-webcam.c
index be77482c3070..3588dc38db87 100644
--- a/drivers/media/usb/stkwebcam/stk-webcam.c
+++ b/drivers/media/usb/stkwebcam/stk-webcam.c
@@ -923,7 +923,6 @@ static int stk_vidioc_g_fmt_vid_cap(struct file *filp,
                 pix_format->bytesperline = 2 * pix_format->width;
         pix_format->sizeimage = pix_format->bytesperline
                                 * pix_format->height;
-        pix_format->priv = 0;
         return 0;
 }
 
@@ -967,7 +966,6 @@ static int stk_try_fmt_vid_cap(struct file *filp,
                 fmtd->fmt.pix.bytesperline = 2 * fmtd->fmt.pix.width;
         fmtd->fmt.pix.sizeimage = fmtd->fmt.pix.bytesperline
                 * fmtd->fmt.pix.height;
-        fmtd->fmt.pix.priv = 0;
         return 0;
 }
 
@@ -1266,7 +1264,6 @@ static int stk_register_video_device(struct stk_camera *dev)
         dev->vdev.lock = &dev->lock;
         dev->vdev.debug = debug;
         dev->vdev.v4l2_dev = &dev->v4l2_dev;
-        set_bit(V4L2_FL_USE_FH_PRIO, &dev->vdev.flags);
         video_set_drvdata(&dev->vdev, dev);
         err = video_register_device(&dev->vdev, VFL_TYPE_GRABBER, -1);
         if (err)
diff --git a/drivers/media/usb/tlg2300/pd-main.c b/drivers/media/usb/tlg2300/pd-main.c
index 3316caa4733b..b31f4791b8ff 100644
--- a/drivers/media/usb/tlg2300/pd-main.c
+++ b/drivers/media/usb/tlg2300/pd-main.c
@@ -476,6 +476,8 @@ err_audio:
 err_video:
         v4l2_device_unregister(&pd->v4l2_dev);
 err_v4l2:
+        usb_put_intf(pd->interface);
+        usb_put_dev(pd->udev);
         kfree(pd);
         return ret;
 }
diff --git a/drivers/media/usb/tlg2300/pd-radio.c b/drivers/media/usb/tlg2300/pd-radio.c
index ea6070ba835e..b391194a840c 100644
--- a/drivers/media/usb/tlg2300/pd-radio.c
+++ b/drivers/media/usb/tlg2300/pd-radio.c
@@ -327,7 +327,6 @@ int poseidon_fm_init(struct poseidon *p)
         }
         vfd->v4l2_dev = &p->v4l2_dev;
         vfd->ctrl_handler = hdl;
-        set_bit(V4L2_FL_USE_FH_PRIO, &vfd->flags);
         video_set_drvdata(vfd, p);
         return video_register_device(vfd, VFL_TYPE_RADIO, -1);
 }
diff --git a/drivers/media/usb/tlg2300/pd-video.c b/drivers/media/usb/tlg2300/pd-video.c
index 8df668d06552..8cd7f02fcf9f 100644
--- a/drivers/media/usb/tlg2300/pd-video.c
+++ b/drivers/media/usb/tlg2300/pd-video.c
@@ -1321,7 +1321,6 @@ static void init_video_context(struct running_context *context)
                                 .bytesperline   = 720 * 2,
                                 .sizeimage      = 720 * 576 * 2,
                                 .colorspace     = V4L2_COLORSPACE_SMPTE170M,
-                                .priv           = 0
                         };
 }
 
diff --git a/drivers/media/usb/tm6000/tm6000-input.c b/drivers/media/usb/tm6000/tm6000-input.c
index d1af5438c168..26b2ebb62547 100644
--- a/drivers/media/usb/tm6000/tm6000-input.c
+++ b/drivers/media/usb/tm6000/tm6000-input.c
@@ -162,11 +162,42 @@ static int tm6000_ir_config(struct tm6000_IR *ir)
         return 0;
 }
 
+static void tm6000_ir_keydown(struct tm6000_IR *ir,
+                              const char *buf, unsigned int len)
+{
+        u8 device, command;
+        u32 scancode;
+        enum rc_type protocol;
+
+        if (len < 1)
+                return;
+
+        command = buf[0];
+        device = (len > 1 ? buf[1] : 0x0);
+        switch (ir->rc_type) {
+        case RC_BIT_RC5:
+                protocol = RC_TYPE_RC5;
+                scancode = RC_SCANCODE_RC5(device, command);
+                break;
+        case RC_BIT_NEC:
+                protocol = RC_TYPE_NEC;
+                scancode = RC_SCANCODE_NEC(device, command);
+                break;
+        default:
+                protocol = RC_TYPE_OTHER;
+                scancode = RC_SCANCODE_OTHER(device << 8 | command);
+                break;
+        }
+
+        dprintk(1, "%s, protocol: 0x%04x, scancode: 0x%08x\n",
+                __func__, protocol, scancode);
+        rc_keydown(ir->rc, protocol, scancode, 0);
+}
+
 static void tm6000_ir_urb_received(struct urb *urb)
 {
         struct tm6000_core *dev = urb->context;
         struct tm6000_IR *ir = dev->ir;
-        struct tm6000_ir_poll_result poll_result;
         char *buf;
 
         dprintk(2, "%s\n",__func__);
@@ -184,12 +215,7 @@ static void tm6000_ir_urb_received(struct urb *urb)
                                DUMP_PREFIX_OFFSET,16, 1,
                                buf, urb->actual_length, false);
 
-        poll_result.rc_data = buf[0];
-        if (urb->actual_length > 1)
-                poll_result.rc_data |= buf[1] << 8;
-
-        dprintk(1, "%s, scancode: 0x%04x\n",__func__, poll_result.rc_data);
-        rc_keydown(ir->rc, poll_result.rc_data, 0);
+        tm6000_ir_keydown(ir, urb->transfer_buffer, urb->actual_length);
 
         usb_submit_urb(urb, GFP_ATOMIC);
         /*
@@ -204,7 +230,6 @@ static void tm6000_ir_handle_key(struct work_struct *work)
 {
         struct tm6000_IR *ir = container_of(work, struct tm6000_IR, work.work);
         struct tm6000_core *dev = ir->dev;
-        struct tm6000_ir_poll_result poll_result;
         int rc;
         u8 buf[2];
 
@@ -219,13 +244,8 @@ static void tm6000_ir_handle_key(struct work_struct *work)
         if (rc < 0)
                 return;
 
-        if (rc > 1)
-                poll_result.rc_data = buf[0] | buf[1] << 8;
-        else
-                poll_result.rc_data = buf[0];
-
         /* Check if something was read */
-        if ((poll_result.rc_data & 0xff) == 0xff) {
+        if ((buf[0] & 0xff) == 0xff) {
                 if (!ir->pwled) {
                         tm6000_flash_led(dev, 1);
                         ir->pwled = 1;
@@ -233,8 +253,7 @@ static void tm6000_ir_handle_key(struct work_struct *work)
                 return;
         }
 
-        dprintk(1, "%s, scancode: 0x%04x\n",__func__, poll_result.rc_data);
-        rc_keydown(ir->rc, poll_result.rc_data, 0);
+        tm6000_ir_keydown(ir, buf, rc);
         tm6000_flash_led(dev, 0);
         ir->pwled = 0;
 
@@ -422,9 +441,9 @@ int tm6000_ir_init(struct tm6000_core *dev)
         ir->rc = rc;
 
         /* input setup */
-        rc_set_allowed_protocols(rc, RC_BIT_RC5 | RC_BIT_NEC);
+        rc->allowed_protocols = RC_BIT_RC5 | RC_BIT_NEC;
         /* Neded, in order to support NEC remotes with 24 or 32 bits */
-        rc->scanmask = 0xffff;
+        rc->scancode_mask = 0xffff;
         rc->priv = ir;
         rc->change_protocol = tm6000_ir_change_protocol;
         if (dev->int_in.endp) {
diff --git a/drivers/media/usb/tm6000/tm6000-video.c b/drivers/media/usb/tm6000/tm6000-video.c
index e6b3d5d83d43..793577fc4633 100644
--- a/drivers/media/usb/tm6000/tm6000-video.c
+++ b/drivers/media/usb/tm6000/tm6000-video.c
@@ -918,7 +918,6 @@ static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
                 (f->fmt.pix.width * fh->fmt->depth) >> 3;
         f->fmt.pix.sizeimage =
                 f->fmt.pix.height * f->fmt.pix.bytesperline;
-        f->fmt.pix.priv = 0;
 
         return 0;
 }
@@ -959,7 +958,6 @@ static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
         f->fmt.pix.width &= ~0x01;
 
         f->fmt.pix.field = field;
-        f->fmt.pix.priv = 0;
 
         f->fmt.pix.bytesperline =
                 (f->fmt.pix.width * fmt->depth) >> 3;
@@ -1626,7 +1624,6 @@ static struct video_device *vdev_init(struct tm6000_core *dev,
         vfd->release = video_device_release;
         vfd->debug = tm6000_debug;
         vfd->lock = &dev->lock;
-        set_bit(V4L2_FL_USE_FH_PRIO, &vfd->flags);
 
         snprintf(vfd->name, sizeof(vfd->name), "%s %s", dev->name, type_name);
 
diff --git a/drivers/media/usb/ttusb-budget/dvb-ttusb-budget.c b/drivers/media/usb/ttusb-budget/dvb-ttusb-budget.c
index f8a60c197534..f166ffc9800a 100644
--- a/drivers/media/usb/ttusb-budget/dvb-ttusb-budget.c
+++ b/drivers/media/usb/ttusb-budget/dvb-ttusb-budget.c
@@ -791,8 +791,7 @@ static void ttusb_free_iso_urbs(struct ttusb *ttusb)
         int i;
 
         for (i = 0; i < ISO_BUF_COUNT; i++)
-                if (ttusb->iso_urb[i])
-                        usb_free_urb(ttusb->iso_urb[i]);
+                usb_free_urb(ttusb->iso_urb[i]);
 
         pci_free_consistent(NULL,
                             ISO_FRAME_SIZE * FRAMES_PER_ISO_BUF *
diff --git a/drivers/media/usb/usbtv/usbtv-core.c b/drivers/media/usb/usbtv/usbtv-core.c
index 2f87ddfa469f..473fab81b602 100644
--- a/drivers/media/usb/usbtv/usbtv-core.c
+++ b/drivers/media/usb/usbtv/usbtv-core.c
@@ -91,6 +91,8 @@ static int usbtv_probe(struct usb_interface *intf,
         return 0;
 
 usbtv_video_fail:
+        usb_set_intfdata(intf, NULL);
+        usb_put_dev(usbtv->udev);
         kfree(usbtv);
 
         return ret;
diff --git a/drivers/media/usb/usbtv/usbtv-video.c b/drivers/media/usb/usbtv/usbtv-video.c
index 2967e808408b..030c5854b4b3 100644
--- a/drivers/media/usb/usbtv/usbtv-video.c
+++ b/drivers/media/usb/usbtv/usbtv-video.c
@@ -701,7 +701,6 @@ int usbtv_video_init(struct usbtv *usbtv)
         usbtv->vdev.tvnorms = USBTV_TV_STD;
         usbtv->vdev.queue = &usbtv->vb2q;
         usbtv->vdev.lock = &usbtv->v4l2_lock;
-        set_bit(V4L2_FL_USE_FH_PRIO, &usbtv->vdev.flags);
         video_set_drvdata(&usbtv->vdev, usbtv);
         ret = video_register_device(&usbtv->vdev, VFL_TYPE_GRABBER, -1);
         if (ret < 0) {
diff --git a/drivers/media/usb/usbvision/usbvision-core.c b/drivers/media/usb/usbvision/usbvision-core.c
index 816b1cffab7d..302aa07c458f 100644
--- a/drivers/media/usb/usbvision/usbvision-core.c
+++ b/drivers/media/usb/usbvision/usbvision-core.c
@@ -1463,8 +1463,6 @@ static int usbvision_write_reg_irq(struct usb_usbvision *usbvision, int address,
 
 static int usbvision_init_compression(struct usb_usbvision *usbvision)
 {
-        int err_code = 0;
-
         usbvision->last_isoc_frame_num = -1;
         usbvision->isoc_data_count = 0;
         usbvision->isoc_packet_count = 0;
@@ -1475,7 +1473,7 @@ static int usbvision_init_compression(struct usb_usbvision *usbvision)
         usbvision->request_intra = 1;
         usbvision->isoc_measure_bandwidth_count = 0;
 
-        return err_code;
+        return 0;
 }
 
 /* this function measures the used bandwidth since last call
@@ -1484,11 +1482,9 @@ static int usbvision_init_compression(struct usb_usbvision *usbvision)
  */
 static int usbvision_measure_bandwidth(struct usb_usbvision *usbvision)
 {
-        int err_code = 0;
-
         if (usbvision->isoc_measure_bandwidth_count < 2) { /* this gives an average bandwidth of 3 frames */
                 usbvision->isoc_measure_bandwidth_count++;
-                return err_code;
+                return 0;
         }
         if ((usbvision->isoc_packet_size > 0) && (usbvision->isoc_packet_count > 0)) {
                 usbvision->used_bandwidth = usbvision->isoc_data_count /
@@ -1499,7 +1495,7 @@ static int usbvision_measure_bandwidth(struct usb_usbvision *usbvision)
         usbvision->isoc_data_count = 0;
         usbvision->isoc_packet_count = 0;
         usbvision->isoc_skip_count = 0;
-        return err_code;
+        return 0;
 }
 
 static int usbvision_adjust_compression(struct usb_usbvision *usbvision)
@@ -1546,26 +1542,24 @@ static int usbvision_adjust_compression(struct usb_usbvision *usbvision)
 
 static int usbvision_request_intra(struct usb_usbvision *usbvision)
 {
-        int err_code = 0;
         unsigned char buffer[1];
 
         PDEBUG(DBG_IRQ, "");
         usbvision->request_intra = 1;
         buffer[0] = 1;
         usbvision_write_reg_irq(usbvision, USBVISION_FORCE_INTRA, buffer, 1);
-        return err_code;
+        return 0;
 }
 
 static int usbvision_unrequest_intra(struct usb_usbvision *usbvision)
 {
-        int err_code = 0;
         unsigned char buffer[1];
 
         PDEBUG(DBG_IRQ, "");
         usbvision->request_intra = 0;
         buffer[0] = 0;
         usbvision_write_reg_irq(usbvision, USBVISION_FORCE_INTRA, buffer, 1);
-        return err_code;
+        return 0;
 }
 
 /*******************************
diff --git a/drivers/media/usb/uvc/uvc_driver.c b/drivers/media/usb/uvc/uvc_driver.c
index ad47c5cb539a..f8135f4e3b52 100644
--- a/drivers/media/usb/uvc/uvc_driver.c
+++ b/drivers/media/usb/uvc/uvc_driver.c
@@ -1746,7 +1746,6 @@ static int uvc_register_video(struct uvc_device *dev,
         vdev->fops = &uvc_fops;
         vdev->release = uvc_release;
         vdev->prio = &stream->chain->prio;
-        set_bit(V4L2_FL_USE_FH_PRIO, &vdev->flags);
         if (stream->type == V4L2_BUF_TYPE_VIDEO_OUTPUT)
                 vdev->vfl_dir = VFL_DIR_TX;
         strlcpy(vdev->name, dev->name, sizeof vdev->name);
diff --git a/drivers/media/usb/zr364xx/zr364xx.c b/drivers/media/usb/zr364xx/zr364xx.c
index 74d56df3347f..5c006277b8b1 100644
--- a/drivers/media/usb/zr364xx/zr364xx.c
+++ b/drivers/media/usb/zr364xx/zr364xx.c
@@ -806,7 +806,6 @@ static int zr364xx_vidioc_try_fmt_vid_cap(struct file *file, void *priv,
         f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
         f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
         f->fmt.pix.colorspace = V4L2_COLORSPACE_JPEG;
-        f->fmt.pix.priv = 0;
         DBG("%s: V4L2_PIX_FMT_%s (%d) ok!\n", __func__,
             decode_fourcc(f->fmt.pix.pixelformat, pixelformat_name),
             f->fmt.pix.field);
@@ -829,7 +828,6 @@ static int zr364xx_vidioc_g_fmt_vid_cap(struct file *file, void *priv,
         f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
         f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
         f->fmt.pix.colorspace = V4L2_COLORSPACE_JPEG;
-        f->fmt.pix.priv = 0;
         return 0;
 }
 
@@ -866,7 +864,6 @@ static int zr364xx_vidioc_s_fmt_vid_cap(struct file *file, void *priv,
         f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
         f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
         f->fmt.pix.colorspace = V4L2_COLORSPACE_JPEG;
-        f->fmt.pix.priv = 0;
         cam->vb_vidq.field = f->fmt.pix.field;
 
         if (f->fmt.pix.width == 160 && f->fmt.pix.height == 120)
@@ -1456,7 +1453,6 @@ static int zr364xx_probe(struct usb_interface *intf,
         cam->vdev.lock = &cam->lock;
         cam->vdev.v4l2_dev = &cam->v4l2_dev;
         cam->vdev.ctrl_handler = &cam->ctrl_handler;
-        set_bit(V4L2_FL_USE_FH_PRIO, &cam->vdev.flags);
         video_set_drvdata(&cam->vdev, cam);
         if (debug)
                 cam->vdev.debug = V4L2_DEBUG_IOCTL | V4L2_DEBUG_IOCTL_ARG;