174 files changed, 17982 insertions, 3386 deletions

diff --git a/drivers/media/video/Kconfig b/drivers/media/video/Kconfig
index 2f83be766d9f..f8fc8654693d 100644
--- a/drivers/media/video/Kconfig
+++ b/drivers/media/video/Kconfig
@@ -388,6 +388,15 @@ config VIDEO_TVP5150
           To compile this driver as a module, choose M here: the
           module will be called tvp5150.
 
+config VIDEO_TVP7002
+        tristate "Texas Instruments TVP7002 video decoder"
+        depends on VIDEO_V4L2 && I2C
+        ---help---
+          Support for the Texas Instruments TVP7002 video decoder.
+
+          To compile this driver as a module, choose M here: the
+          module will be called tvp7002.
+
 config VIDEO_VPX3220
         tristate "vpx3220a, vpx3216b & vpx3214c video decoders"
         depends on VIDEO_V4L2 && I2C
@@ -548,7 +557,6 @@ config VIDEO_VPSS_SYSTEM
         depends on ARCH_DAVINCI
         help
           Support for vpss system module for video driver
-        default y
 
 config VIDEO_VPFE_CAPTURE
         tristate "VPFE Video Capture Driver"
@@ -592,6 +600,19 @@ config VIDEO_DM355_CCDC
            To compile this driver as a module, choose M here: the
            module will be called vpfe.
 
+config VIDEO_ISIF
+        tristate "ISIF HW module"
+        depends on ARCH_DAVINCI_DM365 && VIDEO_VPFE_CAPTURE
+        select VIDEO_VPSS_SYSTEM
+        default y
+        help
+           Enables ISIF hw module. This is the hardware module for
+           configuring ISIF in VPFE to capture Raw Bayer RGB data  from
+           a image sensor or YUV data from a YUV source.
+
+           To compile this driver as a module, choose M here: the
+           module will be called vpfe.
+
 source "drivers/media/video/bt8xx/Kconfig"
 
 config VIDEO_PMS
@@ -638,9 +659,14 @@ config VIDEO_W9966
           information.
 
 config VIDEO_CPIA
-        tristate "CPiA Video For Linux"
+        tristate "CPiA Video For Linux (DEPRECATED)"
         depends on VIDEO_V4L1
+        default n
         ---help---
+          This driver is DEPRECATED please use the gspca cpia1 module
+          instead. Note that you need atleast version 0.6.4 of libv4l for
+          the cpia1 gspca module.
+
           This is the video4linux driver for cameras based on Vision's CPiA
           (Colour Processor Interface ASIC), such as the Creative Labs Video
           Blaster Webcam II. If you have one of these cameras, say Y here
@@ -944,6 +970,8 @@ source "drivers/media/video/hdpvr/Kconfig"
 
 source "drivers/media/video/em28xx/Kconfig"
 
+source "drivers/media/video/tlg2300/Kconfig"
+
 source "drivers/media/video/cx231xx/Kconfig"
 
 source "drivers/media/video/usbvision/Kconfig"
@@ -955,6 +983,7 @@ source "drivers/media/video/et61x251/Kconfig"
 config VIDEO_OVCAMCHIP
         tristate "OmniVision Camera Chip support (DEPRECATED)"
         depends on I2C && VIDEO_V4L1
+        default n
         ---help---
           This driver is DEPRECATED please use the gspca ov519 module
           instead. Note that for the ov511 / ov518 support of the gspca module
@@ -971,6 +1000,7 @@ config VIDEO_OVCAMCHIP
 config USB_W9968CF
         tristate "USB W996[87]CF JPEG Dual Mode Camera support (DEPRECATED)"
         depends on VIDEO_V4L1 && I2C && VIDEO_OVCAMCHIP
+        default n
         ---help---
           This driver is DEPRECATED please use the gspca ov519 module
           instead. Note that for the w9968cf support of the gspca module
@@ -992,6 +1022,7 @@ config USB_W9968CF
 config USB_OV511
         tristate "USB OV511 Camera support (DEPRECATED)"
         depends on VIDEO_V4L1
+        default n
         ---help---
           This driver is DEPRECATED please use the gspca ov519 module
           instead. Note that for the ov511 / ov518 support of the gspca module
@@ -1020,6 +1051,7 @@ source "drivers/media/video/sn9c102/Kconfig"
 config USB_STV680
         tristate "USB STV680 (Pencam) Camera support (DEPRECATED)"
         depends on VIDEO_V4L1
+        default n
         ---help---
           This driver is DEPRECATED please use the gspca stv0680 module
           instead. Note that for the gspca stv0680 module you need
diff --git a/drivers/media/video/Makefile b/drivers/media/video/Makefile
index 2af68ee84122..b88b6174a331 100644
--- a/drivers/media/video/Makefile
+++ b/drivers/media/video/Makefile
@@ -56,6 +56,7 @@ obj-$(CONFIG_VIDEO_THS7303) += ths7303.o
 obj-$(CONFIG_VIDEO_VINO) += indycam.o
 obj-$(CONFIG_VIDEO_TVP5150) += tvp5150.o
 obj-$(CONFIG_VIDEO_TVP514X) += tvp514x.o
+obj-$(CONFIG_VIDEO_TVP7002) += tvp7002.o
 obj-$(CONFIG_VIDEO_MSP3400) += msp3400.o
 obj-$(CONFIG_VIDEO_CS5345) += cs5345.o
 obj-$(CONFIG_VIDEO_CS53L32A) += cs53l32a.o
@@ -99,6 +100,7 @@ obj-$(CONFIG_VIDEO_MEYE) += meye.o
 obj-$(CONFIG_VIDEO_SAA7134) += saa7134/
 obj-$(CONFIG_VIDEO_CX88) += cx88/
 obj-$(CONFIG_VIDEO_EM28XX) += em28xx/
+obj-$(CONFIG_VIDEO_TLG2300) += tlg2300/
 obj-$(CONFIG_VIDEO_CX231XX) += cx231xx/
 obj-$(CONFIG_VIDEO_USBVISION) += usbvision/
 obj-$(CONFIG_VIDEO_PVRUSB2) += pvrusb2/
diff --git a/drivers/media/video/bt819.c b/drivers/media/video/bt819.c
index 5bb0f9e71583..547e1a93c421 100644
--- a/drivers/media/video/bt819.c
+++ b/drivers/media/video/bt819.c
@@ -254,7 +254,7 @@ static int bt819_s_std(struct v4l2_subdev *sd, v4l2_std_id std)
                 v4l2_err(sd, "no notify found!\n");
 
         if (std & V4L2_STD_NTSC) {
-                v4l2_subdev_notify(sd, BT819_FIFO_RESET_LOW, 0);
+                v4l2_subdev_notify(sd, BT819_FIFO_RESET_LOW, NULL);
                 bt819_setbit(decoder, 0x01, 0, 1);
                 bt819_setbit(decoder, 0x01, 1, 0);
                 bt819_setbit(decoder, 0x01, 5, 0);
@@ -263,7 +263,7 @@ static int bt819_s_std(struct v4l2_subdev *sd, v4l2_std_id std)
                 /* bt819_setbit(decoder, 0x1a,  5, 1); */
                 timing = &timing_data[1];
         } else if (std & V4L2_STD_PAL) {
-                v4l2_subdev_notify(sd, BT819_FIFO_RESET_LOW, 0);
+                v4l2_subdev_notify(sd, BT819_FIFO_RESET_LOW, NULL);
                 bt819_setbit(decoder, 0x01, 0, 1);
                 bt819_setbit(decoder, 0x01, 1, 1);
                 bt819_setbit(decoder, 0x01, 5, 1);
@@ -288,7 +288,7 @@ static int bt819_s_std(struct v4l2_subdev *sd, v4l2_std_id std)
         bt819_write(decoder, 0x08, (timing->hscale >> 8) & 0xff);
         bt819_write(decoder, 0x09, timing->hscale & 0xff);
         decoder->norm = std;
-        v4l2_subdev_notify(sd, BT819_FIFO_RESET_HIGH, 0);
+        v4l2_subdev_notify(sd, BT819_FIFO_RESET_HIGH, NULL);
         return 0;
 }
 
@@ -306,7 +306,7 @@ static int bt819_s_routing(struct v4l2_subdev *sd,
                 v4l2_err(sd, "no notify found!\n");
 
         if (decoder->input != input) {
-                v4l2_subdev_notify(sd, BT819_FIFO_RESET_LOW, 0);
+                v4l2_subdev_notify(sd, BT819_FIFO_RESET_LOW, NULL);
                 decoder->input = input;
                 /* select mode */
                 if (decoder->input == 0) {
@@ -316,7 +316,7 @@ static int bt819_s_routing(struct v4l2_subdev *sd,
                         bt819_setbit(decoder, 0x0b, 6, 1);
                         bt819_setbit(decoder, 0x1a, 1, 0);
                 }
-                v4l2_subdev_notify(sd, BT819_FIFO_RESET_HIGH, 0);
+                v4l2_subdev_notify(sd, BT819_FIFO_RESET_HIGH, NULL);
         }
         return 0;
 }
diff --git a/drivers/media/video/bt8xx/bttv-driver.c b/drivers/media/video/bt8xx/bttv-driver.c
index 3182a406bdd1..cb46e8fa8aaa 100644
--- a/drivers/media/video/bt8xx/bttv-driver.c
+++ b/drivers/media/video/bt8xx/bttv-driver.c
@@ -81,6 +81,7 @@ static int video_nr[BTTV_MAX] = { [0 ... (BTTV_MAX-1)] = -1 };
 static int radio_nr[BTTV_MAX] = { [0 ... (BTTV_MAX-1)] = -1 };
 static int vbi_nr[BTTV_MAX] = { [0 ... (BTTV_MAX-1)] = -1 };
 static int debug_latency;
+static int disable_ir;
 
 static unsigned int fdsr;
 
@@ -107,6 +108,7 @@ module_param(bttv_gpio,         int, 0644);
 module_param(bttv_debug,        int, 0644);
 module_param(irq_debug,         int, 0644);
 module_param(debug_latency,     int, 0644);
+module_param(disable_ir,        int, 0444);
 
 module_param(fdsr,              int, 0444);
 module_param(gbuffers,          int, 0444);
@@ -139,6 +141,7 @@ MODULE_PARM_DESC(bttv_verbose,"verbose startup messages, default is 1 (yes)");
 MODULE_PARM_DESC(bttv_gpio,"log gpio changes, default is 0 (no)");
 MODULE_PARM_DESC(bttv_debug,"debug messages, default is 0 (no)");
 MODULE_PARM_DESC(irq_debug,"irq handler debug messages, default is 0 (no)");
+MODULE_PARM_DESC(disable_ir, "disable infrared remote support");
 MODULE_PARM_DESC(gbuffers,"number of capture buffers. range 2-32, default 8");
 MODULE_PARM_DESC(gbufsize,"size of the capture buffers, default is 0x208000");
 MODULE_PARM_DESC(reset_crop,"reset cropping parameters at open(), default "
@@ -4461,7 +4464,10 @@ static int __devinit bttv_probe(struct pci_dev *dev,
                 request_modules(btv);
         }
 
-        bttv_input_init(btv);
+        if (!disable_ir) {
+                init_bttv_i2c_ir(btv);
+                bttv_input_init(btv);
+        }
 
         /* everything is fine */
         bttv_num++;
diff --git a/drivers/media/video/bt8xx/bttv-i2c.c b/drivers/media/video/bt8xx/bttv-i2c.c
index 63aa31a041e8..407fa61e4cda 100644
--- a/drivers/media/video/bt8xx/bttv-i2c.c
+++ b/drivers/media/video/bt8xx/bttv-i2c.c
@@ -388,7 +388,12 @@ int __devinit init_bttv_i2c(struct bttv *btv)
         if (0 == btv->i2c_rc && i2c_scan)
                 do_i2c_scan(btv->c.v4l2_dev.name, &btv->i2c_client);
 
-        /* Instantiate the IR receiver device, if present */
+        return btv->i2c_rc;
+}
+
+/* Instantiate the I2C IR receiver device, if present */
+void __devinit init_bttv_i2c_ir(struct bttv *btv)
+{
         if (0 == btv->i2c_rc) {
                 struct i2c_board_info info;
                 /* The external IR receiver is at i2c address 0x34 (0x35 for
@@ -408,7 +413,6 @@ int __devinit init_bttv_i2c(struct bttv *btv)
                 strlcpy(info.type, "ir_video", I2C_NAME_SIZE);
                 i2c_new_probed_device(&btv->c.i2c_adap, &info, addr_list);
         }
-        return btv->i2c_rc;
 }
 
 int __devexit fini_bttv_i2c(struct bttv *btv)
diff --git a/drivers/media/video/bt8xx/bttv-input.c b/drivers/media/video/bt8xx/bttv-input.c
index 277a092e1214..b320dbd635aa 100644
--- a/drivers/media/video/bt8xx/bttv-input.c
+++ b/drivers/media/video/bt8xx/bttv-input.c
@@ -247,7 +247,7 @@ int bttv_input_init(struct bttv *btv)
         struct card_ir *ir;
         struct ir_scancode_table *ir_codes = NULL;
         struct input_dev *input_dev;
-        int ir_type = IR_TYPE_OTHER;
+        u64 ir_type = IR_TYPE_OTHER;
         int err = -ENOMEM;
 
         if (!btv->has_remote)
@@ -389,7 +389,7 @@ int bttv_input_init(struct bttv *btv)
         bttv_ir_start(btv, ir);
 
         /* all done */
-        err = ir_input_register(btv->remote->dev, ir_codes);
+        err = ir_input_register(btv->remote->dev, ir_codes, NULL);
         if (err)
                 goto err_out_stop;
 
diff --git a/drivers/media/video/bt8xx/bttvp.h b/drivers/media/video/bt8xx/bttvp.h
index a1d0e9c9f286..6cccc2a17eee 100644
--- a/drivers/media/video/bt8xx/bttvp.h
+++ b/drivers/media/video/bt8xx/bttvp.h
@@ -279,6 +279,7 @@ extern unsigned int bttv_debug;
 extern unsigned int bttv_gpio;
 extern void bttv_gpio_tracking(struct bttv *btv, char *comment);
 extern int init_bttv_i2c(struct bttv *btv);
+extern void init_bttv_i2c_ir(struct bttv *btv);
 extern int fini_bttv_i2c(struct bttv *btv);
 
 #define bttv_printk if (bttv_verbose) printk
diff --git a/drivers/media/video/cafe_ccic.c b/drivers/media/video/cafe_ccic.c
index 7bb9c1ec7819..cbbf7e80d2cf 100644
--- a/drivers/media/video/cafe_ccic.c
+++ b/drivers/media/video/cafe_ccic.c
@@ -1907,7 +1907,6 @@ static int cafe_pci_probe(struct pci_dev *pdev,
                 goto out_free;
 
         mutex_init(&cam->s_mutex);
-        mutex_lock(&cam->s_mutex);
         spin_lock_init(&cam->dev_lock);
         cam->state = S_NOTREADY;
         cafe_set_config_needed(cam, 1);
@@ -1947,7 +1946,6 @@ static int cafe_pci_probe(struct pci_dev *pdev,
          * because the sensor could attach in this call chain, leading to
          * unsightly deadlocks.
          */
-        mutex_unlock(&cam->s_mutex);  /* attach can deadlock */
         ret = cafe_smbus_setup(cam);
         if (ret)
                 goto out_freeirq;
@@ -1973,7 +1971,7 @@ static int cafe_pci_probe(struct pci_dev *pdev,
         cam->vdev.v4l2_dev = &cam->v4l2_dev;
         ret = video_register_device(&cam->vdev, VFL_TYPE_GRABBER, -1);
         if (ret)
-                goto out_smbus;
+                goto out_unlock;
         video_set_drvdata(&cam->vdev, cam);
 
         /*
@@ -1988,6 +1986,8 @@ static int cafe_pci_probe(struct pci_dev *pdev,
         mutex_unlock(&cam->s_mutex);
         return 0;
 
+out_unlock:
+        mutex_unlock(&cam->s_mutex);
 out_smbus:
         cafe_smbus_shutdown(cam);
 out_freeirq:
diff --git a/drivers/media/video/cpia.c b/drivers/media/video/cpia.c
index 551ddf216a4b..933ae4c8cb9a 100644
--- a/drivers/media/video/cpia.c
+++ b/drivers/media/video/cpia.c
@@ -3737,9 +3737,6 @@ static int cpia_mmap(struct file *file, struct vm_area_struct *vma)
         if (size > FRAME_NUM*CPIA_MAX_FRAME_SIZE)
                 return -EINVAL;
 
-        if (!cam || !cam->ops)
-                return -ENODEV;
-
         /* make this _really_ smp-safe */
         if (mutex_lock_interruptible(&cam->busy_lock))
                 return -EINTR;
diff --git a/drivers/media/video/cx18/Kconfig b/drivers/media/video/cx18/Kconfig
index e8a50a611ebc..baf7e91ee0f5 100644
--- a/drivers/media/video/cx18/Kconfig
+++ b/drivers/media/video/cx18/Kconfig
@@ -19,3 +19,14 @@ config VIDEO_CX18
 
           To compile this driver as a module, choose M here: the
           module will be called cx18.
+
+config VIDEO_CX18_ALSA
+        tristate "Conexant 23418 DMA audio support"
+        depends on VIDEO_CX18 && SND && EXPERIMENTAL
+        select SND_PCM
+        ---help---
+          This is a video4linux driver for direct (DMA) audio on
+          Conexant 23418 based TV cards using ALSA.
+
+          To compile this driver as a module, choose M here: the
+          module will be called cx18-alsa.
diff --git a/drivers/media/video/cx18/Makefile b/drivers/media/video/cx18/Makefile
index f7bf0edf93f9..2fadd9ded340 100644
--- a/drivers/media/video/cx18/Makefile
+++ b/drivers/media/video/cx18/Makefile
@@ -3,8 +3,10 @@ cx18-objs    := cx18-driver.o cx18-cards.o cx18-i2c.o cx18-firmware.o cx18-gpio.
         cx18-mailbox.o cx18-vbi.o cx18-audio.o cx18-video.o cx18-irq.o \
         cx18-av-core.o cx18-av-audio.o cx18-av-firmware.o cx18-av-vbi.o cx18-scb.o \
         cx18-dvb.o cx18-io.o
+cx18-alsa-objs := cx18-alsa-main.o cx18-alsa-pcm.o
 
 obj-$(CONFIG_VIDEO_CX18) += cx18.o
+obj-$(CONFIG_VIDEO_CX18_ALSA) += cx18-alsa.o
 
 EXTRA_CFLAGS += -Idrivers/media/dvb/dvb-core
 EXTRA_CFLAGS += -Idrivers/media/dvb/frontends
diff --git a/drivers/media/video/cx18/cx18-alsa-main.c b/drivers/media/video/cx18/cx18-alsa-main.c
new file mode 100644
index 000000000000..eb41d7ec65b9
--- /dev/null
+++ b/drivers/media/video/cx18/cx18-alsa-main.c
@@ -0,0 +1,293 @@
+/*
+ *  ALSA interface to cx18 PCM capture streams
+ *
+ *  Copyright (C) 2009  Andy Walls <awalls@radix.net>
+ *  Copyright (C) 2009  Devin Heitmueller <dheitmueller@kernellabs.com>
+ *
+ *  Portions of this work were sponsored by ONELAN Limited.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ *  02111-1307  USA
+ */
+
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/device.h>
+#include <linux/spinlock.h>
+
+#include <media/v4l2-device.h>
+
+#include <sound/core.h>
+#include <sound/initval.h>
+
+#include "cx18-driver.h"
+#include "cx18-version.h"
+#include "cx18-alsa.h"
+#include "cx18-alsa-mixer.h"
+#include "cx18-alsa-pcm.h"
+
+int cx18_alsa_debug;
+
+#define CX18_DEBUG_ALSA_INFO(fmt, arg...) \
+        do { \
+                if (cx18_alsa_debug & 2) \
+                        printk(KERN_INFO "%s: " fmt, "cx18-alsa", ## arg); \
+        } while (0);
+
+module_param_named(debug, cx18_alsa_debug, int, 0644);
+MODULE_PARM_DESC(debug,
+                 "Debug level (bitmask). Default: 0\n"
+                 "\t\t\t  1/0x0001: warning\n"
+                 "\t\t\t  2/0x0002: info\n");
+
+MODULE_AUTHOR("Andy Walls");
+MODULE_DESCRIPTION("CX23418 ALSA Interface");
+MODULE_SUPPORTED_DEVICE("CX23418 MPEG2 encoder");
+MODULE_LICENSE("GPL");
+
+MODULE_VERSION(CX18_VERSION);
+
+static inline
+struct snd_cx18_card *to_snd_cx18_card(struct v4l2_device *v4l2_dev)
+{
+        return to_cx18(v4l2_dev)->alsa;
+}
+
+static inline
+struct snd_cx18_card *p_to_snd_cx18_card(struct v4l2_device **v4l2_dev)
+{
+        return container_of(v4l2_dev, struct snd_cx18_card, v4l2_dev);
+}
+
+static void snd_cx18_card_free(struct snd_cx18_card *cxsc)
+{
+        if (cxsc == NULL)
+                return;
+
+        if (cxsc->v4l2_dev != NULL)
+                to_cx18(cxsc->v4l2_dev)->alsa = NULL;
+
+        /* FIXME - take any other stopping actions needed */
+
+        kfree(cxsc);
+}
+
+static void snd_cx18_card_private_free(struct snd_card *sc)
+{
+        if (sc == NULL)
+                return;
+        snd_cx18_card_free(sc->private_data);
+        sc->private_data = NULL;
+        sc->private_free = NULL;
+}
+
+static int snd_cx18_card_create(struct v4l2_device *v4l2_dev,
+                                       struct snd_card *sc,
+                                       struct snd_cx18_card **cxsc)
+{
+        *cxsc = kzalloc(sizeof(struct snd_cx18_card), GFP_KERNEL);
+        if (*cxsc == NULL)
+                return -ENOMEM;
+
+        (*cxsc)->v4l2_dev = v4l2_dev;
+        (*cxsc)->sc = sc;
+
+        sc->private_data = *cxsc;
+        sc->private_free = snd_cx18_card_private_free;
+
+        return 0;
+}
+
+static int snd_cx18_card_set_names(struct snd_cx18_card *cxsc)
+{
+        struct cx18 *cx = to_cx18(cxsc->v4l2_dev);
+        struct snd_card *sc = cxsc->sc;
+
+        /* sc->driver is used by alsa-lib's configurator: simple, unique */
+        strlcpy(sc->driver, "CX23418", sizeof(sc->driver));
+
+        /* sc->shortname is a symlink in /proc/asound: CX18-M -> cardN */
+        snprintf(sc->shortname,  sizeof(sc->shortname), "CX18-%d",
+                 cx->instance);
+
+        /* sc->longname is read from /proc/asound/cards */
+        snprintf(sc->longname, sizeof(sc->longname),
+                 "CX23418 #%d %s TV/FM Radio/Line-In Capture",
+                 cx->instance, cx->card_name);
+
+        return 0;
+}
+
+static int snd_cx18_init(struct v4l2_device *v4l2_dev)
+{
+        struct cx18 *cx = to_cx18(v4l2_dev);
+        struct snd_card *sc = NULL;
+        struct snd_cx18_card *cxsc;
+        int ret;
+
+        /* Numbrs steps from "Writing an ALSA Driver" by Takashi Iwai */
+
+        /* (1) Check and increment the device index */
+        /* This is a no-op for us.  We'll use the cx->instance */
+
+        /* (2) Create a card instance */
+        ret = snd_card_create(SNDRV_DEFAULT_IDX1, /* use first available id */
+                              SNDRV_DEFAULT_STR1, /* xid from end of shortname*/
+                              THIS_MODULE, 0, &sc);
+        if (ret) {
+                CX18_ALSA_ERR("%s: snd_card_create() failed with err %d\n",
+                              __func__, ret);
+                goto err_exit;
+        }
+
+        /* (3) Create a main component */
+        ret = snd_cx18_card_create(v4l2_dev, sc, &cxsc);
+        if (ret) {
+                CX18_ALSA_ERR("%s: snd_cx18_card_create() failed with err %d\n",
+                              __func__, ret);
+                goto err_exit_free;
+        }
+
+        /* (4) Set the driver ID and name strings */
+        snd_cx18_card_set_names(cxsc);
+
+
+        ret = snd_cx18_pcm_create(cxsc);
+        if (ret) {
+                CX18_ALSA_ERR("%s: snd_cx18_pcm_create() failed with err %d\n",
+                              __func__, ret);
+                goto err_exit_free;
+        }
+        /* FIXME - proc files */
+
+        /* (7) Set the driver data and return 0 */
+        /* We do this out of normal order for PCI drivers to avoid races */
+        cx->alsa = cxsc;
+
+        /* (6) Register the card instance */
+        ret = snd_card_register(sc);
+        if (ret) {
+                cx->alsa = NULL;
+                CX18_ALSA_ERR("%s: snd_card_register() failed with err %d\n",
+                              __func__, ret);
+                goto err_exit_free;
+        }
+
+        return 0;
+
+err_exit_free:
+        if (sc != NULL)
+                snd_card_free(sc);
+err_exit:
+        return ret;
+}
+
+int cx18_alsa_load(struct cx18 *cx)
+{
+        struct v4l2_device *v4l2_dev = &cx->v4l2_dev;
+        struct cx18_stream *s;
+
+        if (v4l2_dev == NULL) {
+                printk(KERN_ERR "cx18-alsa: %s: struct v4l2_device * is NULL\n",
+                       __func__);
+                return 0;
+        }
+
+        cx = to_cx18(v4l2_dev);
+        if (cx == NULL) {
+                printk(KERN_ERR "cx18-alsa cx is NULL\n");
+                return 0;
+        }
+
+        s = &cx->streams[CX18_ENC_STREAM_TYPE_PCM];
+        if (s->video_dev == NULL) {
+                CX18_DEBUG_ALSA_INFO("%s: PCM stream for card is disabled - "
+                                     "skipping\n", __func__);
+                return 0;
+        }
+
+        if (cx->alsa != NULL) {
+                CX18_ALSA_ERR("%s: struct snd_cx18_card * already exists\n",
+                              __func__);
+                return 0;
+        }
+
+        if (snd_cx18_init(v4l2_dev)) {
+                CX18_ALSA_ERR("%s: failed to create struct snd_cx18_card\n",
+                              __func__);
+        } else {
+                CX18_DEBUG_ALSA_INFO("%s: created cx18 ALSA interface instance "
+                                     "\n", __func__);
+        }
+        return 0;
+}
+
+static int __init cx18_alsa_init(void)
+{
+        printk(KERN_INFO "cx18-alsa: module loading...\n");
+        cx18_ext_init = &cx18_alsa_load;
+        return 0;
+}
+
+static void __exit snd_cx18_exit(struct snd_cx18_card *cxsc)
+{
+        struct cx18 *cx = to_cx18(cxsc->v4l2_dev);
+
+        /* FIXME - pointer checks & shutdown cxsc */
+
+        snd_card_free(cxsc->sc);
+        cx->alsa = NULL;
+}
+
+static int __exit cx18_alsa_exit_callback(struct device *dev, void *data)
+{
+        struct v4l2_device *v4l2_dev = dev_get_drvdata(dev);
+        struct snd_cx18_card *cxsc;
+
+        if (v4l2_dev == NULL) {
+                printk(KERN_ERR "cx18-alsa: %s: struct v4l2_device * is NULL\n",
+                       __func__);
+                return 0;
+        }
+
+        cxsc = to_snd_cx18_card(v4l2_dev);
+        if (cxsc == NULL) {
+                CX18_ALSA_WARN("%s: struct snd_cx18_card * is NULL\n",
+                               __func__);
+                return 0;
+        }
+
+        snd_cx18_exit(cxsc);
+        return 0;
+}
+
+static void __exit cx18_alsa_exit(void)
+{
+        struct device_driver *drv;
+        int ret;
+
+        printk(KERN_INFO "cx18-alsa: module unloading...\n");
+
+        drv = driver_find("cx18", &pci_bus_type);
+        ret = driver_for_each_device(drv, NULL, NULL, cx18_alsa_exit_callback);
+        put_driver(drv);
+
+        cx18_ext_init = NULL;
+        printk(KERN_INFO "cx18-alsa: module unload complete\n");
+}
+
+module_init(cx18_alsa_init);
+module_exit(cx18_alsa_exit);
diff --git a/drivers/media/video/cx18/cx18-alsa-mixer.c b/drivers/media/video/cx18/cx18-alsa-mixer.c
new file mode 100644
index 000000000000..ef21114309fe
--- /dev/null
+++ b/drivers/media/video/cx18/cx18-alsa-mixer.c
@@ -0,0 +1,175 @@
+/*
+ *  ALSA mixer controls for the
+ *  ALSA interface to cx18 PCM capture streams
+ *
+ *  Copyright (C) 2009  Andy Walls <awalls@radix.net>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ *  02111-1307  USA
+ */
+
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/device.h>
+#include <linux/spinlock.h>
+#include <linux/videodev2.h>
+
+#include <media/v4l2-device.h>
+
+#include <sound/core.h>
+#include <sound/control.h>
+#include <sound/tlv.h>
+
+#include "cx18-alsa.h"
+#include "cx18-driver.h"
+
+/*
+ * Note the cx18-av-core volume scale is funny, due to the alignment of the
+ * scale with another chip's range:
+ *
+ * v4l2_control value   /512    indicated dB    actual dB       reg 0x8d4
+ * 0x0000 - 0x01ff        0     -119            -96             228
+ * 0x0200 - 0x02ff        1     -118            -96             228
+ * ...
+ * 0x2c00 - 0x2dff       22      -97            -96             228
+ * 0x2e00 - 0x2fff       23      -96            -96             228
+ * 0x3000 - 0x31ff       24      -95            -95             226
+ * ...
+ * 0xee00 - 0xefff      119        0              0              36
+ * ...
+ * 0xfe00 - 0xffff      127       +8             +8              20
+ */
+static inline int dB_to_cx18_av_vol(int dB)
+{
+        if (dB < -96)
+                dB = -96;
+        else if (dB > 8)
+                dB = 8;
+        return (dB + 119) << 9;
+}
+
+static inline int cx18_av_vol_to_dB(int v)
+{
+        if (v < (23 << 9))
+                v = (23 << 9);
+        else if (v > (127 << 9))
+                v = (127 << 9);
+        return (v >> 9) - 119;
+}
+
+static int snd_cx18_mixer_tv_vol_info(struct snd_kcontrol *kcontrol,
+                                      struct snd_ctl_elem_info *uinfo)
+{
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
+        uinfo->count = 1;
+        /* We're already translating values, just keep this control in dB */
+        uinfo->value.integer.min  = -96;
+        uinfo->value.integer.max  =   8;
+        uinfo->value.integer.step =   1;
+        return 0;
+}
+
+static int snd_cx18_mixer_tv_vol_get(struct snd_kcontrol *kctl,
+                                     struct snd_ctl_elem_value *uctl)
+{
+        struct snd_cx18_card *cxsc = snd_kcontrol_chip(kctl);
+        struct cx18 *cx = to_cx18(cxsc->v4l2_dev);
+        struct v4l2_control vctrl;
+        int ret;
+
+        vctrl.id = V4L2_CID_AUDIO_VOLUME;
+        vctrl.value = dB_to_cx18_av_vol(uctl->value.integer.value[0]);
+
+        snd_cx18_lock(cxsc);
+        ret = v4l2_subdev_call(cx->sd_av, core, g_ctrl, &vctrl);
+        snd_cx18_unlock(cxsc);
+
+        if (!ret)
+                uctl->value.integer.value[0] = cx18_av_vol_to_dB(vctrl.value);
+        return ret;
+}
+
+static int snd_cx18_mixer_tv_vol_put(struct snd_kcontrol *kctl,
+                                     struct snd_ctl_elem_value *uctl)
+{
+        struct snd_cx18_card *cxsc = snd_kcontrol_chip(kctl);
+        struct cx18 *cx = to_cx18(cxsc->v4l2_dev);
+        struct v4l2_control vctrl;
+        int ret;
+
+        vctrl.id = V4L2_CID_AUDIO_VOLUME;
+        vctrl.value = dB_to_cx18_av_vol(uctl->value.integer.value[0]);
+
+        snd_cx18_lock(cxsc);
+
+        /* Fetch current state */
+        ret = v4l2_subdev_call(cx->sd_av, core, g_ctrl, &vctrl);
+
+        if (ret ||
+            (cx18_av_vol_to_dB(vctrl.value) != uctl->value.integer.value[0])) {
+
+                /* Set, if needed */
+                vctrl.value = dB_to_cx18_av_vol(uctl->value.integer.value[0]);
+                ret = v4l2_subdev_call(cx->sd_av, core, s_ctrl, &vctrl);
+                if (!ret)
+                        ret = 1; /* Indicate control was changed w/o error */
+        }
+        snd_cx18_unlock(cxsc);
+
+        return ret;
+}
+
+
+/* This is a bit of overkill, the slider is already in dB internally */
+static DECLARE_TLV_DB_SCALE(snd_cx18_mixer_tv_vol_db_scale, -9600, 100, 0);
+
+static struct snd_kcontrol_new snd_cx18_mixer_tv_vol __initdata = {
+        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+        .name = "Analog TV Capture Volume",
+        .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
+                  SNDRV_CTL_ELEM_ACCESS_TLV_READ,
+        .info = snd_cx18_mixer_tv_volume_info,
+        .get = snd_cx18_mixer_tv_volume_get,
+        .put = snd_cx18_mixer_tv_volume_put,
+        .tlv.p = snd_cx18_mixer_tv_vol_db_scale
+};
+
+/* FIXME - add mute switch and balance, bass, treble sliders:
+        V4L2_CID_AUDIO_MUTE
+
+        V4L2_CID_AUDIO_BALANCE
+
+        V4L2_CID_AUDIO_BASS
+        V4L2_CID_AUDIO_TREBLE
+*/
+
+/* FIXME - add stereo, lang1, lang2, mono menu */
+/* FIXME - add CS5345 I2S volume for HVR-1600 */
+
+int __init snd_cx18_mixer_create(struct snd_cx18_card *cxsc)
+{
+        struct v4l2_device *v4l2_dev = cxsc->v4l2_dev;
+        struct snd_card *sc = cxsc->sc;
+        int ret;
+
+        strlcpy(sc->mixername, "CX23418 Mixer", sizeof(sc->mixername));
+
+        ret = snd_ctl_add(sc, snd_ctl_new1(snd_cx18_mixer_tv_vol, cxsc));
+        if (ret) {
+                CX18_ALSA_WARN("%s: failed to add %s control, err %d\n",
+                                __func__, snd_cx18_mixer_tv_vol.name, ret);
+        }
+        return ret;
+}
diff --git a/drivers/media/video/cx18/cx18-alsa-mixer.h b/drivers/media/video/cx18/cx18-alsa-mixer.h
new file mode 100644
index 000000000000..2d418db000fe
--- /dev/null
+++ b/drivers/media/video/cx18/cx18-alsa-mixer.h
@@ -0,0 +1,23 @@
+/*
+ *  ALSA mixer controls for the
+ *  ALSA interface to cx18 PCM capture streams
+ *
+ *  Copyright (C) 2009  Andy Walls <awalls@radix.net>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ *  02111-1307  USA
+ */
+
+int __init snd_cx18_mixer_create(struct snd_cx18_card *cxsc);
diff --git a/drivers/media/video/cx18/cx18-alsa-pcm.c b/drivers/media/video/cx18/cx18-alsa-pcm.c
new file mode 100644
index 000000000000..2bd312daeb1e
--- /dev/null
+++ b/drivers/media/video/cx18/cx18-alsa-pcm.c
@@ -0,0 +1,354 @@
+/*
+ *  ALSA PCM device for the
+ *  ALSA interface to cx18 PCM capture streams
+ *
+ *  Copyright (C) 2009  Andy Walls <awalls@radix.net>
+ *  Copyright (C) 2009  Devin Heitmueller <dheitmueller@kernellabs.com>
+ *
+ *  Portions of this work were sponsored by ONELAN Limited.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ *  02111-1307  USA
+ */
+
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/vmalloc.h>
+
+#include <media/v4l2-device.h>
+
+#include <sound/core.h>
+#include <sound/pcm.h>
+
+#include "cx18-driver.h"
+#include "cx18-queue.h"
+#include "cx18-streams.h"
+#include "cx18-fileops.h"
+#include "cx18-alsa.h"
+
+static unsigned int pcm_debug;
+module_param(pcm_debug, int, 0644);
+MODULE_PARM_DESC(pcm_debug, "enable debug messages for pcm");
+
+#define dprintk(fmt, arg...) do {                                       \
+            if (pcm_debug)                                              \
+                printk(KERN_INFO "cx18-alsa-pcm %s: " fmt,              \
+                                  __func__, ##arg);                     \
+        } while (0)
+
+static struct snd_pcm_hardware snd_cx18_hw_capture = {
+        .info = SNDRV_PCM_INFO_BLOCK_TRANSFER |
+                SNDRV_PCM_INFO_MMAP           |
+                SNDRV_PCM_INFO_INTERLEAVED    |
+                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 = 62720 * 8,  /* just about the value in usbaudio.c */
+        .period_bytes_min = 64,         /* 12544/2, */
+        .period_bytes_max = 12544,
+        .periods_min = 2,
+        .periods_max = 98,              /* 12544, */
+};
+
+void cx18_alsa_announce_pcm_data(struct snd_cx18_card *cxsc, u8 *pcm_data,
+                                 size_t num_bytes)
+{
+        struct snd_pcm_substream *substream;
+        struct snd_pcm_runtime *runtime;
+        unsigned int oldptr;
+        unsigned int stride;
+        int period_elapsed = 0;
+        int length;
+
+        dprintk("cx18 alsa announce ptr=%p data=%p num_bytes=%zd\n", cxsc,
+                pcm_data, num_bytes);
+
+        substream = cxsc->capture_pcm_substream;
+        if (substream == NULL) {
+                dprintk("substream was NULL\n");
+                return;
+        }
+
+        runtime = substream->runtime;
+        if (runtime == NULL) {
+                dprintk("runtime was NULL\n");
+                return;
+        }
+
+        stride = runtime->frame_bits >> 3;
+        if (stride == 0) {
+                dprintk("stride is zero\n");
+                return;
+        }
+
+        length = num_bytes / stride;
+        if (length == 0) {
+                dprintk("%s: length was zero\n", __func__);
+                return;
+        }
+
+        if (runtime->dma_area == NULL) {
+                dprintk("dma area was NULL - ignoring\n");
+                return;
+        }
+
+        oldptr = cxsc->hwptr_done_capture;
+        if (oldptr + length >= runtime->buffer_size) {
+                unsigned int cnt =
+                        runtime->buffer_size - oldptr;
+                memcpy(runtime->dma_area + oldptr * stride, pcm_data,
+                       cnt * stride);
+                memcpy(runtime->dma_area, pcm_data + cnt * stride,
+                       length * stride - cnt * stride);
+        } else {
+                memcpy(runtime->dma_area + oldptr * stride, pcm_data,
+                       length * stride);
+        }
+        snd_pcm_stream_lock(substream);
+
+        cxsc->hwptr_done_capture += length;
+        if (cxsc->hwptr_done_capture >=
+            runtime->buffer_size)
+                cxsc->hwptr_done_capture -=
+                        runtime->buffer_size;
+
+        cxsc->capture_transfer_done += length;
+        if (cxsc->capture_transfer_done >=
+            runtime->period_size) {
+                cxsc->capture_transfer_done -=
+                        runtime->period_size;
+                period_elapsed = 1;
+        }
+
+        snd_pcm_stream_unlock(substream);
+
+        if (period_elapsed)
+                snd_pcm_period_elapsed(substream);
+}
+
+static int snd_cx18_pcm_capture_open(struct snd_pcm_substream *substream)
+{
+        struct snd_cx18_card *cxsc = snd_pcm_substream_chip(substream);
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        struct v4l2_device *v4l2_dev = cxsc->v4l2_dev;
+        struct cx18 *cx = to_cx18(v4l2_dev);
+        struct cx18_stream *s;
+        struct cx18_open_id item;
+        int ret;
+
+        /* Instruct the cx18 to start sending packets */
+        snd_cx18_lock(cxsc);
+        s = &cx->streams[CX18_ENC_STREAM_TYPE_PCM];
+
+        item.cx = cx;
+        item.type = s->type;
+        item.open_id = cx->open_id++;
+
+        /* See if the stream is available */
+        if (cx18_claim_stream(&item, item.type)) {
+                /* No, it's already in use */
+                snd_cx18_unlock(cxsc);
+                return -EBUSY;
+        }
+
+        if (test_bit(CX18_F_S_STREAMOFF, &s->s_flags) ||
+            test_and_set_bit(CX18_F_S_STREAMING, &s->s_flags)) {
+                /* We're already streaming.  No additional action required */
+                snd_cx18_unlock(cxsc);
+                return 0;
+        }
+
+
+        runtime->hw = snd_cx18_hw_capture;
+        snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
+        cxsc->capture_pcm_substream = substream;
+        runtime->private_data = cx;
+
+        cx->pcm_announce_callback = cx18_alsa_announce_pcm_data;
+
+        /* Not currently streaming, so start it up */
+        set_bit(CX18_F_S_STREAMING, &s->s_flags);
+        ret = cx18_start_v4l2_encode_stream(s);
+        snd_cx18_unlock(cxsc);
+
+        return 0;
+}
+
+static int snd_cx18_pcm_capture_close(struct snd_pcm_substream *substream)
+{
+        struct snd_cx18_card *cxsc = snd_pcm_substream_chip(substream);
+        struct v4l2_device *v4l2_dev = cxsc->v4l2_dev;
+        struct cx18 *cx = to_cx18(v4l2_dev);
+        struct cx18_stream *s;
+        int ret;
+
+        /* Instruct the cx18 to stop sending packets */
+        snd_cx18_lock(cxsc);
+        s = &cx->streams[CX18_ENC_STREAM_TYPE_PCM];
+        ret = cx18_stop_v4l2_encode_stream(s, 0);
+        clear_bit(CX18_F_S_STREAMING, &s->s_flags);
+
+        cx18_release_stream(s);
+
+        cx->pcm_announce_callback = NULL;
+        snd_cx18_unlock(cxsc);
+
+        return 0;
+}
+
+static int snd_cx18_pcm_ioctl(struct snd_pcm_substream *substream,
+                     unsigned int cmd, void *arg)
+{
+        return snd_pcm_lib_ioctl(substream, cmd, arg);
+}
+
+
+static int snd_pcm_alloc_vmalloc_buffer(struct snd_pcm_substream *subs,
+                                        size_t size)
+{
+        struct snd_pcm_runtime *runtime = subs->runtime;
+
+        dprintk("Allocating vbuffer\n");
+        if (runtime->dma_area) {
+                if (runtime->dma_bytes > size)
+                        return 0;
+
+                vfree(runtime->dma_area);
+        }
+        runtime->dma_area = vmalloc(size);
+        if (!runtime->dma_area)
+                return -ENOMEM;
+
+        runtime->dma_bytes = size;
+
+        return 0;
+}
+
+static int snd_cx18_pcm_hw_params(struct snd_pcm_substream *substream,
+                         struct snd_pcm_hw_params *params)
+{
+        int ret;
+
+        dprintk("%s called\n", __func__);
+
+        ret = snd_pcm_alloc_vmalloc_buffer(substream,
+                                           params_buffer_bytes(params));
+        return 0;
+}
+
+static int snd_cx18_pcm_hw_free(struct snd_pcm_substream *substream)
+{
+        struct snd_cx18_card *cxsc = snd_pcm_substream_chip(substream);
+        unsigned long flags;
+
+        spin_lock_irqsave(&cxsc->slock, flags);
+        if (substream->runtime->dma_area) {
+                dprintk("freeing pcm capture region\n");
+                vfree(substream->runtime->dma_area);
+                substream->runtime->dma_area = NULL;
+        }
+        spin_unlock_irqrestore(&cxsc->slock, flags);
+
+        return 0;
+}
+
+static int snd_cx18_pcm_prepare(struct snd_pcm_substream *substream)
+{
+        struct snd_cx18_card *cxsc = snd_pcm_substream_chip(substream);
+
+        cxsc->hwptr_done_capture = 0;
+        cxsc->capture_transfer_done = 0;
+
+        return 0;
+}
+
+static int snd_cx18_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
+{
+        return 0;
+}
+
+static
+snd_pcm_uframes_t snd_cx18_pcm_pointer(struct snd_pcm_substream *substream)
+{
+        unsigned long flags;
+        snd_pcm_uframes_t hwptr_done;
+        struct snd_cx18_card *cxsc = snd_pcm_substream_chip(substream);
+
+        spin_lock_irqsave(&cxsc->slock, flags);
+        hwptr_done = cxsc->hwptr_done_capture;
+        spin_unlock_irqrestore(&cxsc->slock, flags);
+
+        return hwptr_done;
+}
+
+static struct page *snd_pcm_get_vmalloc_page(struct snd_pcm_substream *subs,
+                                             unsigned long offset)
+{
+        void *pageptr = subs->runtime->dma_area + offset;
+
+        return vmalloc_to_page(pageptr);
+}
+
+static struct snd_pcm_ops snd_cx18_pcm_capture_ops = {
+        .open           = snd_cx18_pcm_capture_open,
+        .close          = snd_cx18_pcm_capture_close,
+        .ioctl          = snd_cx18_pcm_ioctl,
+        .hw_params      = snd_cx18_pcm_hw_params,
+        .hw_free        = snd_cx18_pcm_hw_free,
+        .prepare        = snd_cx18_pcm_prepare,
+        .trigger        = snd_cx18_pcm_trigger,
+        .pointer        = snd_cx18_pcm_pointer,
+        .page           = snd_pcm_get_vmalloc_page,
+};
+
+int snd_cx18_pcm_create(struct snd_cx18_card *cxsc)
+{
+        struct snd_pcm *sp;
+        struct snd_card *sc = cxsc->sc;
+        struct v4l2_device *v4l2_dev = cxsc->v4l2_dev;
+        struct cx18 *cx = to_cx18(v4l2_dev);
+        int ret;
+
+        ret = snd_pcm_new(sc, "CX23418 PCM",
+                          0, /* PCM device 0, the only one for this card */
+                          0, /* 0 playback substreams */
+                          1, /* 1 capture substream */
+                          &sp);
+        if (ret) {
+                CX18_ALSA_ERR("%s: snd_cx18_pcm_create() failed with err %d\n",
+                              __func__, ret);
+                goto err_exit;
+        }
+
+        spin_lock_init(&cxsc->slock);
+
+        snd_pcm_set_ops(sp, SNDRV_PCM_STREAM_CAPTURE,
+                        &snd_cx18_pcm_capture_ops);
+        sp->info_flags = 0;
+        sp->private_data = cxsc;
+        strlcpy(sp->name, cx->card_name, sizeof(sp->name));
+
+        return 0;
+
+err_exit:
+        return ret;
+}
diff --git a/drivers/media/video/cx18/cx18-alsa-pcm.h b/drivers/media/video/cx18/cx18-alsa-pcm.h
new file mode 100644
index 000000000000..325662c647a0
--- /dev/null
+++ b/drivers/media/video/cx18/cx18-alsa-pcm.h
@@ -0,0 +1,27 @@
+/*
+ *  ALSA PCM device for the
+ *  ALSA interface to cx18 PCM capture streams
+ *
+ *  Copyright (C) 2009  Andy Walls <awalls@radix.net>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ *  02111-1307  USA
+ */
+
+int __init snd_cx18_pcm_create(struct snd_cx18_card *cxsc);
+
+/* Used by cx18-mailbox to announce the PCM data to the module */
+void cx18_alsa_announce_pcm_data(struct snd_cx18_card *card, u8 *pcm_data,
+                                 size_t num_bytes);
diff --git a/drivers/media/video/cx18/cx18-alsa.h b/drivers/media/video/cx18/cx18-alsa.h
new file mode 100644
index 000000000000..88a1cde7540b
--- /dev/null
+++ b/drivers/media/video/cx18/cx18-alsa.h
@@ -0,0 +1,75 @@
+/*
+ *  ALSA interface to cx18 PCM capture streams
+ *
+ *  Copyright (C) 2009  Andy Walls <awalls@radix.net>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ *  02111-1307  USA
+ */
+
+struct snd_card;
+
+struct snd_cx18_card {
+        struct v4l2_device *v4l2_dev;
+        struct snd_card *sc;
+        unsigned int capture_transfer_done;
+        unsigned int hwptr_done_capture;
+        struct snd_pcm_substream *capture_pcm_substream;
+        spinlock_t slock;
+};
+
+extern int cx18_alsa_debug;
+
+/*
+ * File operations that manipulate the encoder or video or audio subdevices
+ * need to be serialized.  Use the same lock we use for v4l2 file ops.
+ */
+static inline void snd_cx18_lock(struct snd_cx18_card *cxsc)
+{
+        struct cx18 *cx = to_cx18(cxsc->v4l2_dev);
+        mutex_lock(&cx->serialize_lock);
+}
+
+static inline void snd_cx18_unlock(struct snd_cx18_card *cxsc)
+{
+        struct cx18 *cx = to_cx18(cxsc->v4l2_dev);
+        mutex_unlock(&cx->serialize_lock);
+}
+
+#define CX18_ALSA_DBGFLG_WARN  (1 << 0)
+#define CX18_ALSA_DBGFLG_WARN  (1 << 0)
+#define CX18_ALSA_DBGFLG_INFO  (1 << 1)
+
+#define CX18_ALSA_DEBUG(x, type, fmt, args...) \
+        do { \
+                if ((x) & cx18_alsa_debug) \
+                        printk(KERN_INFO "%s-alsa: " type ": " fmt, \
+                                v4l2_dev->name , ## args); \
+        } while (0)
+
+#define CX18_ALSA_DEBUG_WARN(fmt, args...) \
+        CX18_ALSA_DEBUG(CX18_ALSA_DBGFLG_WARN, "warning", fmt , ## args)
+
+#define CX18_ALSA_DEBUG_INFO(fmt, args...) \
+        CX18_ALSA_DEBUG(CX18_ALSA_DBGFLG_INFO, "info", fmt , ## args)
+
+#define CX18_ALSA_ERR(fmt, args...) \
+        printk(KERN_ERR "%s-alsa: " fmt, v4l2_dev->name , ## args)
+
+#define CX18_ALSA_WARN(fmt, args...) \
+        printk(KERN_WARNING "%s-alsa: " fmt, v4l2_dev->name , ## args)
+
+#define CX18_ALSA_INFO(fmt, args...) \
+        printk(KERN_INFO "%s-alsa: " fmt, v4l2_dev->name , ## args)
diff --git a/drivers/media/video/cx18/cx18-cards.c b/drivers/media/video/cx18/cx18-cards.c
index f11e47a58286..f808fb6fc1c1 100644
--- a/drivers/media/video/cx18/cx18-cards.c
+++ b/drivers/media/video/cx18/cx18-cards.c
@@ -393,7 +393,7 @@ static const struct cx18_card cx18_card_leadtek_pvr2100 = {
         .gpio_init.direction = 0x7,
         .gpio_audio_input = { .mask   = 0x7,
                               .tuner  = 0x6, .linein = 0x2, .radio  = 0x2 },
-        .xceive_pin = 15,
+        .xceive_pin = 1,
         .pci_list = cx18_pci_leadtek_pvr2100,
         .i2c = &cx18_i2c_std,
 };
diff --git a/drivers/media/video/cx18/cx18-driver.c b/drivers/media/video/cx18/cx18-driver.c
index 7f65a47f12e1..c95a86ba33b0 100644
--- a/drivers/media/video/cx18/cx18-driver.c
+++ b/drivers/media/video/cx18/cx18-driver.c
@@ -47,6 +47,10 @@
    setting this to 1 you ensure that radio0 is now also radio1. */
 int cx18_first_minor;
 
+/* Callback for registering extensions */
+int (*cx18_ext_init)(struct cx18 *);
+EXPORT_SYMBOL(cx18_ext_init);
+
 /* add your revision and whatnot here */
 static struct pci_device_id cx18_pci_tbl[] __devinitdata = {
         {PCI_VENDOR_ID_CX, PCI_DEVICE_ID_CX23418,
@@ -91,7 +95,7 @@ static int enc_pcm_bufsize = CX18_DEFAULT_ENC_PCM_BUFSIZE;
 
 static int enc_ts_bufs = -1;
 static int enc_mpg_bufs = -1;
-static int enc_idx_bufs = -1;
+static int enc_idx_bufs = CX18_MAX_FW_MDLS_PER_STREAM;
 static int enc_yuv_bufs = -1;
 static int enc_vbi_bufs = -1;
 static int enc_pcm_bufs = -1;
@@ -196,14 +200,17 @@ MODULE_PARM_DESC(enc_mpg_bufs,
                  "Number of encoder MPG buffers\n"
                  "\t\t\tDefault is computed from other enc_mpg_* parameters");
 MODULE_PARM_DESC(enc_idx_buffers,
-                 "Encoder IDX buffer memory (MB). (enc_idx_bufs can override)\n"
-                 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_IDX_BUFFERS));
+                 "(Deprecated) Encoder IDX buffer memory (MB)\n"
+                 "\t\t\tIgnored, except 0 disables IDX buffer allocations\n"
+                 "\t\t\tDefault: 1 [Enabled]");
 MODULE_PARM_DESC(enc_idx_bufsize,
                  "Size of an encoder IDX buffer (kB)\n"
-                 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_IDX_BUFSIZE));
+                 "\t\t\tAllowed values are multiples of 1.5 kB rounded up\n"
+                 "\t\t\t(multiples of size required for 64 index entries)\n"
+                 "\t\t\tDefault: 2");
 MODULE_PARM_DESC(enc_idx_bufs,
                  "Number of encoder IDX buffers\n"
-                 "\t\t\tDefault is computed from other enc_idx_* parameters");
+                 "\t\t\tDefault: " __stringify(CX18_MAX_FW_MDLS_PER_STREAM));
 MODULE_PARM_DESC(enc_yuv_buffers,
                  "Encoder YUV buffer memory (MB). (enc_yuv_bufs can override)\n"
                  "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_YUV_BUFFERS));
@@ -231,7 +238,8 @@ MODULE_PARM_DESC(enc_pcm_bufs,
                  "Number of encoder PCM buffers\n"
                  "\t\t\tDefault is computed from other enc_pcm_* parameters");
 
-MODULE_PARM_DESC(cx18_first_minor, "Set device node number assigned to first card");
+MODULE_PARM_DESC(cx18_first_minor,
+                 "Set device node number assigned to first card");
 
 MODULE_AUTHOR("Hans Verkuil");
 MODULE_DESCRIPTION("CX23418 driver");
@@ -240,6 +248,28 @@ MODULE_LICENSE("GPL");
 
 MODULE_VERSION(CX18_VERSION);
 
+#if defined(CONFIG_MODULES) && defined(MODULE)
+static void request_module_async(struct work_struct *work)
+{
+        struct cx18 *dev = container_of(work, struct cx18, request_module_wk);
+
+        /* Make sure cx18-alsa module is loaded */
+        request_module("cx18-alsa");
+
+        /* Initialize cx18-alsa for this instance of the cx18 device */
+        if (cx18_ext_init != NULL)
+                cx18_ext_init(dev);
+}
+
+static void request_modules(struct cx18 *dev)
+{
+        INIT_WORK(&dev->request_module_wk, request_module_async);
+        schedule_work(&dev->request_module_wk);
+}
+#else
+#define request_modules(dev)
+#endif /* CONFIG_MODULES */
+
 /* Generic utility functions */
 int cx18_msleep_timeout(unsigned int msecs, int intr)
 {
@@ -501,7 +531,12 @@ static void cx18_process_options(struct cx18 *cx)
                 /*
                  * YUV is a special case where the stream_buf_size needs to be
                  * an integral multiple of 33.75 kB (storage for 32 screens
-                 * lines to maintain alignment in case of lost buffers
+                 * lines to maintain alignment in case of lost buffers).
+                 *
+                 * IDX is a special case where the stream_buf_size should be
+                 * an integral multiple of 1.5 kB (storage for 64 index entries
+                 * to maintain alignment in case of lost buffers).
+                 *
                  */
                 if (i == CX18_ENC_STREAM_TYPE_YUV) {
                         cx->stream_buf_size[i] *= 1024;
@@ -511,15 +546,24 @@ static void cx18_process_options(struct cx18 *cx)
                         if (cx->stream_buf_size[i] < CX18_UNIT_ENC_YUV_BUFSIZE)
                                 cx->stream_buf_size[i] =
                                                 CX18_UNIT_ENC_YUV_BUFSIZE;
+                } else if (i == CX18_ENC_STREAM_TYPE_IDX) {
+                        cx->stream_buf_size[i] *= 1024;
+                        cx->stream_buf_size[i] -=
+                           (cx->stream_buf_size[i] % CX18_UNIT_ENC_IDX_BUFSIZE);
+
+                        if (cx->stream_buf_size[i] < CX18_UNIT_ENC_IDX_BUFSIZE)
+                                cx->stream_buf_size[i] =
+                                                CX18_UNIT_ENC_IDX_BUFSIZE;
                 }
                 /*
-                 * YUV is a special case where the stream_buf_size is
+                 * YUV and IDX are special cases where the stream_buf_size is
                  * now in bytes.
                  * VBI is a special case where the stream_buf_size is fixed
                  * and already in bytes
                  */
                 if (i == CX18_ENC_STREAM_TYPE_VBI ||
-                    i == CX18_ENC_STREAM_TYPE_YUV) {
+                    i == CX18_ENC_STREAM_TYPE_YUV ||
+                    i == CX18_ENC_STREAM_TYPE_IDX) {
                         if (cx->stream_buffers[i] < 0) {
                                 cx->stream_buffers[i] =
                                         cx->options.megabytes[i] * 1024 * 1024
@@ -1032,6 +1076,10 @@ static int __devinit cx18_probe(struct pci_dev *pci_dev,
         }
 
         CX18_INFO("Initialized card: %s\n", cx->card_name);
+
+        /* Load cx18 submodules (cx18-alsa) */
+        request_modules(cx);
+
         return 0;
 
 free_streams:
@@ -1220,6 +1268,7 @@ static void cx18_remove(struct pci_dev *pci_dev)
         kfree(cx);
 }
 
+
 /* define a pci_driver for card detection */
 static struct pci_driver cx18_pci_driver = {
       .name =     "cx18",
@@ -1230,7 +1279,8 @@ static struct pci_driver cx18_pci_driver = {
 
 static int __init module_start(void)
 {
-        printk(KERN_INFO "cx18:  Start initialization, version %s\n", CX18_VERSION);
+        printk(KERN_INFO "cx18:  Start initialization, version %s\n",
+               CX18_VERSION);
 
         /* Validate parameters */
         if (cx18_first_minor < 0 || cx18_first_minor >= CX18_MAX_CARDS) {
diff --git a/drivers/media/video/cx18/cx18-driver.h b/drivers/media/video/cx18/cx18-driver.h
index e3f7911a7385..23ad6d548dc5 100644
--- a/drivers/media/video/cx18/cx18-driver.h
+++ b/drivers/media/video/cx18/cx18-driver.h
@@ -126,10 +126,22 @@
 #define CX18_625_LINE_ENC_YUV_BUFSIZE   (CX18_UNIT_ENC_YUV_BUFSIZE * 576/32)
 #define CX18_525_LINE_ENC_YUV_BUFSIZE   (CX18_UNIT_ENC_YUV_BUFSIZE * 480/32)
 
+/* IDX buffer size should be a multiple of the index entry size from the chip */
+struct cx18_enc_idx_entry {
+        __le32 length;
+        __le32 offset_low;
+        __le32 offset_high;
+        __le32 flags;
+        __le32 pts_low;
+        __le32 pts_high;
+} __attribute__ ((packed));
+#define CX18_UNIT_ENC_IDX_BUFSIZE \
+        (sizeof(struct cx18_enc_idx_entry) * V4L2_ENC_IDX_ENTRIES)
+
 /* DMA buffer, default size in kB allocated */
 #define CX18_DEFAULT_ENC_TS_BUFSIZE   32
 #define CX18_DEFAULT_ENC_MPG_BUFSIZE  32
-#define CX18_DEFAULT_ENC_IDX_BUFSIZE  32
+#define CX18_DEFAULT_ENC_IDX_BUFSIZE  (CX18_UNIT_ENC_IDX_BUFSIZE * 1 / 1024 + 1)
 #define CX18_DEFAULT_ENC_YUV_BUFSIZE  (CX18_UNIT_ENC_YUV_BUFSIZE * 3 / 1024 + 1)
 #define CX18_DEFAULT_ENC_PCM_BUFSIZE   4
 
@@ -234,16 +246,8 @@
 #define CX18_WARN_DEV(dev, fmt, args...)     v4l2_warn(dev, fmt , ## args)
 #define CX18_INFO_DEV(dev, fmt, args...)     v4l2_info(dev, fmt , ## args)
 
-/* Values for CX18_API_DEC_PLAYBACK_SPEED mpeg_frame_type_mask parameter: */
-#define MPEG_FRAME_TYPE_IFRAME 1
-#define MPEG_FRAME_TYPE_IFRAME_PFRAME 3
-#define MPEG_FRAME_TYPE_ALL 7
-
-#define CX18_MAX_PGM_INDEX (400)
-
 extern int cx18_debug;
 
-
 struct cx18_options {
         int megabytes[CX18_MAX_STREAMS]; /* Size in megabytes of each stream */
         int cardtype;           /* force card type on load */
@@ -276,6 +280,18 @@ struct cx18_options {
 #define CX18_SLICED_TYPE_WSS_625        (5)
 #define CX18_SLICED_TYPE_VPS            (7)
 
+/**
+ * list_entry_is_past_end - check if a previous loop cursor is off list end
+ * @pos:        the type * previously used as a loop cursor.
+ * @head:       the head for your list.
+ * @member:     the name of the list_struct within the struct.
+ *
+ * Check if the entry's list_head is the head of the list, thus it's not a
+ * real entry but was the loop cursor that walked past the end
+ */
+#define list_entry_is_past_end(pos, head, member) \
+        (&pos->member == (head))
+
 struct cx18_buffer {
         struct list_head list;
         dma_addr_t dma_handle;
@@ -558,6 +574,10 @@ struct cx18 {
         int stream_buffers[CX18_MAX_STREAMS]; /* # of buffers for each stream */
         int stream_buf_size[CX18_MAX_STREAMS]; /* Stream buffer size */
         struct cx18_stream streams[CX18_MAX_STREAMS];   /* Stream data */
+        struct snd_cx18_card *alsa; /* ALSA interface for PCM capture stream */
+        void (*pcm_announce_callback)(struct snd_cx18_card *card, u8 *pcm_data,
+                                      size_t num_bytes);
+
         unsigned long i_flags;  /* global cx18 flags */
         atomic_t ana_capturing; /* count number of active analog capture streams */
         atomic_t tot_capturing; /* total count number of active capture streams */
@@ -575,12 +595,6 @@ struct cx18 {
 
         struct vbi_info vbi;
 
-        u32 pgm_info_offset;
-        u32 pgm_info_num;
-        u32 pgm_info_write_idx;
-        u32 pgm_info_read_idx;
-        struct v4l2_enc_idx_entry pgm_info[CX18_MAX_PGM_INDEX];
-
         u64 mpg_data_received;
         u64 vbi_data_inserted;
 
@@ -623,6 +637,9 @@ struct cx18 {
         u32 active_input;
         v4l2_std_id std;
         v4l2_std_id tuner_std;  /* The norm of the tuner (fixed) */
+
+        /* Used for cx18-alsa module loading */
+        struct work_struct request_module_wk;
 };
 
 static inline struct cx18 *to_cx18(struct v4l2_device *v4l2_dev)
@@ -630,6 +647,9 @@ static inline struct cx18 *to_cx18(struct v4l2_device *v4l2_dev)
         return container_of(v4l2_dev, struct cx18, v4l2_dev);
 }
 
+/* cx18 extensions to be loaded */
+extern int (*cx18_ext_init)(struct cx18 *);
+
 /* Globals */
 extern int cx18_first_minor;
 
diff --git a/drivers/media/video/cx18/cx18-dvb.c b/drivers/media/video/cx18/cx18-dvb.c
index 71ad2d1b4c2c..0ae2c2e1eab5 100644
--- a/drivers/media/video/cx18/cx18-dvb.c
+++ b/drivers/media/video/cx18/cx18-dvb.c
@@ -213,10 +213,14 @@ static int cx18_dvb_start_feed(struct dvb_demux_feed *feed)
 {
         struct dvb_demux *demux = feed->demux;
         struct cx18_stream *stream = (struct cx18_stream *) demux->priv;
-        struct cx18 *cx = stream->cx;
+        struct cx18 *cx;
         int ret;
         u32 v;
 
+        if (!stream)
+                return -EINVAL;
+
+        cx = stream->cx;
         CX18_DEBUG_INFO("Start feed: pid = 0x%x index = %d\n",
                         feed->pid, feed->index);
 
@@ -253,12 +257,10 @@ static int cx18_dvb_start_feed(struct dvb_demux_feed *feed)
         if (!demux->dmx.frontend)
                 return -EINVAL;
 
-        if (!stream)
-                return -EINVAL;
-
         mutex_lock(&stream->dvb.feedlock);
         if (stream->dvb.feeding++ == 0) {
                 CX18_DEBUG_INFO("Starting Transport DMA\n");
+                mutex_lock(&cx->serialize_lock);
                 set_bit(CX18_F_S_STREAMING, &stream->s_flags);
                 ret = cx18_start_v4l2_encode_stream(stream);
                 if (ret < 0) {
@@ -267,6 +269,7 @@ static int cx18_dvb_start_feed(struct dvb_demux_feed *feed)
                         if (stream->dvb.feeding == 0)
                                 clear_bit(CX18_F_S_STREAMING, &stream->s_flags);
                 }
+                mutex_unlock(&cx->serialize_lock);
         } else
                 ret = 0;
         mutex_unlock(&stream->dvb.feedlock);
@@ -279,17 +282,20 @@ static int cx18_dvb_stop_feed(struct dvb_demux_feed *feed)
 {
         struct dvb_demux *demux = feed->demux;
         struct cx18_stream *stream = (struct cx18_stream *)demux->priv;
-        struct cx18 *cx = stream->cx;
+        struct cx18 *cx;
         int ret = -EINVAL;
 
-        CX18_DEBUG_INFO("Stop feed: pid = 0x%x index = %d\n",
-                        feed->pid, feed->index);
-
         if (stream) {
+                cx = stream->cx;
+                CX18_DEBUG_INFO("Stop feed: pid = 0x%x index = %d\n",
+                                feed->pid, feed->index);
+
                 mutex_lock(&stream->dvb.feedlock);
                 if (--stream->dvb.feeding == 0) {
                         CX18_DEBUG_INFO("Stopping Transport DMA\n");
+                        mutex_lock(&cx->serialize_lock);
                         ret = cx18_stop_v4l2_encode_stream(stream, 0);
+                        mutex_unlock(&cx->serialize_lock);
                 } else
                         ret = 0;
                 mutex_unlock(&stream->dvb.feedlock);
diff --git a/drivers/media/video/cx18/cx18-fileops.c b/drivers/media/video/cx18/cx18-fileops.c
index c0885c69fd89..863ce7758239 100644
--- a/drivers/media/video/cx18/cx18-fileops.c
+++ b/drivers/media/video/cx18/cx18-fileops.c
@@ -37,15 +37,21 @@
 
 /* This function tries to claim the stream for a specific file descriptor.
    If no one else is using this stream then the stream is claimed and
-   associated VBI streams are also automatically claimed.
+   associated VBI and IDX streams are also automatically claimed.
    Possible error returns: -EBUSY if someone else has claimed
    the stream or 0 on success. */
-static int cx18_claim_stream(struct cx18_open_id *id, int type)
+int cx18_claim_stream(struct cx18_open_id *id, int type)
 {
         struct cx18 *cx = id->cx;
         struct cx18_stream *s = &cx->streams[type];
-        struct cx18_stream *s_vbi;
-        int vbi_type;
+        struct cx18_stream *s_assoc;
+
+        /* Nothing should ever try to directly claim the IDX stream */
+        if (type == CX18_ENC_STREAM_TYPE_IDX) {
+                CX18_WARN("MPEG Index stream cannot be claimed "
+                          "directly, but something tried.\n");
+                return -EINVAL;
+        }
 
         if (test_and_set_bit(CX18_F_S_CLAIMED, &s->s_flags)) {
                 /* someone already claimed this stream */
@@ -67,32 +73,47 @@ static int cx18_claim_stream(struct cx18_open_id *id, int type)
         }
         s->id = id->open_id;
 
-        /* CX18_ENC_STREAM_TYPE_MPG needs to claim CX18_ENC_STREAM_TYPE_VBI
-           (provided VBI insertion is on and sliced VBI is selected), for all
-           other streams we're done */
-        if (type == CX18_ENC_STREAM_TYPE_MPG &&
-            cx->vbi.insert_mpeg && !cx18_raw_vbi(cx)) {
-                vbi_type = CX18_ENC_STREAM_TYPE_VBI;
-        } else {
+        /*
+         * CX18_ENC_STREAM_TYPE_MPG needs to claim:
+         * CX18_ENC_STREAM_TYPE_VBI, if VBI insertion is on for sliced VBI, or
+         * CX18_ENC_STREAM_TYPE_IDX, if VBI insertion is off for sliced VBI
+         * (We don't yet fix up MPEG Index entries for our inserted packets).
+         *
+         * For all other streams we're done.
+         */
+        if (type != CX18_ENC_STREAM_TYPE_MPG)
                 return 0;
-        }
-        s_vbi = &cx->streams[vbi_type];
 
-        set_bit(CX18_F_S_CLAIMED, &s_vbi->s_flags);
+        s_assoc = &cx->streams[CX18_ENC_STREAM_TYPE_IDX];
+        if (cx->vbi.insert_mpeg && !cx18_raw_vbi(cx))
+                s_assoc = &cx->streams[CX18_ENC_STREAM_TYPE_VBI];
+        else if (!cx18_stream_enabled(s_assoc))
+                return 0;
+
+        set_bit(CX18_F_S_CLAIMED, &s_assoc->s_flags);
 
         /* mark that it is used internally */
-        set_bit(CX18_F_S_INTERNAL_USE, &s_vbi->s_flags);
+        set_bit(CX18_F_S_INTERNAL_USE, &s_assoc->s_flags);
         return 0;
 }
+EXPORT_SYMBOL(cx18_claim_stream);
 
 /* This function releases a previously claimed stream. It will take into
    account associated VBI streams. */
-static void cx18_release_stream(struct cx18_stream *s)
+void cx18_release_stream(struct cx18_stream *s)
 {
         struct cx18 *cx = s->cx;
-        struct cx18_stream *s_vbi;
+        struct cx18_stream *s_assoc;
 
         s->id = -1;
+        if (s->type == CX18_ENC_STREAM_TYPE_IDX) {
+                /*
+                 * The IDX stream is only used internally, and can
+                 * only be indirectly unclaimed by unclaiming the MPG stream.
+                 */
+                return;
+        }
+
         if (s->type == CX18_ENC_STREAM_TYPE_VBI &&
                 test_bit(CX18_F_S_INTERNAL_USE, &s->s_flags)) {
                 /* this stream is still in use internally */
@@ -105,25 +126,36 @@ static void cx18_release_stream(struct cx18_stream *s)
 
         cx18_flush_queues(s);
 
-        /* CX18_ENC_STREAM_TYPE_MPG needs to release CX18_ENC_STREAM_TYPE_VBI,
-           for all other streams we're done */
-        if (s->type == CX18_ENC_STREAM_TYPE_MPG)
-                s_vbi = &cx->streams[CX18_ENC_STREAM_TYPE_VBI];
-        else
+        /*
+         * CX18_ENC_STREAM_TYPE_MPG needs to release the
+         * CX18_ENC_STREAM_TYPE_VBI and/or CX18_ENC_STREAM_TYPE_IDX streams.
+         *
+         * For all other streams we're done.
+         */
+        if (s->type != CX18_ENC_STREAM_TYPE_MPG)
                 return;
 
-        /* clear internal use flag */
-        if (!test_and_clear_bit(CX18_F_S_INTERNAL_USE, &s_vbi->s_flags)) {
-                /* was already cleared */
-                return;
+        /* Unclaim the associated MPEG Index stream */
+        s_assoc = &cx->streams[CX18_ENC_STREAM_TYPE_IDX];
+        if (test_and_clear_bit(CX18_F_S_INTERNAL_USE, &s_assoc->s_flags)) {
+                clear_bit(CX18_F_S_CLAIMED, &s_assoc->s_flags);
+                cx18_flush_queues(s_assoc);
         }
-        if (s_vbi->id != -1) {
-                /* VBI stream still claimed by a file descriptor */
-                return;
+
+        /* Unclaim the associated VBI stream */
+        s_assoc = &cx->streams[CX18_ENC_STREAM_TYPE_VBI];
+        if (test_and_clear_bit(CX18_F_S_INTERNAL_USE, &s_assoc->s_flags)) {
+                if (s_assoc->id == -1) {
+                        /*
+                         * The VBI stream is not still claimed by a file
+                         * descriptor, so completely unclaim it.
+                         */
+                        clear_bit(CX18_F_S_CLAIMED, &s_assoc->s_flags);
+                        cx18_flush_queues(s_assoc);
+                }
         }
-        clear_bit(CX18_F_S_CLAIMED, &s_vbi->s_flags);
-        cx18_flush_queues(s_vbi);
 }
+EXPORT_SYMBOL(cx18_release_stream);
 
 static void cx18_dualwatch(struct cx18 *cx)
 {
@@ -177,9 +209,7 @@ static struct cx18_mdl *cx18_get_mdl(struct cx18_stream *s, int non_block,
         *err = 0;
         while (1) {
                 if (s->type == CX18_ENC_STREAM_TYPE_MPG) {
-                        /* Process pending program info updates and pending
-                           VBI data */
-
+                        /* Process pending program updates and VBI data */
                         if (time_after(jiffies, cx->dualwatch_jiffies + msecs_to_jiffies(1000))) {
                                 cx->dualwatch_jiffies = jiffies;
                                 cx18_dualwatch(cx);
@@ -362,18 +392,6 @@ static size_t cx18_copy_buf_to_user(struct cx18_stream *s,
         return len;
 }
 
-/**
- * list_entry_is_past_end - check if a previous loop cursor is off list end
- * @pos:        the type * previously used as a loop cursor.
- * @head:       the head for your list.
- * @member:     the name of the list_struct within the struct.
- *
- * Check if the entry's list_head is the head of the list, thus it's not a
- * real entry but was the loop cursor that walked past the end
- */
-#define list_entry_is_past_end(pos, head, member) \
-        (&pos->member == (head))
-
 static size_t cx18_copy_mdl_to_user(struct cx18_stream *s,
                 struct cx18_mdl *mdl, char __user *ubuf, size_t ucount)
 {
@@ -498,6 +516,7 @@ int cx18_start_capture(struct cx18_open_id *id)
         struct cx18 *cx = id->cx;
         struct cx18_stream *s = &cx->streams[id->type];
         struct cx18_stream *s_vbi;
+        struct cx18_stream *s_idx;
 
         if (s->type == CX18_ENC_STREAM_TYPE_RAD) {
                 /* you cannot read from these stream types. */
@@ -516,25 +535,33 @@ int cx18_start_capture(struct cx18_open_id *id)
                 return 0;
         }
 
-        /* Start VBI capture if required */
+        /* Start associated VBI or IDX stream capture if required */
         s_vbi = &cx->streams[CX18_ENC_STREAM_TYPE_VBI];
-        if (s->type == CX18_ENC_STREAM_TYPE_MPG &&
-            test_bit(CX18_F_S_INTERNAL_USE, &s_vbi->s_flags) &&
-            !test_and_set_bit(CX18_F_S_STREAMING, &s_vbi->s_flags)) {
-                /* Note: the CX18_ENC_STREAM_TYPE_VBI is claimed
-                   automatically when the MPG stream is claimed.
-                   We only need to start the VBI capturing. */
-                if (cx18_start_v4l2_encode_stream(s_vbi)) {
-                        CX18_DEBUG_WARN("VBI capture start failed\n");
-
-                        /* Failure, clean up and return an error */
-                        clear_bit(CX18_F_S_STREAMING, &s_vbi->s_flags);
-                        clear_bit(CX18_F_S_STREAMING, &s->s_flags);
-                        /* also releases the associated VBI stream */
-                        cx18_release_stream(s);
-                        return -EIO;
+        s_idx = &cx->streams[CX18_ENC_STREAM_TYPE_IDX];
+        if (s->type == CX18_ENC_STREAM_TYPE_MPG) {
+                /*
+                 * The VBI and IDX streams should have been claimed
+                 * automatically, if for internal use, when the MPG stream was
+                 * claimed.  We only need to start these streams capturing.
+                 */
+                if (test_bit(CX18_F_S_INTERNAL_USE, &s_idx->s_flags) &&
+                    !test_and_set_bit(CX18_F_S_STREAMING, &s_idx->s_flags)) {
+                        if (cx18_start_v4l2_encode_stream(s_idx)) {
+                                CX18_DEBUG_WARN("IDX capture start failed\n");
+                                clear_bit(CX18_F_S_STREAMING, &s_idx->s_flags);
+                                goto start_failed;
+                        }
+                        CX18_DEBUG_INFO("IDX capture started\n");
+                }
+                if (test_bit(CX18_F_S_INTERNAL_USE, &s_vbi->s_flags) &&
+                    !test_and_set_bit(CX18_F_S_STREAMING, &s_vbi->s_flags)) {
+                        if (cx18_start_v4l2_encode_stream(s_vbi)) {
+                                CX18_DEBUG_WARN("VBI capture start failed\n");
+                                clear_bit(CX18_F_S_STREAMING, &s_vbi->s_flags);
+                                goto start_failed;
+                        }
+                        CX18_DEBUG_INFO("VBI insertion started\n");
                 }
-                CX18_DEBUG_INFO("VBI insertion started\n");
         }
 
         /* Tell the card to start capturing */
@@ -547,19 +574,29 @@ int cx18_start_capture(struct cx18_open_id *id)
                 return 0;
         }
 
-        /* failure, clean up */
+start_failed:
         CX18_DEBUG_WARN("Failed to start capturing for stream %s\n", s->name);
 
-        /* Note: the CX18_ENC_STREAM_TYPE_VBI is released
-           automatically when the MPG stream is released.
-           We only need to stop the VBI capturing. */
-        if (s->type == CX18_ENC_STREAM_TYPE_MPG &&
-            test_bit(CX18_F_S_STREAMING, &s_vbi->s_flags)) {
-                cx18_stop_v4l2_encode_stream(s_vbi, 0);
-                clear_bit(CX18_F_S_STREAMING, &s_vbi->s_flags);
+        /*
+         * The associated VBI and IDX streams for internal use are released
+         * automatically when the MPG stream is released.  We only need to stop
+         * the associated stream.
+         */
+        if (s->type == CX18_ENC_STREAM_TYPE_MPG) {
+                /* Stop the IDX stream which is always for internal use */
+                if (test_bit(CX18_F_S_STREAMING, &s_idx->s_flags)) {
+                        cx18_stop_v4l2_encode_stream(s_idx, 0);
+                        clear_bit(CX18_F_S_STREAMING, &s_idx->s_flags);
+                }
+                /* Stop the VBI stream, if only running for internal use */
+                if (test_bit(CX18_F_S_STREAMING, &s_vbi->s_flags) &&
+                    !test_bit(CX18_F_S_APPL_IO, &s_vbi->s_flags)) {
+                        cx18_stop_v4l2_encode_stream(s_vbi, 0);
+                        clear_bit(CX18_F_S_STREAMING, &s_vbi->s_flags);
+                }
         }
         clear_bit(CX18_F_S_STREAMING, &s->s_flags);
-        cx18_release_stream(s);
+        cx18_release_stream(s); /* Also releases associated streams */
         return -EIO;
 }
 
@@ -618,6 +655,8 @@ void cx18_stop_capture(struct cx18_open_id *id, int gop_end)
 {
         struct cx18 *cx = id->cx;
         struct cx18_stream *s = &cx->streams[id->type];
+        struct cx18_stream *s_vbi = &cx->streams[CX18_ENC_STREAM_TYPE_VBI];
+        struct cx18_stream *s_idx = &cx->streams[CX18_ENC_STREAM_TYPE_IDX];
 
         CX18_DEBUG_IOCTL("close() of %s\n", s->name);
 
@@ -625,17 +664,19 @@ void cx18_stop_capture(struct cx18_open_id *id, int gop_end)
 
         /* Stop capturing */
         if (test_bit(CX18_F_S_STREAMING, &s->s_flags)) {
-                struct cx18_stream *s_vbi =
-                        &cx->streams[CX18_ENC_STREAM_TYPE_VBI];
-
                 CX18_DEBUG_INFO("close stopping capture\n");
-                /* Special case: a running VBI capture for VBI insertion
-                   in the mpeg stream. Need to stop that too. */
-                if (id->type == CX18_ENC_STREAM_TYPE_MPG &&
-                    test_bit(CX18_F_S_STREAMING, &s_vbi->s_flags) &&
-                    !test_bit(CX18_F_S_APPL_IO, &s_vbi->s_flags)) {
-                        CX18_DEBUG_INFO("close stopping embedded VBI capture\n");
-                        cx18_stop_v4l2_encode_stream(s_vbi, 0);
+                if (id->type == CX18_ENC_STREAM_TYPE_MPG) {
+                        /* Stop internal use associated VBI and IDX streams */
+                        if (test_bit(CX18_F_S_STREAMING, &s_vbi->s_flags) &&
+                            !test_bit(CX18_F_S_APPL_IO, &s_vbi->s_flags)) {
+                                CX18_DEBUG_INFO("close stopping embedded VBI "
+                                                "capture\n");
+                                cx18_stop_v4l2_encode_stream(s_vbi, 0);
+                        }
+                        if (test_bit(CX18_F_S_STREAMING, &s_idx->s_flags)) {
+                                CX18_DEBUG_INFO("close stopping IDX capture\n");
+                                cx18_stop_v4l2_encode_stream(s_idx, 0);
+                        }
                 }
                 if (id->type == CX18_ENC_STREAM_TYPE_VBI &&
                     test_bit(CX18_F_S_INTERNAL_USE, &s->s_flags))
diff --git a/drivers/media/video/cx18/cx18-fileops.h b/drivers/media/video/cx18/cx18-fileops.h
index 92e2d5dab936..5c8fcb884f0a 100644
--- a/drivers/media/video/cx18/cx18-fileops.h
+++ b/drivers/media/video/cx18/cx18-fileops.h
@@ -34,3 +34,6 @@ void cx18_stop_capture(struct cx18_open_id *id, int gop_end);
 void cx18_mute(struct cx18 *cx);
 void cx18_unmute(struct cx18 *cx);
 
+/* Shared with cx18-alsa module */
+int cx18_claim_stream(struct cx18_open_id *id, int type);
+void cx18_release_stream(struct cx18_stream *s);
diff --git a/drivers/media/video/cx18/cx18-ioctl.c b/drivers/media/video/cx18/cx18-ioctl.c
index 3e4fc192fdec..b81dd0ea8eb9 100644
--- a/drivers/media/video/cx18/cx18-ioctl.c
+++ b/drivers/media/video/cx18/cx18-ioctl.c
@@ -775,10 +775,143 @@ static int cx18_g_sliced_vbi_cap(struct file *file, void *fh,
         return 0;
 }
 
+static int _cx18_process_idx_data(struct cx18_buffer *buf,
+                                  struct v4l2_enc_idx *idx)
+{
+        int consumed, remaining;
+        struct v4l2_enc_idx_entry *e_idx;
+        struct cx18_enc_idx_entry *e_buf;
+
+        /* Frame type lookup: 1=I, 2=P, 4=B */
+        const int mapping[8] = {
+                -1, V4L2_ENC_IDX_FRAME_I, V4L2_ENC_IDX_FRAME_P,
+                -1, V4L2_ENC_IDX_FRAME_B, -1, -1, -1
+        };
+
+        /*
+         * Assumption here is that a buf holds an integral number of
+         * struct cx18_enc_idx_entry objects and is properly aligned.
+         * This is enforced by the module options on IDX buffer sizes.
+         */
+        remaining = buf->bytesused - buf->readpos;
+        consumed = 0;
+        e_idx = &idx->entry[idx->entries];
+        e_buf = (struct cx18_enc_idx_entry *) &buf->buf[buf->readpos];
+
+        while (remaining >= sizeof(struct cx18_enc_idx_entry) &&
+               idx->entries < V4L2_ENC_IDX_ENTRIES) {
+
+                e_idx->offset = (((u64) le32_to_cpu(e_buf->offset_high)) << 32)
+                                | le32_to_cpu(e_buf->offset_low);
+
+                e_idx->pts = (((u64) (le32_to_cpu(e_buf->pts_high) & 1)) << 32)
+                             | le32_to_cpu(e_buf->pts_low);
+
+                e_idx->length = le32_to_cpu(e_buf->length);
+
+                e_idx->flags = mapping[le32_to_cpu(e_buf->flags) & 0x7];
+
+                e_idx->reserved[0] = 0;
+                e_idx->reserved[1] = 0;
+
+                idx->entries++;
+                e_idx = &idx->entry[idx->entries];
+                e_buf++;
+
+                remaining -= sizeof(struct cx18_enc_idx_entry);
+                consumed += sizeof(struct cx18_enc_idx_entry);
+        }
+
+        /* Swallow any partial entries at the end, if there are any */
+        if (remaining > 0 && remaining < sizeof(struct cx18_enc_idx_entry))
+                consumed += remaining;
+
+        buf->readpos += consumed;
+        return consumed;
+}
+
+static int cx18_process_idx_data(struct cx18_stream *s, struct cx18_mdl *mdl,
+                                 struct v4l2_enc_idx *idx)
+{
+        if (s->type != CX18_ENC_STREAM_TYPE_IDX)
+                return -EINVAL;
+
+        if (mdl->curr_buf == NULL)
+                mdl->curr_buf = list_first_entry(&mdl->buf_list,
+                                                 struct cx18_buffer, list);
+
+        if (list_entry_is_past_end(mdl->curr_buf, &mdl->buf_list, list)) {
+                /*
+                 * For some reason we've exhausted the buffers, but the MDL
+                 * object still said some data was unread.
+                 * Fix that and bail out.
+                 */
+                mdl->readpos = mdl->bytesused;
+                return 0;
+        }
+
+        list_for_each_entry_from(mdl->curr_buf, &mdl->buf_list, list) {
+
+                /* Skip any empty buffers in the MDL */
+                if (mdl->curr_buf->readpos >= mdl->curr_buf->bytesused)
+                        continue;
+
+                mdl->readpos += _cx18_process_idx_data(mdl->curr_buf, idx);
+
+                /* exit when MDL drained or request satisfied */
+                if (idx->entries >= V4L2_ENC_IDX_ENTRIES ||
+                    mdl->curr_buf->readpos < mdl->curr_buf->bytesused ||
+                    mdl->readpos >= mdl->bytesused)
+                        break;
+        }
+        return 0;
+}
+
 static int cx18_g_enc_index(struct file *file, void *fh,
                                 struct v4l2_enc_idx *idx)
 {
-        return -EINVAL;
+        struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
+        struct cx18_stream *s = &cx->streams[CX18_ENC_STREAM_TYPE_IDX];
+        s32 tmp;
+        struct cx18_mdl *mdl;
+
+        if (!cx18_stream_enabled(s)) /* Module options inhibited IDX stream */
+                return -EINVAL;
+
+        /* Compute the best case number of entries we can buffer */
+        tmp = s->buffers -
+                          s->bufs_per_mdl * CX18_ENC_STREAM_TYPE_IDX_FW_MDL_MIN;
+        if (tmp <= 0)
+                tmp = 1;
+        tmp = tmp * s->buf_size / sizeof(struct cx18_enc_idx_entry);
+
+        /* Fill out the header of the return structure */
+        idx->entries = 0;
+        idx->entries_cap = tmp;
+        memset(idx->reserved, 0, sizeof(idx->reserved));
+
+        /* Pull IDX MDLs and buffers from q_full and populate the entries */
+        do {
+                mdl = cx18_dequeue(s, &s->q_full);
+                if (mdl == NULL) /* No more IDX data right now */
+                        break;
+
+                /* Extract the Index entry data from the MDL and buffers */
+                cx18_process_idx_data(s, mdl, idx);
+                if (mdl->readpos < mdl->bytesused) {
+                        /* We finished with data remaining, push the MDL back */
+                        cx18_push(s, mdl, &s->q_full);
+                        break;
+                }
+
+                /* We drained this MDL, schedule it to go to the firmware */
+                cx18_enqueue(s, mdl, &s->q_free);
+
+        } while (idx->entries < V4L2_ENC_IDX_ENTRIES);
+
+        /* Tell the work handler to send free IDX MDLs to the firmware */
+        cx18_stream_load_fw_queue(s);
+        return 0;
 }
 
 static int cx18_encoder_cmd(struct file *file, void *fh,
diff --git a/drivers/media/video/cx18/cx18-mailbox.c b/drivers/media/video/cx18/cx18-mailbox.c
index f231dd09c720..6dcce297752f 100644
--- a/drivers/media/video/cx18/cx18-mailbox.c
+++ b/drivers/media/video/cx18/cx18-mailbox.c
@@ -29,6 +29,7 @@
 #include "cx18-mailbox.h"
 #include "cx18-queue.h"
 #include "cx18-streams.h"
+#include "cx18-alsa-pcm.h" /* FIXME make configurable */
 
 static const char *rpu_str[] = { "APU", "CPU", "EPU", "HPU" };
 
@@ -157,6 +158,34 @@ static void cx18_mdl_send_to_dvb(struct cx18_stream *s, struct cx18_mdl *mdl)
         }
 }
 
+
+static void cx18_mdl_send_to_alsa(struct cx18 *cx, struct cx18_stream *s,
+                                  struct cx18_mdl *mdl)
+{
+        struct cx18_buffer *buf;
+
+        if (mdl->bytesused == 0)
+                return;
+
+        /* We ignore mdl and buf readpos accounting here - it doesn't matter */
+
+        /* The likely case */
+        if (list_is_singular(&mdl->buf_list)) {
+                buf = list_first_entry(&mdl->buf_list, struct cx18_buffer,
+                                       list);
+                if (buf->bytesused)
+                        cx->pcm_announce_callback(cx->alsa, buf->buf,
+                                                  buf->bytesused);
+                return;
+        }
+
+        list_for_each_entry(buf, &mdl->buf_list, list) {
+                if (buf->bytesused == 0)
+                        break;
+                cx->pcm_announce_callback(cx->alsa, buf->buf, buf->bytesused);
+        }
+}
+
 static void epu_dma_done(struct cx18 *cx, struct cx18_in_work_order *order)
 {
         u32 handle, mdl_ack_count, id;
@@ -223,11 +252,21 @@ static void epu_dma_done(struct cx18 *cx, struct cx18_in_work_order *order)
                 CX18_DEBUG_HI_DMA("%s recv bytesused = %d\n",
                                   s->name, mdl->bytesused);
 
-                if (s->type != CX18_ENC_STREAM_TYPE_TS)
-                        cx18_enqueue(s, mdl, &s->q_full);
-                else {
+                if (s->type == CX18_ENC_STREAM_TYPE_TS) {
                         cx18_mdl_send_to_dvb(s, mdl);
                         cx18_enqueue(s, mdl, &s->q_free);
+                } else if (s->type == CX18_ENC_STREAM_TYPE_PCM) {
+                        /* Pass the data to cx18-alsa */
+                        if (cx->pcm_announce_callback != NULL) {
+                                cx18_mdl_send_to_alsa(cx, s, mdl);
+                                cx18_enqueue(s, mdl, &s->q_free);
+                        } else {
+                                cx18_enqueue(s, mdl, &s->q_full);
+                        }
+                } else {
+                        cx18_enqueue(s, mdl, &s->q_full);
+                        if (s->type == CX18_ENC_STREAM_TYPE_IDX)
+                                cx18_stream_rotate_idx_mdls(cx);
                 }
         }
         /* Put as many MDLs as possible back into fw use */
diff --git a/drivers/media/video/cx18/cx18-queue.c b/drivers/media/video/cx18/cx18-queue.c
index 63304823cef5..aefc8c8cf3c1 100644
--- a/drivers/media/video/cx18/cx18-queue.c
+++ b/drivers/media/video/cx18/cx18-queue.c
@@ -419,6 +419,9 @@ void cx18_stream_free(struct cx18_stream *s)
 {
         struct cx18_mdl *mdl;
         struct cx18_buffer *buf;
+        struct cx18 *cx = s->cx;
+
+        CX18_DEBUG_INFO("Deallocating buffers for %s stream\n", s->name);
 
         /* move all buffers to buf_pool and all MDLs to q_idle */
         cx18_unload_queues(s);
diff --git a/drivers/media/video/cx18/cx18-streams.c b/drivers/media/video/cx18/cx18-streams.c
index 987a9308d938..054450f65a60 100644
--- a/drivers/media/video/cx18/cx18-streams.c
+++ b/drivers/media/video/cx18/cx18-streams.c
@@ -319,11 +319,27 @@ void cx18_streams_cleanup(struct cx18 *cx, int unregister)
 
         /* Teardown all streams */
         for (type = 0; type < CX18_MAX_STREAMS; type++) {
-                if (cx->streams[type].dvb.enabled) {
-                        cx18_dvb_unregister(&cx->streams[type]);
-                        cx->streams[type].dvb.enabled = false;
+
+                /* No struct video_device, but can have buffers allocated */
+                if (type == CX18_ENC_STREAM_TYPE_TS) {
+                        if (cx->streams[type].dvb.enabled) {
+                                cx18_dvb_unregister(&cx->streams[type]);
+                                cx->streams[type].dvb.enabled = false;
+                                cx18_stream_free(&cx->streams[type]);
+                        }
+                        continue;
+                }
+
+                /* No struct video_device, but can have buffers allocated */
+                if (type == CX18_ENC_STREAM_TYPE_IDX) {
+                        if (cx->stream_buffers[type] != 0) {
+                                cx->stream_buffers[type] = 0;
+                                cx18_stream_free(&cx->streams[type]);
+                        }
+                        continue;
                 }
 
+                /* If struct video_device exists, can have buffers allocated */
                 vdev = cx->streams[type].video_dev;
 
                 cx->streams[type].video_dev = NULL;
@@ -447,6 +463,32 @@ static void cx18_vbi_setup(struct cx18_stream *s)
         cx18_api(cx, CX18_CPU_SET_RAW_VBI_PARAM, 6, data);
 }
 
+void cx18_stream_rotate_idx_mdls(struct cx18 *cx)
+{
+        struct cx18_stream *s = &cx->streams[CX18_ENC_STREAM_TYPE_IDX];
+        struct cx18_mdl *mdl;
+
+        if (!cx18_stream_enabled(s))
+                return;
+
+        /* Return if the firmware is not running low on MDLs */
+        if ((atomic_read(&s->q_free.depth) + atomic_read(&s->q_busy.depth)) >=
+                                            CX18_ENC_STREAM_TYPE_IDX_FW_MDL_MIN)
+                return;
+
+        /* Return if there are no MDLs to rotate back to the firmware */
+        if (atomic_read(&s->q_full.depth) < 2)
+                return;
+
+        /*
+         * Take the oldest IDX MDL still holding data, and discard its index
+         * entries by scheduling the MDL to go back to the firmware
+         */
+        mdl = cx18_dequeue(s, &s->q_full);
+        if (mdl != NULL)
+                cx18_enqueue(s, mdl, &s->q_free);
+}
+
 static
 struct cx18_queue *_cx18_stream_put_mdl_fw(struct cx18_stream *s,
                                            struct cx18_mdl *mdl)
@@ -546,8 +588,9 @@ int cx18_start_v4l2_encode_stream(struct cx18_stream *s)
         struct cx18 *cx = s->cx;
         int captype = 0;
         struct cx18_api_func_private priv;
+        struct cx18_stream *s_idx;
 
-        if (s->video_dev == NULL && s->dvb.enabled == 0)
+        if (!cx18_stream_enabled(s))
                 return -EINVAL;
 
         CX18_DEBUG_INFO("Start encoder stream %s\n", s->name);
@@ -561,6 +604,9 @@ int cx18_start_v4l2_encode_stream(struct cx18_stream *s)
                 cx->search_pack_header = 0;
                 break;
 
+        case CX18_ENC_STREAM_TYPE_IDX:
+                captype = CAPTURE_CHANNEL_TYPE_INDEX;
+                break;
         case CX18_ENC_STREAM_TYPE_TS:
                 captype = CAPTURE_CHANNEL_TYPE_TS;
                 break;
@@ -635,11 +681,13 @@ int cx18_start_v4l2_encode_stream(struct cx18_stream *s)
                         cx18_vbi_setup(s);
 
                 /*
-                 * assign program index info.
-                 * Mask 7: select I/P/B, Num_req: 400 max
-                 * FIXME - currently we have this hardcoded as disabled
+                 * Select to receive I, P, and B frame index entries, if the
+                 * index stream is enabled.  Otherwise disable index entry
+                 * generation.
                  */
-                cx18_vapi_result(cx, data, CX18_CPU_SET_INDEXTABLE, 1, 0);
+                s_idx = &cx->streams[CX18_ENC_STREAM_TYPE_IDX];
+                cx18_vapi_result(cx, data, CX18_CPU_SET_INDEXTABLE, 2,
+                                 s->handle, cx18_stream_enabled(s_idx) ? 7 : 0);
 
                 /* Call out to the common CX2341x API setup for user controls */
                 priv.cx = cx;
@@ -697,6 +745,7 @@ int cx18_start_v4l2_encode_stream(struct cx18_stream *s)
         atomic_inc(&cx->tot_capturing);
         return 0;
 }
+EXPORT_SYMBOL(cx18_start_v4l2_encode_stream);
 
 void cx18_stop_all_captures(struct cx18 *cx)
 {
@@ -705,7 +754,7 @@ void cx18_stop_all_captures(struct cx18 *cx)
         for (i = CX18_MAX_STREAMS - 1; i >= 0; i--) {
                 struct cx18_stream *s = &cx->streams[i];
 
-                if (s->video_dev == NULL && s->dvb.enabled == 0)
+                if (!cx18_stream_enabled(s))
                         continue;
                 if (test_bit(CX18_F_S_STREAMING, &s->s_flags))
                         cx18_stop_v4l2_encode_stream(s, 0);
@@ -717,7 +766,7 @@ int cx18_stop_v4l2_encode_stream(struct cx18_stream *s, int gop_end)
         struct cx18 *cx = s->cx;
         unsigned long then;
 
-        if (s->video_dev == NULL && s->dvb.enabled == 0)
+        if (!cx18_stream_enabled(s))
                 return -EINVAL;
 
         /* This function assumes that you are allowed to stop the capture
@@ -762,6 +811,7 @@ int cx18_stop_v4l2_encode_stream(struct cx18_stream *s, int gop_end)
 
         return 0;
 }
+EXPORT_SYMBOL(cx18_stop_v4l2_encode_stream);
 
 u32 cx18_find_handle(struct cx18 *cx)
 {
@@ -789,7 +839,7 @@ struct cx18_stream *cx18_handle_to_stream(struct cx18 *cx, u32 handle)
                 s = &cx->streams[i];
                 if (s->handle != handle)
                         continue;
-                if (s->video_dev || s->dvb.enabled)
+                if (cx18_stream_enabled(s))
                         return s;
         }
         return NULL;
diff --git a/drivers/media/video/cx18/cx18-streams.h b/drivers/media/video/cx18/cx18-streams.h
index 4a01db5e5a35..0bff0fa29763 100644
--- a/drivers/media/video/cx18/cx18-streams.h
+++ b/drivers/media/video/cx18/cx18-streams.h
@@ -28,6 +28,16 @@ int cx18_streams_setup(struct cx18 *cx);
 int cx18_streams_register(struct cx18 *cx);
 void cx18_streams_cleanup(struct cx18 *cx, int unregister);
 
+#define CX18_ENC_STREAM_TYPE_IDX_FW_MDL_MIN (3)
+void cx18_stream_rotate_idx_mdls(struct cx18 *cx);
+
+static inline bool cx18_stream_enabled(struct cx18_stream *s)
+{
+        return s->video_dev || s->dvb.enabled ||
+               (s->type == CX18_ENC_STREAM_TYPE_IDX &&
+                s->cx->stream_buffers[CX18_ENC_STREAM_TYPE_IDX] != 0);
+}
+
 /* Related to submission of mdls to firmware */
 static inline void cx18_stream_load_fw_queue(struct cx18_stream *s)
 {
diff --git a/drivers/media/video/cx18/cx18-version.h b/drivers/media/video/cx18/cx18-version.h
index 9c0b5bb1b019..3e1aec4bcfde 100644
--- a/drivers/media/video/cx18/cx18-version.h
+++ b/drivers/media/video/cx18/cx18-version.h
@@ -24,7 +24,7 @@
 
 #define CX18_DRIVER_NAME "cx18"
 #define CX18_DRIVER_VERSION_MAJOR 1
-#define CX18_DRIVER_VERSION_MINOR 3
+#define CX18_DRIVER_VERSION_MINOR 4
 #define CX18_DRIVER_VERSION_PATCHLEVEL 0
 
 #define CX18_VERSION __stringify(CX18_DRIVER_VERSION_MAJOR) "." __stringify(CX18_DRIVER_VERSION_MINOR) "." __stringify(CX18_DRIVER_VERSION_PATCHLEVEL)
diff --git a/drivers/media/video/cx18/cx23418.h b/drivers/media/video/cx18/cx23418.h
index 868806effdcf..2c00980acfcb 100644
--- a/drivers/media/video/cx18/cx23418.h
+++ b/drivers/media/video/cx18/cx23418.h
@@ -191,7 +191,8 @@
 #define CX18_CPU_SET_MEDIAN_CORING              (CPU_CMD_MASK_CAPTURE | 0x000E)
 
 /* Description: This command set the picture type mask for index file
-   IN[0] -      0 = disable index file output
+   IN[0] - Task handle (ignored by firmware)
+   IN[1] -      0 = disable index file output
                         1 = output I picture
                         2 = P picture
                         4 = B picture
diff --git a/drivers/media/video/cx231xx/cx231xx-dvb.c b/drivers/media/video/cx231xx/cx231xx-dvb.c
index c5082a4e8ced..64e025e2bdf1 100644
--- a/drivers/media/video/cx231xx/cx231xx-dvb.c
+++ b/drivers/media/video/cx231xx/cx231xx-dvb.c
@@ -464,9 +464,9 @@ static int dvb_init(struct cx231xx *dev)
                 /* define general-purpose callback pointer */
                 dvb->frontend->callback = cx231xx_tuner_callback;
 
-                if (dvb_attach(xc5000_attach, dev->dvb->frontend,
+                if (!dvb_attach(xc5000_attach, dev->dvb->frontend,
                                &dev->i2c_bus[1].i2c_adap,
-                               &cnxt_rde250_tunerconfig) < 0) {
+                               &cnxt_rde250_tunerconfig)) {
                         result = -EINVAL;
                         goto out_free;
                 }
@@ -486,9 +486,9 @@ static int dvb_init(struct cx231xx *dev)
                 /* define general-purpose callback pointer */
                 dvb->frontend->callback = cx231xx_tuner_callback;
 
-                if (dvb_attach(xc5000_attach, dev->dvb->frontend,
+                if (!dvb_attach(xc5000_attach, dev->dvb->frontend,
                                &dev->i2c_bus[1].i2c_adap,
-                               &cnxt_rde250_tunerconfig) < 0) {
+                               &cnxt_rde250_tunerconfig)) {
                         result = -EINVAL;
                         goto out_free;
                 }
diff --git a/drivers/media/video/cx231xx/cx231xx-input.c b/drivers/media/video/cx231xx/cx231xx-input.c
index 15826f98b688..c5771db3bfce 100644
--- a/drivers/media/video/cx231xx/cx231xx-input.c
+++ b/drivers/media/video/cx231xx/cx231xx-input.c
@@ -216,7 +216,7 @@ int cx231xx_ir_init(struct cx231xx *dev)
         cx231xx_ir_start(ir);
 
         /* all done */
-        err = ir_input_register(ir->input, dev->board.ir_codes);
+        err = ir_input_register(ir->input, dev->board.ir_codes, NULL);
         if (err)
                 goto err_out_stop;
 
diff --git a/drivers/media/video/cx23885/cx23885-417.c b/drivers/media/video/cx23885/cx23885-417.c
index 88c0d2481118..2ab97ad7b6fb 100644
--- a/drivers/media/video/cx23885/cx23885-417.c
+++ b/drivers/media/video/cx23885/cx23885-417.c
@@ -681,7 +681,7 @@ static char *cmd_to_str(int cmd)
         case CX2341X_ENC_SET_VIDEO_ID:
                 return  "SET_VIDEO_ID";
         case CX2341X_ENC_SET_PCR_ID:
-                return  "SET_PCR_PID";
+                return  "SET_PCR_ID";
         case CX2341X_ENC_SET_FRAME_RATE:
                 return  "SET_FRAME_RATE";
         case CX2341X_ENC_SET_FRAME_SIZE:
@@ -693,7 +693,7 @@ static char *cmd_to_str(int cmd)
         case CX2341X_ENC_SET_ASPECT_RATIO:
                 return  "SET_ASPECT_RATIO";
         case CX2341X_ENC_SET_DNR_FILTER_MODE:
-                return  "SET_DNR_FILTER_PROPS";
+                return  "SET_DNR_FILTER_MODE";
         case CX2341X_ENC_SET_DNR_FILTER_PROPS:
                 return  "SET_DNR_FILTER_PROPS";
         case CX2341X_ENC_SET_CORING_LEVELS:
diff --git a/drivers/media/video/cx23885/cx23885-cards.c b/drivers/media/video/cx23885/cx23885-cards.c
index 1ec48169277d..d639186f645d 100644
--- a/drivers/media/video/cx23885/cx23885-cards.c
+++ b/drivers/media/video/cx23885/cx23885-cards.c
@@ -274,6 +274,31 @@ struct cx23885_board cx23885_boards[] = {
                 .portb          = CX23885_MPEG_DVB,
                 .portc          = CX23885_MPEG_DVB,
         },
+        [CX23885_BOARD_LEADTEK_WINFAST_PXTV1200] = {
+                .name           = "LEADTEK WinFast PxTV1200",
+                .porta          = CX23885_ANALOG_VIDEO,
+                .tuner_type     = TUNER_XC2028,
+                .tuner_addr     = 0x61,
+                .input          = {{
+                        .type   = CX23885_VMUX_TELEVISION,
+                        .vmux   = CX25840_VIN2_CH1 |
+                                  CX25840_VIN5_CH2 |
+                                  CX25840_NONE0_CH3,
+                }, {
+                        .type   = CX23885_VMUX_COMPOSITE1,
+                        .vmux   = CX25840_COMPOSITE1,
+                }, {
+                        .type   = CX23885_VMUX_SVIDEO,
+                        .vmux   = CX25840_SVIDEO_LUMA3 |
+                                  CX25840_SVIDEO_CHROMA4,
+                }, {
+                        .type   = CX23885_VMUX_COMPONENT,
+                        .vmux   = CX25840_VIN7_CH1 |
+                                  CX25840_VIN6_CH2 |
+                                  CX25840_VIN8_CH3 |
+                                  CX25840_COMPONENT_ON,
+                } },
+        },
 };
 const unsigned int cx23885_bcount = ARRAY_SIZE(cx23885_boards);
 
@@ -417,6 +442,10 @@ struct cx23885_subid cx23885_subids[] = {
                 .subvendor = 0x14f1,
                 .subdevice = 0x8578,
                 .card      = CX23885_BOARD_MYGICA_X8558PRO,
+        }, {
+                .subvendor = 0x107d,
+                .subdevice = 0x6f22,
+                .card      = CX23885_BOARD_LEADTEK_WINFAST_PXTV1200,
         },
 };
 const unsigned int cx23885_idcount = ARRAY_SIZE(cx23885_subids);
@@ -617,6 +646,7 @@ int cx23885_tuner_callback(void *priv, int component, int command, int arg)
         case CX23885_BOARD_LEADTEK_WINFAST_PXDVR3200_H:
         case CX23885_BOARD_COMPRO_VIDEOMATE_E650F:
         case CX23885_BOARD_COMPRO_VIDEOMATE_E800:
+        case CX23885_BOARD_LEADTEK_WINFAST_PXTV1200:
                 /* Tuner Reset Command */
                 bitmask = 0x04;
                 break;
@@ -769,6 +799,7 @@ void cx23885_gpio_setup(struct cx23885_dev *dev)
         case CX23885_BOARD_LEADTEK_WINFAST_PXDVR3200_H:
         case CX23885_BOARD_COMPRO_VIDEOMATE_E650F:
         case CX23885_BOARD_COMPRO_VIDEOMATE_E800:
+        case CX23885_BOARD_LEADTEK_WINFAST_PXTV1200:
                 /* GPIO-2  xc3028 tuner reset */
 
                 /* The following GPIO's are on the internal AVCore (cx25840) */
@@ -1076,6 +1107,7 @@ void cx23885_card_setup(struct cx23885_dev *dev)
         case CX23885_BOARD_MYGICA_X8506:
         case CX23885_BOARD_MAGICPRO_PROHDTVE2:
         case CX23885_BOARD_HAUPPAUGE_HVR1290:
+        case CX23885_BOARD_LEADTEK_WINFAST_PXTV1200:
                 dev->sd_cx25840 = v4l2_i2c_new_subdev(&dev->v4l2_dev,
                                 &dev->i2c_bus[2].i2c_adap,
                                 "cx25840", "cx25840", 0x88 >> 1, NULL);
diff --git a/drivers/media/video/cx23885/cx23885-dvb.c b/drivers/media/video/cx23885/cx23885-dvb.c
index e45d2df08138..939079d7bbb9 100644
--- a/drivers/media/video/cx23885/cx23885-dvb.c
+++ b/drivers/media/video/cx23885/cx23885-dvb.c
@@ -542,6 +542,9 @@ static struct atbm8830_config mygica_x8558pro_atbm8830_cfg1 = {
         .osc_clk_freq = 30400, /* in kHz */
         .if_freq = 0, /* zero IF */
         .zif_swap_iq = 1,
+        .agc_min = 0x2E,
+        .agc_max = 0xFF,
+        .agc_hold_loop = 0,
 };
 
 static struct max2165_config mygic_x8558pro_max2165_cfg1 = {
@@ -558,6 +561,9 @@ static struct atbm8830_config mygica_x8558pro_atbm8830_cfg2 = {
         .osc_clk_freq = 30400, /* in kHz */
         .if_freq = 0, /* zero IF */
         .zif_swap_iq = 1,
+        .agc_min = 0x2E,
+        .agc_max = 0xFF,
+        .agc_hold_loop = 0,
 };
 
 static struct max2165_config mygic_x8558pro_max2165_cfg2 = {
@@ -994,15 +1000,8 @@ static int dvb_register(struct cx23885_tsport *port)
                 netup_get_card_info(&dev->i2c_bus[0].i2c_adap, &cinfo);
                 memcpy(port->frontends.adapter.proposed_mac,
                                 cinfo.port[port->nr - 1].mac, 6);
-                printk(KERN_INFO "NetUP Dual DVB-S2 CI card port%d MAC="
-                        "%02X:%02X:%02X:%02X:%02X:%02X\n",
-                        port->nr,
-                        port->frontends.adapter.proposed_mac[0],
-                        port->frontends.adapter.proposed_mac[1],
-                        port->frontends.adapter.proposed_mac[2],
-                        port->frontends.adapter.proposed_mac[3],
-                        port->frontends.adapter.proposed_mac[4],
-                        port->frontends.adapter.proposed_mac[5]);
+                printk(KERN_INFO "NetUP Dual DVB-S2 CI card port%d MAC=%pM\n",
+                        port->nr, port->frontends.adapter.proposed_mac);
 
                 netup_ci_init(port);
                 break;
diff --git a/drivers/media/video/cx23885/cx23885-input.c b/drivers/media/video/cx23885/cx23885-input.c
index 768eec92ccf9..9c6620f86dca 100644
--- a/drivers/media/video/cx23885/cx23885-input.c
+++ b/drivers/media/video/cx23885/cx23885-input.c
@@ -397,7 +397,7 @@ int cx23885_input_init(struct cx23885_dev *dev)
         dev->ir_input = ir;
         cx23885_input_ir_start(dev);
 
-        ret = ir_input_register(ir->dev, ir_codes);
+        ret = ir_input_register(ir->dev, ir_codes, NULL);
         if (ret)
                 goto err_out_stop;
 
diff --git a/drivers/media/video/cx23885/cx23885-video.c b/drivers/media/video/cx23885/cx23885-video.c
index 8934d61cf660..2d3ac8b83dc3 100644
--- a/drivers/media/video/cx23885/cx23885-video.c
+++ b/drivers/media/video/cx23885/cx23885-video.c
@@ -36,6 +36,7 @@
 #include <media/v4l2-common.h>
 #include <media/v4l2-ioctl.h>
 #include "cx23885-ioctl.h"
+#include "tuner-xc2028.h"
 
 MODULE_DESCRIPTION("v4l2 driver module for cx23885 based TV cards");
 MODULE_AUTHOR("Steven Toth <stoth@linuxtv.org>");
@@ -1505,6 +1506,18 @@ int cx23885_video_register(struct cx23885_dev *dev)
                         tun_setup.tuner_callback = cx23885_tuner_callback;
 
                         v4l2_subdev_call(sd, tuner, s_type_addr, &tun_setup);
+
+                        if (dev->board == CX23885_BOARD_LEADTEK_WINFAST_PXTV1200) {
+                                struct xc2028_ctrl ctrl = {
+                                        .fname = XC2028_DEFAULT_FIRMWARE,
+                                        .max_len = 64
+                                };
+                                struct v4l2_priv_tun_config cfg = {
+                                        .tuner = dev->tuner_type,
+                                        .priv = &ctrl
+                                };
+                                v4l2_subdev_call(sd, tuner, s_config, &cfg);
+                        }
                 }
         }
 
diff --git a/drivers/media/video/cx23885/cx23885.h b/drivers/media/video/cx23885/cx23885.h
index 08b3f6b136a0..0e3a98d243c5 100644
--- a/drivers/media/video/cx23885/cx23885.h
+++ b/drivers/media/video/cx23885/cx23885.h
@@ -81,6 +81,7 @@
 #define CX23885_BOARD_COMPRO_VIDEOMATE_E800    25
 #define CX23885_BOARD_HAUPPAUGE_HVR1290        26
 #define CX23885_BOARD_MYGICA_X8558PRO          27
+#define CX23885_BOARD_LEADTEK_WINFAST_PXTV1200 28
 
 #define GPIO_0 0x00000001
 #define GPIO_1 0x00000002
diff --git a/drivers/media/video/cx25840/cx25840-core.c b/drivers/media/video/cx25840/cx25840-core.c
index 385ecd58f1c0..f2461cd3de5a 100644
--- a/drivers/media/video/cx25840/cx25840-core.c
+++ b/drivers/media/video/cx25840/cx25840-core.c
@@ -734,10 +734,8 @@ static int set_input(struct i2c_client *client, enum cx25840_video_input vid_inp
                 v4l_dbg(1, cx25840_debug, client, "vid_input 0x%x\n",
                         vid_input);
                 reg = vid_input & 0xff;
-                if ((vid_input & CX25840_SVIDEO_ON) == CX25840_SVIDEO_ON)
-                        is_composite = 0;
-                else if ((vid_input & CX25840_COMPONENT_ON) == 0)
-                        is_composite = 1;
+                is_composite = !is_component &&
+                        ((vid_input & CX25840_SVIDEO_ON) != CX25840_SVIDEO_ON);
 
                 v4l_dbg(1, cx25840_debug, client, "mux cfg 0x%x comp=%d\n",
                         reg, is_composite);
@@ -1347,30 +1345,59 @@ static int cx25840_s_register(struct v4l2_subdev *sd, struct v4l2_dbg_register *
 }
 #endif
 
+static int cx25840_s_audio_stream(struct v4l2_subdev *sd, int enable)
+{
+        struct cx25840_state *state = to_state(sd);
+        struct i2c_client *client = v4l2_get_subdevdata(sd);
+        u8 v;
+
+        if (is_cx2583x(state) || is_cx2388x(state) || is_cx231xx(state))
+                return 0;
+
+        v4l_dbg(1, cx25840_debug, client, "%s audio output\n",
+                        enable ? "enable" : "disable");
+
+        if (enable) {
+                v = cx25840_read(client, 0x115) | 0x80;
+                cx25840_write(client, 0x115, v);
+                v = cx25840_read(client, 0x116) | 0x03;
+                cx25840_write(client, 0x116, v);
+        } else {
+                v = cx25840_read(client, 0x115) & ~(0x80);
+                cx25840_write(client, 0x115, v);
+                v = cx25840_read(client, 0x116) & ~(0x03);
+                cx25840_write(client, 0x116, v);
+        }
+        return 0;
+}
+
 static int cx25840_s_stream(struct v4l2_subdev *sd, int enable)
 {
         struct cx25840_state *state = to_state(sd);
         struct i2c_client *client = v4l2_get_subdevdata(sd);
+        u8 v;
 
-        v4l_dbg(1, cx25840_debug, client, "%s output\n",
+        v4l_dbg(1, cx25840_debug, client, "%s video output\n",
                         enable ? "enable" : "disable");
         if (enable) {
                 if (is_cx2388x(state) || is_cx231xx(state)) {
-                        u8 v = (cx25840_read(client, 0x421) | 0x0b);
+                        v = cx25840_read(client, 0x421) | 0x0b;
                         cx25840_write(client, 0x421, v);
                 } else {
-                        cx25840_write(client, 0x115,
-                                        is_cx2583x(state) ? 0x0c : 0x8c);
-                        cx25840_write(client, 0x116,
-                                        is_cx2583x(state) ? 0x04 : 0x07);
+                        v = cx25840_read(client, 0x115) | 0x0c;
+                        cx25840_write(client, 0x115, v);
+                        v = cx25840_read(client, 0x116) | 0x04;
+                        cx25840_write(client, 0x116, v);
                 }
         } else {
                 if (is_cx2388x(state) || is_cx231xx(state)) {
-                        u8 v = cx25840_read(client, 0x421) & ~(0x0b);
+                        v = cx25840_read(client, 0x421) & ~(0x0b);
                         cx25840_write(client, 0x421, v);
                 } else {
-                        cx25840_write(client, 0x115, 0x00);
-                        cx25840_write(client, 0x116, 0x00);
+                        v = cx25840_read(client, 0x115) & ~(0x0c);
+                        cx25840_write(client, 0x115, v);
+                        v = cx25840_read(client, 0x116) & ~(0x04);
+                        cx25840_write(client, 0x116, v);
                 }
         }
         return 0;
@@ -1601,6 +1628,7 @@ static const struct v4l2_subdev_tuner_ops cx25840_tuner_ops = {
 static const struct v4l2_subdev_audio_ops cx25840_audio_ops = {
         .s_clock_freq = cx25840_s_clock_freq,
         .s_routing = cx25840_s_audio_routing,
+        .s_stream = cx25840_s_audio_stream,
 };
 
 static const struct v4l2_subdev_video_ops cx25840_video_ops = {
diff --git a/drivers/media/video/cx88/cx88-alsa.c b/drivers/media/video/cx88/cx88-alsa.c
index 5a67445dd6ed..64b350df78e3 100644
--- a/drivers/media/video/cx88/cx88-alsa.c
+++ b/drivers/media/video/cx88/cx88-alsa.c
@@ -583,16 +583,18 @@ static int snd_cx88_volume_put(struct snd_kcontrol *kcontrol,
 {
         snd_cx88_card_t *chip = snd_kcontrol_chip(kcontrol);
         struct cx88_core *core=chip->core;
-        int v, b;
+        int left, right, v, b;
         int changed = 0;
         u32 old;
 
-        b = value->value.integer.value[1] - value->value.integer.value[0];
+        left = value->value.integer.value[0] & 0x3f;
+        right = value->value.integer.value[1] & 0x3f;
+        b = right - left;
         if (b < 0) {
-            v = 0x3f - value->value.integer.value[0];
+            v = 0x3f - left;
             b = (-b) | 0x40;
         } else {
-            v = 0x3f - value->value.integer.value[1];
+            v = 0x3f - right;
         }
         /* Do we really know this will always be called with IRQs on? */
         spin_lock_irq(&chip->reg_lock);
diff --git a/drivers/media/video/cx88/cx88-cards.c b/drivers/media/video/cx88/cx88-cards.c
index d844f2aaa01d..eaf0ee7de832 100644
--- a/drivers/media/video/cx88/cx88-cards.c
+++ b/drivers/media/video/cx88/cx88-cards.c
@@ -1466,6 +1466,18 @@ static const struct cx88_board cx88_boards[] = {
                         .audioroute = 8,
                 },
         },
+        [CX88_BOARD_SAMSUNG_SMT_7020] = {
+                .name           = "Samsung SMT 7020 DVB-S",
+                .tuner_type     = TUNER_ABSENT,
+                .radio_type     = UNSET,
+                .tuner_addr     = ADDR_UNSET,
+                .radio_addr     = ADDR_UNSET,
+                .input          = { {
+                        .type   = CX88_VMUX_DVB,
+                        .vmux   = 0,
+                } },
+                .mpeg           = CX88_MPEG_DVB,
+        },
         [CX88_BOARD_ADSTECH_PTV_390] = {
                 .name           = "ADS Tech Instant Video PCI",
                 .tuner_type     = TUNER_ABSENT,
@@ -2355,6 +2367,14 @@ static const struct cx88_subid cx88_subids[] = {
                 .subvendor = 0x0070,
                 .subdevice = 0x1404,
                 .card      = CX88_BOARD_HAUPPAUGE_HVR3000,
+        }, {
+                .subvendor = 0x18ac,
+                .subdevice = 0xdc00,
+                .card      = CX88_BOARD_SAMSUNG_SMT_7020,
+        }, {
+                .subvendor = 0x18ac,
+                .subdevice = 0xdccd,
+                .card      = CX88_BOARD_SAMSUNG_SMT_7020,
         },{
                 .subvendor = 0x1461,
                 .subdevice = 0xc111, /* AverMedia M150-D */
@@ -2633,6 +2653,9 @@ static void hauppauge_eeprom(struct cx88_core *core, u8 *eeprom_data)
         case 98559: /* WinTV-HVR1100LP (Video no IR, Retail - Low Profile) */
                 /* known */
                 break;
+        case CX88_BOARD_SAMSUNG_SMT_7020:
+                cx_set(MO_GP0_IO, 0x008989FF);
+                break;
         default:
                 warn_printk(core, "warning: unknown hauppauge model #%d\n",
                             tv.model);
diff --git a/drivers/media/video/cx88/cx88-dvb.c b/drivers/media/video/cx88/cx88-dvb.c
index b14296923250..94ab862f0219 100644
--- a/drivers/media/video/cx88/cx88-dvb.c
+++ b/drivers/media/video/cx88/cx88-dvb.c
@@ -674,6 +674,194 @@ static int cx8802_alloc_frontends(struct cx8802_dev *dev)
         return 0;
 }
 
+
+
+static u8 samsung_smt_7020_inittab[] = {
+             0x01, 0x15,
+             0x02, 0x00,
+             0x03, 0x00,
+             0x04, 0x7D,
+             0x05, 0x0F,
+             0x06, 0x02,
+             0x07, 0x00,
+             0x08, 0x60,
+
+             0x0A, 0xC2,
+             0x0B, 0x00,
+             0x0C, 0x01,
+             0x0D, 0x81,
+             0x0E, 0x44,
+             0x0F, 0x09,
+             0x10, 0x3C,
+             0x11, 0x84,
+             0x12, 0xDA,
+             0x13, 0x99,
+             0x14, 0x8D,
+             0x15, 0xCE,
+             0x16, 0xE8,
+             0x17, 0x43,
+             0x18, 0x1C,
+             0x19, 0x1B,
+             0x1A, 0x1D,
+
+             0x1C, 0x12,
+             0x1D, 0x00,
+             0x1E, 0x00,
+             0x1F, 0x00,
+             0x20, 0x00,
+             0x21, 0x00,
+             0x22, 0x00,
+             0x23, 0x00,
+
+             0x28, 0x02,
+             0x29, 0x28,
+             0x2A, 0x14,
+             0x2B, 0x0F,
+             0x2C, 0x09,
+             0x2D, 0x05,
+
+             0x31, 0x1F,
+             0x32, 0x19,
+             0x33, 0xFC,
+             0x34, 0x13,
+             0xff, 0xff,
+};
+
+
+static int samsung_smt_7020_tuner_set_params(struct dvb_frontend *fe,
+        struct dvb_frontend_parameters *params)
+{
+        struct cx8802_dev *dev = fe->dvb->priv;
+        u8 buf[4];
+        u32 div;
+        struct i2c_msg msg = {
+                .addr = 0x61,
+                .flags = 0,
+                .buf = buf,
+                .len = sizeof(buf) };
+
+        div = params->frequency / 125;
+
+        buf[0] = (div >> 8) & 0x7f;
+        buf[1] = div & 0xff;
+        buf[2] = 0x84;  /* 0xC4 */
+        buf[3] = 0x00;
+
+        if (params->frequency < 1500000)
+                buf[3] |= 0x10;
+
+        if (fe->ops.i2c_gate_ctrl)
+                fe->ops.i2c_gate_ctrl(fe, 1);
+
+        if (i2c_transfer(&dev->core->i2c_adap, &msg, 1) != 1)
+                return -EIO;
+
+        return 0;
+}
+
+static int samsung_smt_7020_set_tone(struct dvb_frontend *fe,
+        fe_sec_tone_mode_t tone)
+{
+        struct cx8802_dev *dev = fe->dvb->priv;
+        struct cx88_core *core = dev->core;
+
+        cx_set(MO_GP0_IO, 0x0800);
+
+        switch (tone) {
+        case SEC_TONE_ON:
+                cx_set(MO_GP0_IO, 0x08);
+                break;
+        case SEC_TONE_OFF:
+                cx_clear(MO_GP0_IO, 0x08);
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static int samsung_smt_7020_set_voltage(struct dvb_frontend *fe,
+        fe_sec_voltage_t voltage)
+{
+        struct cx8802_dev *dev = fe->dvb->priv;
+        struct cx88_core *core = dev->core;
+
+        u8 data;
+        struct i2c_msg msg = {
+                .addr = 8,
+                .flags = 0,
+                .buf = &data,
+                .len = sizeof(data) };
+
+        cx_set(MO_GP0_IO, 0x8000);
+
+        switch (voltage) {
+        case SEC_VOLTAGE_OFF:
+                break;
+        case SEC_VOLTAGE_13:
+                data = ISL6421_EN1 | ISL6421_LLC1;
+                cx_clear(MO_GP0_IO, 0x80);
+                break;
+        case SEC_VOLTAGE_18:
+                data = ISL6421_EN1 | ISL6421_LLC1 | ISL6421_VSEL1;
+                cx_clear(MO_GP0_IO, 0x80);
+                break;
+        default:
+                return -EINVAL;
+        };
+
+        return (i2c_transfer(&dev->core->i2c_adap, &msg, 1) == 1) ? 0 : -EIO;
+}
+
+static int samsung_smt_7020_stv0299_set_symbol_rate(struct dvb_frontend *fe,
+        u32 srate, u32 ratio)
+{
+        u8 aclk = 0;
+        u8 bclk = 0;
+
+        if (srate < 1500000) {
+                aclk = 0xb7;
+                bclk = 0x47;
+        } else if (srate < 3000000) {
+                aclk = 0xb7;
+                bclk = 0x4b;
+        } else if (srate < 7000000) {
+                aclk = 0xb7;
+                bclk = 0x4f;
+        } else if (srate < 14000000) {
+                aclk = 0xb7;
+                bclk = 0x53;
+        } else if (srate < 30000000) {
+                aclk = 0xb6;
+                bclk = 0x53;
+        } else if (srate < 45000000) {
+                aclk = 0xb4;
+                bclk = 0x51;
+        }
+
+        stv0299_writereg(fe, 0x13, aclk);
+        stv0299_writereg(fe, 0x14, bclk);
+        stv0299_writereg(fe, 0x1f, (ratio >> 16) & 0xff);
+        stv0299_writereg(fe, 0x20, (ratio >>  8) & 0xff);
+        stv0299_writereg(fe, 0x21, ratio & 0xf0);
+
+        return 0;
+}
+
+
+static struct stv0299_config samsung_stv0299_config = {
+        .demod_address = 0x68,
+        .inittab = samsung_smt_7020_inittab,
+        .mclk = 88000000UL,
+        .invert = 0,
+        .skip_reinit = 0,
+        .lock_output = STV0299_LOCKOUTPUT_LK,
+        .volt13_op0_op1 = STV0299_VOLT13_OP1,
+        .min_delay_ms = 100,
+        .set_symbol_rate = samsung_smt_7020_stv0299_set_symbol_rate,
+};
+
 static int dvb_register(struct cx8802_dev *dev)
 {
         struct cx88_core *core = dev->core;
@@ -1203,6 +1391,32 @@ static int dvb_register(struct cx8802_dev *dev)
                 }
                 break;
                 }
+        case CX88_BOARD_SAMSUNG_SMT_7020:
+                dev->ts_gen_cntrl = 0x08;
+
+                cx_set(MO_GP0_IO, 0x0101);
+
+                cx_clear(MO_GP0_IO, 0x01);
+                mdelay(100);
+                cx_set(MO_GP0_IO, 0x01);
+                mdelay(200);
+
+                fe0->dvb.frontend = dvb_attach(stv0299_attach,
+                                        &samsung_stv0299_config,
+                                        &dev->core->i2c_adap);
+                if (fe0->dvb.frontend) {
+                        fe0->dvb.frontend->ops.tuner_ops.set_params =
+                                samsung_smt_7020_tuner_set_params;
+                        fe0->dvb.frontend->tuner_priv =
+                                &dev->core->i2c_adap;
+                        fe0->dvb.frontend->ops.set_voltage =
+                                samsung_smt_7020_set_voltage;
+                        fe0->dvb.frontend->ops.set_tone =
+                                samsung_smt_7020_set_tone;
+                }
+
+                break;
+
         default:
                 printk(KERN_ERR "%s/2: The frontend of your DVB/ATSC card isn't supported yet\n",
                        core->name);
diff --git a/drivers/media/video/cx88/cx88-input.c b/drivers/media/video/cx88/cx88-input.c
index f9fda18b410c..de180d4d5a21 100644
--- a/drivers/media/video/cx88/cx88-input.c
+++ b/drivers/media/video/cx88/cx88-input.c
@@ -192,7 +192,7 @@ int cx88_ir_init(struct cx88_core *core, struct pci_dev *pci)
         struct cx88_IR *ir;
         struct input_dev *input_dev;
         struct ir_scancode_table *ir_codes = NULL;
-        int ir_type = IR_TYPE_OTHER;
+        u64 ir_type = IR_TYPE_OTHER;
         int err = -ENOMEM;
 
         ir = kzalloc(sizeof(*ir), GFP_KERNEL);
@@ -383,7 +383,7 @@ int cx88_ir_init(struct cx88_core *core, struct pci_dev *pci)
         cx88_ir_start(core, ir);
 
         /* all done */
-        err = ir_input_register(ir->input, ir_codes);
+        err = ir_input_register(ir->input, ir_codes, NULL);
         if (err)
                 goto err_out_stop;
 
diff --git a/drivers/media/video/cx88/cx88-mpeg.c b/drivers/media/video/cx88/cx88-mpeg.c
index bb5104893411..338af77f7f01 100644
--- a/drivers/media/video/cx88/cx88-mpeg.c
+++ b/drivers/media/video/cx88/cx88-mpeg.c
@@ -110,6 +110,9 @@ static int cx8802_start_dma(struct cx8802_dev    *dev,
                 case CX88_BOARD_PCHDTV_HD5500:
                         cx_write(TS_SOP_STAT, 1<<13);
                         break;
+                case CX88_BOARD_SAMSUNG_SMT_7020:
+                        cx_write(TS_SOP_STAT, 0x00);
+                        break;
                 case CX88_BOARD_HAUPPAUGE_NOVASPLUS_S1:
                 case CX88_BOARD_HAUPPAUGE_NOVASE2_S1:
                         cx_write(MO_PINMUX_IO, 0x88); /* Enable MPEG parallel IO and video signal pins */
diff --git a/drivers/media/video/cx88/cx88.h b/drivers/media/video/cx88/cx88.h
index b1499bf604ea..48b6c04fb497 100644
--- a/drivers/media/video/cx88/cx88.h
+++ b/drivers/media/video/cx88/cx88.h
@@ -239,6 +239,7 @@ extern struct sram_channel cx88_sram_channels[];
 #define CX88_BOARD_WINFAST_DTV1800H        81
 #define CX88_BOARD_WINFAST_DTV2000H_J      82
 #define CX88_BOARD_PROF_7301               83
+#define CX88_BOARD_SAMSUNG_SMT_7020        84
 
 enum cx88_itype {
         CX88_VMUX_COMPOSITE1 = 1,
diff --git a/drivers/media/video/dabusb.c b/drivers/media/video/dabusb.c
index ee43876adb06..9b413a35e048 100644
--- a/drivers/media/video/dabusb.c
+++ b/drivers/media/video/dabusb.c
@@ -913,6 +913,8 @@ static void __exit dabusb_cleanup (void)
 MODULE_AUTHOR( DRIVER_AUTHOR );
 MODULE_DESCRIPTION( DRIVER_DESC );
 MODULE_LICENSE("GPL");
+MODULE_FIRMWARE("dabusb/firmware.fw");
+MODULE_FIRMWARE("dabusb/bitstream.bin");
 
 module_param(buffers, int, 0);
 MODULE_PARM_DESC (buffers, "Number of buffers (default=256)");
diff --git a/drivers/media/video/davinci/Makefile b/drivers/media/video/davinci/Makefile
index 1a8b8f3f182e..a37955745aaa 100644
--- a/drivers/media/video/davinci/Makefile
+++ b/drivers/media/video/davinci/Makefile
@@ -15,3 +15,4 @@ obj-$(CONFIG_VIDEO_VPSS_SYSTEM) += vpss.o
 obj-$(CONFIG_VIDEO_VPFE_CAPTURE) += vpfe_capture.o
 obj-$(CONFIG_VIDEO_DM6446_CCDC) += dm644x_ccdc.o
 obj-$(CONFIG_VIDEO_DM355_CCDC) += dm355_ccdc.o
+obj-$(CONFIG_VIDEO_ISIF) += isif.o
diff --git a/drivers/media/video/davinci/dm355_ccdc.c b/drivers/media/video/davinci/dm355_ccdc.c
index 314390016370..c29ac88ffd78 100644
--- a/drivers/media/video/davinci/dm355_ccdc.c
+++ b/drivers/media/video/davinci/dm355_ccdc.c
@@ -37,8 +37,12 @@
 #include <linux/platform_device.h>
 #include <linux/uaccess.h>
 #include <linux/videodev2.h>
+#include <linux/clk.h>
+#include <linux/err.h>
+
 #include <media/davinci/dm355_ccdc.h>
 #include <media/davinci/vpss.h>
+
 #include "dm355_ccdc_regs.h"
 #include "ccdc_hw_device.h"
 
@@ -46,67 +50,75 @@ MODULE_LICENSE("GPL");
 MODULE_DESCRIPTION("CCDC Driver for DM355");
 MODULE_AUTHOR("Texas Instruments");
 
-static struct device *dev;
-
-/* Object for CCDC raw mode */
-static struct ccdc_params_raw ccdc_hw_params_raw = {
-        .pix_fmt = CCDC_PIXFMT_RAW,
-        .frm_fmt = CCDC_FRMFMT_PROGRESSIVE,
-        .win = CCDC_WIN_VGA,
-        .fid_pol = VPFE_PINPOL_POSITIVE,
-        .vd_pol = VPFE_PINPOL_POSITIVE,
-        .hd_pol = VPFE_PINPOL_POSITIVE,
-        .gain = {
-                .r_ye = 256,
-                .gb_g = 256,
-                .gr_cy = 256,
-                .b_mg = 256
-        },
-        .config_params = {
-                .datasft = 2,
-                .data_sz = CCDC_DATA_10BITS,
-                .mfilt1 = CCDC_NO_MEDIAN_FILTER1,
-                .mfilt2 = CCDC_NO_MEDIAN_FILTER2,
-                .alaw = {
-                        .gama_wd = 2,
+static struct ccdc_oper_config {
+        struct device *dev;
+        /* CCDC interface type */
+        enum vpfe_hw_if_type if_type;
+        /* Raw Bayer configuration */
+        struct ccdc_params_raw bayer;
+        /* YCbCr configuration */
+        struct ccdc_params_ycbcr ycbcr;
+        /* Master clock */
+        struct clk *mclk;
+        /* slave clock */
+        struct clk *sclk;
+        /* ccdc base address */
+        void __iomem *base_addr;
+} ccdc_cfg = {
+        /* Raw configurations */
+        .bayer = {
+                .pix_fmt = CCDC_PIXFMT_RAW,
+                .frm_fmt = CCDC_FRMFMT_PROGRESSIVE,
+                .win = CCDC_WIN_VGA,
+                .fid_pol = VPFE_PINPOL_POSITIVE,
+                .vd_pol = VPFE_PINPOL_POSITIVE,
+                .hd_pol = VPFE_PINPOL_POSITIVE,
+                .gain = {
+                        .r_ye = 256,
+                        .gb_g = 256,
+                        .gr_cy = 256,
+                        .b_mg = 256
                 },
-                .blk_clamp = {
-                        .sample_pixel = 1,
-                        .dc_sub = 25
-                },
-                .col_pat_field0 = {
-                        .olop = CCDC_GREEN_BLUE,
-                        .olep = CCDC_BLUE,
-                        .elop = CCDC_RED,
-                        .elep = CCDC_GREEN_RED
-                },
-                .col_pat_field1 = {
-                        .olop = CCDC_GREEN_BLUE,
-                        .olep = CCDC_BLUE,
-                        .elop = CCDC_RED,
-                        .elep = CCDC_GREEN_RED
+                .config_params = {
+                        .datasft = 2,
+                        .mfilt1 = CCDC_NO_MEDIAN_FILTER1,
+                        .mfilt2 = CCDC_NO_MEDIAN_FILTER2,
+                        .alaw = {
+                                .gama_wd = 2,
+                        },
+                        .blk_clamp = {
+                                .sample_pixel = 1,
+                                .dc_sub = 25
+                        },
+                        .col_pat_field0 = {
+                                .olop = CCDC_GREEN_BLUE,
+                                .olep = CCDC_BLUE,
+                                .elop = CCDC_RED,
+                                .elep = CCDC_GREEN_RED
+                        },
+                        .col_pat_field1 = {
+                                .olop = CCDC_GREEN_BLUE,
+                                .olep = CCDC_BLUE,
+                                .elop = CCDC_RED,
+                                .elep = CCDC_GREEN_RED
+                        },
                 },
         },
+        /* YCbCr configuration */
+        .ycbcr = {
+                .win = CCDC_WIN_PAL,
+                .pix_fmt = CCDC_PIXFMT_YCBCR_8BIT,
+                .frm_fmt = CCDC_FRMFMT_INTERLACED,
+                .fid_pol = VPFE_PINPOL_POSITIVE,
+                .vd_pol = VPFE_PINPOL_POSITIVE,
+                .hd_pol = VPFE_PINPOL_POSITIVE,
+                .bt656_enable = 1,
+                .pix_order = CCDC_PIXORDER_CBYCRY,
+                .buf_type = CCDC_BUFTYPE_FLD_INTERLEAVED
+        },
 };
 
 
-/* Object for CCDC ycbcr mode */
-static struct ccdc_params_ycbcr ccdc_hw_params_ycbcr = {
-        .win = CCDC_WIN_PAL,
-        .pix_fmt = CCDC_PIXFMT_YCBCR_8BIT,
-        .frm_fmt = CCDC_FRMFMT_INTERLACED,
-        .fid_pol = VPFE_PINPOL_POSITIVE,
-        .vd_pol = VPFE_PINPOL_POSITIVE,
-        .hd_pol = VPFE_PINPOL_POSITIVE,
-        .bt656_enable = 1,
-        .pix_order = CCDC_PIXORDER_CBYCRY,
-        .buf_type = CCDC_BUFTYPE_FLD_INTERLEAVED
-};
-
-static enum vpfe_hw_if_type ccdc_if_type;
-static void *__iomem ccdc_base_addr;
-static int ccdc_addr_size;
-
 /* Raw Bayer formats */
 static u32 ccdc_raw_bayer_pix_formats[] =
                 {V4L2_PIX_FMT_SBGGR8, V4L2_PIX_FMT_SBGGR16};
@@ -118,18 +130,12 @@ static u32 ccdc_raw_yuv_pix_formats[] =
 /* register access routines */
 static inline u32 regr(u32 offset)
 {
-        return __raw_readl(ccdc_base_addr + offset);
+        return __raw_readl(ccdc_cfg.base_addr + offset);
 }
 
 static inline void regw(u32 val, u32 offset)
 {
-        __raw_writel(val, ccdc_base_addr + offset);
-}
-
-static void ccdc_set_ccdc_base(void *addr, int size)
-{
-        ccdc_base_addr = addr;
-        ccdc_addr_size = size;
+        __raw_writel(val, ccdc_cfg.base_addr + offset);
 }
 
 static void ccdc_enable(int en)
@@ -153,12 +159,12 @@ static void ccdc_enable_output_to_sdram(int en)
 static void ccdc_config_gain_offset(void)
 {
         /* configure gain */
-        regw(ccdc_hw_params_raw.gain.r_ye, RYEGAIN);
-        regw(ccdc_hw_params_raw.gain.gr_cy, GRCYGAIN);
-        regw(ccdc_hw_params_raw.gain.gb_g, GBGGAIN);
-        regw(ccdc_hw_params_raw.gain.b_mg, BMGGAIN);
+        regw(ccdc_cfg.bayer.gain.r_ye, RYEGAIN);
+        regw(ccdc_cfg.bayer.gain.gr_cy, GRCYGAIN);
+        regw(ccdc_cfg.bayer.gain.gb_g, GBGGAIN);
+        regw(ccdc_cfg.bayer.gain.b_mg, BMGGAIN);
         /* configure offset */
-        regw(ccdc_hw_params_raw.ccdc_offset, OFFSET);
+        regw(ccdc_cfg.bayer.ccdc_offset, OFFSET);
 }
 
 /*
@@ -169,7 +175,7 @@ static int ccdc_restore_defaults(void)
 {
         int i;
 
-        dev_dbg(dev, "\nstarting ccdc_restore_defaults...");
+        dev_dbg(ccdc_cfg.dev, "\nstarting ccdc_restore_defaults...");
         /* set all registers to zero */
         for (i = 0; i <= CCDC_REG_LAST; i += 4)
                 regw(0, i);
@@ -180,30 +186,29 @@ static int ccdc_restore_defaults(void)
         regw(CULH_DEFAULT, CULH);
         regw(CULV_DEFAULT, CULV);
         /* Set default Gain and Offset */
-        ccdc_hw_params_raw.gain.r_ye = GAIN_DEFAULT;
-        ccdc_hw_params_raw.gain.gb_g = GAIN_DEFAULT;
-        ccdc_hw_params_raw.gain.gr_cy = GAIN_DEFAULT;
-        ccdc_hw_params_raw.gain.b_mg = GAIN_DEFAULT;
+        ccdc_cfg.bayer.gain.r_ye = GAIN_DEFAULT;
+        ccdc_cfg.bayer.gain.gb_g = GAIN_DEFAULT;
+        ccdc_cfg.bayer.gain.gr_cy = GAIN_DEFAULT;
+        ccdc_cfg.bayer.gain.b_mg = GAIN_DEFAULT;
         ccdc_config_gain_offset();
         regw(OUTCLIP_DEFAULT, OUTCLIP);
         regw(LSCCFG2_DEFAULT, LSCCFG2);
         /* select ccdc input */
         if (vpss_select_ccdc_source(VPSS_CCDCIN)) {
-                dev_dbg(dev, "\ncouldn't select ccdc input source");
+                dev_dbg(ccdc_cfg.dev, "\ncouldn't select ccdc input source");
                 return -EFAULT;
         }
         /* select ccdc clock */
         if (vpss_enable_clock(VPSS_CCDC_CLOCK, 1) < 0) {
-                dev_dbg(dev, "\ncouldn't enable ccdc clock");
+                dev_dbg(ccdc_cfg.dev, "\ncouldn't enable ccdc clock");
                 return -EFAULT;
         }
-        dev_dbg(dev, "\nEnd of ccdc_restore_defaults...");
+        dev_dbg(ccdc_cfg.dev, "\nEnd of ccdc_restore_defaults...");
         return 0;
 }
 
 static int ccdc_open(struct device *device)
 {
-        dev = device;
         return ccdc_restore_defaults();
 }
 
@@ -226,7 +231,7 @@ static void ccdc_setwin(struct v4l2_rect *image_win,
         int vert_start, vert_nr_lines;
         int mid_img = 0;
 
-        dev_dbg(dev, "\nStarting ccdc_setwin...");
+        dev_dbg(ccdc_cfg.dev, "\nStarting ccdc_setwin...");
 
         /*
          * ppc - per pixel count. indicates how many pixels per cell
@@ -260,45 +265,46 @@ static void ccdc_setwin(struct v4l2_rect *image_win,
         regw(vert_start & CCDC_START_VER_ONE_MASK, SLV0);
         regw(vert_start & CCDC_START_VER_TWO_MASK, SLV1);
         regw(vert_nr_lines & CCDC_NUM_LINES_VER, NLV);
-        dev_dbg(dev, "\nEnd of ccdc_setwin...");
+        dev_dbg(ccdc_cfg.dev, "\nEnd of ccdc_setwin...");
 }
 
 static int validate_ccdc_param(struct ccdc_config_params_raw *ccdcparam)
 {
         if (ccdcparam->datasft < CCDC_DATA_NO_SHIFT ||
             ccdcparam->datasft > CCDC_DATA_SHIFT_6BIT) {
-                dev_dbg(dev, "Invalid value of data shift\n");
+                dev_dbg(ccdc_cfg.dev, "Invalid value of data shift\n");
                 return -EINVAL;
         }
 
         if (ccdcparam->mfilt1 < CCDC_NO_MEDIAN_FILTER1 ||
             ccdcparam->mfilt1 > CCDC_MEDIAN_FILTER1) {
-                dev_dbg(dev, "Invalid value of median filter1\n");
+                dev_dbg(ccdc_cfg.dev, "Invalid value of median filter1\n");
                 return -EINVAL;
         }
 
         if (ccdcparam->mfilt2 < CCDC_NO_MEDIAN_FILTER2 ||
             ccdcparam->mfilt2 > CCDC_MEDIAN_FILTER2) {
-                dev_dbg(dev, "Invalid value of median filter2\n");
+                dev_dbg(ccdc_cfg.dev, "Invalid value of median filter2\n");
                 return -EINVAL;
         }
 
         if ((ccdcparam->med_filt_thres < 0) ||
            (ccdcparam->med_filt_thres > CCDC_MED_FILT_THRESH)) {
-                dev_dbg(dev, "Invalid value of median filter threshold\n");
+                dev_dbg(ccdc_cfg.dev,
+                        "Invalid value of median filter thresold\n");
                 return -EINVAL;
         }
 
         if (ccdcparam->data_sz < CCDC_DATA_16BITS ||
             ccdcparam->data_sz > CCDC_DATA_8BITS) {
-                dev_dbg(dev, "Invalid value of data size\n");
+                dev_dbg(ccdc_cfg.dev, "Invalid value of data size\n");
                 return -EINVAL;
         }
 
         if (ccdcparam->alaw.enable) {
                 if (ccdcparam->alaw.gama_wd < CCDC_GAMMA_BITS_13_4 ||
                     ccdcparam->alaw.gama_wd > CCDC_GAMMA_BITS_09_0) {
-                        dev_dbg(dev, "Invalid value of ALAW\n");
+                        dev_dbg(ccdc_cfg.dev, "Invalid value of ALAW\n");
                         return -EINVAL;
                 }
         }
@@ -306,12 +312,14 @@ static int validate_ccdc_param(struct ccdc_config_params_raw *ccdcparam)
         if (ccdcparam->blk_clamp.b_clamp_enable) {
                 if (ccdcparam->blk_clamp.sample_pixel < CCDC_SAMPLE_1PIXELS ||
                     ccdcparam->blk_clamp.sample_pixel > CCDC_SAMPLE_16PIXELS) {
-                        dev_dbg(dev, "Invalid value of sample pixel\n");
+                        dev_dbg(ccdc_cfg.dev,
+                                "Invalid value of sample pixel\n");
                         return -EINVAL;
                 }
                 if (ccdcparam->blk_clamp.sample_ln < CCDC_SAMPLE_1LINES ||
                     ccdcparam->blk_clamp.sample_ln > CCDC_SAMPLE_16LINES) {
-                        dev_dbg(dev, "Invalid value of sample lines\n");
+                        dev_dbg(ccdc_cfg.dev,
+                                "Invalid value of sample lines\n");
                         return -EINVAL;
                 }
         }
@@ -325,18 +333,18 @@ static int ccdc_set_params(void __user *params)
         int x;
 
         /* only raw module parameters can be set through the IOCTL */
-        if (ccdc_if_type != VPFE_RAW_BAYER)
+        if (ccdc_cfg.if_type != VPFE_RAW_BAYER)
                 return -EINVAL;
 
         x = copy_from_user(&ccdc_raw_params, params, sizeof(ccdc_raw_params));
         if (x) {
-                dev_dbg(dev, "ccdc_set_params: error in copying ccdc"
+                dev_dbg(ccdc_cfg.dev, "ccdc_set_params: error in copying ccdc"
                         "params, %d\n", x);
                 return -EFAULT;
         }
 
         if (!validate_ccdc_param(&ccdc_raw_params)) {
-                memcpy(&ccdc_hw_params_raw.config_params,
+                memcpy(&ccdc_cfg.bayer.config_params,
                         &ccdc_raw_params,
                         sizeof(ccdc_raw_params));
                 return 0;
@@ -347,11 +355,11 @@ static int ccdc_set_params(void __user *params)
 /* This function will configure CCDC for YCbCr video capture */
 static void ccdc_config_ycbcr(void)
 {
-        struct ccdc_params_ycbcr *params = &ccdc_hw_params_ycbcr;
+        struct ccdc_params_ycbcr *params = &ccdc_cfg.ycbcr;
         u32 temp;
 
         /* first set the CCDC power on defaults values in all registers */
-        dev_dbg(dev, "\nStarting ccdc_config_ycbcr...");
+        dev_dbg(ccdc_cfg.dev, "\nStarting ccdc_config_ycbcr...");
         ccdc_restore_defaults();
 
         /* configure pixel format & video frame format */
@@ -403,7 +411,7 @@ static void ccdc_config_ycbcr(void)
                 regw(CCDC_SDOFST_FIELD_INTERLEAVED, SDOFST);
         }
 
-        dev_dbg(dev, "\nEnd of ccdc_config_ycbcr...\n");
+        dev_dbg(ccdc_cfg.dev, "\nEnd of ccdc_config_ycbcr...\n");
 }
 
 /*
@@ -483,7 +491,7 @@ int ccdc_write_dfc_entry(int index, struct ccdc_vertical_dft *dfc)
          */
 
         if (count) {
-                dev_err(dev, "defect table write timeout !!!\n");
+                dev_err(ccdc_cfg.dev, "defect table write timeout !!!\n");
                 return -1;
         }
         return 0;
@@ -605,12 +613,12 @@ static void ccdc_config_color_patterns(struct ccdc_col_pat *pat0,
 /* This function will configure CCDC for Raw mode image capture */
 static int ccdc_config_raw(void)
 {
-        struct ccdc_params_raw *params = &ccdc_hw_params_raw;
+        struct ccdc_params_raw *params = &ccdc_cfg.bayer;
         struct ccdc_config_params_raw *config_params =
-                &ccdc_hw_params_raw.config_params;
+                                        &ccdc_cfg.bayer.config_params;
         unsigned int val;
 
-        dev_dbg(dev, "\nStarting ccdc_config_raw...");
+        dev_dbg(ccdc_cfg.dev, "\nStarting ccdc_config_raw...");
 
         /* restore power on defaults to register */
         ccdc_restore_defaults();
@@ -659,7 +667,7 @@ static int ccdc_config_raw(void)
         val |= (config_params->datasft & CCDC_DATASFT_MASK) <<
                 CCDC_DATASFT_SHIFT;
         regw(val , MODESET);
-        dev_dbg(dev, "\nWriting 0x%x to MODESET...\n", val);
+        dev_dbg(ccdc_cfg.dev, "\nWriting 0x%x to MODESET...\n", val);
 
         /* Configure the Median Filter threshold */
         regw((config_params->med_filt_thres) & CCDC_MED_FILT_THRESH, MEDFILT);
@@ -681,7 +689,7 @@ static int ccdc_config_raw(void)
                 (config_params->mfilt2 << CCDC_MFILT2_SHIFT));
 
         regw(val, GAMMAWD);
-        dev_dbg(dev, "\nWriting 0x%x to GAMMAWD...\n", val);
+        dev_dbg(ccdc_cfg.dev, "\nWriting 0x%x to GAMMAWD...\n", val);
 
         /* configure video window */
         ccdc_setwin(&params->win, params->frm_fmt, 1);
@@ -706,7 +714,7 @@ static int ccdc_config_raw(void)
         /* Configure the Gain  & offset control */
         ccdc_config_gain_offset();
 
-        dev_dbg(dev, "\nWriting %x to COLPTN...\n", val);
+        dev_dbg(ccdc_cfg.dev, "\nWriting %x to COLPTN...\n", val);
 
         /* Configure DATAOFST  register */
         val = (config_params->data_offset.horz_offset & CCDC_DATAOFST_MASK) <<
@@ -726,7 +734,7 @@ static int ccdc_config_raw(void)
                         CCDC_HSIZE_VAL_MASK;
 
                 /* adjust to multiple of 32 */
-                dev_dbg(dev, "\nWriting 0x%x to HSIZE...\n",
+                dev_dbg(ccdc_cfg.dev, "\nWriting 0x%x to HSIZE...\n",
                        (((params->win.width) + 31) >> 5) &
                         CCDC_HSIZE_VAL_MASK);
         } else {
@@ -734,7 +742,7 @@ static int ccdc_config_raw(void)
                 val |= (((params->win.width * 2) + 31) >> 5) &
                         CCDC_HSIZE_VAL_MASK;
 
-                dev_dbg(dev, "\nWriting 0x%x to HSIZE...\n",
+                dev_dbg(ccdc_cfg.dev, "\nWriting 0x%x to HSIZE...\n",
                        (((params->win.width * 2) + 31) >> 5) &
                         CCDC_HSIZE_VAL_MASK);
         }
@@ -745,34 +753,34 @@ static int ccdc_config_raw(void)
                 if (params->image_invert_enable) {
                         /* For interlace inverse mode */
                         regw(CCDC_SDOFST_INTERLACE_INVERSE, SDOFST);
-                        dev_dbg(dev, "\nWriting %x to SDOFST...\n",
+                        dev_dbg(ccdc_cfg.dev, "\nWriting %x to SDOFST...\n",
                                 CCDC_SDOFST_INTERLACE_INVERSE);
                 } else {
                         /* For interlace non inverse mode */
                         regw(CCDC_SDOFST_INTERLACE_NORMAL, SDOFST);
-                        dev_dbg(dev, "\nWriting %x to SDOFST...\n",
+                        dev_dbg(ccdc_cfg.dev, "\nWriting %x to SDOFST...\n",
                                 CCDC_SDOFST_INTERLACE_NORMAL);
                 }
         } else if (params->frm_fmt == CCDC_FRMFMT_PROGRESSIVE) {
                 if (params->image_invert_enable) {
                         /* For progessive inverse mode */
                         regw(CCDC_SDOFST_PROGRESSIVE_INVERSE, SDOFST);
-                        dev_dbg(dev, "\nWriting %x to SDOFST...\n",
+                        dev_dbg(ccdc_cfg.dev, "\nWriting %x to SDOFST...\n",
                                 CCDC_SDOFST_PROGRESSIVE_INVERSE);
                 } else {
                         /* For progessive non inverse mode */
                         regw(CCDC_SDOFST_PROGRESSIVE_NORMAL, SDOFST);
-                        dev_dbg(dev, "\nWriting %x to SDOFST...\n",
+                        dev_dbg(ccdc_cfg.dev, "\nWriting %x to SDOFST...\n",
                                 CCDC_SDOFST_PROGRESSIVE_NORMAL);
                 }
         }
-        dev_dbg(dev, "\nend of ccdc_config_raw...");
+        dev_dbg(ccdc_cfg.dev, "\nend of ccdc_config_raw...");
         return 0;
 }
 
 static int ccdc_configure(void)
 {
-        if (ccdc_if_type == VPFE_RAW_BAYER)
+        if (ccdc_cfg.if_type == VPFE_RAW_BAYER)
                 return ccdc_config_raw();
         else
                 ccdc_config_ycbcr();
@@ -781,23 +789,23 @@ static int ccdc_configure(void)
 
 static int ccdc_set_buftype(enum ccdc_buftype buf_type)
 {
-        if (ccdc_if_type == VPFE_RAW_BAYER)
-                ccdc_hw_params_raw.buf_type = buf_type;
+        if (ccdc_cfg.if_type == VPFE_RAW_BAYER)
+                ccdc_cfg.bayer.buf_type = buf_type;
         else
-                ccdc_hw_params_ycbcr.buf_type = buf_type;
+                ccdc_cfg.ycbcr.buf_type = buf_type;
         return 0;
 }
 static enum ccdc_buftype ccdc_get_buftype(void)
 {
-        if (ccdc_if_type == VPFE_RAW_BAYER)
-                return ccdc_hw_params_raw.buf_type;
-        return ccdc_hw_params_ycbcr.buf_type;
+        if (ccdc_cfg.if_type == VPFE_RAW_BAYER)
+                return ccdc_cfg.bayer.buf_type;
+        return ccdc_cfg.ycbcr.buf_type;
 }
 
 static int ccdc_enum_pix(u32 *pix, int i)
 {
         int ret = -EINVAL;
-        if (ccdc_if_type == VPFE_RAW_BAYER) {
+        if (ccdc_cfg.if_type == VPFE_RAW_BAYER) {
                 if (i < ARRAY_SIZE(ccdc_raw_bayer_pix_formats)) {
                         *pix = ccdc_raw_bayer_pix_formats[i];
                         ret = 0;
@@ -813,20 +821,19 @@ static int ccdc_enum_pix(u32 *pix, int i)
 
 static int ccdc_set_pixel_format(u32 pixfmt)
 {
-        struct ccdc_a_law *alaw =
-                &ccdc_hw_params_raw.config_params.alaw;
+        struct ccdc_a_law *alaw = &ccdc_cfg.bayer.config_params.alaw;
 
-        if (ccdc_if_type == VPFE_RAW_BAYER) {
-                ccdc_hw_params_raw.pix_fmt = CCDC_PIXFMT_RAW;
+        if (ccdc_cfg.if_type == VPFE_RAW_BAYER) {
+                ccdc_cfg.bayer.pix_fmt = CCDC_PIXFMT_RAW;
                 if (pixfmt == V4L2_PIX_FMT_SBGGR8)
                         alaw->enable = 1;
                 else if (pixfmt != V4L2_PIX_FMT_SBGGR16)
                         return -EINVAL;
         } else {
                 if (pixfmt == V4L2_PIX_FMT_YUYV)
-                        ccdc_hw_params_ycbcr.pix_order = CCDC_PIXORDER_YCBYCR;
+                        ccdc_cfg.ycbcr.pix_order = CCDC_PIXORDER_YCBYCR;
                 else if (pixfmt == V4L2_PIX_FMT_UYVY)
-                        ccdc_hw_params_ycbcr.pix_order = CCDC_PIXORDER_CBYCRY;
+                        ccdc_cfg.ycbcr.pix_order = CCDC_PIXORDER_CBYCRY;
                 else
                         return -EINVAL;
         }
@@ -834,17 +841,16 @@ static int ccdc_set_pixel_format(u32 pixfmt)
 }
 static u32 ccdc_get_pixel_format(void)
 {
-        struct ccdc_a_law *alaw =
-                &ccdc_hw_params_raw.config_params.alaw;
+        struct ccdc_a_law *alaw = &ccdc_cfg.bayer.config_params.alaw;
         u32 pixfmt;
 
-        if (ccdc_if_type == VPFE_RAW_BAYER)
+        if (ccdc_cfg.if_type == VPFE_RAW_BAYER)
                 if (alaw->enable)
                         pixfmt = V4L2_PIX_FMT_SBGGR8;
                 else
                         pixfmt = V4L2_PIX_FMT_SBGGR16;
         else {
-                if (ccdc_hw_params_ycbcr.pix_order == CCDC_PIXORDER_YCBYCR)
+                if (ccdc_cfg.ycbcr.pix_order == CCDC_PIXORDER_YCBYCR)
                         pixfmt = V4L2_PIX_FMT_YUYV;
                 else
                         pixfmt = V4L2_PIX_FMT_UYVY;
@@ -853,53 +859,53 @@ static u32 ccdc_get_pixel_format(void)
 }
 static int ccdc_set_image_window(struct v4l2_rect *win)
 {
-        if (ccdc_if_type == VPFE_RAW_BAYER)
-                ccdc_hw_params_raw.win = *win;
+        if (ccdc_cfg.if_type == VPFE_RAW_BAYER)
+                ccdc_cfg.bayer.win = *win;
         else
-                ccdc_hw_params_ycbcr.win = *win;
+                ccdc_cfg.ycbcr.win = *win;
         return 0;
 }
 
 static void ccdc_get_image_window(struct v4l2_rect *win)
 {
-        if (ccdc_if_type == VPFE_RAW_BAYER)
-                *win = ccdc_hw_params_raw.win;
+        if (ccdc_cfg.if_type == VPFE_RAW_BAYER)
+                *win = ccdc_cfg.bayer.win;
         else
-                *win = ccdc_hw_params_ycbcr.win;
+                *win = ccdc_cfg.ycbcr.win;
 }
 
 static unsigned int ccdc_get_line_length(void)
 {
         struct ccdc_config_params_raw *config_params =
-                &ccdc_hw_params_raw.config_params;
+                                &ccdc_cfg.bayer.config_params;
         unsigned int len;
 
-        if (ccdc_if_type == VPFE_RAW_BAYER) {
+        if (ccdc_cfg.if_type == VPFE_RAW_BAYER) {
                 if ((config_params->alaw.enable) ||
                     (config_params->data_sz == CCDC_DATA_8BITS))
-                        len = ccdc_hw_params_raw.win.width;
+                        len = ccdc_cfg.bayer.win.width;
                 else
-                        len = ccdc_hw_params_raw.win.width * 2;
+                        len = ccdc_cfg.bayer.win.width * 2;
         } else
-                len = ccdc_hw_params_ycbcr.win.width * 2;
+                len = ccdc_cfg.ycbcr.win.width * 2;
         return ALIGN(len, 32);
 }
 
 static int ccdc_set_frame_format(enum ccdc_frmfmt frm_fmt)
 {
-        if (ccdc_if_type == VPFE_RAW_BAYER)
-                ccdc_hw_params_raw.frm_fmt = frm_fmt;
+        if (ccdc_cfg.if_type == VPFE_RAW_BAYER)
+                ccdc_cfg.bayer.frm_fmt = frm_fmt;
         else
-                ccdc_hw_params_ycbcr.frm_fmt = frm_fmt;
+                ccdc_cfg.ycbcr.frm_fmt = frm_fmt;
         return 0;
 }
 
 static enum ccdc_frmfmt ccdc_get_frame_format(void)
 {
-        if (ccdc_if_type == VPFE_RAW_BAYER)
-                return ccdc_hw_params_raw.frm_fmt;
+        if (ccdc_cfg.if_type == VPFE_RAW_BAYER)
+                return ccdc_cfg.bayer.frm_fmt;
         else
-                return ccdc_hw_params_ycbcr.frm_fmt;
+                return ccdc_cfg.ycbcr.frm_fmt;
 }
 
 static int ccdc_getfid(void)
@@ -916,14 +922,14 @@ static inline void ccdc_setfbaddr(unsigned long addr)
 
 static int ccdc_set_hw_if_params(struct vpfe_hw_if_param *params)
 {
-        ccdc_if_type = params->if_type;
+        ccdc_cfg.if_type = params->if_type;
 
         switch (params->if_type) {
         case VPFE_BT656:
         case VPFE_YCBCR_SYNC_16:
         case VPFE_YCBCR_SYNC_8:
-                ccdc_hw_params_ycbcr.vd_pol = params->vdpol;
-                ccdc_hw_params_ycbcr.hd_pol = params->hdpol;
+                ccdc_cfg.ycbcr.vd_pol = params->vdpol;
+                ccdc_cfg.ycbcr.hd_pol = params->hdpol;
                 break;
         default:
                 /* TODO add support for raw bayer here */
@@ -938,7 +944,6 @@ static struct ccdc_hw_device ccdc_hw_dev = {
         .hw_ops = {
                 .open = ccdc_open,
                 .close = ccdc_close,
-                .set_ccdc_base = ccdc_set_ccdc_base,
                 .enable = ccdc_enable,
                 .enable_out_to_sdram = ccdc_enable_output_to_sdram,
                 .set_hw_if_params = ccdc_set_hw_if_params,
@@ -959,19 +964,118 @@ static struct ccdc_hw_device ccdc_hw_dev = {
         },
 };
 
-static int __init dm355_ccdc_init(void)
+static int __init dm355_ccdc_probe(struct platform_device *pdev)
 {
-        printk(KERN_NOTICE "dm355_ccdc_init\n");
-        if (vpfe_register_ccdc_device(&ccdc_hw_dev) < 0)
-                return -1;
-        printk(KERN_NOTICE "%s is registered with vpfe.\n",
-                ccdc_hw_dev.name);
+        void (*setup_pinmux)(void);
+        struct resource *res;
+        int status = 0;
+
+        /*
+         * first try to register with vpfe. If not correct platform, then we
+         * don't have to iomap
+         */
+        status = vpfe_register_ccdc_device(&ccdc_hw_dev);
+        if (status < 0)
+                return status;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                status = -ENODEV;
+                goto fail_nores;
+        }
+
+        res = request_mem_region(res->start, resource_size(res), res->name);
+        if (!res) {
+                status = -EBUSY;
+                goto fail_nores;
+        }
+
+        ccdc_cfg.base_addr = ioremap_nocache(res->start, resource_size(res));
+        if (!ccdc_cfg.base_addr) {
+                status = -ENOMEM;
+                goto fail_nomem;
+        }
+
+        /* Get and enable Master clock */
+        ccdc_cfg.mclk = clk_get(&pdev->dev, "master");
+        if (IS_ERR(ccdc_cfg.mclk)) {
+                status = PTR_ERR(ccdc_cfg.mclk);
+                goto fail_nomap;
+        }
+        if (clk_enable(ccdc_cfg.mclk)) {
+                status = -ENODEV;
+                goto fail_mclk;
+        }
+
+        /* Get and enable Slave clock */
+        ccdc_cfg.sclk = clk_get(&pdev->dev, "slave");
+        if (IS_ERR(ccdc_cfg.sclk)) {
+                status = PTR_ERR(ccdc_cfg.sclk);
+                goto fail_mclk;
+        }
+        if (clk_enable(ccdc_cfg.sclk)) {
+                status = -ENODEV;
+                goto fail_sclk;
+        }
+
+        /* Platform data holds setup_pinmux function ptr */
+        if (NULL == pdev->dev.platform_data) {
+                status = -ENODEV;
+                goto fail_sclk;
+        }
+        setup_pinmux = pdev->dev.platform_data;
+        /*
+         * setup Mux configuration for ccdc which may be different for
+         * different SoCs using this CCDC
+         */
+        setup_pinmux();
+        ccdc_cfg.dev = &pdev->dev;
+        printk(KERN_NOTICE "%s is registered with vpfe.\n", ccdc_hw_dev.name);
         return 0;
+fail_sclk:
+        clk_put(ccdc_cfg.sclk);
+fail_mclk:
+        clk_put(ccdc_cfg.mclk);
+fail_nomap:
+        iounmap(ccdc_cfg.base_addr);
+fail_nomem:
+        release_mem_region(res->start, resource_size(res));
+fail_nores:
+        vpfe_unregister_ccdc_device(&ccdc_hw_dev);
+        return status;
 }
 
-static void __exit dm355_ccdc_exit(void)
+static int dm355_ccdc_remove(struct platform_device *pdev)
 {
+        struct resource *res;
+
+        clk_put(ccdc_cfg.mclk);
+        clk_put(ccdc_cfg.sclk);
+        iounmap(ccdc_cfg.base_addr);
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (res)
+                release_mem_region(res->start, resource_size(res));
         vpfe_unregister_ccdc_device(&ccdc_hw_dev);
+        return 0;
+}
+
+static struct platform_driver dm355_ccdc_driver = {
+        .driver = {
+                .name   = "dm355_ccdc",
+                .owner = THIS_MODULE,
+        },
+        .remove = __devexit_p(dm355_ccdc_remove),
+        .probe = dm355_ccdc_probe,
+};
+
+static int __init dm355_ccdc_init(void)
+{
+        return platform_driver_register(&dm355_ccdc_driver);
+}
+
+static void __exit dm355_ccdc_exit(void)
+{
+        platform_driver_unregister(&dm355_ccdc_driver);
 }
 
 module_init(dm355_ccdc_init);
diff --git a/drivers/media/video/davinci/dm644x_ccdc.c b/drivers/media/video/davinci/dm644x_ccdc.c
index d5fa193f32d2..0c394cade22a 100644
--- a/drivers/media/video/davinci/dm644x_ccdc.c
+++ b/drivers/media/video/davinci/dm644x_ccdc.c
@@ -37,8 +37,12 @@
 #include <linux/platform_device.h>
 #include <linux/uaccess.h>
 #include <linux/videodev2.h>
+#include <linux/clk.h>
+#include <linux/err.h>
+
 #include <media/davinci/dm644x_ccdc.h>
 #include <media/davinci/vpss.h>
+
 #include "dm644x_ccdc_regs.h"
 #include "ccdc_hw_device.h"
 
@@ -46,32 +50,44 @@ MODULE_LICENSE("GPL");
 MODULE_DESCRIPTION("CCDC Driver for DM6446");
 MODULE_AUTHOR("Texas Instruments");
 
-static struct device *dev;
-
-/* Object for CCDC raw mode */
-static struct ccdc_params_raw ccdc_hw_params_raw = {
-        .pix_fmt = CCDC_PIXFMT_RAW,
-        .frm_fmt = CCDC_FRMFMT_PROGRESSIVE,
-        .win = CCDC_WIN_VGA,
-        .fid_pol = VPFE_PINPOL_POSITIVE,
-        .vd_pol = VPFE_PINPOL_POSITIVE,
-        .hd_pol = VPFE_PINPOL_POSITIVE,
-        .config_params = {
-                .data_sz = CCDC_DATA_10BITS,
+static struct ccdc_oper_config {
+        struct device *dev;
+        /* CCDC interface type */
+        enum vpfe_hw_if_type if_type;
+        /* Raw Bayer configuration */
+        struct ccdc_params_raw bayer;
+        /* YCbCr configuration */
+        struct ccdc_params_ycbcr ycbcr;
+        /* Master clock */
+        struct clk *mclk;
+        /* slave clock */
+        struct clk *sclk;
+        /* ccdc base address */
+        void __iomem *base_addr;
+} ccdc_cfg = {
+        /* Raw configurations */
+        .bayer = {
+                .pix_fmt = CCDC_PIXFMT_RAW,
+                .frm_fmt = CCDC_FRMFMT_PROGRESSIVE,
+                .win = CCDC_WIN_VGA,
+                .fid_pol = VPFE_PINPOL_POSITIVE,
+                .vd_pol = VPFE_PINPOL_POSITIVE,
+                .hd_pol = VPFE_PINPOL_POSITIVE,
+                .config_params = {
+                        .data_sz = CCDC_DATA_10BITS,
+                },
+        },
+        .ycbcr = {
+                .pix_fmt = CCDC_PIXFMT_YCBCR_8BIT,
+                .frm_fmt = CCDC_FRMFMT_INTERLACED,
+                .win = CCDC_WIN_PAL,
+                .fid_pol = VPFE_PINPOL_POSITIVE,
+                .vd_pol = VPFE_PINPOL_POSITIVE,
+                .hd_pol = VPFE_PINPOL_POSITIVE,
+                .bt656_enable = 1,
+                .pix_order = CCDC_PIXORDER_CBYCRY,
+                .buf_type = CCDC_BUFTYPE_FLD_INTERLEAVED
         },
-};
-
-/* Object for CCDC ycbcr mode */
-static struct ccdc_params_ycbcr ccdc_hw_params_ycbcr = {
-        .pix_fmt = CCDC_PIXFMT_YCBCR_8BIT,
-        .frm_fmt = CCDC_FRMFMT_INTERLACED,
-        .win = CCDC_WIN_PAL,
-        .fid_pol = VPFE_PINPOL_POSITIVE,
-        .vd_pol = VPFE_PINPOL_POSITIVE,
-        .hd_pol = VPFE_PINPOL_POSITIVE,
-        .bt656_enable = 1,
-        .pix_order = CCDC_PIXORDER_CBYCRY,
-        .buf_type = CCDC_BUFTYPE_FLD_INTERLEAVED
 };
 
 #define CCDC_MAX_RAW_YUV_FORMATS        2
@@ -84,25 +100,15 @@ static u32 ccdc_raw_bayer_pix_formats[] =
 static u32 ccdc_raw_yuv_pix_formats[] =
         {V4L2_PIX_FMT_UYVY, V4L2_PIX_FMT_YUYV};
 
-static void *__iomem ccdc_base_addr;
-static int ccdc_addr_size;
-static enum vpfe_hw_if_type ccdc_if_type;
-
 /* register access routines */
 static inline u32 regr(u32 offset)
 {
-        return __raw_readl(ccdc_base_addr + offset);
+        return __raw_readl(ccdc_cfg.base_addr + offset);
 }
 
 static inline void regw(u32 val, u32 offset)
 {
-        __raw_writel(val, ccdc_base_addr + offset);
-}
-
-static void ccdc_set_ccdc_base(void *addr, int size)
-{
-        ccdc_base_addr = addr;
-        ccdc_addr_size = size;
+        __raw_writel(val, ccdc_cfg.base_addr + offset);
 }
 
 static void ccdc_enable(int flag)
@@ -132,7 +138,7 @@ void ccdc_setwin(struct v4l2_rect *image_win,
         int vert_start, vert_nr_lines;
         int val = 0, mid_img = 0;
 
-        dev_dbg(dev, "\nStarting ccdc_setwin...");
+        dev_dbg(ccdc_cfg.dev, "\nStarting ccdc_setwin...");
         /*
          * ppc - per pixel count. indicates how many pixels per cell
          * output to SDRAM. example, for ycbcr, it is one y and one c, so 2.
@@ -171,7 +177,7 @@ void ccdc_setwin(struct v4l2_rect *image_win,
         regw((vert_start << CCDC_VERT_START_SLV0_SHIFT) | vert_start,
              CCDC_VERT_START);
         regw(vert_nr_lines, CCDC_VERT_LINES);
-        dev_dbg(dev, "\nEnd of ccdc_setwin...");
+        dev_dbg(ccdc_cfg.dev, "\nEnd of ccdc_setwin...");
 }
 
 static void ccdc_readregs(void)
@@ -179,39 +185,39 @@ static void ccdc_readregs(void)
         unsigned int val = 0;
 
         val = regr(CCDC_ALAW);
-        dev_notice(dev, "\nReading 0x%x to ALAW...\n", val);
+        dev_notice(ccdc_cfg.dev, "\nReading 0x%x to ALAW...\n", val);
         val = regr(CCDC_CLAMP);
-        dev_notice(dev, "\nReading 0x%x to CLAMP...\n", val);
+        dev_notice(ccdc_cfg.dev, "\nReading 0x%x to CLAMP...\n", val);
         val = regr(CCDC_DCSUB);
-        dev_notice(dev, "\nReading 0x%x to DCSUB...\n", val);
+        dev_notice(ccdc_cfg.dev, "\nReading 0x%x to DCSUB...\n", val);
         val = regr(CCDC_BLKCMP);
-        dev_notice(dev, "\nReading 0x%x to BLKCMP...\n", val);
+        dev_notice(ccdc_cfg.dev, "\nReading 0x%x to BLKCMP...\n", val);
         val = regr(CCDC_FPC_ADDR);
-        dev_notice(dev, "\nReading 0x%x to FPC_ADDR...\n", val);
+        dev_notice(ccdc_cfg.dev, "\nReading 0x%x to FPC_ADDR...\n", val);
         val = regr(CCDC_FPC);
-        dev_notice(dev, "\nReading 0x%x to FPC...\n", val);
+        dev_notice(ccdc_cfg.dev, "\nReading 0x%x to FPC...\n", val);
         val = regr(CCDC_FMTCFG);
-        dev_notice(dev, "\nReading 0x%x to FMTCFG...\n", val);
+        dev_notice(ccdc_cfg.dev, "\nReading 0x%x to FMTCFG...\n", val);
         val = regr(CCDC_COLPTN);
-        dev_notice(dev, "\nReading 0x%x to COLPTN...\n", val);
+        dev_notice(ccdc_cfg.dev, "\nReading 0x%x to COLPTN...\n", val);
         val = regr(CCDC_FMT_HORZ);
-        dev_notice(dev, "\nReading 0x%x to FMT_HORZ...\n", val);
+        dev_notice(ccdc_cfg.dev, "\nReading 0x%x to FMT_HORZ...\n", val);
         val = regr(CCDC_FMT_VERT);
-        dev_notice(dev, "\nReading 0x%x to FMT_VERT...\n", val);
+        dev_notice(ccdc_cfg.dev, "\nReading 0x%x to FMT_VERT...\n", val);
         val = regr(CCDC_HSIZE_OFF);
-        dev_notice(dev, "\nReading 0x%x to HSIZE_OFF...\n", val);
+        dev_notice(ccdc_cfg.dev, "\nReading 0x%x to HSIZE_OFF...\n", val);
         val = regr(CCDC_SDOFST);
-        dev_notice(dev, "\nReading 0x%x to SDOFST...\n", val);
+        dev_notice(ccdc_cfg.dev, "\nReading 0x%x to SDOFST...\n", val);
         val = regr(CCDC_VP_OUT);
-        dev_notice(dev, "\nReading 0x%x to VP_OUT...\n", val);
+        dev_notice(ccdc_cfg.dev, "\nReading 0x%x to VP_OUT...\n", val);
         val = regr(CCDC_SYN_MODE);
-        dev_notice(dev, "\nReading 0x%x to SYN_MODE...\n", val);
+        dev_notice(ccdc_cfg.dev, "\nReading 0x%x to SYN_MODE...\n", val);
         val = regr(CCDC_HORZ_INFO);
-        dev_notice(dev, "\nReading 0x%x to HORZ_INFO...\n", val);
+        dev_notice(ccdc_cfg.dev, "\nReading 0x%x to HORZ_INFO...\n", val);
         val = regr(CCDC_VERT_START);
-        dev_notice(dev, "\nReading 0x%x to VERT_START...\n", val);
+        dev_notice(ccdc_cfg.dev, "\nReading 0x%x to VERT_START...\n", val);
         val = regr(CCDC_VERT_LINES);
-        dev_notice(dev, "\nReading 0x%x to VERT_LINES...\n", val);
+        dev_notice(ccdc_cfg.dev, "\nReading 0x%x to VERT_LINES...\n", val);
 }
 
 static int validate_ccdc_param(struct ccdc_config_params_raw *ccdcparam)
@@ -220,7 +226,7 @@ static int validate_ccdc_param(struct ccdc_config_params_raw *ccdcparam)
                 if ((ccdcparam->alaw.gama_wd > CCDC_GAMMA_BITS_09_0) ||
                     (ccdcparam->alaw.gama_wd < CCDC_GAMMA_BITS_15_6) ||
                     (ccdcparam->alaw.gama_wd < ccdcparam->data_sz)) {
-                        dev_dbg(dev, "\nInvalid data line select");
+                        dev_dbg(ccdc_cfg.dev, "\nInvalid data line select");
                         return -1;
                 }
         }
@@ -230,7 +236,7 @@ static int validate_ccdc_param(struct ccdc_config_params_raw *ccdcparam)
 static int ccdc_update_raw_params(struct ccdc_config_params_raw *raw_params)
 {
         struct ccdc_config_params_raw *config_params =
-                &ccdc_hw_params_raw.config_params;
+                                &ccdc_cfg.bayer.config_params;
         unsigned int *fpc_virtaddr = NULL;
         unsigned int *fpc_physaddr = NULL;
 
@@ -266,7 +272,7 @@ static int ccdc_update_raw_params(struct ccdc_config_params_raw *raw_params)
                                                          FP_NUM_BYTES));
 
                 if (fpc_virtaddr == NULL) {
-                        dev_dbg(dev,
+                        dev_dbg(ccdc_cfg.dev,
                                 "\nUnable to allocate memory for FPC");
                         return -EFAULT;
                 }
@@ -279,7 +285,7 @@ static int ccdc_update_raw_params(struct ccdc_config_params_raw *raw_params)
         if (copy_from_user(fpc_virtaddr,
                         (void __user *)raw_params->fault_pxl.fpc_table_addr,
                         config_params->fault_pxl.fp_num * FP_NUM_BYTES)) {
-                dev_dbg(dev, "\n copy_from_user failed");
+                dev_dbg(ccdc_cfg.dev, "\n copy_from_user failed");
                 return -EFAULT;
         }
         config_params->fault_pxl.fpc_table_addr = (unsigned int)fpc_physaddr;
@@ -289,7 +295,7 @@ static int ccdc_update_raw_params(struct ccdc_config_params_raw *raw_params)
 static int ccdc_close(struct device *dev)
 {
         struct ccdc_config_params_raw *config_params =
-                &ccdc_hw_params_raw.config_params;
+                                &ccdc_cfg.bayer.config_params;
         unsigned int *fpc_physaddr = NULL, *fpc_virtaddr = NULL;
 
         fpc_physaddr = (unsigned int *)config_params->fault_pxl.fpc_table_addr;
@@ -323,9 +329,8 @@ static void ccdc_restore_defaults(void)
 
 static int ccdc_open(struct device *device)
 {
-        dev = device;
         ccdc_restore_defaults();
-        if (ccdc_if_type == VPFE_RAW_BAYER)
+        if (ccdc_cfg.if_type == VPFE_RAW_BAYER)
                 ccdc_enable_vport(1);
         return 0;
 }
@@ -341,12 +346,12 @@ static int ccdc_set_params(void __user *params)
         struct ccdc_config_params_raw ccdc_raw_params;
         int x;
 
-        if (ccdc_if_type != VPFE_RAW_BAYER)
+        if (ccdc_cfg.if_type != VPFE_RAW_BAYER)
                 return -EINVAL;
 
         x = copy_from_user(&ccdc_raw_params, params, sizeof(ccdc_raw_params));
         if (x) {
-                dev_dbg(dev, "ccdc_set_params: error in copying"
+                dev_dbg(ccdc_cfg.dev, "ccdc_set_params: error in copying"
                            "ccdc params, %d\n", x);
                 return -EFAULT;
         }
@@ -364,10 +369,10 @@ static int ccdc_set_params(void __user *params)
  */
 void ccdc_config_ycbcr(void)
 {
-        struct ccdc_params_ycbcr *params = &ccdc_hw_params_ycbcr;
+        struct ccdc_params_ycbcr *params = &ccdc_cfg.ycbcr;
         u32 syn_mode;
 
-        dev_dbg(dev, "\nStarting ccdc_config_ycbcr...");
+        dev_dbg(ccdc_cfg.dev, "\nStarting ccdc_config_ycbcr...");
         /*
          * first restore the CCDC registers to default values
          * This is important since we assume default values to be set in
@@ -428,7 +433,7 @@ void ccdc_config_ycbcr(void)
                 regw(CCDC_SDOFST_FIELD_INTERLEAVED, CCDC_SDOFST);
 
         ccdc_sbl_reset();
-        dev_dbg(dev, "\nEnd of ccdc_config_ycbcr...\n");
+        dev_dbg(ccdc_cfg.dev, "\nEnd of ccdc_config_ycbcr...\n");
         ccdc_readregs();
 }
 
@@ -440,9 +445,9 @@ static void ccdc_config_black_clamp(struct ccdc_black_clamp *bclamp)
                 /* configure DCSub */
                 val = (bclamp->dc_sub) & CCDC_BLK_DC_SUB_MASK;
                 regw(val, CCDC_DCSUB);
-                dev_dbg(dev, "\nWriting 0x%x to DCSUB...\n", val);
+                dev_dbg(ccdc_cfg.dev, "\nWriting 0x%x to DCSUB...\n", val);
                 regw(CCDC_CLAMP_DEFAULT_VAL, CCDC_CLAMP);
-                dev_dbg(dev, "\nWriting 0x0000 to CLAMP...\n");
+                dev_dbg(ccdc_cfg.dev, "\nWriting 0x0000 to CLAMP...\n");
                 return;
         }
         /*
@@ -457,10 +462,10 @@ static void ccdc_config_black_clamp(struct ccdc_black_clamp *bclamp)
                ((bclamp->sample_pixel & CCDC_BLK_SAMPLE_LN_MASK) <<
                 CCDC_BLK_SAMPLE_LN_SHIFT) | CCDC_BLK_CLAMP_ENABLE);
         regw(val, CCDC_CLAMP);
-        dev_dbg(dev, "\nWriting 0x%x to CLAMP...\n", val);
+        dev_dbg(ccdc_cfg.dev, "\nWriting 0x%x to CLAMP...\n", val);
         /* If Black clamping is enable then make dcsub 0 */
         regw(CCDC_DCSUB_DEFAULT_VAL, CCDC_DCSUB);
-        dev_dbg(dev, "\nWriting 0x00000000 to DCSUB...\n");
+        dev_dbg(ccdc_cfg.dev, "\nWriting 0x00000000 to DCSUB...\n");
 }
 
 static void ccdc_config_black_compense(struct ccdc_black_compensation *bcomp)
@@ -490,17 +495,17 @@ static void ccdc_config_fpc(struct ccdc_fault_pixel *fpc)
 
         /* Configure Fault pixel if needed */
         regw(fpc->fpc_table_addr, CCDC_FPC_ADDR);
-        dev_dbg(dev, "\nWriting 0x%x to FPC_ADDR...\n",
+        dev_dbg(ccdc_cfg.dev, "\nWriting 0x%x to FPC_ADDR...\n",
                        (fpc->fpc_table_addr));
         /* Write the FPC params with FPC disable */
         val = fpc->fp_num & CCDC_FPC_FPC_NUM_MASK;
         regw(val, CCDC_FPC);
 
-        dev_dbg(dev, "\nWriting 0x%x to FPC...\n", val);
+        dev_dbg(ccdc_cfg.dev, "\nWriting 0x%x to FPC...\n", val);
         /* read the FPC register */
         val = regr(CCDC_FPC) | CCDC_FPC_ENABLE;
         regw(val, CCDC_FPC);
-        dev_dbg(dev, "\nWriting 0x%x to FPC...\n", val);
+        dev_dbg(ccdc_cfg.dev, "\nWriting 0x%x to FPC...\n", val);
 }
 
 /*
@@ -509,13 +514,13 @@ static void ccdc_config_fpc(struct ccdc_fault_pixel *fpc)
  */
 void ccdc_config_raw(void)
 {
-        struct ccdc_params_raw *params = &ccdc_hw_params_raw;
+        struct ccdc_params_raw *params = &ccdc_cfg.bayer;
         struct ccdc_config_params_raw *config_params =
-                &ccdc_hw_params_raw.config_params;
+                                &ccdc_cfg.bayer.config_params;
         unsigned int syn_mode = 0;
         unsigned int val;
 
-        dev_dbg(dev, "\nStarting ccdc_config_raw...");
+        dev_dbg(ccdc_cfg.dev, "\nStarting ccdc_config_raw...");
 
         /*      Reset CCDC */
         ccdc_restore_defaults();
@@ -545,7 +550,7 @@ void ccdc_config_raw(void)
                 val = ((config_params->alaw.gama_wd &
                       CCDC_ALAW_GAMA_WD_MASK) | CCDC_ALAW_ENABLE);
                 regw(val, CCDC_ALAW);
-                dev_dbg(dev, "\nWriting 0x%x to ALAW...\n", val);
+                dev_dbg(ccdc_cfg.dev, "\nWriting 0x%x to ALAW...\n", val);
         }
 
         /* Configure video window */
@@ -582,11 +587,11 @@ void ccdc_config_raw(void)
         /* Write value in FMTCFG */
         regw(val, CCDC_FMTCFG);
 
-        dev_dbg(dev, "\nWriting 0x%x to FMTCFG...\n", val);
+        dev_dbg(ccdc_cfg.dev, "\nWriting 0x%x to FMTCFG...\n", val);
         /* Configure the color pattern according to mt9t001 sensor */
         regw(CCDC_COLPTN_VAL, CCDC_COLPTN);
 
-        dev_dbg(dev, "\nWriting 0xBB11BB11 to COLPTN...\n");
+        dev_dbg(ccdc_cfg.dev, "\nWriting 0xBB11BB11 to COLPTN...\n");
         /*
          * Configure Data formatter(Video port) pixel selection
          * (FMT_HORZ, FMT_VERT)
@@ -596,7 +601,7 @@ void ccdc_config_raw(void)
               (params->win.width & CCDC_FMT_HORZ_FMTLNH_MASK);
         regw(val, CCDC_FMT_HORZ);
 
-        dev_dbg(dev, "\nWriting 0x%x to FMT_HORZ...\n", val);
+        dev_dbg(ccdc_cfg.dev, "\nWriting 0x%x to FMT_HORZ...\n", val);
         val = (params->win.top & CCDC_FMT_VERT_FMTSLV_MASK)
             << CCDC_FMT_VERT_FMTSLV_SHIFT;
         if (params->frm_fmt == CCDC_FRMFMT_PROGRESSIVE)
@@ -604,13 +609,13 @@ void ccdc_config_raw(void)
         else
                 val |= (params->win.height >> 1) & CCDC_FMT_VERT_FMTLNV_MASK;
 
-        dev_dbg(dev, "\nparams->win.height  0x%x ...\n",
+        dev_dbg(ccdc_cfg.dev, "\nparams->win.height  0x%x ...\n",
                params->win.height);
         regw(val, CCDC_FMT_VERT);
 
-        dev_dbg(dev, "\nWriting 0x%x to FMT_VERT...\n", val);
+        dev_dbg(ccdc_cfg.dev, "\nWriting 0x%x to FMT_VERT...\n", val);
 
-        dev_dbg(dev, "\nbelow regw(val, FMT_VERT)...");
+        dev_dbg(ccdc_cfg.dev, "\nbelow regw(val, FMT_VERT)...");
 
         /*
          * Configure Horizontal offset register. If pack 8 is enabled then
@@ -631,17 +636,17 @@ void ccdc_config_raw(void)
                 if (params->image_invert_enable) {
                         /* For intelace inverse mode */
                         regw(CCDC_INTERLACED_IMAGE_INVERT, CCDC_SDOFST);
-                        dev_dbg(dev, "\nWriting 0x4B6D to SDOFST...\n");
+                        dev_dbg(ccdc_cfg.dev, "\nWriting 0x4B6D to SDOFST..\n");
                 }
 
                 else {
                         /* For intelace non inverse mode */
                         regw(CCDC_INTERLACED_NO_IMAGE_INVERT, CCDC_SDOFST);
-                        dev_dbg(dev, "\nWriting 0x0249 to SDOFST...\n");
+                        dev_dbg(ccdc_cfg.dev, "\nWriting 0x0249 to SDOFST..\n");
                 }
         } else if (params->frm_fmt == CCDC_FRMFMT_PROGRESSIVE) {
                 regw(CCDC_PROGRESSIVE_NO_IMAGE_INVERT, CCDC_SDOFST);
-                dev_dbg(dev, "\nWriting 0x0000 to SDOFST...\n");
+                dev_dbg(ccdc_cfg.dev, "\nWriting 0x0000 to SDOFST...\n");
         }
 
         /*
@@ -662,18 +667,18 @@ void ccdc_config_raw(void)
         val |= (params->win.left) & CCDC_VP_OUT_HORZ_ST_MASK;
         regw(val, CCDC_VP_OUT);
 
-        dev_dbg(dev, "\nWriting 0x%x to VP_OUT...\n", val);
+        dev_dbg(ccdc_cfg.dev, "\nWriting 0x%x to VP_OUT...\n", val);
         regw(syn_mode, CCDC_SYN_MODE);
-        dev_dbg(dev, "\nWriting 0x%x to SYN_MODE...\n", syn_mode);
+        dev_dbg(ccdc_cfg.dev, "\nWriting 0x%x to SYN_MODE...\n", syn_mode);
 
         ccdc_sbl_reset();
-        dev_dbg(dev, "\nend of ccdc_config_raw...");
+        dev_dbg(ccdc_cfg.dev, "\nend of ccdc_config_raw...");
         ccdc_readregs();
 }
 
 static int ccdc_configure(void)
 {
-        if (ccdc_if_type == VPFE_RAW_BAYER)
+        if (ccdc_cfg.if_type == VPFE_RAW_BAYER)
                 ccdc_config_raw();
         else
                 ccdc_config_ycbcr();
@@ -682,24 +687,24 @@ static int ccdc_configure(void)
 
 static int ccdc_set_buftype(enum ccdc_buftype buf_type)
 {
-        if (ccdc_if_type == VPFE_RAW_BAYER)
-                ccdc_hw_params_raw.buf_type = buf_type;
+        if (ccdc_cfg.if_type == VPFE_RAW_BAYER)
+                ccdc_cfg.bayer.buf_type = buf_type;
         else
-                ccdc_hw_params_ycbcr.buf_type = buf_type;
+                ccdc_cfg.ycbcr.buf_type = buf_type;
         return 0;
 }
 
 static enum ccdc_buftype ccdc_get_buftype(void)
 {
-        if (ccdc_if_type == VPFE_RAW_BAYER)
-                return ccdc_hw_params_raw.buf_type;
-        return ccdc_hw_params_ycbcr.buf_type;
+        if (ccdc_cfg.if_type == VPFE_RAW_BAYER)
+                return ccdc_cfg.bayer.buf_type;
+        return ccdc_cfg.ycbcr.buf_type;
 }
 
 static int ccdc_enum_pix(u32 *pix, int i)
 {
         int ret = -EINVAL;
-        if (ccdc_if_type == VPFE_RAW_BAYER) {
+        if (ccdc_cfg.if_type == VPFE_RAW_BAYER) {
                 if (i < ARRAY_SIZE(ccdc_raw_bayer_pix_formats)) {
                         *pix = ccdc_raw_bayer_pix_formats[i];
                         ret = 0;
@@ -715,17 +720,17 @@ static int ccdc_enum_pix(u32 *pix, int i)
 
 static int ccdc_set_pixel_format(u32 pixfmt)
 {
-        if (ccdc_if_type == VPFE_RAW_BAYER) {
-                ccdc_hw_params_raw.pix_fmt = CCDC_PIXFMT_RAW;
+        if (ccdc_cfg.if_type == VPFE_RAW_BAYER) {
+                ccdc_cfg.bayer.pix_fmt = CCDC_PIXFMT_RAW;
                 if (pixfmt == V4L2_PIX_FMT_SBGGR8)
-                        ccdc_hw_params_raw.config_params.alaw.enable = 1;
+                        ccdc_cfg.bayer.config_params.alaw.enable = 1;
                 else if (pixfmt != V4L2_PIX_FMT_SBGGR16)
                         return -EINVAL;
         } else {
                 if (pixfmt == V4L2_PIX_FMT_YUYV)
-                        ccdc_hw_params_ycbcr.pix_order = CCDC_PIXORDER_YCBYCR;
+                        ccdc_cfg.ycbcr.pix_order = CCDC_PIXORDER_YCBYCR;
                 else if (pixfmt == V4L2_PIX_FMT_UYVY)
-                        ccdc_hw_params_ycbcr.pix_order = CCDC_PIXORDER_CBYCRY;
+                        ccdc_cfg.ycbcr.pix_order = CCDC_PIXORDER_CBYCRY;
                 else
                         return -EINVAL;
         }
@@ -734,17 +739,16 @@ static int ccdc_set_pixel_format(u32 pixfmt)
 
 static u32 ccdc_get_pixel_format(void)
 {
-        struct ccdc_a_law *alaw =
-                &ccdc_hw_params_raw.config_params.alaw;
+        struct ccdc_a_law *alaw = &ccdc_cfg.bayer.config_params.alaw;
         u32 pixfmt;
 
-        if (ccdc_if_type == VPFE_RAW_BAYER)
+        if (ccdc_cfg.if_type == VPFE_RAW_BAYER)
                 if (alaw->enable)
                         pixfmt = V4L2_PIX_FMT_SBGGR8;
                 else
                         pixfmt = V4L2_PIX_FMT_SBGGR16;
         else {
-                if (ccdc_hw_params_ycbcr.pix_order == CCDC_PIXORDER_YCBYCR)
+                if (ccdc_cfg.ycbcr.pix_order == CCDC_PIXORDER_YCBYCR)
                         pixfmt = V4L2_PIX_FMT_YUYV;
                 else
                         pixfmt = V4L2_PIX_FMT_UYVY;
@@ -754,53 +758,53 @@ static u32 ccdc_get_pixel_format(void)
 
 static int ccdc_set_image_window(struct v4l2_rect *win)
 {
-        if (ccdc_if_type == VPFE_RAW_BAYER)
-                ccdc_hw_params_raw.win = *win;
+        if (ccdc_cfg.if_type == VPFE_RAW_BAYER)
+                ccdc_cfg.bayer.win = *win;
         else
-                ccdc_hw_params_ycbcr.win = *win;
+                ccdc_cfg.ycbcr.win = *win;
         return 0;
 }
 
 static void ccdc_get_image_window(struct v4l2_rect *win)
 {
-        if (ccdc_if_type == VPFE_RAW_BAYER)
-                *win = ccdc_hw_params_raw.win;
+        if (ccdc_cfg.if_type == VPFE_RAW_BAYER)
+                *win = ccdc_cfg.bayer.win;
         else
-                *win = ccdc_hw_params_ycbcr.win;
+                *win = ccdc_cfg.ycbcr.win;
 }
 
 static unsigned int ccdc_get_line_length(void)
 {
         struct ccdc_config_params_raw *config_params =
-                &ccdc_hw_params_raw.config_params;
+                                &ccdc_cfg.bayer.config_params;
         unsigned int len;
 
-        if (ccdc_if_type == VPFE_RAW_BAYER) {
+        if (ccdc_cfg.if_type == VPFE_RAW_BAYER) {
                 if ((config_params->alaw.enable) ||
                     (config_params->data_sz == CCDC_DATA_8BITS))
-                        len = ccdc_hw_params_raw.win.width;
+                        len = ccdc_cfg.bayer.win.width;
                 else
-                        len = ccdc_hw_params_raw.win.width * 2;
+                        len = ccdc_cfg.bayer.win.width * 2;
         } else
-                len = ccdc_hw_params_ycbcr.win.width * 2;
+                len = ccdc_cfg.ycbcr.win.width * 2;
         return ALIGN(len, 32);
 }
 
 static int ccdc_set_frame_format(enum ccdc_frmfmt frm_fmt)
 {
-        if (ccdc_if_type == VPFE_RAW_BAYER)
-                ccdc_hw_params_raw.frm_fmt = frm_fmt;
+        if (ccdc_cfg.if_type == VPFE_RAW_BAYER)
+                ccdc_cfg.bayer.frm_fmt = frm_fmt;
         else
-                ccdc_hw_params_ycbcr.frm_fmt = frm_fmt;
+                ccdc_cfg.ycbcr.frm_fmt = frm_fmt;
         return 0;
 }
 
 static enum ccdc_frmfmt ccdc_get_frame_format(void)
 {
-        if (ccdc_if_type == VPFE_RAW_BAYER)
-                return ccdc_hw_params_raw.frm_fmt;
+        if (ccdc_cfg.if_type == VPFE_RAW_BAYER)
+                return ccdc_cfg.bayer.frm_fmt;
         else
-                return ccdc_hw_params_ycbcr.frm_fmt;
+                return ccdc_cfg.ycbcr.frm_fmt;
 }
 
 static int ccdc_getfid(void)
@@ -816,14 +820,14 @@ static inline void ccdc_setfbaddr(unsigned long addr)
 
 static int ccdc_set_hw_if_params(struct vpfe_hw_if_param *params)
 {
-        ccdc_if_type = params->if_type;
+        ccdc_cfg.if_type = params->if_type;
 
         switch (params->if_type) {
         case VPFE_BT656:
         case VPFE_YCBCR_SYNC_16:
         case VPFE_YCBCR_SYNC_8:
-                ccdc_hw_params_ycbcr.vd_pol = params->vdpol;
-                ccdc_hw_params_ycbcr.hd_pol = params->hdpol;
+                ccdc_cfg.ycbcr.vd_pol = params->vdpol;
+                ccdc_cfg.ycbcr.hd_pol = params->hdpol;
                 break;
         default:
                 /* TODO add support for raw bayer here */
@@ -838,7 +842,6 @@ static struct ccdc_hw_device ccdc_hw_dev = {
         .hw_ops = {
                 .open = ccdc_open,
                 .close = ccdc_close,
-                .set_ccdc_base = ccdc_set_ccdc_base,
                 .reset = ccdc_sbl_reset,
                 .enable = ccdc_enable,
                 .set_hw_if_params = ccdc_set_hw_if_params,
@@ -859,19 +862,105 @@ static struct ccdc_hw_device ccdc_hw_dev = {
         },
 };
 
-static int __init dm644x_ccdc_init(void)
+static int __init dm644x_ccdc_probe(struct platform_device *pdev)
 {
-        printk(KERN_NOTICE "dm644x_ccdc_init\n");
-        if (vpfe_register_ccdc_device(&ccdc_hw_dev) < 0)
-                return -1;
-        printk(KERN_NOTICE "%s is registered with vpfe.\n",
-                ccdc_hw_dev.name);
+        struct resource *res;
+        int status = 0;
+
+        /*
+         * first try to register with vpfe. If not correct platform, then we
+         * don't have to iomap
+         */
+        status = vpfe_register_ccdc_device(&ccdc_hw_dev);
+        if (status < 0)
+                return status;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                status = -ENODEV;
+                goto fail_nores;
+        }
+
+        res = request_mem_region(res->start, resource_size(res), res->name);
+        if (!res) {
+                status = -EBUSY;
+                goto fail_nores;
+        }
+
+        ccdc_cfg.base_addr = ioremap_nocache(res->start, resource_size(res));
+        if (!ccdc_cfg.base_addr) {
+                status = -ENOMEM;
+                goto fail_nomem;
+        }
+
+        /* Get and enable Master clock */
+        ccdc_cfg.mclk = clk_get(&pdev->dev, "master");
+        if (IS_ERR(ccdc_cfg.mclk)) {
+                status = PTR_ERR(ccdc_cfg.mclk);
+                goto fail_nomap;
+        }
+        if (clk_enable(ccdc_cfg.mclk)) {
+                status = -ENODEV;
+                goto fail_mclk;
+        }
+
+        /* Get and enable Slave clock */
+        ccdc_cfg.sclk = clk_get(&pdev->dev, "slave");
+        if (IS_ERR(ccdc_cfg.sclk)) {
+                status = PTR_ERR(ccdc_cfg.sclk);
+                goto fail_mclk;
+        }
+        if (clk_enable(ccdc_cfg.sclk)) {
+                status = -ENODEV;
+                goto fail_sclk;
+        }
+        ccdc_cfg.dev = &pdev->dev;
+        printk(KERN_NOTICE "%s is registered with vpfe.\n", ccdc_hw_dev.name);
         return 0;
+fail_sclk:
+        clk_put(ccdc_cfg.sclk);
+fail_mclk:
+        clk_put(ccdc_cfg.mclk);
+fail_nomap:
+        iounmap(ccdc_cfg.base_addr);
+fail_nomem:
+        release_mem_region(res->start, resource_size(res));
+fail_nores:
+        vpfe_unregister_ccdc_device(&ccdc_hw_dev);
+        return status;
 }
 
-static void __exit dm644x_ccdc_exit(void)
+static int dm644x_ccdc_remove(struct platform_device *pdev)
 {
+        struct resource *res;
+
+        clk_put(ccdc_cfg.mclk);
+        clk_put(ccdc_cfg.sclk);
+        iounmap(ccdc_cfg.base_addr);
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (res)
+                release_mem_region(res->start, resource_size(res));
         vpfe_unregister_ccdc_device(&ccdc_hw_dev);
+        return 0;
+}
+
+static struct platform_driver dm644x_ccdc_driver = {
+        .driver = {
+                .name   = "dm644x_ccdc",
+                .owner = THIS_MODULE,
+        },
+        .remove = __devexit_p(dm644x_ccdc_remove),
+        .probe = dm644x_ccdc_probe,
+};
+
+static int __init dm644x_ccdc_init(void)
+{
+        return platform_driver_register(&dm644x_ccdc_driver);
+}
+
+static void __exit dm644x_ccdc_exit(void)
+{
+        platform_driver_unregister(&dm644x_ccdc_driver);
 }
 
 module_init(dm644x_ccdc_init);
diff --git a/drivers/media/video/davinci/isif.c b/drivers/media/video/davinci/isif.c
new file mode 100644
index 000000000000..29c29c668596
--- /dev/null
+++ b/drivers/media/video/davinci/isif.c
@@ -0,0 +1,1172 @@
+/*
+ * Copyright (C) 2008-2009 Texas Instruments Inc
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ * Image Sensor Interface (ISIF) driver
+ *
+ * This driver is for configuring the ISIF IP available on DM365 or any other
+ * TI SoCs. This is used for capturing yuv or bayer video or image data
+ * from a decoder or sensor. This IP is similar to the CCDC IP on DM355
+ * and DM6446, but with enhanced or additional ip blocks. The driver
+ * configures the ISIF upon commands from the vpfe bridge driver through
+ * ccdc_hw_device interface.
+ *
+ * TODO: 1) Raw bayer parameter settings and bayer capture
+ *       2) Add support for control ioctl
+ */
+#include <linux/delay.h>
+#include <linux/platform_device.h>
+#include <linux/uaccess.h>
+#include <linux/io.h>
+#include <linux/videodev2.h>
+#include <linux/clk.h>
+#include <linux/err.h>
+
+#include <mach/mux.h>
+
+#include <media/davinci/isif.h>
+#include <media/davinci/vpss.h>
+
+#include "isif_regs.h"
+#include "ccdc_hw_device.h"
+
+/* Defaults for module configuration parameters */
+static struct isif_config_params_raw isif_config_defaults = {
+        .linearize = {
+                .en = 0,
+                .corr_shft = ISIF_NO_SHIFT,
+                .scale_fact = {1, 0},
+        },
+        .df_csc = {
+                .df_or_csc = 0,
+                .csc = {
+                        .en = 0,
+                },
+        },
+        .dfc = {
+                .en = 0,
+        },
+        .bclamp = {
+                .en = 0,
+        },
+        .gain_offset = {
+                .gain = {
+                        .r_ye = {1, 0},
+                        .gr_cy = {1, 0},
+                        .gb_g = {1, 0},
+                        .b_mg = {1, 0},
+                },
+        },
+        .culling = {
+                .hcpat_odd = 0xff,
+                .hcpat_even = 0xff,
+                .vcpat = 0xff,
+        },
+        .compress = {
+                .alg = ISIF_ALAW,
+        },
+};
+
+/* ISIF operation configuration */
+static struct isif_oper_config {
+        struct device *dev;
+        enum vpfe_hw_if_type if_type;
+        struct isif_ycbcr_config ycbcr;
+        struct isif_params_raw bayer;
+        enum isif_data_pack data_pack;
+        /* Master clock */
+        struct clk *mclk;
+        /* ISIF base address */
+        void __iomem *base_addr;
+        /* ISIF Linear Table 0 */
+        void __iomem *linear_tbl0_addr;
+        /* ISIF Linear Table 1 */
+        void __iomem *linear_tbl1_addr;
+} isif_cfg = {
+        .ycbcr = {
+                .pix_fmt = CCDC_PIXFMT_YCBCR_8BIT,
+                .frm_fmt = CCDC_FRMFMT_INTERLACED,
+                .win = ISIF_WIN_NTSC,
+                .fid_pol = VPFE_PINPOL_POSITIVE,
+                .vd_pol = VPFE_PINPOL_POSITIVE,
+                .hd_pol = VPFE_PINPOL_POSITIVE,
+                .pix_order = CCDC_PIXORDER_CBYCRY,
+                .buf_type = CCDC_BUFTYPE_FLD_INTERLEAVED,
+        },
+        .bayer = {
+                .pix_fmt = CCDC_PIXFMT_RAW,
+                .frm_fmt = CCDC_FRMFMT_PROGRESSIVE,
+                .win = ISIF_WIN_VGA,
+                .fid_pol = VPFE_PINPOL_POSITIVE,
+                .vd_pol = VPFE_PINPOL_POSITIVE,
+                .hd_pol = VPFE_PINPOL_POSITIVE,
+                .gain = {
+                        .r_ye = {1, 0},
+                        .gr_cy = {1, 0},
+                        .gb_g = {1, 0},
+                        .b_mg = {1, 0},
+                },
+                .cfa_pat = ISIF_CFA_PAT_MOSAIC,
+                .data_msb = ISIF_BIT_MSB_11,
+                .config_params = {
+                        .data_shift = ISIF_NO_SHIFT,
+                        .col_pat_field0 = {
+                                .olop = ISIF_GREEN_BLUE,
+                                .olep = ISIF_BLUE,
+                                .elop = ISIF_RED,
+                                .elep = ISIF_GREEN_RED,
+                        },
+                        .col_pat_field1 = {
+                                .olop = ISIF_GREEN_BLUE,
+                                .olep = ISIF_BLUE,
+                                .elop = ISIF_RED,
+                                .elep = ISIF_GREEN_RED,
+                        },
+                        .test_pat_gen = 0,
+                },
+        },
+        .data_pack = ISIF_DATA_PACK8,
+};
+
+/* Raw Bayer formats */
+static const u32 isif_raw_bayer_pix_formats[] = {
+        V4L2_PIX_FMT_SBGGR8, V4L2_PIX_FMT_SBGGR16};
+
+/* Raw YUV formats */
+static const u32 isif_raw_yuv_pix_formats[] = {
+        V4L2_PIX_FMT_UYVY, V4L2_PIX_FMT_YUYV};
+
+/* register access routines */
+static inline u32 regr(u32 offset)
+{
+        return __raw_readl(isif_cfg.base_addr + offset);
+}
+
+static inline void regw(u32 val, u32 offset)
+{
+        __raw_writel(val, isif_cfg.base_addr + offset);
+}
+
+/* reg_modify() - read, modify and write register */
+static inline u32 reg_modify(u32 mask, u32 val, u32 offset)
+{
+        u32 new_val = (regr(offset) & ~mask) | (val & mask);
+
+        regw(new_val, offset);
+        return new_val;
+}
+
+static inline void regw_lin_tbl(u32 val, u32 offset, int i)
+{
+        if (!i)
+                __raw_writel(val, isif_cfg.linear_tbl0_addr + offset);
+        else
+                __raw_writel(val, isif_cfg.linear_tbl1_addr + offset);
+}
+
+static void isif_disable_all_modules(void)
+{
+        /* disable BC */
+        regw(0, CLAMPCFG);
+        /* disable vdfc */
+        regw(0, DFCCTL);
+        /* disable CSC */
+        regw(0, CSCCTL);
+        /* disable linearization */
+        regw(0, LINCFG0);
+        /* disable other modules here as they are supported */
+}
+
+static void isif_enable(int en)
+{
+        if (!en) {
+                /* Before disable isif, disable all ISIF modules */
+                isif_disable_all_modules();
+                /*
+                 * wait for next VD. Assume lowest scan rate is 12 Hz. So
+                 * 100 msec delay is good enough
+                 */
+                msleep(100);
+        }
+        reg_modify(ISIF_SYNCEN_VDHDEN_MASK, en, SYNCEN);
+}
+
+static void isif_enable_output_to_sdram(int en)
+{
+        reg_modify(ISIF_SYNCEN_WEN_MASK, en << ISIF_SYNCEN_WEN_SHIFT, SYNCEN);
+}
+
+static void isif_config_culling(struct isif_cul *cul)
+{
+        u32 val;
+
+        /* Horizontal pattern */
+        val = (cul->hcpat_even << CULL_PAT_EVEN_LINE_SHIFT) | cul->hcpat_odd;
+        regw(val, CULH);
+
+        /* vertical pattern */
+        regw(cul->vcpat, CULV);
+
+        /* LPF */
+        reg_modify(ISIF_LPF_MASK << ISIF_LPF_SHIFT,
+                  cul->en_lpf << ISIF_LPF_SHIFT, MODESET);
+}
+
+static void isif_config_gain_offset(void)
+{
+        struct isif_gain_offsets_adj *gain_off_p =
+                &isif_cfg.bayer.config_params.gain_offset;
+        u32 val;
+
+        val = (!!gain_off_p->gain_sdram_en << GAIN_SDRAM_EN_SHIFT) |
+              (!!gain_off_p->gain_ipipe_en << GAIN_IPIPE_EN_SHIFT) |
+              (!!gain_off_p->gain_h3a_en << GAIN_H3A_EN_SHIFT) |
+              (!!gain_off_p->offset_sdram_en << OFST_SDRAM_EN_SHIFT) |
+              (!!gain_off_p->offset_ipipe_en << OFST_IPIPE_EN_SHIFT) |
+              (!!gain_off_p->offset_h3a_en << OFST_H3A_EN_SHIFT);
+
+        reg_modify(GAIN_OFFSET_EN_MASK, val, CGAMMAWD);
+
+        val = (gain_off_p->gain.r_ye.integer << GAIN_INTEGER_SHIFT) |
+               gain_off_p->gain.r_ye.decimal;
+        regw(val, CRGAIN);
+
+        val = (gain_off_p->gain.gr_cy.integer << GAIN_INTEGER_SHIFT) |
+               gain_off_p->gain.gr_cy.decimal;
+        regw(val, CGRGAIN);
+
+        val = (gain_off_p->gain.gb_g.integer << GAIN_INTEGER_SHIFT) |
+               gain_off_p->gain.gb_g.decimal;
+        regw(val, CGBGAIN);
+
+        val = (gain_off_p->gain.b_mg.integer << GAIN_INTEGER_SHIFT) |
+               gain_off_p->gain.b_mg.decimal;
+        regw(val, CBGAIN);
+
+        regw(gain_off_p->offset, COFSTA);
+}
+
+static void isif_restore_defaults(void)
+{
+        enum vpss_ccdc_source_sel source = VPSS_CCDCIN;
+
+        dev_dbg(isif_cfg.dev, "\nstarting isif_restore_defaults...");
+        isif_cfg.bayer.config_params = isif_config_defaults;
+        /* Enable clock to ISIF, IPIPEIF and BL */
+        vpss_enable_clock(VPSS_CCDC_CLOCK, 1);
+        vpss_enable_clock(VPSS_IPIPEIF_CLOCK, 1);
+        vpss_enable_clock(VPSS_BL_CLOCK, 1);
+        /* Set default offset and gain */
+        isif_config_gain_offset();
+        vpss_select_ccdc_source(source);
+        dev_dbg(isif_cfg.dev, "\nEnd of isif_restore_defaults...");
+}
+
+static int isif_open(struct device *device)
+{
+        isif_restore_defaults();
+        return 0;
+}
+
+/* This function will configure the window size to be capture in ISIF reg */
+static void isif_setwin(struct v4l2_rect *image_win,
+                        enum ccdc_frmfmt frm_fmt, int ppc)
+{
+        int horz_start, horz_nr_pixels;
+        int vert_start, vert_nr_lines;
+        int mid_img = 0;
+
+        dev_dbg(isif_cfg.dev, "\nStarting isif_setwin...");
+        /*
+         * ppc - per pixel count. indicates how many pixels per cell
+         * output to SDRAM. example, for ycbcr, it is one y and one c, so 2.
+         * raw capture this is 1
+         */
+        horz_start = image_win->left << (ppc - 1);
+        horz_nr_pixels = ((image_win->width) << (ppc - 1)) - 1;
+
+        /* Writing the horizontal info into the registers */
+        regw(horz_start & START_PX_HOR_MASK, SPH);
+        regw(horz_nr_pixels & NUM_PX_HOR_MASK, LNH);
+        vert_start = image_win->top;
+
+        if (frm_fmt == CCDC_FRMFMT_INTERLACED) {
+                vert_nr_lines = (image_win->height >> 1) - 1;
+                vert_start >>= 1;
+                /* To account for VD since line 0 doesn't have any data */
+                vert_start += 1;
+        } else {
+                /* To account for VD since line 0 doesn't have any data */
+                vert_start += 1;
+                vert_nr_lines = image_win->height - 1;
+                /* configure VDINT0 and VDINT1 */
+                mid_img = vert_start + (image_win->height / 2);
+                regw(mid_img, VDINT1);
+        }
+
+        regw(0, VDINT0);
+        regw(vert_start & START_VER_ONE_MASK, SLV0);
+        regw(vert_start & START_VER_TWO_MASK, SLV1);
+        regw(vert_nr_lines & NUM_LINES_VER, LNV);
+}
+
+static void isif_config_bclamp(struct isif_black_clamp *bc)
+{
+        u32 val;
+
+        /*
+         * DC Offset is always added to image data irrespective of bc enable
+         * status
+         */
+        regw(bc->dc_offset, CLDCOFST);
+
+        if (bc->en) {
+                val = bc->bc_mode_color << ISIF_BC_MODE_COLOR_SHIFT;
+
+                /* Enable BC and horizontal clamp caculation paramaters */
+                val = val | 1 | (bc->horz.mode << ISIF_HORZ_BC_MODE_SHIFT);
+
+                regw(val, CLAMPCFG);
+
+                if (bc->horz.mode != ISIF_HORZ_BC_DISABLE) {
+                        /*
+                         * Window count for calculation
+                         * Base window selection
+                         * pixel limit
+                         * Horizontal size of window
+                         * vertical size of the window
+                         * Horizontal start position of the window
+                         * Vertical start position of the window
+                         */
+                        val = bc->horz.win_count_calc |
+                              ((!!bc->horz.base_win_sel_calc) <<
+                                ISIF_HORZ_BC_WIN_SEL_SHIFT) |
+                              ((!!bc->horz.clamp_pix_limit) <<
+                                ISIF_HORZ_BC_PIX_LIMIT_SHIFT) |
+                              (bc->horz.win_h_sz_calc <<
+                                ISIF_HORZ_BC_WIN_H_SIZE_SHIFT) |
+                              (bc->horz.win_v_sz_calc <<
+                                ISIF_HORZ_BC_WIN_V_SIZE_SHIFT);
+                        regw(val, CLHWIN0);
+
+                        regw(bc->horz.win_start_h_calc, CLHWIN1);
+                        regw(bc->horz.win_start_v_calc, CLHWIN2);
+                }
+
+                /* vertical clamp caculation paramaters */
+
+                /* Reset clamp value sel for previous line */
+                val |=
+                (bc->vert.reset_val_sel << ISIF_VERT_BC_RST_VAL_SEL_SHIFT) |
+                (bc->vert.line_ave_coef << ISIF_VERT_BC_LINE_AVE_COEF_SHIFT);
+                regw(val, CLVWIN0);
+
+                /* Optical Black horizontal start position */
+                regw(bc->vert.ob_start_h, CLVWIN1);
+                /* Optical Black vertical start position */
+                regw(bc->vert.ob_start_v, CLVWIN2);
+                /* Optical Black vertical size for calculation */
+                regw(bc->vert.ob_v_sz_calc, CLVWIN3);
+                /* Vertical start position for BC subtraction */
+                regw(bc->vert_start_sub, CLSV);
+        }
+}
+
+static void isif_config_linearization(struct isif_linearize *linearize)
+{
+        u32 val, i;
+
+        if (!linearize->en) {
+                regw(0, LINCFG0);
+                return;
+        }
+
+        /* shift value for correction & enable linearization (set lsb) */
+        val = (linearize->corr_shft << ISIF_LIN_CORRSFT_SHIFT) | 1;
+        regw(val, LINCFG0);
+
+        /* Scale factor */
+        val = ((!!linearize->scale_fact.integer) <<
+               ISIF_LIN_SCALE_FACT_INTEG_SHIFT) |
+               linearize->scale_fact.decimal;
+        regw(val, LINCFG1);
+
+        for (i = 0; i < ISIF_LINEAR_TAB_SIZE; i++) {
+                if (i % 2)
+                        regw_lin_tbl(linearize->table[i], ((i >> 1) << 2), 1);
+                else
+                        regw_lin_tbl(linearize->table[i], ((i >> 1) << 2), 0);
+        }
+}
+
+static int isif_config_dfc(struct isif_dfc *vdfc)
+{
+        /* initialize retries to loop for max ~ 250 usec */
+        u32 val, count, retries = loops_per_jiffy / (4000/HZ);
+        int i;
+
+        if (!vdfc->en)
+                return 0;
+
+        /* Correction mode */
+        val = (vdfc->corr_mode << ISIF_VDFC_CORR_MOD_SHIFT);
+
+        /* Correct whole line or partial */
+        if (vdfc->corr_whole_line)
+                val |= 1 << ISIF_VDFC_CORR_WHOLE_LN_SHIFT;
+
+        /* level shift value */
+        val |= vdfc->def_level_shift << ISIF_VDFC_LEVEL_SHFT_SHIFT;
+
+        regw(val, DFCCTL);
+
+        /* Defect saturation level */
+        regw(vdfc->def_sat_level, VDFSATLV);
+
+        regw(vdfc->table[0].pos_vert, DFCMEM0);
+        regw(vdfc->table[0].pos_horz, DFCMEM1);
+        if (vdfc->corr_mode == ISIF_VDFC_NORMAL ||
+            vdfc->corr_mode == ISIF_VDFC_HORZ_INTERPOL_IF_SAT) {
+                regw(vdfc->table[0].level_at_pos, DFCMEM2);
+                regw(vdfc->table[0].level_up_pixels, DFCMEM3);
+                regw(vdfc->table[0].level_low_pixels, DFCMEM4);
+        }
+
+        /* set DFCMARST and set DFCMWR */
+        val = regr(DFCMEMCTL) | (1 << ISIF_DFCMEMCTL_DFCMARST_SHIFT) | 1;
+        regw(val, DFCMEMCTL);
+
+        count = retries;
+        while (count && (regr(DFCMEMCTL) & 0x1))
+                count--;
+
+        if (!count) {
+                dev_dbg(isif_cfg.dev, "defect table write timeout !!!\n");
+                return -1;
+        }
+
+        for (i = 1; i < vdfc->num_vdefects; i++) {
+                regw(vdfc->table[i].pos_vert, DFCMEM0);
+                regw(vdfc->table[i].pos_horz, DFCMEM1);
+                if (vdfc->corr_mode == ISIF_VDFC_NORMAL ||
+                    vdfc->corr_mode == ISIF_VDFC_HORZ_INTERPOL_IF_SAT) {
+                        regw(vdfc->table[i].level_at_pos, DFCMEM2);
+                        regw(vdfc->table[i].level_up_pixels, DFCMEM3);
+                        regw(vdfc->table[i].level_low_pixels, DFCMEM4);
+                }
+                val = regr(DFCMEMCTL);
+                /* clear DFCMARST and set DFCMWR */
+                val &= ~BIT(ISIF_DFCMEMCTL_DFCMARST_SHIFT);
+                val |= 1;
+                regw(val, DFCMEMCTL);
+
+                count = retries;
+                while (count && (regr(DFCMEMCTL) & 0x1))
+                        count--;
+
+                if (!count) {
+                        dev_err(isif_cfg.dev,
+                                "defect table write timeout !!!\n");
+                        return -1;
+                }
+        }
+        if (vdfc->num_vdefects < ISIF_VDFC_TABLE_SIZE) {
+                /* Extra cycle needed */
+                regw(0, DFCMEM0);
+                regw(0x1FFF, DFCMEM1);
+                regw(1, DFCMEMCTL);
+        }
+
+        /* enable VDFC */
+        reg_modify((1 << ISIF_VDFC_EN_SHIFT), (1 << ISIF_VDFC_EN_SHIFT),
+                   DFCCTL);
+        return 0;
+}
+
+static void isif_config_csc(struct isif_df_csc *df_csc)
+{
+        u32 val1 = 0, val2 = 0, i;
+
+        if (!df_csc->csc.en) {
+                regw(0, CSCCTL);
+                return;
+        }
+        for (i = 0; i < ISIF_CSC_NUM_COEFF; i++) {
+                if ((i % 2) == 0) {
+                        /* CSCM - LSB */
+                        val1 = (df_csc->csc.coeff[i].integer <<
+                                ISIF_CSC_COEF_INTEG_SHIFT) |
+                                df_csc->csc.coeff[i].decimal;
+                } else {
+
+                        /* CSCM - MSB */
+                        val2 = (df_csc->csc.coeff[i].integer <<
+                                ISIF_CSC_COEF_INTEG_SHIFT) |
+                                df_csc->csc.coeff[i].decimal;
+                        val2 <<= ISIF_CSCM_MSB_SHIFT;
+                        val2 |= val1;
+                        regw(val2, (CSCM0 + ((i - 1) << 1)));
+                }
+        }
+
+        /* program the active area */
+        regw(df_csc->start_pix, FMTSPH);
+        /*
+         * one extra pixel as required for CSC. Actually number of
+         * pixel - 1 should be configured in this register. So we
+         * need to subtract 1 before writing to FMTSPH, but we will
+         * not do this since csc requires one extra pixel
+         */
+        regw(df_csc->num_pixels, FMTLNH);
+        regw(df_csc->start_line, FMTSLV);
+        /*
+         * one extra line as required for CSC. See reason documented for
+         * num_pixels
+         */
+        regw(df_csc->num_lines, FMTLNV);
+
+        /* Enable CSC */
+        regw(1, CSCCTL);
+}
+
+static int isif_config_raw(void)
+{
+        struct isif_params_raw *params = &isif_cfg.bayer;
+        struct isif_config_params_raw *module_params =
+                &isif_cfg.bayer.config_params;
+        struct vpss_pg_frame_size frame_size;
+        struct vpss_sync_pol sync;
+        u32 val;
+
+        dev_dbg(isif_cfg.dev, "\nStarting isif_config_raw..\n");
+
+        /*
+         * Configure CCDCFG register:-
+         * Set CCD Not to swap input since input is RAW data
+         * Set FID detection function to Latch at V-Sync
+         * Set WENLOG - isif valid area
+         * Set TRGSEL
+         * Set EXTRG
+         * Packed to 8 or 16 bits
+         */
+
+        val = ISIF_YCINSWP_RAW | ISIF_CCDCFG_FIDMD_LATCH_VSYNC |
+                ISIF_CCDCFG_WENLOG_AND | ISIF_CCDCFG_TRGSEL_WEN |
+                ISIF_CCDCFG_EXTRG_DISABLE | isif_cfg.data_pack;
+
+        dev_dbg(isif_cfg.dev, "Writing 0x%x to ...CCDCFG \n", val);
+        regw(val, CCDCFG);
+
+        /*
+         * Configure the vertical sync polarity(MODESET.VDPOL)
+         * Configure the horizontal sync polarity (MODESET.HDPOL)
+         * Configure frame id polarity (MODESET.FLDPOL)
+         * Configure data polarity
+         * Configure External WEN Selection
+         * Configure frame format(progressive or interlace)
+         * Configure pixel format (Input mode)
+         * Configure the data shift
+         */
+
+        val = ISIF_VDHDOUT_INPUT | (params->vd_pol << ISIF_VD_POL_SHIFT) |
+                (params->hd_pol << ISIF_HD_POL_SHIFT) |
+                (params->fid_pol << ISIF_FID_POL_SHIFT) |
+                (ISIF_DATAPOL_NORMAL << ISIF_DATAPOL_SHIFT) |
+                (ISIF_EXWEN_DISABLE << ISIF_EXWEN_SHIFT) |
+                (params->frm_fmt << ISIF_FRM_FMT_SHIFT) |
+                (params->pix_fmt << ISIF_INPUT_SHIFT) |
+                (params->config_params.data_shift << ISIF_DATASFT_SHIFT);
+
+        regw(val, MODESET);
+        dev_dbg(isif_cfg.dev, "Writing 0x%x to MODESET...\n", val);
+
+        /*
+         * Configure GAMMAWD register
+         * CFA pattern setting
+         */
+        val = params->cfa_pat << ISIF_GAMMAWD_CFA_SHIFT;
+
+        /* Gamma msb */
+        if (module_params->compress.alg == ISIF_ALAW)
+                val |= ISIF_ALAW_ENABLE;
+
+        val |= (params->data_msb << ISIF_ALAW_GAMA_WD_SHIFT);
+        regw(val, CGAMMAWD);
+
+        /* Configure DPCM compression settings */
+        if (module_params->compress.alg == ISIF_DPCM) {
+                val =  BIT(ISIF_DPCM_EN_SHIFT) |
+                       (module_params->compress.pred <<
+                       ISIF_DPCM_PREDICTOR_SHIFT);
+        }
+
+        regw(val, MISC);
+
+        /* Configure Gain & Offset */
+        isif_config_gain_offset();
+
+        /* Configure Color pattern */
+        val = (params->config_params.col_pat_field0.olop) |
+              (params->config_params.col_pat_field0.olep << 2) |
+              (params->config_params.col_pat_field0.elop << 4) |
+              (params->config_params.col_pat_field0.elep << 6) |
+              (params->config_params.col_pat_field1.olop << 8) |
+              (params->config_params.col_pat_field1.olep << 10) |
+              (params->config_params.col_pat_field1.elop << 12) |
+              (params->config_params.col_pat_field1.elep << 14);
+        regw(val, CCOLP);
+        dev_dbg(isif_cfg.dev, "Writing %x to CCOLP ...\n", val);
+
+        /* Configure HSIZE register  */
+        val = (!!params->horz_flip_en) << ISIF_HSIZE_FLIP_SHIFT;
+
+        /* calculate line offset in 32 bytes based on pack value */
+        if (isif_cfg.data_pack == ISIF_PACK_8BIT)
+                val |= ((params->win.width + 31) >> 5);
+        else if (isif_cfg.data_pack == ISIF_PACK_12BIT)
+                val |= (((params->win.width +
+                       (params->win.width >> 2)) + 31) >> 5);
+        else
+                val |= (((params->win.width * 2) + 31) >> 5);
+        regw(val, HSIZE);
+
+        /* Configure SDOFST register  */
+        if (params->frm_fmt == CCDC_FRMFMT_INTERLACED) {
+                if (params->image_invert_en) {
+                        /* For interlace inverse mode */
+                        regw(0x4B6D, SDOFST);
+                        dev_dbg(isif_cfg.dev, "Writing 0x4B6D to SDOFST...\n");
+                } else {
+                        /* For interlace non inverse mode */
+                        regw(0x0B6D, SDOFST);
+                        dev_dbg(isif_cfg.dev, "Writing 0x0B6D to SDOFST...\n");
+                }
+        } else if (params->frm_fmt == CCDC_FRMFMT_PROGRESSIVE) {
+                if (params->image_invert_en) {
+                        /* For progressive inverse mode */
+                        regw(0x4000, SDOFST);
+                        dev_dbg(isif_cfg.dev, "Writing 0x4000 to SDOFST...\n");
+                } else {
+                        /* For progressive non inverse mode */
+                        regw(0x0000, SDOFST);
+                        dev_dbg(isif_cfg.dev, "Writing 0x0000 to SDOFST...\n");
+                }
+        }
+
+        /* Configure video window */
+        isif_setwin(&params->win, params->frm_fmt, 1);
+
+        /* Configure Black Clamp */
+        isif_config_bclamp(&module_params->bclamp);
+
+        /* Configure Vertical Defection Pixel Correction */
+        if (isif_config_dfc(&module_params->dfc) < 0)
+                return -EFAULT;
+
+        if (!module_params->df_csc.df_or_csc)
+                /* Configure Color Space Conversion */
+                isif_config_csc(&module_params->df_csc);
+
+        isif_config_linearization(&module_params->linearize);
+
+        /* Configure Culling */
+        isif_config_culling(&module_params->culling);
+
+        /* Configure horizontal and vertical offsets(DFC,LSC,Gain) */
+        regw(module_params->horz_offset, DATAHOFST);
+        regw(module_params->vert_offset, DATAVOFST);
+
+        /* Setup test pattern if enabled */
+        if (params->config_params.test_pat_gen) {
+                /* Use the HD/VD pol settings from user */
+                sync.ccdpg_hdpol = params->hd_pol;
+                sync.ccdpg_vdpol = params->vd_pol;
+                dm365_vpss_set_sync_pol(sync);
+                frame_size.hlpfr = isif_cfg.bayer.win.width;
+                frame_size.pplen = isif_cfg.bayer.win.height;
+                dm365_vpss_set_pg_frame_size(frame_size);
+                vpss_select_ccdc_source(VPSS_PGLPBK);
+        }
+
+        dev_dbg(isif_cfg.dev, "\nEnd of isif_config_ycbcr...\n");
+        return 0;
+}
+
+static int isif_set_buftype(enum ccdc_buftype buf_type)
+{
+        if (isif_cfg.if_type == VPFE_RAW_BAYER)
+                isif_cfg.bayer.buf_type = buf_type;
+        else
+                isif_cfg.ycbcr.buf_type = buf_type;
+
+        return 0;
+
+}
+static enum ccdc_buftype isif_get_buftype(void)
+{
+        if (isif_cfg.if_type == VPFE_RAW_BAYER)
+                return isif_cfg.bayer.buf_type;
+
+        return isif_cfg.ycbcr.buf_type;
+}
+
+static int isif_enum_pix(u32 *pix, int i)
+{
+        int ret = -EINVAL;
+
+        if (isif_cfg.if_type == VPFE_RAW_BAYER) {
+                if (i < ARRAY_SIZE(isif_raw_bayer_pix_formats)) {
+                        *pix = isif_raw_bayer_pix_formats[i];
+                        ret = 0;
+                }
+        } else {
+                if (i < ARRAY_SIZE(isif_raw_yuv_pix_formats)) {
+                        *pix = isif_raw_yuv_pix_formats[i];
+                        ret = 0;
+                }
+        }
+
+        return ret;
+}
+
+static int isif_set_pixel_format(unsigned int pixfmt)
+{
+        if (isif_cfg.if_type == VPFE_RAW_BAYER) {
+                if (pixfmt == V4L2_PIX_FMT_SBGGR8) {
+                        if ((isif_cfg.bayer.config_params.compress.alg !=
+                             ISIF_ALAW) &&
+                            (isif_cfg.bayer.config_params.compress.alg !=
+                             ISIF_DPCM)) {
+                                dev_dbg(isif_cfg.dev,
+                                        "Either configure A-Law or DPCM\n");
+                                return -EINVAL;
+                        }
+                        isif_cfg.data_pack = ISIF_PACK_8BIT;
+                } else if (pixfmt == V4L2_PIX_FMT_SBGGR16) {
+                        isif_cfg.bayer.config_params.compress.alg =
+                                        ISIF_NO_COMPRESSION;
+                        isif_cfg.data_pack = ISIF_PACK_16BIT;
+                } else
+                        return -EINVAL;
+                isif_cfg.bayer.pix_fmt = CCDC_PIXFMT_RAW;
+        } else {
+                if (pixfmt == V4L2_PIX_FMT_YUYV)
+                        isif_cfg.ycbcr.pix_order = CCDC_PIXORDER_YCBYCR;
+                else if (pixfmt == V4L2_PIX_FMT_UYVY)
+                        isif_cfg.ycbcr.pix_order = CCDC_PIXORDER_CBYCRY;
+                else
+                        return -EINVAL;
+                isif_cfg.data_pack = ISIF_PACK_8BIT;
+        }
+        return 0;
+}
+
+static u32 isif_get_pixel_format(void)
+{
+        u32 pixfmt;
+
+        if (isif_cfg.if_type == VPFE_RAW_BAYER)
+                if (isif_cfg.bayer.config_params.compress.alg == ISIF_ALAW ||
+                    isif_cfg.bayer.config_params.compress.alg == ISIF_DPCM)
+                        pixfmt = V4L2_PIX_FMT_SBGGR8;
+                else
+                        pixfmt = V4L2_PIX_FMT_SBGGR16;
+        else {
+                if (isif_cfg.ycbcr.pix_order == CCDC_PIXORDER_YCBYCR)
+                        pixfmt = V4L2_PIX_FMT_YUYV;
+                else
+                        pixfmt = V4L2_PIX_FMT_UYVY;
+        }
+        return pixfmt;
+}
+
+static int isif_set_image_window(struct v4l2_rect *win)
+{
+        if (isif_cfg.if_type == VPFE_RAW_BAYER) {
+                isif_cfg.bayer.win.top = win->top;
+                isif_cfg.bayer.win.left = win->left;
+                isif_cfg.bayer.win.width = win->width;
+                isif_cfg.bayer.win.height = win->height;
+        } else {
+                isif_cfg.ycbcr.win.top = win->top;
+                isif_cfg.ycbcr.win.left = win->left;
+                isif_cfg.ycbcr.win.width = win->width;
+                isif_cfg.ycbcr.win.height = win->height;
+        }
+        return 0;
+}
+
+static void isif_get_image_window(struct v4l2_rect *win)
+{
+        if (isif_cfg.if_type == VPFE_RAW_BAYER)
+                *win = isif_cfg.bayer.win;
+        else
+                *win = isif_cfg.ycbcr.win;
+}
+
+static unsigned int isif_get_line_length(void)
+{
+        unsigned int len;
+
+        if (isif_cfg.if_type == VPFE_RAW_BAYER) {
+                if (isif_cfg.data_pack == ISIF_PACK_8BIT)
+                        len = ((isif_cfg.bayer.win.width));
+                else if (isif_cfg.data_pack == ISIF_PACK_12BIT)
+                        len = (((isif_cfg.bayer.win.width * 2) +
+                                 (isif_cfg.bayer.win.width >> 2)));
+                else
+                        len = (((isif_cfg.bayer.win.width * 2)));
+        } else
+                len = (((isif_cfg.ycbcr.win.width * 2)));
+        return ALIGN(len, 32);
+}
+
+static int isif_set_frame_format(enum ccdc_frmfmt frm_fmt)
+{
+        if (isif_cfg.if_type == VPFE_RAW_BAYER)
+                isif_cfg.bayer.frm_fmt = frm_fmt;
+        else
+                isif_cfg.ycbcr.frm_fmt = frm_fmt;
+        return 0;
+}
+static enum ccdc_frmfmt isif_get_frame_format(void)
+{
+        if (isif_cfg.if_type == VPFE_RAW_BAYER)
+                return isif_cfg.bayer.frm_fmt;
+        return isif_cfg.ycbcr.frm_fmt;
+}
+
+static int isif_getfid(void)
+{
+        return (regr(MODESET) >> 15) & 0x1;
+}
+
+/* misc operations */
+static void isif_setfbaddr(unsigned long addr)
+{
+        regw((addr >> 21) & 0x07ff, CADU);
+        regw((addr >> 5) & 0x0ffff, CADL);
+}
+
+static int isif_set_hw_if_params(struct vpfe_hw_if_param *params)
+{
+        isif_cfg.if_type = params->if_type;
+
+        switch (params->if_type) {
+        case VPFE_BT656:
+        case VPFE_BT656_10BIT:
+        case VPFE_YCBCR_SYNC_8:
+                isif_cfg.ycbcr.pix_fmt = CCDC_PIXFMT_YCBCR_8BIT;
+                isif_cfg.ycbcr.pix_order = CCDC_PIXORDER_CBYCRY;
+                break;
+        case VPFE_BT1120:
+        case VPFE_YCBCR_SYNC_16:
+                isif_cfg.ycbcr.pix_fmt = CCDC_PIXFMT_YCBCR_16BIT;
+                isif_cfg.ycbcr.pix_order = CCDC_PIXORDER_CBYCRY;
+                break;
+        case VPFE_RAW_BAYER:
+                isif_cfg.bayer.pix_fmt = CCDC_PIXFMT_RAW;
+                break;
+        default:
+                dev_dbg(isif_cfg.dev, "Invalid interface type\n");
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+/* This function will configure ISIF for YCbCr parameters. */
+static int isif_config_ycbcr(void)
+{
+        struct isif_ycbcr_config *params = &isif_cfg.ycbcr;
+        struct vpss_pg_frame_size frame_size;
+        u32 modeset = 0, ccdcfg = 0;
+        struct vpss_sync_pol sync;
+
+        dev_dbg(isif_cfg.dev, "\nStarting isif_config_ycbcr...");
+
+        /* configure pixel format or input mode */
+        modeset = modeset | (params->pix_fmt << ISIF_INPUT_SHIFT) |
+                  (params->frm_fmt << ISIF_FRM_FMT_SHIFT) |
+                  (params->fid_pol << ISIF_FID_POL_SHIFT) |
+                  (params->hd_pol << ISIF_HD_POL_SHIFT) |
+                  (params->vd_pol << ISIF_VD_POL_SHIFT);
+
+        /* pack the data to 8-bit ISIFCFG */
+        switch (isif_cfg.if_type) {
+        case VPFE_BT656:
+                if (params->pix_fmt != CCDC_PIXFMT_YCBCR_8BIT) {
+                        dev_dbg(isif_cfg.dev, "Invalid pix_fmt(input mode)\n");
+                        return -EINVAL;
+                }
+                modeset |= (VPFE_PINPOL_NEGATIVE << ISIF_VD_POL_SHIFT);
+                regw(3, REC656IF);
+                ccdcfg = ccdcfg | ISIF_DATA_PACK8 | ISIF_YCINSWP_YCBCR;
+                break;
+        case VPFE_BT656_10BIT:
+                if (params->pix_fmt != CCDC_PIXFMT_YCBCR_8BIT) {
+                        dev_dbg(isif_cfg.dev, "Invalid pix_fmt(input mode)\n");
+                        return -EINVAL;
+                }
+                /* setup BT.656, embedded sync  */
+                regw(3, REC656IF);
+                /* enable 10 bit mode in ccdcfg */
+                ccdcfg = ccdcfg | ISIF_DATA_PACK8 | ISIF_YCINSWP_YCBCR |
+                        ISIF_BW656_ENABLE;
+                break;
+        case VPFE_BT1120:
+                if (params->pix_fmt != CCDC_PIXFMT_YCBCR_16BIT) {
+                        dev_dbg(isif_cfg.dev, "Invalid pix_fmt(input mode)\n");
+                        return -EINVAL;
+                }
+                regw(3, REC656IF);
+                break;
+
+        case VPFE_YCBCR_SYNC_8:
+                ccdcfg |= ISIF_DATA_PACK8;
+                ccdcfg |= ISIF_YCINSWP_YCBCR;
+                if (params->pix_fmt != CCDC_PIXFMT_YCBCR_8BIT) {
+                        dev_dbg(isif_cfg.dev, "Invalid pix_fmt(input mode)\n");
+                        return -EINVAL;
+                }
+                break;
+        case VPFE_YCBCR_SYNC_16:
+                if (params->pix_fmt != CCDC_PIXFMT_YCBCR_16BIT) {
+                        dev_dbg(isif_cfg.dev, "Invalid pix_fmt(input mode)\n");
+                        return -EINVAL;
+                }
+                break;
+        default:
+                /* should never come here */
+                dev_dbg(isif_cfg.dev, "Invalid interface type\n");
+                return -EINVAL;
+        }
+
+        regw(modeset, MODESET);
+
+        /* Set up pix order */
+        ccdcfg |= params->pix_order << ISIF_PIX_ORDER_SHIFT;
+
+        regw(ccdcfg, CCDCFG);
+
+        /* configure video window */
+        if ((isif_cfg.if_type == VPFE_BT1120) ||
+            (isif_cfg.if_type == VPFE_YCBCR_SYNC_16))
+                isif_setwin(&params->win, params->frm_fmt, 1);
+        else
+                isif_setwin(&params->win, params->frm_fmt, 2);
+
+        /*
+         * configure the horizontal line offset
+         * this is done by rounding up width to a multiple of 16 pixels
+         * and multiply by two to account for y:cb:cr 4:2:2 data
+         */
+        regw(((((params->win.width * 2) + 31) & 0xffffffe0) >> 5), HSIZE);
+
+        /* configure the memory line offset */
+        if ((params->frm_fmt == CCDC_FRMFMT_INTERLACED) &&
+            (params->buf_type == CCDC_BUFTYPE_FLD_INTERLEAVED))
+                /* two fields are interleaved in memory */
+                regw(0x00000249, SDOFST);
+
+        /* Setup test pattern if enabled */
+        if (isif_cfg.bayer.config_params.test_pat_gen) {
+                sync.ccdpg_hdpol = params->hd_pol;
+                sync.ccdpg_vdpol = params->vd_pol;
+                dm365_vpss_set_sync_pol(sync);
+                dm365_vpss_set_pg_frame_size(frame_size);
+        }
+        return 0;
+}
+
+static int isif_configure(void)
+{
+        if (isif_cfg.if_type == VPFE_RAW_BAYER)
+                return isif_config_raw();
+        return isif_config_ycbcr();
+}
+
+static int isif_close(struct device *device)
+{
+        /* copy defaults to module params */
+        isif_cfg.bayer.config_params = isif_config_defaults;
+        return 0;
+}
+
+static struct ccdc_hw_device isif_hw_dev = {
+        .name = "ISIF",
+        .owner = THIS_MODULE,
+        .hw_ops = {
+                .open = isif_open,
+                .close = isif_close,
+                .enable = isif_enable,
+                .enable_out_to_sdram = isif_enable_output_to_sdram,
+                .set_hw_if_params = isif_set_hw_if_params,
+                .configure = isif_configure,
+                .set_buftype = isif_set_buftype,
+                .get_buftype = isif_get_buftype,
+                .enum_pix = isif_enum_pix,
+                .set_pixel_format = isif_set_pixel_format,
+                .get_pixel_format = isif_get_pixel_format,
+                .set_frame_format = isif_set_frame_format,
+                .get_frame_format = isif_get_frame_format,
+                .set_image_window = isif_set_image_window,
+                .get_image_window = isif_get_image_window,
+                .get_line_length = isif_get_line_length,
+                .setfbaddr = isif_setfbaddr,
+                .getfid = isif_getfid,
+        },
+};
+
+static int __init isif_probe(struct platform_device *pdev)
+{
+        void (*setup_pinmux)(void);
+        struct resource *res;
+        void *__iomem addr;
+        int status = 0, i;
+
+        /*
+         * first try to register with vpfe. If not correct platform, then we
+         * don't have to iomap
+         */
+        status = vpfe_register_ccdc_device(&isif_hw_dev);
+        if (status < 0)
+                return status;
+
+        /* Get and enable Master clock */
+        isif_cfg.mclk = clk_get(&pdev->dev, "master");
+        if (IS_ERR(isif_cfg.mclk)) {
+                status = PTR_ERR(isif_cfg.mclk);
+                goto fail_mclk;
+        }
+        if (clk_enable(isif_cfg.mclk)) {
+                status = -ENODEV;
+                goto fail_mclk;
+        }
+
+        /* Platform data holds setup_pinmux function ptr */
+        if (NULL == pdev->dev.platform_data) {
+                status = -ENODEV;
+                goto fail_mclk;
+        }
+        setup_pinmux = pdev->dev.platform_data;
+        /*
+         * setup Mux configuration for ccdc which may be different for
+         * different SoCs using this CCDC
+         */
+        setup_pinmux();
+
+        i = 0;
+        /* Get the ISIF base address, linearization table0 and table1 addr. */
+        while (i < 3) {
+                res = platform_get_resource(pdev, IORESOURCE_MEM, i);
+                if (!res) {
+                        status = -ENODEV;
+                        goto fail_nobase_res;
+                }
+                res = request_mem_region(res->start, resource_size(res),
+                                         res->name);
+                if (!res) {
+                        status = -EBUSY;
+                        goto fail_nobase_res;
+                }
+                addr = ioremap_nocache(res->start, resource_size(res));
+                if (!addr) {
+                        status = -ENOMEM;
+                        goto fail_base_iomap;
+                }
+                switch (i) {
+                case 0:
+                        /* ISIF base address */
+                        isif_cfg.base_addr = addr;
+                        break;
+                case 1:
+                        /* ISIF linear tbl0 address */
+                        isif_cfg.linear_tbl0_addr = addr;
+                        break;
+                default:
+                        /* ISIF linear tbl0 address */
+                        isif_cfg.linear_tbl1_addr = addr;
+                        break;
+                }
+                i++;
+        }
+        isif_cfg.dev = &pdev->dev;
+
+        printk(KERN_NOTICE "%s is registered with vpfe.\n",
+                isif_hw_dev.name);
+        return 0;
+fail_base_iomap:
+        release_mem_region(res->start, resource_size(res));
+        i--;
+fail_nobase_res:
+        if (isif_cfg.base_addr)
+                iounmap(isif_cfg.base_addr);
+        if (isif_cfg.linear_tbl0_addr)
+                iounmap(isif_cfg.linear_tbl0_addr);
+
+        while (i >= 0) {
+                res = platform_get_resource(pdev, IORESOURCE_MEM, i);
+                release_mem_region(res->start, resource_size(res));
+                i--;
+        }
+fail_mclk:
+        clk_put(isif_cfg.mclk);
+        vpfe_unregister_ccdc_device(&isif_hw_dev);
+        return status;
+}
+
+static int isif_remove(struct platform_device *pdev)
+{
+        struct resource *res;
+        int i = 0;
+
+        iounmap(isif_cfg.base_addr);
+        iounmap(isif_cfg.linear_tbl0_addr);
+        iounmap(isif_cfg.linear_tbl1_addr);
+        while (i < 3) {
+                res = platform_get_resource(pdev, IORESOURCE_MEM, i);
+                if (res)
+                        release_mem_region(res->start, resource_size(res));
+                i++;
+        }
+        vpfe_unregister_ccdc_device(&isif_hw_dev);
+        return 0;
+}
+
+static struct platform_driver isif_driver = {
+        .driver = {
+                .name   = "isif",
+                .owner = THIS_MODULE,
+        },
+        .remove = __devexit_p(isif_remove),
+        .probe = isif_probe,
+};
+
+static int __init isif_init(void)
+{
+        return platform_driver_register(&isif_driver);
+}
+
+static void isif_exit(void)
+{
+        platform_driver_unregister(&isif_driver);
+}
+
+module_init(isif_init);
+module_exit(isif_exit);
+
+MODULE_LICENSE("GPL");
diff --git a/drivers/media/video/davinci/isif_regs.h b/drivers/media/video/davinci/isif_regs.h
new file mode 100644
index 000000000000..f7b8893a2957
--- /dev/null
+++ b/drivers/media/video/davinci/isif_regs.h
@@ -0,0 +1,269 @@
+/*
+ * Copyright (C) 2008-2009 Texas Instruments Inc
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+#ifndef _ISIF_REGS_H
+#define _ISIF_REGS_H
+
+/* ISIF registers relative offsets */
+#define SYNCEN                                  0x00
+#define MODESET                                 0x04
+#define HDW                                     0x08
+#define VDW                                     0x0c
+#define PPLN                                    0x10
+#define LPFR                                    0x14
+#define SPH                                     0x18
+#define LNH                                     0x1c
+#define SLV0                                    0x20
+#define SLV1                                    0x24
+#define LNV                                     0x28
+#define CULH                                    0x2c
+#define CULV                                    0x30
+#define HSIZE                                   0x34
+#define SDOFST                                  0x38
+#define CADU                                    0x3c
+#define CADL                                    0x40
+#define LINCFG0                                 0x44
+#define LINCFG1                                 0x48
+#define CCOLP                                   0x4c
+#define CRGAIN                                  0x50
+#define CGRGAIN                                 0x54
+#define CGBGAIN                                 0x58
+#define CBGAIN                                  0x5c
+#define COFSTA                                  0x60
+#define FLSHCFG0                                0x64
+#define FLSHCFG1                                0x68
+#define FLSHCFG2                                0x6c
+#define VDINT0                                  0x70
+#define VDINT1                                  0x74
+#define VDINT2                                  0x78
+#define MISC                                    0x7c
+#define CGAMMAWD                                0x80
+#define REC656IF                                0x84
+#define CCDCFG                                  0x88
+/*****************************************************
+* Defect Correction registers
+*****************************************************/
+#define DFCCTL                                  0x8c
+#define VDFSATLV                                0x90
+#define DFCMEMCTL                               0x94
+#define DFCMEM0                                 0x98
+#define DFCMEM1                                 0x9c
+#define DFCMEM2                                 0xa0
+#define DFCMEM3                                 0xa4
+#define DFCMEM4                                 0xa8
+/****************************************************
+* Black Clamp registers
+****************************************************/
+#define CLAMPCFG                                0xac
+#define CLDCOFST                                0xb0
+#define CLSV                                    0xb4
+#define CLHWIN0                                 0xb8
+#define CLHWIN1                                 0xbc
+#define CLHWIN2                                 0xc0
+#define CLVRV                                   0xc4
+#define CLVWIN0                                 0xc8
+#define CLVWIN1                                 0xcc
+#define CLVWIN2                                 0xd0
+#define CLVWIN3                                 0xd4
+/****************************************************
+* Lense Shading Correction
+****************************************************/
+#define DATAHOFST                               0xd8
+#define DATAVOFST                               0xdc
+#define LSCHVAL                                 0xe0
+#define LSCVVAL                                 0xe4
+#define TWODLSCCFG                              0xe8
+#define TWODLSCOFST                             0xec
+#define TWODLSCINI                              0xf0
+#define TWODLSCGRBU                             0xf4
+#define TWODLSCGRBL                             0xf8
+#define TWODLSCGROF                             0xfc
+#define TWODLSCORBU                             0x100
+#define TWODLSCORBL                             0x104
+#define TWODLSCOROF                             0x108
+#define TWODLSCIRQEN                            0x10c
+#define TWODLSCIRQST                            0x110
+/****************************************************
+* Data formatter
+****************************************************/
+#define FMTCFG                                  0x114
+#define FMTPLEN                                 0x118
+#define FMTSPH                                  0x11c
+#define FMTLNH                                  0x120
+#define FMTSLV                                  0x124
+#define FMTLNV                                  0x128
+#define FMTRLEN                                 0x12c
+#define FMTHCNT                                 0x130
+#define FMTAPTR_BASE                            0x134
+/* Below macro for addresses FMTAPTR0 - FMTAPTR15 */
+#define FMTAPTR(i)                      (FMTAPTR_BASE + (i * 4))
+#define FMTPGMVF0                               0x174
+#define FMTPGMVF1                               0x178
+#define FMTPGMAPU0                              0x17c
+#define FMTPGMAPU1                              0x180
+#define FMTPGMAPS0                              0x184
+#define FMTPGMAPS1                              0x188
+#define FMTPGMAPS2                              0x18c
+#define FMTPGMAPS3                              0x190
+#define FMTPGMAPS4                              0x194
+#define FMTPGMAPS5                              0x198
+#define FMTPGMAPS6                              0x19c
+#define FMTPGMAPS7                              0x1a0
+/************************************************
+* Color Space Converter
+************************************************/
+#define CSCCTL                                  0x1a4
+#define CSCM0                                   0x1a8
+#define CSCM1                                   0x1ac
+#define CSCM2                                   0x1b0
+#define CSCM3                                   0x1b4
+#define CSCM4                                   0x1b8
+#define CSCM5                                   0x1bc
+#define CSCM6                                   0x1c0
+#define CSCM7                                   0x1c4
+#define OBWIN0                                  0x1c8
+#define OBWIN1                                  0x1cc
+#define OBWIN2                                  0x1d0
+#define OBWIN3                                  0x1d4
+#define OBVAL0                                  0x1d8
+#define OBVAL1                                  0x1dc
+#define OBVAL2                                  0x1e0
+#define OBVAL3                                  0x1e4
+#define OBVAL4                                  0x1e8
+#define OBVAL5                                  0x1ec
+#define OBVAL6                                  0x1f0
+#define OBVAL7                                  0x1f4
+#define CLKCTL                                  0x1f8
+
+/* Masks & Shifts below */
+#define START_PX_HOR_MASK                       0x7FFF
+#define NUM_PX_HOR_MASK                         0x7FFF
+#define START_VER_ONE_MASK                      0x7FFF
+#define START_VER_TWO_MASK                      0x7FFF
+#define NUM_LINES_VER                           0x7FFF
+
+/* gain - offset masks */
+#define GAIN_INTEGER_SHIFT                      9
+#define OFFSET_MASK                             0xFFF
+#define GAIN_SDRAM_EN_SHIFT                     12
+#define GAIN_IPIPE_EN_SHIFT                     13
+#define GAIN_H3A_EN_SHIFT                       14
+#define OFST_SDRAM_EN_SHIFT                     8
+#define OFST_IPIPE_EN_SHIFT                     9
+#define OFST_H3A_EN_SHIFT                       10
+#define GAIN_OFFSET_EN_MASK                     0x7700
+
+/* Culling */
+#define CULL_PAT_EVEN_LINE_SHIFT                8
+
+/* CCDCFG register */
+#define ISIF_YCINSWP_RAW                        (0x00 << 4)
+#define ISIF_YCINSWP_YCBCR                      (0x01 << 4)
+#define ISIF_CCDCFG_FIDMD_LATCH_VSYNC           (0x00 << 6)
+#define ISIF_CCDCFG_WENLOG_AND                  (0x00 << 8)
+#define ISIF_CCDCFG_TRGSEL_WEN                  (0x00 << 9)
+#define ISIF_CCDCFG_EXTRG_DISABLE               (0x00 << 10)
+#define ISIF_LATCH_ON_VSYNC_DISABLE             (0x01 << 15)
+#define ISIF_LATCH_ON_VSYNC_ENABLE              (0x00 << 15)
+#define ISIF_DATA_PACK_MASK                     3
+#define ISIF_DATA_PACK16                        0
+#define ISIF_DATA_PACK12                        1
+#define ISIF_DATA_PACK8                         2
+#define ISIF_PIX_ORDER_SHIFT                    11
+#define ISIF_BW656_ENABLE                       (0x01 << 5)
+
+/* MODESET registers */
+#define ISIF_VDHDOUT_INPUT                      (0x00 << 0)
+#define ISIF_INPUT_SHIFT                        12
+#define ISIF_RAW_INPUT_MODE                     0
+#define ISIF_FID_POL_SHIFT                      4
+#define ISIF_HD_POL_SHIFT                       3
+#define ISIF_VD_POL_SHIFT                       2
+#define ISIF_DATAPOL_NORMAL                     0
+#define ISIF_DATAPOL_SHIFT                      6
+#define ISIF_EXWEN_DISABLE                      0
+#define ISIF_EXWEN_SHIFT                        5
+#define ISIF_FRM_FMT_SHIFT                      7
+#define ISIF_DATASFT_SHIFT                      8
+#define ISIF_LPF_SHIFT                          14
+#define ISIF_LPF_MASK                           1
+
+/* GAMMAWD registers */
+#define ISIF_ALAW_GAMA_WD_MASK                  0xF
+#define ISIF_ALAW_GAMA_WD_SHIFT                 1
+#define ISIF_ALAW_ENABLE                        1
+#define ISIF_GAMMAWD_CFA_SHIFT                  5
+
+/* HSIZE registers */
+#define ISIF_HSIZE_FLIP_MASK                    1
+#define ISIF_HSIZE_FLIP_SHIFT                   12
+
+/* MISC registers */
+#define ISIF_DPCM_EN_SHIFT                      12
+#define ISIF_DPCM_PREDICTOR_SHIFT               13
+
+/* Black clamp related */
+#define ISIF_BC_MODE_COLOR_SHIFT                4
+#define ISIF_HORZ_BC_MODE_SHIFT                 1
+#define ISIF_HORZ_BC_WIN_SEL_SHIFT              5
+#define ISIF_HORZ_BC_PIX_LIMIT_SHIFT            6
+#define ISIF_HORZ_BC_WIN_H_SIZE_SHIFT           8
+#define ISIF_HORZ_BC_WIN_V_SIZE_SHIFT           12
+#define ISIF_VERT_BC_RST_VAL_SEL_SHIFT          4
+#define ISIF_VERT_BC_LINE_AVE_COEF_SHIFT        8
+
+/* VDFC registers */
+#define ISIF_VDFC_EN_SHIFT                      4
+#define ISIF_VDFC_CORR_MOD_SHIFT                5
+#define ISIF_VDFC_CORR_WHOLE_LN_SHIFT           7
+#define ISIF_VDFC_LEVEL_SHFT_SHIFT              8
+#define ISIF_VDFC_POS_MASK                      0x1FFF
+#define ISIF_DFCMEMCTL_DFCMARST_SHIFT           2
+
+/* CSC registers */
+#define ISIF_CSC_COEF_INTEG_MASK                7
+#define ISIF_CSC_COEF_DECIMAL_MASK              0x1f
+#define ISIF_CSC_COEF_INTEG_SHIFT               5
+#define ISIF_CSCM_MSB_SHIFT                     8
+#define ISIF_DF_CSC_SPH_MASK                    0x1FFF
+#define ISIF_DF_CSC_LNH_MASK                    0x1FFF
+#define ISIF_DF_CSC_SLV_MASK                    0x1FFF
+#define ISIF_DF_CSC_LNV_MASK                    0x1FFF
+#define ISIF_DF_NUMLINES                        0x7FFF
+#define ISIF_DF_NUMPIX                          0x1FFF
+
+/* Offsets for LSC/DFC/Gain */
+#define ISIF_DATA_H_OFFSET_MASK                 0x1FFF
+#define ISIF_DATA_V_OFFSET_MASK                 0x1FFF
+
+/* Linearization */
+#define ISIF_LIN_CORRSFT_SHIFT                  4
+#define ISIF_LIN_SCALE_FACT_INTEG_SHIFT         10
+
+
+/* Pattern registers */
+#define ISIF_PG_EN                              (1 << 3)
+#define ISIF_SEL_PG_SRC                         (3 << 4)
+#define ISIF_PG_VD_POL_SHIFT                    0
+#define ISIF_PG_HD_POL_SHIFT                    1
+
+/*random other junk*/
+#define ISIF_SYNCEN_VDHDEN_MASK                 (1 << 0)
+#define ISIF_SYNCEN_WEN_MASK                    (1 << 1)
+#define ISIF_SYNCEN_WEN_SHIFT                   1
+
+#endif
diff --git a/drivers/media/video/davinci/vpfe_capture.c b/drivers/media/video/davinci/vpfe_capture.c
index de22bc9faf21..885cd54499cf 100644
--- a/drivers/media/video/davinci/vpfe_capture.c
+++ b/drivers/media/video/davinci/vpfe_capture.c
@@ -107,9 +107,6 @@ struct ccdc_config {
         int vpfe_probed;
         /* name of ccdc device */
         char name[32];
-        /* for storing mem maps for CCDC */
-        int ccdc_addr_size;
-        void *__iomem ccdc_addr;
 };
 
 /* data structures */
@@ -229,7 +226,6 @@ int vpfe_register_ccdc_device(struct ccdc_hw_device *dev)
         BUG_ON(!dev->hw_ops.set_image_window);
         BUG_ON(!dev->hw_ops.get_image_window);
         BUG_ON(!dev->hw_ops.get_line_length);
-        BUG_ON(!dev->hw_ops.setfbaddr);
         BUG_ON(!dev->hw_ops.getfid);
 
         mutex_lock(&ccdc_lock);
@@ -240,25 +236,23 @@ int vpfe_register_ccdc_device(struct ccdc_hw_device *dev)
                  * walk through it during vpfe probe
                  */
                 printk(KERN_ERR "vpfe capture not initialized\n");
-                ret = -1;
+                ret = -EFAULT;
                 goto unlock;
         }
 
         if (strcmp(dev->name, ccdc_cfg->name)) {
                 /* ignore this ccdc */
-                ret = -1;
+                ret = -EINVAL;
                 goto unlock;
         }
 
         if (ccdc_dev) {
                 printk(KERN_ERR "ccdc already registered\n");
-                ret = -1;
+                ret = -EINVAL;
                 goto unlock;
         }
 
         ccdc_dev = dev;
-        dev->hw_ops.set_ccdc_base(ccdc_cfg->ccdc_addr,
-                                  ccdc_cfg->ccdc_addr_size);
 unlock:
         mutex_unlock(&ccdc_lock);
         return ret;
@@ -1786,61 +1780,6 @@ static struct vpfe_device *vpfe_initialize(void)
         return vpfe_dev;
 }
 
-static void vpfe_disable_clock(struct vpfe_device *vpfe_dev)
-{
-        struct vpfe_config *vpfe_cfg = vpfe_dev->cfg;
-
-        clk_disable(vpfe_cfg->vpssclk);
-        clk_put(vpfe_cfg->vpssclk);
-        clk_disable(vpfe_cfg->slaveclk);
-        clk_put(vpfe_cfg->slaveclk);
-        v4l2_info(vpfe_dev->pdev->driver,
-                 "vpfe vpss master & slave clocks disabled\n");
-}
-
-static int vpfe_enable_clock(struct vpfe_device *vpfe_dev)
-{
-        struct vpfe_config *vpfe_cfg = vpfe_dev->cfg;
-        int ret = -ENOENT;
-
-        vpfe_cfg->vpssclk = clk_get(vpfe_dev->pdev, "vpss_master");
-        if (NULL == vpfe_cfg->vpssclk) {
-                v4l2_err(vpfe_dev->pdev->driver, "No clock defined for"
-                         "vpss_master\n");
-                return ret;
-        }
-
-        if (clk_enable(vpfe_cfg->vpssclk)) {
-                v4l2_err(vpfe_dev->pdev->driver,
-                        "vpfe vpss master clock not enabled\n");
-                goto out;
-        }
-        v4l2_info(vpfe_dev->pdev->driver,
-                 "vpfe vpss master clock enabled\n");
-
-        vpfe_cfg->slaveclk = clk_get(vpfe_dev->pdev, "vpss_slave");
-        if (NULL == vpfe_cfg->slaveclk) {
-                v4l2_err(vpfe_dev->pdev->driver,
-                        "No clock defined for vpss slave\n");
-                goto out;
-        }
-
-        if (clk_enable(vpfe_cfg->slaveclk)) {
-                v4l2_err(vpfe_dev->pdev->driver,
-                         "vpfe vpss slave clock not enabled\n");
-                goto out;
-        }
-        v4l2_info(vpfe_dev->pdev->driver, "vpfe vpss slave clock enabled\n");
-        return 0;
-out:
-        if (vpfe_cfg->vpssclk)
-                clk_put(vpfe_cfg->vpssclk);
-        if (vpfe_cfg->slaveclk)
-                clk_put(vpfe_cfg->slaveclk);
-
-        return -1;
-}
-
 /*
  * vpfe_probe : This function creates device entries by register
  * itself to the V4L2 driver and initializes fields of each
@@ -1870,7 +1809,7 @@ static __init int vpfe_probe(struct platform_device *pdev)
 
         if (NULL == pdev->dev.platform_data) {
                 v4l2_err(pdev->dev.driver, "Unable to get vpfe config\n");
-                ret = -ENOENT;
+                ret = -ENODEV;
                 goto probe_free_dev_mem;
         }
 
@@ -1884,18 +1823,13 @@ static __init int vpfe_probe(struct platform_device *pdev)
                 goto probe_free_dev_mem;
         }
 
-        /* enable vpss clocks */
-        ret = vpfe_enable_clock(vpfe_dev);
-        if (ret)
-                goto probe_free_dev_mem;
-
         mutex_lock(&ccdc_lock);
         /* Allocate memory for ccdc configuration */
         ccdc_cfg = kmalloc(sizeof(struct ccdc_config), GFP_KERNEL);
         if (NULL == ccdc_cfg) {
                 v4l2_err(pdev->dev.driver,
                          "Memory allocation failed for ccdc_cfg\n");
-                goto probe_disable_clock;
+                goto probe_free_dev_mem;
         }
 
         strncpy(ccdc_cfg->name, vpfe_cfg->ccdc, 32);
@@ -1904,61 +1838,34 @@ static __init int vpfe_probe(struct platform_device *pdev)
         if (!res1) {
                 v4l2_err(pdev->dev.driver,
                          "Unable to get interrupt for VINT0\n");
-                ret = -ENOENT;
-                goto probe_disable_clock;
+                ret = -ENODEV;
+                goto probe_free_ccdc_cfg_mem;
         }
         vpfe_dev->ccdc_irq0 = res1->start;
 
         /* Get VINT1 irq resource */
-        res1 = platform_get_resource(pdev,
-                                IORESOURCE_IRQ, 1);
+        res1 = platform_get_resource(pdev, IORESOURCE_IRQ, 1);
         if (!res1) {
                 v4l2_err(pdev->dev.driver,
                          "Unable to get interrupt for VINT1\n");
-                ret = -ENOENT;
-                goto probe_disable_clock;
+                ret = -ENODEV;
+                goto probe_free_ccdc_cfg_mem;
         }
         vpfe_dev->ccdc_irq1 = res1->start;
 
-        /* Get address base of CCDC */
-        res1 = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (!res1) {
-                v4l2_err(pdev->dev.driver,
-                        "Unable to get register address map\n");
-                ret = -ENOENT;
-                goto probe_disable_clock;
-        }
-
-        ccdc_cfg->ccdc_addr_size = res1->end - res1->start + 1;
-        if (!request_mem_region(res1->start, ccdc_cfg->ccdc_addr_size,
-                                pdev->dev.driver->name)) {
-                v4l2_err(pdev->dev.driver,
-                        "Failed request_mem_region for ccdc base\n");
-                ret = -ENXIO;
-                goto probe_disable_clock;
-        }
-        ccdc_cfg->ccdc_addr = ioremap_nocache(res1->start,
-                                             ccdc_cfg->ccdc_addr_size);
-        if (!ccdc_cfg->ccdc_addr) {
-                v4l2_err(pdev->dev.driver, "Unable to ioremap ccdc addr\n");
-                ret = -ENXIO;
-                goto probe_out_release_mem1;
-        }
-
         ret = request_irq(vpfe_dev->ccdc_irq0, vpfe_isr, IRQF_DISABLED,
                           "vpfe_capture0", vpfe_dev);
 
         if (0 != ret) {
                 v4l2_err(pdev->dev.driver, "Unable to request interrupt\n");
-                goto probe_out_unmap1;
+                goto probe_free_ccdc_cfg_mem;
         }
 
         /* Allocate memory for video device */
         vfd = video_device_alloc();
         if (NULL == vfd) {
                 ret = -ENOMEM;
-                v4l2_err(pdev->dev.driver,
-                        "Unable to alloc video device\n");
+                v4l2_err(pdev->dev.driver, "Unable to alloc video device\n");
                 goto probe_out_release_irq;
         }
 
@@ -2073,12 +1980,7 @@ probe_out_video_release:
                 video_device_release(vpfe_dev->video_dev);
 probe_out_release_irq:
         free_irq(vpfe_dev->ccdc_irq0, vpfe_dev);
-probe_out_unmap1:
-        iounmap(ccdc_cfg->ccdc_addr);
-probe_out_release_mem1:
-        release_mem_region(res1->start, res1->end - res1->start + 1);
-probe_disable_clock:
-        vpfe_disable_clock(vpfe_dev);
+probe_free_ccdc_cfg_mem:
         mutex_unlock(&ccdc_lock);
         kfree(ccdc_cfg);
 probe_free_dev_mem:
@@ -2092,7 +1994,6 @@ probe_free_dev_mem:
 static int __devexit vpfe_remove(struct platform_device *pdev)
 {
         struct vpfe_device *vpfe_dev = platform_get_drvdata(pdev);
-        struct resource *res;
 
         v4l2_info(pdev->dev.driver, "vpfe_remove\n");
 
@@ -2100,12 +2001,6 @@ static int __devexit vpfe_remove(struct platform_device *pdev)
         kfree(vpfe_dev->sd);
         v4l2_device_unregister(&vpfe_dev->v4l2_dev);
         video_unregister_device(vpfe_dev->video_dev);
-        mutex_lock(&ccdc_lock);
-        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        release_mem_region(res->start, res->end - res->start + 1);
-        iounmap(ccdc_cfg->ccdc_addr);
-        mutex_unlock(&ccdc_lock);
-        vpfe_disable_clock(vpfe_dev);
         kfree(vpfe_dev);
         kfree(ccdc_cfg);
         return 0;
diff --git a/drivers/media/video/davinci/vpss.c b/drivers/media/video/davinci/vpss.c
index 7ee72ecd3d81..7918680917d0 100644
--- a/drivers/media/video/davinci/vpss.c
+++ b/drivers/media/video/davinci/vpss.c
@@ -15,7 +15,7 @@
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  *
- * common vpss driver for all video drivers.
+ * common vpss system module platform driver for all video drivers.
  */
 #include <linux/kernel.h>
 #include <linux/sched.h>
@@ -35,12 +35,52 @@ MODULE_AUTHOR("Texas Instruments");
 /* DM644x defines */
 #define DM644X_SBL_PCR_VPSS             (4)
 
+#define DM355_VPSSBL_INTSEL             0x10
+#define DM355_VPSSBL_EVTSEL             0x14
 /* vpss BL register offsets */
 #define DM355_VPSSBL_CCDCMUX            0x1c
 /* vpss CLK register offsets */
 #define DM355_VPSSCLK_CLKCTRL           0x04
 /* masks and shifts */
 #define VPSS_HSSISEL_SHIFT              4
+/*
+ * VDINT0 - vpss_int0, VDINT1 - vpss_int1, H3A - vpss_int4,
+ * IPIPE_INT1_SDR - vpss_int5
+ */
+#define DM355_VPSSBL_INTSEL_DEFAULT     0xff83ff10
+/* VENCINT - vpss_int8 */
+#define DM355_VPSSBL_EVTSEL_DEFAULT     0x4
+
+#define DM365_ISP5_PCCR                 0x04
+#define DM365_ISP5_INTSEL1              0x10
+#define DM365_ISP5_INTSEL2              0x14
+#define DM365_ISP5_INTSEL3              0x18
+#define DM365_ISP5_CCDCMUX              0x20
+#define DM365_ISP5_PG_FRAME_SIZE        0x28
+#define DM365_VPBE_CLK_CTRL             0x00
+/*
+ * vpss interrupts. VDINT0 - vpss_int0, VDINT1 - vpss_int1,
+ * AF - vpss_int3
+ */
+#define DM365_ISP5_INTSEL1_DEFAULT      0x0b1f0100
+/* AEW - vpss_int6, RSZ_INT_DMA - vpss_int5 */
+#define DM365_ISP5_INTSEL2_DEFAULT      0x1f0a0f1f
+/* VENC - vpss_int8 */
+#define DM365_ISP5_INTSEL3_DEFAULT      0x00000015
+
+/* masks and shifts for DM365*/
+#define DM365_CCDC_PG_VD_POL_SHIFT      0
+#define DM365_CCDC_PG_HD_POL_SHIFT      1
+
+#define CCD_SRC_SEL_MASK                (BIT_MASK(5) | BIT_MASK(4))
+#define CCD_SRC_SEL_SHIFT               4
+
+/* Different SoC platforms supported by this driver */
+enum vpss_platform_type {
+        DM644X,
+        DM355,
+        DM365,
+};
 
 /*
  * vpss operations. Depends on platform. Not all functions are available
@@ -59,13 +99,9 @@ struct vpss_hw_ops {
 
 /* vpss configuration */
 struct vpss_oper_config {
-        __iomem void *vpss_bl_regs_base;
-        __iomem void *vpss_regs_base;
-        struct resource         *r1;
-        resource_size_t         len1;
-        struct resource         *r2;
-        resource_size_t         len2;
-        char vpss_name[32];
+        __iomem void *vpss_regs_base0;
+        __iomem void *vpss_regs_base1;
+        enum vpss_platform_type platform;
         spinlock_t vpss_lock;
         struct vpss_hw_ops hw_ops;
 };
@@ -75,22 +111,46 @@ static struct vpss_oper_config oper_cfg;
 /* register access routines */
 static inline u32 bl_regr(u32 offset)
 {
-        return __raw_readl(oper_cfg.vpss_bl_regs_base + offset);
+        return __raw_readl(oper_cfg.vpss_regs_base0 + offset);
 }
 
 static inline void bl_regw(u32 val, u32 offset)
 {
-        __raw_writel(val, oper_cfg.vpss_bl_regs_base + offset);
+        __raw_writel(val, oper_cfg.vpss_regs_base0 + offset);
 }
 
 static inline u32 vpss_regr(u32 offset)
 {
-        return __raw_readl(oper_cfg.vpss_regs_base + offset);
+        return __raw_readl(oper_cfg.vpss_regs_base1 + offset);
 }
 
 static inline void vpss_regw(u32 val, u32 offset)
 {
-        __raw_writel(val, oper_cfg.vpss_regs_base + offset);
+        __raw_writel(val, oper_cfg.vpss_regs_base1 + offset);
+}
+
+/* For DM365 only */
+static inline u32 isp5_read(u32 offset)
+{
+        return __raw_readl(oper_cfg.vpss_regs_base0 + offset);
+}
+
+/* For DM365 only */
+static inline void isp5_write(u32 val, u32 offset)
+{
+        __raw_writel(val, oper_cfg.vpss_regs_base0 + offset);
+}
+
+static void dm365_select_ccdc_source(enum vpss_ccdc_source_sel src_sel)
+{
+        u32 temp = isp5_read(DM365_ISP5_CCDCMUX) & ~CCD_SRC_SEL_MASK;
+
+        /* if we are using pattern generator, enable it */
+        if (src_sel == VPSS_PGLPBK || src_sel == VPSS_CCDCPG)
+                temp |= 0x08;
+
+        temp |= (src_sel << CCD_SRC_SEL_SHIFT);
+        isp5_write(temp, DM365_ISP5_CCDCMUX);
 }
 
 static void dm355_select_ccdc_source(enum vpss_ccdc_source_sel src_sel)
@@ -101,9 +161,9 @@ static void dm355_select_ccdc_source(enum vpss_ccdc_source_sel src_sel)
 int vpss_select_ccdc_source(enum vpss_ccdc_source_sel src_sel)
 {
         if (!oper_cfg.hw_ops.select_ccdc_source)
-                return -1;
+                return -EINVAL;
 
-        dm355_select_ccdc_source(src_sel);
+        oper_cfg.hw_ops.select_ccdc_source(src_sel);
         return 0;
 }
 EXPORT_SYMBOL(vpss_select_ccdc_source);
@@ -114,7 +174,7 @@ static int dm644x_clear_wbl_overflow(enum vpss_wbl_sel wbl_sel)
 
         if (wbl_sel < VPSS_PCR_AEW_WBL_0 ||
             wbl_sel > VPSS_PCR_CCDC_WBL_O)
-                return -1;
+                return -EINVAL;
 
         /* writing a 0 clear the overflow */
         mask = ~(mask << wbl_sel);
@@ -126,7 +186,7 @@ static int dm644x_clear_wbl_overflow(enum vpss_wbl_sel wbl_sel)
 int vpss_clear_wbl_overflow(enum vpss_wbl_sel wbl_sel)
 {
         if (!oper_cfg.hw_ops.clear_wbl_overflow)
-                return -1;
+                return -EINVAL;
 
         return oper_cfg.hw_ops.clear_wbl_overflow(wbl_sel);
 }
@@ -166,7 +226,7 @@ static int dm355_enable_clock(enum vpss_clock_sel clock_sel, int en)
         default:
                 printk(KERN_ERR "dm355_enable_clock:"
                                 " Invalid selector: %d\n", clock_sel);
-                return -1;
+                return -EINVAL;
         }
 
         spin_lock_irqsave(&oper_cfg.vpss_lock, flags);
@@ -181,100 +241,221 @@ static int dm355_enable_clock(enum vpss_clock_sel clock_sel, int en)
         return 0;
 }
 
+static int dm365_enable_clock(enum vpss_clock_sel clock_sel, int en)
+{
+        unsigned long flags;
+        u32 utemp, mask = 0x1, shift = 0, offset = DM365_ISP5_PCCR;
+        u32 (*read)(u32 offset) = isp5_read;
+        void(*write)(u32 val, u32 offset) = isp5_write;
+
+        switch (clock_sel) {
+        case VPSS_BL_CLOCK:
+                break;
+        case VPSS_CCDC_CLOCK:
+                shift = 1;
+                break;
+        case VPSS_H3A_CLOCK:
+                shift = 2;
+                break;
+        case VPSS_RSZ_CLOCK:
+                shift = 3;
+                break;
+        case VPSS_IPIPE_CLOCK:
+                shift = 4;
+                break;
+        case VPSS_IPIPEIF_CLOCK:
+                shift = 5;
+                break;
+        case VPSS_PCLK_INTERNAL:
+                shift = 6;
+                break;
+        case VPSS_PSYNC_CLOCK_SEL:
+                shift = 7;
+                break;
+        case VPSS_VPBE_CLOCK:
+                read = vpss_regr;
+                write = vpss_regw;
+                offset = DM365_VPBE_CLK_CTRL;
+                break;
+        case VPSS_VENC_CLOCK_SEL:
+                shift = 2;
+                read = vpss_regr;
+                write = vpss_regw;
+                offset = DM365_VPBE_CLK_CTRL;
+                break;
+        case VPSS_LDC_CLOCK:
+                shift = 3;
+                read = vpss_regr;
+                write = vpss_regw;
+                offset = DM365_VPBE_CLK_CTRL;
+                break;
+        case VPSS_FDIF_CLOCK:
+                shift = 4;
+                read = vpss_regr;
+                write = vpss_regw;
+                offset = DM365_VPBE_CLK_CTRL;
+                break;
+        case VPSS_OSD_CLOCK_SEL:
+                shift = 6;
+                read = vpss_regr;
+                write = vpss_regw;
+                offset = DM365_VPBE_CLK_CTRL;
+                break;
+        case VPSS_LDC_CLOCK_SEL:
+                shift = 7;
+                read = vpss_regr;
+                write = vpss_regw;
+                offset = DM365_VPBE_CLK_CTRL;
+                break;
+        default:
+                printk(KERN_ERR "dm365_enable_clock: Invalid selector: %d\n",
+                       clock_sel);
+                return -1;
+        }
+
+        spin_lock_irqsave(&oper_cfg.vpss_lock, flags);
+        utemp = read(offset);
+        if (!en) {
+                mask = ~mask;
+                utemp &= (mask << shift);
+        } else
+                utemp |= (mask << shift);
+
+        write(utemp, offset);
+        spin_unlock_irqrestore(&oper_cfg.vpss_lock, flags);
+
+        return 0;
+}
+
 int vpss_enable_clock(enum vpss_clock_sel clock_sel, int en)
 {
         if (!oper_cfg.hw_ops.enable_clock)
-                return -1;
+                return -EINVAL;
 
         return oper_cfg.hw_ops.enable_clock(clock_sel, en);
 }
 EXPORT_SYMBOL(vpss_enable_clock);
 
+void dm365_vpss_set_sync_pol(struct vpss_sync_pol sync)
+{
+        int val = 0;
+        val = isp5_read(DM365_ISP5_CCDCMUX);
+
+        val |= (sync.ccdpg_hdpol << DM365_CCDC_PG_HD_POL_SHIFT);
+        val |= (sync.ccdpg_vdpol << DM365_CCDC_PG_VD_POL_SHIFT);
+
+        isp5_write(val, DM365_ISP5_CCDCMUX);
+}
+EXPORT_SYMBOL(dm365_vpss_set_sync_pol);
+
+void dm365_vpss_set_pg_frame_size(struct vpss_pg_frame_size frame_size)
+{
+        int current_reg = ((frame_size.hlpfr >> 1) - 1) << 16;
+
+        current_reg |= (frame_size.pplen - 1);
+        isp5_write(current_reg, DM365_ISP5_PG_FRAME_SIZE);
+}
+EXPORT_SYMBOL(dm365_vpss_set_pg_frame_size);
+
 static int __init vpss_probe(struct platform_device *pdev)
 {
-        int status, dm355 = 0;
+        struct resource         *r1, *r2;
+        char *platform_name;
+        int status;
 
         if (!pdev->dev.platform_data) {
                 dev_err(&pdev->dev, "no platform data\n");
                 return -ENOENT;
         }
-        strcpy(oper_cfg.vpss_name, pdev->dev.platform_data);
 
-        if (!strcmp(oper_cfg.vpss_name, "dm355_vpss"))
-                dm355 = 1;
-        else if (strcmp(oper_cfg.vpss_name, "dm644x_vpss")) {
+        platform_name = pdev->dev.platform_data;
+        if (!strcmp(platform_name, "dm355_vpss"))
+                oper_cfg.platform = DM355;
+        else if (!strcmp(platform_name, "dm365_vpss"))
+                oper_cfg.platform = DM365;
+        else if (!strcmp(platform_name, "dm644x_vpss"))
+                oper_cfg.platform = DM644X;
+        else {
                 dev_err(&pdev->dev, "vpss driver not supported on"
                         " this platform\n");
                 return -ENODEV;
         }
 
-        dev_info(&pdev->dev, "%s vpss probed\n", oper_cfg.vpss_name);
-        oper_cfg.r1 = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (!oper_cfg.r1)
+        dev_info(&pdev->dev, "%s vpss probed\n", platform_name);
+        r1 = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!r1)
                 return -ENOENT;
 
-        oper_cfg.len1 = oper_cfg.r1->end - oper_cfg.r1->start + 1;
-
-        oper_cfg.r1 = request_mem_region(oper_cfg.r1->start, oper_cfg.len1,
-                                         oper_cfg.r1->name);
-        if (!oper_cfg.r1)
+        r1 = request_mem_region(r1->start, resource_size(r1), r1->name);
+        if (!r1)
                 return -EBUSY;
 
-        oper_cfg.vpss_bl_regs_base = ioremap(oper_cfg.r1->start, oper_cfg.len1);
-        if (!oper_cfg.vpss_bl_regs_base) {
+        oper_cfg.vpss_regs_base0 = ioremap(r1->start, resource_size(r1));
+        if (!oper_cfg.vpss_regs_base0) {
                 status = -EBUSY;
                 goto fail1;
         }
 
-        if (dm355) {
-                oper_cfg.r2 = platform_get_resource(pdev, IORESOURCE_MEM, 1);
-                if (!oper_cfg.r2) {
+        if (oper_cfg.platform == DM355 || oper_cfg.platform == DM365) {
+                r2 = platform_get_resource(pdev, IORESOURCE_MEM, 1);
+                if (!r2) {
                         status = -ENOENT;
                         goto fail2;
                 }
-                oper_cfg.len2 = oper_cfg.r2->end - oper_cfg.r2->start + 1;
-                oper_cfg.r2 = request_mem_region(oper_cfg.r2->start,
-                                                 oper_cfg.len2,
-                                                 oper_cfg.r2->name);
-                if (!oper_cfg.r2) {
+                r2 = request_mem_region(r2->start, resource_size(r2), r2->name);
+                if (!r2) {
                         status = -EBUSY;
                         goto fail2;
                 }
 
-                oper_cfg.vpss_regs_base = ioremap(oper_cfg.r2->start,
-                                                  oper_cfg.len2);
-                if (!oper_cfg.vpss_regs_base) {
+                oper_cfg.vpss_regs_base1 = ioremap(r2->start,
+                                                   resource_size(r2));
+                if (!oper_cfg.vpss_regs_base1) {
                         status = -EBUSY;
                         goto fail3;
                 }
         }
 
-        if (dm355) {
+        if (oper_cfg.platform == DM355) {
                 oper_cfg.hw_ops.enable_clock = dm355_enable_clock;
                 oper_cfg.hw_ops.select_ccdc_source = dm355_select_ccdc_source;
+                /* Setup vpss interrupts */
+                bl_regw(DM355_VPSSBL_INTSEL_DEFAULT, DM355_VPSSBL_INTSEL);
+                bl_regw(DM355_VPSSBL_EVTSEL_DEFAULT, DM355_VPSSBL_EVTSEL);
+        } else if (oper_cfg.platform == DM365) {
+                oper_cfg.hw_ops.enable_clock = dm365_enable_clock;
+                oper_cfg.hw_ops.select_ccdc_source = dm365_select_ccdc_source;
+                /* Setup vpss interrupts */
+                isp5_write(DM365_ISP5_INTSEL1_DEFAULT, DM365_ISP5_INTSEL1);
+                isp5_write(DM365_ISP5_INTSEL2_DEFAULT, DM365_ISP5_INTSEL2);
+                isp5_write(DM365_ISP5_INTSEL3_DEFAULT, DM365_ISP5_INTSEL3);
         } else
                 oper_cfg.hw_ops.clear_wbl_overflow = dm644x_clear_wbl_overflow;
 
         spin_lock_init(&oper_cfg.vpss_lock);
-        dev_info(&pdev->dev, "%s vpss probe success\n", oper_cfg.vpss_name);
+        dev_info(&pdev->dev, "%s vpss probe success\n", platform_name);
         return 0;
 
 fail3:
-        release_mem_region(oper_cfg.r2->start, oper_cfg.len2);
+        release_mem_region(r2->start, resource_size(r2));
 fail2:
-        iounmap(oper_cfg.vpss_bl_regs_base);
+        iounmap(oper_cfg.vpss_regs_base0);
 fail1:
-        release_mem_region(oper_cfg.r1->start, oper_cfg.len1);
+        release_mem_region(r1->start, resource_size(r1));
         return status;
 }
 
 static int __devexit vpss_remove(struct platform_device *pdev)
 {
-        iounmap(oper_cfg.vpss_bl_regs_base);
-        release_mem_region(oper_cfg.r1->start, oper_cfg.len1);
-        if (!strcmp(oper_cfg.vpss_name, "dm355_vpss")) {
-                iounmap(oper_cfg.vpss_regs_base);
-                release_mem_region(oper_cfg.r2->start, oper_cfg.len2);
+        struct resource         *res;
+
+        iounmap(oper_cfg.vpss_regs_base0);
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        release_mem_region(res->start, resource_size(res));
+        if (oper_cfg.platform == DM355 || oper_cfg.platform == DM365) {
+                iounmap(oper_cfg.vpss_regs_base1);
+                res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
+                release_mem_region(res->start, resource_size(res));
         }
         return 0;
 }
diff --git a/drivers/media/video/em28xx/em28xx-cards.c b/drivers/media/video/em28xx/em28xx-cards.c
index 25100001ffff..ecbcefb08739 100644
--- a/drivers/media/video/em28xx/em28xx-cards.c
+++ b/drivers/media/video/em28xx/em28xx-cards.c
@@ -232,6 +232,12 @@ static struct em28xx_reg_seq vc211a_enable[] = {
         {       -1,             -1,     -1,             -1},
 };
 
+static struct em28xx_reg_seq dikom_dk300_digital[] = {
+        {EM28XX_R08_GPIO,       0x6e,   ~EM_GPIO_4,     10},
+        {EM2880_R04_GPO,        0x08,   0xff,           10},
+        { -1,                   -1,     -1,             -1},
+};
+
 
 /*
  *  Board definitions
@@ -461,21 +467,30 @@ struct em28xx_board em28xx_boards[] = {
                 .name         = "Leadtek Winfast USB II Deluxe",
                 .valid        = EM28XX_BOARD_NOT_VALIDATED,
                 .tuner_type   = TUNER_PHILIPS_FM1216ME_MK3,
-                .tda9887_conf = TDA9887_PRESENT,
+                .has_ir_i2c   = 1,
+                .tvaudio_addr = 0x58,
+                .tda9887_conf = TDA9887_PRESENT |
+                                TDA9887_PORT2_ACTIVE |
+                                TDA9887_QSS,
                 .decoder      = EM28XX_SAA711X,
+                .adecoder     = EM28XX_TVAUDIO,
                 .input        = { {
                         .type     = EM28XX_VMUX_TELEVISION,
-                        .vmux     = SAA7115_COMPOSITE2,
-                        .amux     = EM28XX_AMUX_VIDEO,
+                        .vmux     = SAA7115_COMPOSITE4,
+                        .amux     = EM28XX_AMUX_AUX,
                 }, {
                         .type     = EM28XX_VMUX_COMPOSITE1,
-                        .vmux     = SAA7115_COMPOSITE0,
+                        .vmux     = SAA7115_COMPOSITE5,
                         .amux     = EM28XX_AMUX_LINE_IN,
                 }, {
                         .type     = EM28XX_VMUX_SVIDEO,
-                        .vmux     = SAA7115_COMPOSITE0,
+                        .vmux     = SAA7115_SVIDEO3,
                         .amux     = EM28XX_AMUX_LINE_IN,
                 } },
+                        .radio    = {
+                        .type     = EM28XX_RADIO,
+                        .amux     = EM28XX_AMUX_AUX,
+                        }
         },
         [EM2820_BOARD_VIDEOLOGY_20K14XUSB] = {
                 .name         = "Videology 20K14XUSB USB2.0",
@@ -730,11 +745,12 @@ struct em28xx_board em28xx_boards[] = {
 
         [EM2880_BOARD_TERRATEC_HYBRID_XS_FR] = {
                 .name         = "Terratec Hybrid XS Secam",
-                .valid        = EM28XX_BOARD_NOT_VALIDATED,
                 .has_msp34xx  = 1,
                 .tuner_type   = TUNER_XC2028,
                 .tuner_gpio   = default_tuner_gpio,
                 .decoder      = EM28XX_TVP5150,
+                .has_dvb      = 1,
+                .dvb_gpio     = default_digital,
                 .input        = { {
                         .type     = EM28XX_VMUX_TELEVISION,
                         .vmux     = TVP5150_COMPOSITE0,
@@ -1265,6 +1281,7 @@ struct em28xx_board em28xx_boards[] = {
                 .decoder        = EM28XX_SAA711X,
                 .has_dvb        = 1,
                 .dvb_gpio       = em2882_kworld_315u_digital,
+                .ir_codes       = &ir_codes_kworld_315u_table,
                 .xclk           = EM28XX_XCLK_FREQUENCY_12MHZ,
                 .i2c_speed      = EM28XX_I2C_CLK_WAIT_ENABLE,
                 /* Analog mode - still not ready */
@@ -1431,6 +1448,21 @@ struct em28xx_board em28xx_boards[] = {
                         .gpio     = hauppauge_wintv_hvr_900_analog,
                 } },
         },
+        [EM2882_BOARD_DIKOM_DK300] = {
+                .name         = "Dikom DK300",
+                .tuner_type   = TUNER_XC2028,
+                .tuner_gpio   = default_tuner_gpio,
+                .decoder      = EM28XX_TVP5150,
+                .mts_firmware = 1,
+                .has_dvb      = 1,
+                .dvb_gpio     = dikom_dk300_digital,
+                .input        = { {
+                        .type     = EM28XX_VMUX_TELEVISION,
+                        .vmux     = TVP5150_COMPOSITE0,
+                        .amux     = EM28XX_AMUX_VIDEO,
+                        .gpio     = default_analog,
+                } },
+        },
         [EM2883_BOARD_KWORLD_HYBRID_330U] = {
                 .name         = "Kworld PlusTV HD Hybrid 330",
                 .tuner_type   = TUNER_XC2028,
@@ -1751,6 +1783,7 @@ static struct em28xx_hash_table em28xx_eeprom_hash[] = {
         {0xcee44a99, EM2882_BOARD_EVGA_INDTUBE, TUNER_XC2028},
         {0xb8846b20, EM2881_BOARD_PINNACLE_HYBRID_PRO, TUNER_XC2028},
         {0x63f653bd, EM2870_BOARD_REDDO_DVB_C_USB_BOX, TUNER_ABSENT},
+        {0x4e913442, EM2882_BOARD_DIKOM_DK300, TUNER_XC2028},
 };
 
 /* I2C devicelist hash table for devices with generic USB IDs */
@@ -2103,6 +2136,7 @@ static void em28xx_setup_xc3028(struct em28xx *dev, struct xc2028_ctrl *ctl)
                 ctl->demod = XC3028_FE_DEFAULT;
                 break;
         case EM2883_BOARD_KWORLD_HYBRID_330U:
+        case EM2882_BOARD_DIKOM_DK300:
                 ctl->demod = XC3028_FE_CHINA;
                 ctl->fname = XC2028_DEFAULT_FIRMWARE;
                 break;
@@ -2259,9 +2293,12 @@ static int em28xx_hint_board(struct em28xx *dev)
 /* ----------------------------------------------------------------------- */
 void em28xx_register_i2c_ir(struct em28xx *dev)
 {
+        /* Leadtek winfast tv USBII deluxe can find a non working IR-device */
+        /* at address 0x18, so if that address is needed for another board in */
+        /* the future, please put it after 0x1f. */
         struct i2c_board_info info;
         const unsigned short addr_list[] = {
-                 0x30, 0x47, I2C_CLIENT_END
+                 0x1f, 0x30, 0x47, I2C_CLIENT_END
         };
 
         if (disable_ir)
@@ -2288,6 +2325,10 @@ void em28xx_register_i2c_ir(struct em28xx *dev)
                 dev->init_data.ir_codes = &ir_codes_rc5_hauppauge_new_table;
                 dev->init_data.get_key = em28xx_get_key_em_haup;
                 dev->init_data.name = "i2c IR (EM2840 Hauppauge)";
+        case EM2820_BOARD_LEADTEK_WINFAST_USBII_DELUXE:
+                dev->init_data.ir_codes = &ir_codes_winfast_usbii_deluxe_table;;
+                dev->init_data.get_key = em28xx_get_key_winfast_usbii_deluxe;
+                dev->init_data.name = "i2c IR (EM2820 Winfast TV USBII Deluxe)";
                 break;
         }
 
@@ -2381,6 +2422,31 @@ void em28xx_card_setup(struct em28xx *dev)
                 em28xx_gpio_set(dev, dev->board.tuner_gpio);
                 em28xx_set_mode(dev, EM28XX_ANALOG_MODE);
                 break;
+
+/*
+                 * The Dikom DK300 is detected as an Kworld VS-DVB-T 323UR.
+                 *
+                 * This occurs because they share identical USB vendor and
+                 * product IDs.
+                 *
+                 * What we do here is look up the EEPROM hash of the Dikom
+                 * and if it is found then we decide that we do not have
+                 * a Kworld and reset the device to the Dikom instead.
+                 *
+                 * This solution is only valid if they do not share eeprom
+                 * hash identities which has not been determined as yet.
+                 */
+        case EM2882_BOARD_KWORLD_VS_DVBT:
+                if (!em28xx_hint_board(dev))
+                        em28xx_set_model(dev);
+
+                /* In cases where we had to use a board hint, the call to
+                   em28xx_set_mode() in em28xx_pre_card_setup() was a no-op,
+                   so make the call now so the analog GPIOs are set properly
+                   before probing the i2c bus. */
+                em28xx_gpio_set(dev, dev->board.tuner_gpio);
+                em28xx_set_mode(dev, EM28XX_ANALOG_MODE);
+                break;
         }
 
 #if defined(CONFIG_MODULES) && defined(MODULE)
diff --git a/drivers/media/video/em28xx/em28xx-core.c b/drivers/media/video/em28xx/em28xx-core.c
index b311d4514bdf..5a37eccbd7d6 100644
--- a/drivers/media/video/em28xx/em28xx-core.c
+++ b/drivers/media/video/em28xx/em28xx-core.c
@@ -691,9 +691,15 @@ int em28xx_set_outfmt(struct em28xx *dev)
         if (em28xx_vbi_supported(dev) == 1) {
                 vinctrl |= EM28XX_VINCTRL_VBI_RAW;
                 em28xx_write_reg(dev, EM28XX_R34_VBI_START_H, 0x00);
-                em28xx_write_reg(dev, EM28XX_R35_VBI_START_V, 0x09);
-                em28xx_write_reg(dev, EM28XX_R36_VBI_WIDTH, 0xb4);
-                em28xx_write_reg(dev, EM28XX_R37_VBI_HEIGHT, 0x0c);
+                em28xx_write_reg(dev, EM28XX_R36_VBI_WIDTH, dev->vbi_width/4);
+                em28xx_write_reg(dev, EM28XX_R37_VBI_HEIGHT, dev->vbi_height);
+                if (dev->norm & V4L2_STD_525_60) {
+                        /* NTSC */
+                        em28xx_write_reg(dev, EM28XX_R35_VBI_START_V, 0x09);
+                } else if (dev->norm & V4L2_STD_625_50) {
+                        /* PAL */
+                        em28xx_write_reg(dev, EM28XX_R35_VBI_START_V, 0x07);
+                }
         }
 
         return em28xx_write_reg(dev, EM28XX_R11_VINCTRL, vinctrl);
@@ -760,6 +766,13 @@ int em28xx_resolution_set(struct em28xx *dev)
         width = norm_maxw(dev);
         height = norm_maxh(dev);
 
+        /* Properly setup VBI */
+        dev->vbi_width = 720;
+        if (dev->norm & V4L2_STD_525_60)
+                dev->vbi_height = 12;
+        else
+                dev->vbi_height = 18;
+
         if (!dev->progressive)
                 height >>= norm_maxh(dev);
 
diff --git a/drivers/media/video/em28xx/em28xx-dvb.c b/drivers/media/video/em28xx/em28xx-dvb.c
index cc0505eb900f..1b96356b3ab2 100644
--- a/drivers/media/video/em28xx/em28xx-dvb.c
+++ b/drivers/media/video/em28xx/em28xx-dvb.c
@@ -502,7 +502,9 @@ static int dvb_init(struct em28xx *dev)
                 }
                 break;
         case EM2880_BOARD_TERRATEC_HYBRID_XS:
+        case EM2880_BOARD_TERRATEC_HYBRID_XS_FR:
         case EM2881_BOARD_PINNACLE_HYBRID_PRO:
+        case EM2882_BOARD_DIKOM_DK300:
                 dvb->frontend = dvb_attach(zl10353_attach,
                                            &em28xx_zl10353_xc3028_no_i2c_gate,
                                            &dev->i2c_adap);
@@ -606,6 +608,7 @@ static int dvb_fini(struct em28xx *dev)
 
         if (dev->dvb) {
                 unregister_dvb(dev->dvb);
+                kfree(dev->dvb);
                 dev->dvb = NULL;
         }
 
diff --git a/drivers/media/video/em28xx/em28xx-input.c b/drivers/media/video/em28xx/em28xx-input.c
index af0d935c29be..1fb754e20875 100644
--- a/drivers/media/video/em28xx/em28xx-input.c
+++ b/drivers/media/video/em28xx/em28xx-input.c
@@ -75,6 +75,10 @@ struct em28xx_IR {
         unsigned int repeat_interval;
 
         int  (*get_key)(struct em28xx_IR *, struct em28xx_ir_poll_result *);
+
+        /* IR device properties */
+
+        struct ir_dev_props props;
 };
 
 /**********************************************************
@@ -180,6 +184,36 @@ int em28xx_get_key_pinnacle_usb_grey(struct IR_i2c *ir, u32 *ir_key,
         return 1;
 }
 
+int em28xx_get_key_winfast_usbii_deluxe(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
+{
+        unsigned char subaddr, keydetect, key;
+
+        struct i2c_msg msg[] = { { .addr = ir->c->addr, .flags = 0, .buf = &subaddr, .len = 1},
+
+                                { .addr = ir->c->addr, .flags = I2C_M_RD, .buf = &keydetect, .len = 1} };
+
+        subaddr = 0x10;
+        if (2 != i2c_transfer(ir->c->adapter, msg, 2)) {
+                i2cdprintk("read error\n");
+                return -EIO;
+        }
+        if (keydetect == 0x00)
+                return 0;
+
+        subaddr = 0x00;
+        msg[1].buf = &key;
+        if (2 != i2c_transfer(ir->c->adapter, msg, 2)) {
+                i2cdprintk("read error\n");
+        return -EIO;
+        }
+        if (key == 0x00)
+                return 0;
+
+        *ir_key = key;
+        *ir_raw = key;
+        return 1;
+}
+
 /**********************************************************
  Poll based get keycode functions
  **********************************************************/
@@ -336,35 +370,28 @@ static void em28xx_ir_stop(struct em28xx_IR *ir)
         cancel_delayed_work_sync(&ir->work);
 }
 
-int em28xx_ir_init(struct em28xx *dev)
+int em28xx_ir_change_protocol(void *priv, u64 ir_type)
 {
-        struct em28xx_IR *ir;
-        struct input_dev *input_dev;
-        u8 ir_config;
-        int err = -ENOMEM;
-
-        if (dev->board.ir_codes == NULL) {
-                /* No remote control support */
-                return 0;
-        }
-
-        ir = kzalloc(sizeof(*ir), GFP_KERNEL);
-        input_dev = input_allocate_device();
-        if (!ir || !input_dev)
-                goto err_out_free;
-
-        ir->input = input_dev;
-        ir_config = EM2874_IR_RC5;
+        int rc = 0;
+        struct em28xx_IR *ir = priv;
+        struct em28xx *dev = ir->dev;
+        u8 ir_config = EM2874_IR_RC5;
 
         /* Adjust xclk based o IR table for RC5/NEC tables */
-        if (dev->board.ir_codes->ir_type == IR_TYPE_RC5) {
+
+        dev->board.ir_codes->ir_type = IR_TYPE_OTHER;
+        if (ir_type == IR_TYPE_RC5) {
                 dev->board.xclk |= EM28XX_XCLK_IR_RC5_MODE;
                 ir->full_code = 1;
-        } else  if (dev->board.ir_codes->ir_type == IR_TYPE_NEC) {
+        } else if (ir_type == IR_TYPE_NEC) {
                 dev->board.xclk &= ~EM28XX_XCLK_IR_RC5_MODE;
                 ir_config = EM2874_IR_NEC;
                 ir->full_code = 1;
-        }
+        } else
+                rc = -EINVAL;
+
+        dev->board.ir_codes->ir_type = ir_type;
+
         em28xx_write_reg_bits(dev, EM28XX_R0F_XCLK, dev->board.xclk,
                               EM28XX_XCLK_IR_RC5_MODE);
 
@@ -380,9 +407,42 @@ int em28xx_ir_init(struct em28xx *dev)
                 break;
         default:
                 printk("Unrecognized em28xx chip id: IR not supported\n");
-                goto err_out_free;
+                rc = -EINVAL;
+        }
+
+        return rc;
+}
+
+int em28xx_ir_init(struct em28xx *dev)
+{
+        struct em28xx_IR *ir;
+        struct input_dev *input_dev;
+        int err = -ENOMEM;
+
+        if (dev->board.ir_codes == NULL) {
+                /* No remote control support */
+                return 0;
         }
 
+        ir = kzalloc(sizeof(*ir), GFP_KERNEL);
+        input_dev = input_allocate_device();
+        if (!ir || !input_dev)
+                goto err_out_free;
+
+        /* record handles to ourself */
+        ir->dev = dev;
+        dev->ir = ir;
+
+        ir->input = input_dev;
+
+        /*
+         * em2874 supports more protocols. For now, let's just announce
+         * the two protocols that were already tested
+         */
+        ir->props.allowed_protos = IR_TYPE_RC5 | IR_TYPE_NEC;
+        ir->props.priv = ir;
+        ir->props.change_protocol = em28xx_ir_change_protocol;
+
         /* This is how often we ask the chip for IR information */
         ir->polling = 100; /* ms */
 
@@ -393,6 +453,8 @@ int em28xx_ir_init(struct em28xx *dev)
         usb_make_path(dev->udev, ir->phys, sizeof(ir->phys));
         strlcat(ir->phys, "/input0", sizeof(ir->phys));
 
+        /* Set IR protocol */
+        em28xx_ir_change_protocol(ir, dev->board.ir_codes->ir_type);
         err = ir_input_init(input_dev, &ir->ir, IR_TYPE_OTHER);
         if (err < 0)
                 goto err_out_free;
@@ -405,14 +467,13 @@ int em28xx_ir_init(struct em28xx *dev)
         input_dev->id.product = le16_to_cpu(dev->udev->descriptor.idProduct);
 
         input_dev->dev.parent = &dev->udev->dev;
-        /* record handles to ourself */
-        ir->dev = dev;
-        dev->ir = ir;
+
 
         em28xx_ir_start(ir);
 
         /* all done */
-        err = ir_input_register(ir->input, dev->board.ir_codes);
+        err = ir_input_register(ir->input, dev->board.ir_codes,
+                                &ir->props);
         if (err)
                 goto err_out_stop;
 
diff --git a/drivers/media/video/em28xx/em28xx-reg.h b/drivers/media/video/em28xx/em28xx-reg.h
index 058ac87639ce..91e90559642b 100644
--- a/drivers/media/video/em28xx/em28xx-reg.h
+++ b/drivers/media/video/em28xx/em28xx-reg.h
@@ -173,8 +173,8 @@
 /* em2874 IR config register (0x50) */
 #define EM2874_IR_NEC           0x00
 #define EM2874_IR_RC5           0x04
-#define EM2874_IR_RC5_MODE_0    0x08
-#define EM2874_IR_RC5_MODE_6A   0x0b
+#define EM2874_IR_RC6_MODE_0    0x08
+#define EM2874_IR_RC6_MODE_6A   0x0b
 
 /* em2874 Transport Stream Enable Register (0x5f) */
 #define EM2874_TS1_CAPTURE_ENABLE (1 << 0)
diff --git a/drivers/media/video/em28xx/em28xx-vbi.c b/drivers/media/video/em28xx/em28xx-vbi.c
index 94943e5a1529..c7dce39823d8 100644
--- a/drivers/media/video/em28xx/em28xx-vbi.c
+++ b/drivers/media/video/em28xx/em28xx-vbi.c
@@ -71,7 +71,11 @@ free_buffer(struct videobuf_queue *vq, struct em28xx_buffer *buf)
 static int
 vbi_setup(struct videobuf_queue *q, unsigned int *count, unsigned int *size)
 {
-        *size = 720 * 12 * 2;
+        struct em28xx_fh     *fh  = q->priv_data;
+        struct em28xx        *dev = fh->dev;
+
+        *size = dev->vbi_width * dev->vbi_height * 2;
+
         if (0 == *count)
                 *count = vbibufs;
         if (*count < 2)
@@ -85,19 +89,18 @@ static int
 vbi_prepare(struct videobuf_queue *q, struct videobuf_buffer *vb,
             enum v4l2_field field)
 {
+        struct em28xx_fh     *fh  = q->priv_data;
+        struct em28xx        *dev = fh->dev;
         struct em28xx_buffer *buf = container_of(vb, struct em28xx_buffer, vb);
         int                  rc = 0;
-        unsigned int size;
-
-        size = 720 * 12 * 2;
 
-        buf->vb.size = size;
+        buf->vb.size = dev->vbi_width * dev->vbi_height * 2;
 
         if (0 != buf->vb.baddr  &&  buf->vb.bsize < buf->vb.size)
                 return -EINVAL;
 
-        buf->vb.width  = 720;
-        buf->vb.height = 12;
+        buf->vb.width  = dev->vbi_width;
+        buf->vb.height = dev->vbi_height;
         buf->vb.field  = field;
 
         if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
diff --git a/drivers/media/video/em28xx/em28xx-video.c b/drivers/media/video/em28xx/em28xx-video.c
index 849b18c94037..ac2bd935927e 100644
--- a/drivers/media/video/em28xx/em28xx-video.c
+++ b/drivers/media/video/em28xx/em28xx-video.c
@@ -282,7 +282,7 @@ static void em28xx_copy_vbi(struct em28xx *dev,
 {
         void *startwrite, *startread;
         int  offset;
-        int bytesperline = 720;
+        int bytesperline = dev->vbi_width;
 
         if (dev == NULL) {
                 em28xx_isocdbg("dev is null\n");
@@ -323,8 +323,8 @@ static void em28xx_copy_vbi(struct em28xx *dev,
 
         /* Make sure the bottom field populates the second half of the frame */
         if (buf->top_field == 0) {
-                startwrite += bytesperline * 0x0c;
-                offset += bytesperline * 0x0c;
+                startwrite += bytesperline * dev->vbi_height;
+                offset += bytesperline * dev->vbi_height;
         }
 
         memcpy(startwrite, startread, len);
@@ -578,8 +578,7 @@ static inline int em28xx_isoc_copy_vbi(struct em28xx *dev, struct urb *urb)
                         dev->cur_field = p[2];
                 }
 
-                /* FIXME: get rid of hard-coded value */
-                vbi_size = 720 * 0x0c;
+                vbi_size = dev->vbi_width * dev->vbi_height;
 
                 if (dev->capture_type == 0) {
                         if (dev->vbi_read >= vbi_size) {
@@ -1850,18 +1849,27 @@ static int vidioc_try_set_sliced_vbi_cap(struct file *file, void *priv,
 static int vidioc_g_fmt_vbi_cap(struct file *file, void *priv,
                                 struct v4l2_format *format)
 {
-        format->fmt.vbi.samples_per_line = 720;
+        struct em28xx_fh      *fh  = priv;
+        struct em28xx         *dev = fh->dev;
+
+        format->fmt.vbi.samples_per_line = dev->vbi_width;
         format->fmt.vbi.sample_format = V4L2_PIX_FMT_GREY;
         format->fmt.vbi.offset = 0;
         format->fmt.vbi.flags = 0;
+        format->fmt.vbi.sampling_rate = 6750000 * 4 / 2;
+        format->fmt.vbi.count[0] = dev->vbi_height;
+        format->fmt.vbi.count[1] = dev->vbi_height;
 
         /* Varies by video standard (NTSC, PAL, etc.) */
-        /* FIXME: hard-coded for NTSC support */
-        format->fmt.vbi.sampling_rate = 6750000 * 4 / 2; /* FIXME: ??? */
-        format->fmt.vbi.count[0] = 12;
-        format->fmt.vbi.count[1] = 12;
-        format->fmt.vbi.start[0] = 10;
-        format->fmt.vbi.start[1] = 273;
+        if (dev->norm & V4L2_STD_525_60) {
+                /* NTSC */
+                format->fmt.vbi.start[0] = 10;
+                format->fmt.vbi.start[1] = 273;
+        } else if (dev->norm & V4L2_STD_625_50) {
+                /* PAL */
+                format->fmt.vbi.start[0] = 6;
+                format->fmt.vbi.start[1] = 318;
+        }
 
         return 0;
 }
@@ -1869,18 +1877,27 @@ static int vidioc_g_fmt_vbi_cap(struct file *file, void *priv,
 static int vidioc_s_fmt_vbi_cap(struct file *file, void *priv,
                                 struct v4l2_format *format)
 {
-        format->fmt.vbi.samples_per_line = 720;
+        struct em28xx_fh      *fh  = priv;
+        struct em28xx         *dev = fh->dev;
+
+        format->fmt.vbi.samples_per_line = dev->vbi_width;
         format->fmt.vbi.sample_format = V4L2_PIX_FMT_GREY;
         format->fmt.vbi.offset = 0;
         format->fmt.vbi.flags = 0;
+        format->fmt.vbi.sampling_rate = 6750000 * 4 / 2;
+        format->fmt.vbi.count[0] = dev->vbi_height;
+        format->fmt.vbi.count[1] = dev->vbi_height;
 
         /* Varies by video standard (NTSC, PAL, etc.) */
-        /* FIXME: hard-coded for NTSC support */
-        format->fmt.vbi.sampling_rate = 6750000 * 4 / 2; /* FIXME: ??? */
-        format->fmt.vbi.count[0] = 12;
-        format->fmt.vbi.count[1] = 12;
-        format->fmt.vbi.start[0] = 10;
-        format->fmt.vbi.start[1] = 273;
+        if (dev->norm & V4L2_STD_525_60) {
+                /* NTSC */
+                format->fmt.vbi.start[0] = 10;
+                format->fmt.vbi.start[1] = 273;
+        } else if (dev->norm & V4L2_STD_625_50) {
+                /* PAL */
+                format->fmt.vbi.start[0] = 6;
+                format->fmt.vbi.start[1] = 318;
+        }
 
         return 0;
 }
@@ -1922,7 +1939,8 @@ static int vidioc_querybuf(struct file *file, void *priv,
                    At a minimum, it causes a crash in zvbi since it does
                    a memcpy based on the source buffer length */
                 int result = videobuf_querybuf(&fh->vb_vbiq, b);
-                b->length = 17280;
+                b->length = dev->vbi_width * dev->vbi_height * 2;
+
                 return result;
         }
 }
diff --git a/drivers/media/video/em28xx/em28xx.h b/drivers/media/video/em28xx/em28xx.h
index 80d9b4fa1b97..ba6fe5daff84 100644
--- a/drivers/media/video/em28xx/em28xx.h
+++ b/drivers/media/video/em28xx/em28xx.h
@@ -111,6 +111,7 @@
 #define EM2861_BOARD_GADMEI_UTV330PLUS           72
 #define EM2870_BOARD_REDDO_DVB_C_USB_BOX          73
 #define EM2800_BOARD_VC211A                       74
+#define EM2882_BOARD_DIKOM_DK300                  75
 
 /* Limits minimum and default number of buffers */
 #define EM28XX_MIN_BUF 4
@@ -552,7 +553,8 @@ struct em28xx {
         int capture_type;
         int vbi_read;
         unsigned char cur_field;
-
+        unsigned int vbi_width;
+        unsigned int vbi_height; /* lines per field */
 
         struct work_struct         request_module_wk;
 
@@ -693,6 +695,8 @@ int em28xx_get_key_terratec(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw);
 int em28xx_get_key_em_haup(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw);
 int em28xx_get_key_pinnacle_usb_grey(struct IR_i2c *ir, u32 *ir_key,
                                      u32 *ir_raw);
+int em28xx_get_key_winfast_usbii_deluxe(struct IR_i2c *ir, u32 *ir_key,
+                                     u32 *ir_raw);
 void em28xx_register_snapshot_button(struct em28xx *dev);
 void em28xx_deregister_snapshot_button(struct em28xx *dev);
 
diff --git a/drivers/media/video/et61x251/Kconfig b/drivers/media/video/et61x251/Kconfig
index dcc1a0335440..87981b078fe6 100644
--- a/drivers/media/video/et61x251/Kconfig
+++ b/drivers/media/video/et61x251/Kconfig
@@ -1,7 +1,11 @@
 config USB_ET61X251
-        tristate "USB ET61X[12]51 PC Camera Controller support"
+        tristate "USB ET61X[12]51 PC Camera Controller support (DEPRECATED)"
         depends on VIDEO_V4L2
+        default n
         ---help---
+          This driver is DEPRECATED please use the gspca zc3xx module
+          instead.
+
           Say Y here if you want support for cameras based on Etoms ET61X151
           or ET61X251 PC Camera Controllers.
 
diff --git a/drivers/media/video/gspca/Kconfig b/drivers/media/video/gspca/Kconfig
index 609d65b0b10d..e0060c1f0544 100644
--- a/drivers/media/video/gspca/Kconfig
+++ b/drivers/media/video/gspca/Kconfig
@@ -21,6 +21,15 @@ source "drivers/media/video/gspca/m5602/Kconfig"
 source "drivers/media/video/gspca/stv06xx/Kconfig"
 source "drivers/media/video/gspca/gl860/Kconfig"
 
+config USB_GSPCA_BENQ
+        tristate "Benq USB Camera Driver"
+        depends on VIDEO_V4L2 && USB_GSPCA
+        help
+          Say Y here if you want support for the Benq DC E300 camera.
+
+          To compile this driver as a module, choose M here: the
+          module will be called gspca_benq.
+
 config USB_GSPCA_CONEX
         tristate "Conexant Camera Driver"
         depends on VIDEO_V4L2 && USB_GSPCA
@@ -30,6 +39,17 @@ config USB_GSPCA_CONEX
           To compile this driver as a module, choose M here: the
           module will be called gspca_conex.
 
+config USB_GSPCA_CPIA1
+        tristate "cpia CPiA (version 1) Camera Driver"
+        depends on VIDEO_V4L2 && USB_GSPCA
+        help
+          Say Y here if you want support for USB cameras based on the cpia
+          CPiA chip. Note that you need atleast version 0.6.4 of libv4l for
+          applications to understand the videoformat generated by this driver.
+
+          To compile this driver as a module, choose M here: the
+          module will be called gspca_cpia1.
+
 config USB_GSPCA_ETOMS
         tristate "Etoms USB Camera Driver"
         depends on VIDEO_V4L2 && USB_GSPCA
@@ -86,15 +106,25 @@ config USB_GSPCA_OV519
           module will be called gspca_ov519.
 
 config USB_GSPCA_OV534
-        tristate "OV534 USB Camera Driver"
+        tristate "OV534 OV772x USB Camera Driver"
         depends on VIDEO_V4L2 && USB_GSPCA
         help
-          Say Y here if you want support for cameras based on the OV534 chip.
-          (e.g. Sony Playstation EYE)
+          Say Y here if you want support for cameras based on the OV534 chip
+          and sensor OV772x (e.g. Sony Playstation EYE)
 
           To compile this driver as a module, choose M here: the
           module will be called gspca_ov534.
 
+config USB_GSPCA_OV534_9
+        tristate "OV534 OV965x USB Camera Driver"
+        depends on VIDEO_V4L2 && USB_GSPCA
+        help
+          Say Y here if you want support for cameras based on the OV534 chip
+          and sensor OV965x (e.g. Hercules Dualpix)
+
+          To compile this driver as a module, choose M here: the
+          module will be called gspca_ov534_9.
+
 config USB_GSPCA_PAC207
         tristate "Pixart PAC207 USB Camera Driver"
         depends on VIDEO_V4L2 && USB_GSPCA
@@ -122,6 +152,16 @@ config USB_GSPCA_PAC7311
           To compile this driver as a module, choose M here: the
           module will be called gspca_pac7311.
 
+config USB_GSPCA_SN9C2028
+        tristate "SONIX Dual-Mode USB Camera Driver"
+        depends on VIDEO_V4L2 && USB_GSPCA
+        help
+          Say Y here if you want streaming support for Sonix SN9C2028 cameras.
+          These are supported as stillcams in libgphoto2/camlibs/sonix.
+
+          To compile this driver as a module, choose M here: the
+          module will be called gspca_sn9c2028.
+
 config USB_GSPCA_SN9C20X
         tristate "SN9C20X USB Camera Driver"
         depends on VIDEO_V4L2 && USB_GSPCA
diff --git a/drivers/media/video/gspca/Makefile b/drivers/media/video/gspca/Makefile
index ff2c7279d82e..6e4cf1ce01c9 100644
--- a/drivers/media/video/gspca/Makefile
+++ b/drivers/media/video/gspca/Makefile
@@ -1,5 +1,7 @@
 obj-$(CONFIG_USB_GSPCA)          += gspca_main.o
+obj-$(CONFIG_USB_GSPCA_BENQ)     += gspca_benq.o
 obj-$(CONFIG_USB_GSPCA_CONEX)    += gspca_conex.o
+obj-$(CONFIG_USB_GSPCA_CPIA1)    += gspca_cpia1.o
 obj-$(CONFIG_USB_GSPCA_ETOMS)    += gspca_etoms.o
 obj-$(CONFIG_USB_GSPCA_FINEPIX)  += gspca_finepix.o
 obj-$(CONFIG_USB_GSPCA_JEILINJ)  += gspca_jeilinj.o
@@ -7,9 +9,11 @@ obj-$(CONFIG_USB_GSPCA_MARS)     += gspca_mars.o
 obj-$(CONFIG_USB_GSPCA_MR97310A) += gspca_mr97310a.o
 obj-$(CONFIG_USB_GSPCA_OV519)    += gspca_ov519.o
 obj-$(CONFIG_USB_GSPCA_OV534)    += gspca_ov534.o
+obj-$(CONFIG_USB_GSPCA_OV534_9)  += gspca_ov534_9.o
 obj-$(CONFIG_USB_GSPCA_PAC207)   += gspca_pac207.o
 obj-$(CONFIG_USB_GSPCA_PAC7302)  += gspca_pac7302.o
 obj-$(CONFIG_USB_GSPCA_PAC7311)  += gspca_pac7311.o
+obj-$(CONFIG_USB_GSPCA_SN9C2028) += gspca_sn9c2028.o
 obj-$(CONFIG_USB_GSPCA_SN9C20X)  += gspca_sn9c20x.o
 obj-$(CONFIG_USB_GSPCA_SONIXB)   += gspca_sonixb.o
 obj-$(CONFIG_USB_GSPCA_SONIXJ)   += gspca_sonixj.o
@@ -30,7 +34,9 @@ obj-$(CONFIG_USB_GSPCA_VC032X)   += gspca_vc032x.o
 obj-$(CONFIG_USB_GSPCA_ZC3XX)    += gspca_zc3xx.o
 
 gspca_main-objs     := gspca.o
+gspca_benq-objs     := benq.o
 gspca_conex-objs    := conex.o
+gspca_cpia1-objs    := cpia1.o
 gspca_etoms-objs    := etoms.o
 gspca_finepix-objs  := finepix.o
 gspca_jeilinj-objs  := jeilinj.o
@@ -38,9 +44,11 @@ gspca_mars-objs     := mars.o
 gspca_mr97310a-objs := mr97310a.o
 gspca_ov519-objs    := ov519.o
 gspca_ov534-objs    := ov534.o
+gspca_ov534_9-objs  := ov534_9.o
 gspca_pac207-objs   := pac207.o
 gspca_pac7302-objs  := pac7302.o
 gspca_pac7311-objs  := pac7311.o
+gspca_sn9c2028-objs := sn9c2028.o
 gspca_sn9c20x-objs  := sn9c20x.o
 gspca_sonixb-objs   := sonixb.o
 gspca_sonixj-objs   := sonixj.o
diff --git a/drivers/media/video/gspca/benq.c b/drivers/media/video/gspca/benq.c
new file mode 100644
index 000000000000..43ac4af8d3ed
--- /dev/null
+++ b/drivers/media/video/gspca/benq.c
@@ -0,0 +1,322 @@
+/*
+ * Benq DC E300 subdriver
+ *
+ * Copyright (C) 2009 Jean-Francois Moine (http://moinejf.free.fr)
+ *
+ * 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
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#define MODULE_NAME "benq"
+
+#include "gspca.h"
+
+MODULE_AUTHOR("Jean-Francois Moine <http://moinejf.free.fr>");
+MODULE_DESCRIPTION("Benq DC E300 USB Camera Driver");
+MODULE_LICENSE("GPL");
+
+/* specific webcam descriptor */
+struct sd {
+        struct gspca_dev gspca_dev;     /* !! must be the first item */
+};
+
+/* V4L2 controls supported by the driver */
+static const struct ctrl sd_ctrls[] = {
+};
+
+static const struct v4l2_pix_format vga_mode[] = {
+        {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
+                .bytesperline = 320,
+                .sizeimage = 320 * 240 * 3 / 8 + 590,
+                .colorspace = V4L2_COLORSPACE_JPEG},
+};
+
+static void sd_isoc_irq(struct urb *urb);
+
+/* -- write a register -- */
+static void reg_w(struct gspca_dev *gspca_dev,
+                        u16 value, u16 index)
+{
+        struct usb_device *dev = gspca_dev->dev;
+        int ret;
+
+        if (gspca_dev->usb_err < 0)
+                return;
+        ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
+                        0x02,
+                        USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+                        value,
+                        index,
+                        NULL,
+                        0,
+                        500);
+        if (ret < 0) {
+                PDEBUG(D_ERR, "reg_w err %d", ret);
+                gspca_dev->usb_err = ret;
+        }
+}
+
+/* this function is called at probe time */
+static int sd_config(struct gspca_dev *gspca_dev,
+                        const struct usb_device_id *id)
+{
+        gspca_dev->cam.cam_mode = vga_mode;
+        gspca_dev->cam.nmodes = ARRAY_SIZE(vga_mode);
+        gspca_dev->cam.no_urb_create = 1;
+        gspca_dev->cam.reverse_alts = 1;
+        return 0;
+}
+
+/* this function is called at probe and resume time */
+static int sd_init(struct gspca_dev *gspca_dev)
+{
+        return 0;
+}
+
+static int sd_isoc_init(struct gspca_dev *gspca_dev)
+{
+        int ret;
+
+        ret = usb_set_interface(gspca_dev->dev, gspca_dev->iface,
+                gspca_dev->nbalt - 1);
+        if (ret < 0) {
+                err("usb_set_interface failed");
+                return ret;
+        }
+/*      reg_w(gspca_dev, 0x0003, 0x0002); */
+        return 0;
+}
+
+/* -- start the camera -- */
+static int sd_start(struct gspca_dev *gspca_dev)
+{
+        struct urb *urb;
+        int i, n;
+
+        /* create 4 URBs - 2 on endpoint 0x83 and 2 on 0x082 */
+#if MAX_NURBS < 4
+#error "Not enough URBs in the gspca table"
+#endif
+#define SD_PKT_SZ 64
+#define SD_NPKT 32
+        for (n = 0; n < 4; n++) {
+                urb = usb_alloc_urb(SD_NPKT, GFP_KERNEL);
+                if (!urb) {
+                        err("usb_alloc_urb failed");
+                        return -ENOMEM;
+                }
+                gspca_dev->urb[n] = urb;
+                urb->transfer_buffer = usb_buffer_alloc(gspca_dev->dev,
+                                                SD_PKT_SZ * SD_NPKT,
+                                                GFP_KERNEL,
+                                                &urb->transfer_dma);
+
+                if (urb->transfer_buffer == NULL) {
+                        err("usb_buffer_alloc failed");
+                        return -ENOMEM;
+                }
+                urb->dev = gspca_dev->dev;
+                urb->context = gspca_dev;
+                urb->transfer_buffer_length = SD_PKT_SZ * SD_NPKT;
+                urb->pipe = usb_rcvisocpipe(gspca_dev->dev,
+                                        n & 1 ? 0x82 : 0x83);
+                urb->transfer_flags = URB_ISO_ASAP
+                                        | URB_NO_TRANSFER_DMA_MAP;
+                urb->interval = 1;
+                urb->complete = sd_isoc_irq;
+                urb->number_of_packets = SD_NPKT;
+                for (i = 0; i < SD_NPKT; i++) {
+                        urb->iso_frame_desc[i].length = SD_PKT_SZ;
+                        urb->iso_frame_desc[i].offset = SD_PKT_SZ * i;
+                }
+        }
+
+        return gspca_dev->usb_err;
+}
+
+static void sd_stopN(struct gspca_dev *gspca_dev)
+{
+        reg_w(gspca_dev, 0x003c, 0x0003);
+        reg_w(gspca_dev, 0x003c, 0x0004);
+        reg_w(gspca_dev, 0x003c, 0x0005);
+        reg_w(gspca_dev, 0x003c, 0x0006);
+        reg_w(gspca_dev, 0x003c, 0x0007);
+        usb_set_interface(gspca_dev->dev, gspca_dev->iface, gspca_dev->nbalt - 1);
+}
+
+static void sd_pkt_scan(struct gspca_dev *gspca_dev,
+                        u8 *data,               /* isoc packet */
+                        int len)                /* iso packet length */
+{
+        /* unused */
+}
+
+/* reception of an URB */
+static void sd_isoc_irq(struct urb *urb)
+{
+        struct gspca_dev *gspca_dev = (struct gspca_dev *) urb->context;
+        struct urb *urb0;
+        u8 *data;
+        int i, st;
+
+        PDEBUG(D_PACK, "sd isoc irq");
+        if (!gspca_dev->streaming)
+                return;
+        if (urb->status != 0) {
+                if (urb->status == -ESHUTDOWN)
+                        return;         /* disconnection */
+#ifdef CONFIG_PM
+                if (gspca_dev->frozen)
+                        return;
+#endif
+                PDEBUG(D_ERR|D_PACK, "urb status: %d", urb->status);
+                return;
+        }
+
+        /* if this is a control URN (ep 0x83), wait */
+        if (urb == gspca_dev->urb[0] || urb == gspca_dev->urb[2])
+                return;
+
+        /* scan both received URBs */
+        if (urb == gspca_dev->urb[1])
+                urb0 = gspca_dev->urb[0];
+        else
+                urb0 = gspca_dev->urb[2];
+        for (i = 0; i < urb->number_of_packets; i++) {
+
+                /* check the packet status and length */
+                if (urb0->iso_frame_desc[i].actual_length != SD_PKT_SZ
+                    || urb->iso_frame_desc[i].actual_length != SD_PKT_SZ) {
+                        PDEBUG(D_ERR, "ISOC bad lengths %d / %d",
+                                urb0->iso_frame_desc[i].actual_length,
+                                urb->iso_frame_desc[i].actual_length);
+                        gspca_dev->last_packet_type = DISCARD_PACKET;
+                        continue;
+                }
+                st = urb0->iso_frame_desc[i].status;
+                if (st == 0)
+                        st = urb->iso_frame_desc[i].status;
+                if (st) {
+                        PDEBUG(D_ERR,
+                                "ISOC data error: [%d] status=%d",
+                                i, st);
+                        gspca_dev->last_packet_type = DISCARD_PACKET;
+                        continue;
+                }
+
+                /*
+                 * The images are received in URBs of different endpoints
+                 * (0x83 and 0x82).
+                 * Image pieces in URBs of ep 0x83 are continuated in URBs of
+                 * ep 0x82 of the same index.
+                 * The packets in the URBs of endpoint 0x83 start with:
+                 *      - 80 ba/bb 00 00 = start of image followed by 'ff d8'
+                 *      - 04 ba/bb oo oo = image piece
+                 *              where 'oo oo' is the image offset
+                                                (not cheked)
+                 *      - (other -> bad frame)
+                 * The images are JPEG encoded with full header and
+                 * normal ff escape.
+                 * The end of image ('ff d9') may occur in any URB.
+                 * (not cheked)
+                 */
+                data = (u8 *) urb0->transfer_buffer
+                                        + urb0->iso_frame_desc[i].offset;
+                if (data[0] == 0x80 && (data[1] & 0xfe) == 0xba) {
+
+                        /* new image */
+                        gspca_frame_add(gspca_dev, LAST_PACKET,
+                                        NULL, 0);
+                        gspca_frame_add(gspca_dev, FIRST_PACKET,
+                                        data + 4, SD_PKT_SZ - 4);
+                } else if (data[0] == 0x04 && (data[1] & 0xfe) == 0xba) {
+                        gspca_frame_add(gspca_dev, INTER_PACKET,
+                                        data + 4, SD_PKT_SZ - 4);
+                } else {
+                        gspca_dev->last_packet_type = DISCARD_PACKET;
+                        continue;
+                }
+                data = (u8 *) urb->transfer_buffer
+                                        + urb->iso_frame_desc[i].offset;
+                        gspca_frame_add(gspca_dev, INTER_PACKET,
+                                        data, SD_PKT_SZ);
+        }
+
+        /* resubmit the URBs */
+        st = usb_submit_urb(urb0, GFP_ATOMIC);
+        if (st < 0)
+                PDEBUG(D_ERR|D_PACK, "usb_submit_urb(0) ret %d", st);
+        st = usb_submit_urb(urb, GFP_ATOMIC);
+        if (st < 0)
+                PDEBUG(D_ERR|D_PACK, "usb_submit_urb() ret %d", st);
+}
+
+/* sub-driver description */
+static const struct sd_desc sd_desc = {
+        .name = MODULE_NAME,
+        .ctrls = sd_ctrls,
+        .nctrls = ARRAY_SIZE(sd_ctrls),
+        .config = sd_config,
+        .init = sd_init,
+        .isoc_init = sd_isoc_init,
+        .start = sd_start,
+        .stopN = sd_stopN,
+        .pkt_scan = sd_pkt_scan,
+};
+
+/* -- module initialisation -- */
+static const __devinitdata struct usb_device_id device_table[] = {
+        {USB_DEVICE(0x04a5, 0x3035)},
+        {}
+};
+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);
+}
+
+static struct usb_driver sd_driver = {
+        .name = MODULE_NAME,
+        .id_table = device_table,
+        .probe = sd_probe,
+        .disconnect = gspca_disconnect,
+#ifdef CONFIG_PM
+        .suspend = gspca_suspend,
+        .resume = gspca_resume,
+#endif
+};
+
+/* -- module insert / remove -- */
+static int __init sd_mod_init(void)
+{
+        int ret;
+
+        ret = usb_register(&sd_driver);
+        if (ret < 0)
+                return ret;
+        info("registered");
+        return 0;
+}
+static void __exit sd_mod_exit(void)
+{
+        usb_deregister(&sd_driver);
+        info("deregistered");
+}
+
+module_init(sd_mod_init);
+module_exit(sd_mod_exit);
diff --git a/drivers/media/video/gspca/coarse_expo_autogain.h b/drivers/media/video/gspca/coarse_expo_autogain.h
new file mode 100644
index 000000000000..1cb9d941eaf6
--- /dev/null
+++ b/drivers/media/video/gspca/coarse_expo_autogain.h
@@ -0,0 +1,116 @@
+/*
+ * Auto gain algorithm for camera's with a coarse exposure control
+ *
+ * Copyright (C) 2010 Hans de Goede <hdegoede@redhat.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+/* Autogain + exposure algorithm for cameras with a coarse exposure control
+   (usually this means we can only control the clockdiv to change exposure)
+   As changing the clockdiv so that the fps drops from 30 to 15 fps for
+   example, will lead to a huge exposure change (it effectively doubles),
+   this algorithm normally tries to only adjust the gain (between 40 and
+   80 %) and if that does not help, only then changes exposure. This leads
+   to a much more stable image then using the knee algorithm which at
+   certain points of the knee graph will only try to adjust exposure,
+   which leads to oscilating as one exposure step is huge.
+
+   Note this assumes that the sd struct for the cam in question has
+   exp_too_high_cnt and exp_too_high_cnt int members for use by this function.
+
+   Returns 0 if no changes were made, 1 if the gain and or exposure settings
+   where changed. */
+static int gspca_coarse_grained_expo_autogain(struct gspca_dev *gspca_dev,
+        int avg_lum, int desired_avg_lum, int deadzone)
+{
+        int i, steps, gain, orig_gain, exposure, orig_exposure;
+        int gain_low, gain_high;
+        const struct ctrl *gain_ctrl = NULL;
+        const struct ctrl *exposure_ctrl = NULL;
+        struct sd *sd = (struct sd *) gspca_dev;
+        int retval = 0;
+
+        for (i = 0; i < gspca_dev->sd_desc->nctrls; i++) {
+                if (gspca_dev->ctrl_dis & (1 << i))
+                        continue;
+                if (gspca_dev->sd_desc->ctrls[i].qctrl.id == V4L2_CID_GAIN)
+                        gain_ctrl = &gspca_dev->sd_desc->ctrls[i];
+                if (gspca_dev->sd_desc->ctrls[i].qctrl.id == V4L2_CID_EXPOSURE)
+                        exposure_ctrl = &gspca_dev->sd_desc->ctrls[i];
+        }
+        if (!gain_ctrl || !exposure_ctrl) {
+                PDEBUG(D_ERR, "Error: gspca_coarse_grained_expo_autogain "
+                        "called on cam without gain or exposure");
+                return 0;
+        }
+
+        if (gain_ctrl->get(gspca_dev, &gain) ||
+            exposure_ctrl->get(gspca_dev, &exposure))
+                return 0;
+
+        orig_gain = gain;
+        orig_exposure = exposure;
+        gain_low =
+                (gain_ctrl->qctrl.maximum - gain_ctrl->qctrl.minimum) / 5 * 2;
+        gain_low += gain_ctrl->qctrl.minimum;
+        gain_high =
+                (gain_ctrl->qctrl.maximum - gain_ctrl->qctrl.minimum) / 5 * 4;
+        gain_high += gain_ctrl->qctrl.minimum;
+
+        /* If we are of a multiple of deadzone, do multiple steps to reach the
+           desired lumination fast (with the risc of a slight overshoot) */
+        steps = (desired_avg_lum - avg_lum) / deadzone;
+
+        PDEBUG(D_FRAM, "autogain: lum: %d, desired: %d, steps: %d",
+                avg_lum, desired_avg_lum, steps);
+
+        if ((gain + steps) > gain_high &&
+            sd->exposure < exposure_ctrl->qctrl.maximum) {
+                gain = gain_high;
+                sd->exp_too_low_cnt++;
+        } else if ((gain + steps) < gain_low &&
+                   sd->exposure > exposure_ctrl->qctrl.minimum) {
+                gain = gain_low;
+                sd->exp_too_high_cnt++;
+        } else {
+                gain += steps;
+                if (gain > gain_ctrl->qctrl.maximum)
+                        gain = gain_ctrl->qctrl.maximum;
+                else if (gain < gain_ctrl->qctrl.minimum)
+                        gain = gain_ctrl->qctrl.minimum;
+                sd->exp_too_high_cnt = 0;
+                sd->exp_too_low_cnt = 0;
+        }
+
+        if (sd->exp_too_high_cnt > 3) {
+                exposure--;
+                sd->exp_too_high_cnt = 0;
+        } else if (sd->exp_too_low_cnt > 3) {
+                exposure++;
+                sd->exp_too_low_cnt = 0;
+        }
+
+        if (gain != orig_gain) {
+                gain_ctrl->set(gspca_dev, gain);
+                retval = 1;
+        }
+        if (exposure != orig_exposure) {
+                exposure_ctrl->set(gspca_dev, exposure);
+                retval = 1;
+        }
+
+        return retval;
+}
diff --git a/drivers/media/video/gspca/conex.c b/drivers/media/video/gspca/conex.c
index c98b5d69c438..19fe6b24c9a3 100644
--- a/drivers/media/video/gspca/conex.c
+++ b/drivers/media/video/gspca/conex.c
@@ -52,7 +52,7 @@ static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val);
 static int sd_setcolors(struct gspca_dev *gspca_dev, __s32 val);
 static int sd_getcolors(struct gspca_dev *gspca_dev, __s32 *val);
 
-static struct ctrl sd_ctrls[] = {
+static const struct ctrl sd_ctrls[] = {
         {
             {
                 .id      = V4L2_CID_BRIGHTNESS,
@@ -1032,7 +1032,7 @@ static int sd_get_jcomp(struct gspca_dev *gspca_dev,
 }
 
 /* sub-driver description */
-static struct sd_desc sd_desc = {
+static const struct sd_desc sd_desc = {
         .name = MODULE_NAME,
         .ctrls = sd_ctrls,
         .nctrls = ARRAY_SIZE(sd_ctrls),
diff --git a/drivers/media/video/gspca/cpia1.c b/drivers/media/video/gspca/cpia1.c
new file mode 100644
index 000000000000..82945ed5cbe5
--- /dev/null
+++ b/drivers/media/video/gspca/cpia1.c
@@ -0,0 +1,2022 @@
+/*
+ * cpia CPiA (1) gspca driver
+ *
+ * Copyright (C) 2010 Hans de Goede <hdgoede@redhat.com>
+ *
+ * This module is adapted from the in kernel v4l1 cpia driver which is :
+ *
+ * (C) Copyright 1999-2000 Peter Pregler
+ * (C) Copyright 1999-2000 Scott J. Bertin
+ * (C) Copyright 1999-2000 Johannes Erdfelt <johannes@erdfelt.com>
+ * (C) Copyright 2000 STMicroelectronics
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ */
+
+#define MODULE_NAME "cpia1"
+
+#include "gspca.h"
+
+MODULE_AUTHOR("Hans de Goede <hdgoede@redhat.com>");
+MODULE_DESCRIPTION("Vision CPiA");
+MODULE_LICENSE("GPL");
+
+/* constant value's */
+#define MAGIC_0         0x19
+#define MAGIC_1         0x68
+#define DATA_IN         0xC0
+#define DATA_OUT        0x40
+#define VIDEOSIZE_QCIF  0       /* 176x144 */
+#define VIDEOSIZE_CIF   1       /* 352x288 */
+#define SUBSAMPLE_420   0
+#define SUBSAMPLE_422   1
+#define YUVORDER_YUYV   0
+#define YUVORDER_UYVY   1
+#define NOT_COMPRESSED  0
+#define COMPRESSED      1
+#define NO_DECIMATION   0
+#define DECIMATION_ENAB 1
+#define EOI             0xff    /* End Of Image */
+#define EOL             0xfd    /* End Of Line */
+#define FRAME_HEADER_SIZE       64
+
+/* Image grab modes */
+#define CPIA_GRAB_SINGLE        0
+#define CPIA_GRAB_CONTINEOUS    1
+
+/* Compression parameters */
+#define CPIA_COMPRESSION_NONE   0
+#define CPIA_COMPRESSION_AUTO   1
+#define CPIA_COMPRESSION_MANUAL 2
+#define CPIA_COMPRESSION_TARGET_QUALITY         0
+#define CPIA_COMPRESSION_TARGET_FRAMERATE       1
+
+/* Return offsets for GetCameraState */
+#define SYSTEMSTATE     0
+#define GRABSTATE       1
+#define STREAMSTATE     2
+#define FATALERROR      3
+#define CMDERROR        4
+#define DEBUGFLAGS      5
+#define VPSTATUS        6
+#define ERRORCODE       7
+
+/* SystemState */
+#define UNINITIALISED_STATE     0
+#define PASS_THROUGH_STATE      1
+#define LO_POWER_STATE          2
+#define HI_POWER_STATE          3
+#define WARM_BOOT_STATE         4
+
+/* GrabState */
+#define GRAB_IDLE               0
+#define GRAB_ACTIVE             1
+#define GRAB_DONE               2
+
+/* StreamState */
+#define STREAM_NOT_READY        0
+#define STREAM_READY            1
+#define STREAM_OPEN             2
+#define STREAM_PAUSED           3
+#define STREAM_FINISHED         4
+
+/* Fatal Error, CmdError, and DebugFlags */
+#define CPIA_FLAG         1
+#define SYSTEM_FLAG       2
+#define INT_CTRL_FLAG     4
+#define PROCESS_FLAG      8
+#define COM_FLAG         16
+#define VP_CTRL_FLAG     32
+#define CAPTURE_FLAG     64
+#define DEBUG_FLAG      128
+
+/* VPStatus */
+#define VP_STATE_OK                     0x00
+
+#define VP_STATE_FAILED_VIDEOINIT       0x01
+#define VP_STATE_FAILED_AECACBINIT      0x02
+#define VP_STATE_AEC_MAX                0x04
+#define VP_STATE_ACB_BMAX               0x08
+
+#define VP_STATE_ACB_RMIN               0x10
+#define VP_STATE_ACB_GMIN               0x20
+#define VP_STATE_ACB_RMAX               0x40
+#define VP_STATE_ACB_GMAX               0x80
+
+/* default (minimum) compensation values */
+#define COMP_RED        220
+#define COMP_GREEN1     214
+#define COMP_GREEN2     COMP_GREEN1
+#define COMP_BLUE       230
+
+/* exposure status */
+#define EXPOSURE_VERY_LIGHT 0
+#define EXPOSURE_LIGHT      1
+#define EXPOSURE_NORMAL     2
+#define EXPOSURE_DARK       3
+#define EXPOSURE_VERY_DARK  4
+
+#define CPIA_MODULE_CPIA                        (0 << 5)
+#define CPIA_MODULE_SYSTEM                      (1 << 5)
+#define CPIA_MODULE_VP_CTRL                     (5 << 5)
+#define CPIA_MODULE_CAPTURE                     (6 << 5)
+#define CPIA_MODULE_DEBUG                       (7 << 5)
+
+#define INPUT (DATA_IN << 8)
+#define OUTPUT (DATA_OUT << 8)
+
+#define CPIA_COMMAND_GetCPIAVersion     (INPUT | CPIA_MODULE_CPIA | 1)
+#define CPIA_COMMAND_GetPnPID           (INPUT | CPIA_MODULE_CPIA | 2)
+#define CPIA_COMMAND_GetCameraStatus    (INPUT | CPIA_MODULE_CPIA | 3)
+#define CPIA_COMMAND_GotoHiPower        (OUTPUT | CPIA_MODULE_CPIA | 4)
+#define CPIA_COMMAND_GotoLoPower        (OUTPUT | CPIA_MODULE_CPIA | 5)
+#define CPIA_COMMAND_GotoSuspend        (OUTPUT | CPIA_MODULE_CPIA | 7)
+#define CPIA_COMMAND_GotoPassThrough    (OUTPUT | CPIA_MODULE_CPIA | 8)
+#define CPIA_COMMAND_ModifyCameraStatus (OUTPUT | CPIA_MODULE_CPIA | 10)
+
+#define CPIA_COMMAND_ReadVCRegs         (INPUT | CPIA_MODULE_SYSTEM | 1)
+#define CPIA_COMMAND_WriteVCReg         (OUTPUT | CPIA_MODULE_SYSTEM | 2)
+#define CPIA_COMMAND_ReadMCPorts        (INPUT | CPIA_MODULE_SYSTEM | 3)
+#define CPIA_COMMAND_WriteMCPort        (OUTPUT | CPIA_MODULE_SYSTEM | 4)
+#define CPIA_COMMAND_SetBaudRate        (OUTPUT | CPIA_MODULE_SYSTEM | 5)
+#define CPIA_COMMAND_SetECPTiming       (OUTPUT | CPIA_MODULE_SYSTEM | 6)
+#define CPIA_COMMAND_ReadIDATA          (INPUT | CPIA_MODULE_SYSTEM | 7)
+#define CPIA_COMMAND_WriteIDATA         (OUTPUT | CPIA_MODULE_SYSTEM | 8)
+#define CPIA_COMMAND_GenericCall        (OUTPUT | CPIA_MODULE_SYSTEM | 9)
+#define CPIA_COMMAND_I2CStart           (OUTPUT | CPIA_MODULE_SYSTEM | 10)
+#define CPIA_COMMAND_I2CStop            (OUTPUT | CPIA_MODULE_SYSTEM | 11)
+#define CPIA_COMMAND_I2CWrite           (OUTPUT | CPIA_MODULE_SYSTEM | 12)
+#define CPIA_COMMAND_I2CRead            (INPUT | CPIA_MODULE_SYSTEM | 13)
+
+#define CPIA_COMMAND_GetVPVersion       (INPUT | CPIA_MODULE_VP_CTRL | 1)
+#define CPIA_COMMAND_ResetFrameCounter  (INPUT | CPIA_MODULE_VP_CTRL | 2)
+#define CPIA_COMMAND_SetColourParams    (OUTPUT | CPIA_MODULE_VP_CTRL | 3)
+#define CPIA_COMMAND_SetExposure        (OUTPUT | CPIA_MODULE_VP_CTRL | 4)
+#define CPIA_COMMAND_SetColourBalance   (OUTPUT | CPIA_MODULE_VP_CTRL | 6)
+#define CPIA_COMMAND_SetSensorFPS       (OUTPUT | CPIA_MODULE_VP_CTRL | 7)
+#define CPIA_COMMAND_SetVPDefaults      (OUTPUT | CPIA_MODULE_VP_CTRL | 8)
+#define CPIA_COMMAND_SetApcor           (OUTPUT | CPIA_MODULE_VP_CTRL | 9)
+#define CPIA_COMMAND_SetFlickerCtrl     (OUTPUT | CPIA_MODULE_VP_CTRL | 10)
+#define CPIA_COMMAND_SetVLOffset        (OUTPUT | CPIA_MODULE_VP_CTRL | 11)
+#define CPIA_COMMAND_GetColourParams    (INPUT | CPIA_MODULE_VP_CTRL | 16)
+#define CPIA_COMMAND_GetColourBalance   (INPUT | CPIA_MODULE_VP_CTRL | 17)
+#define CPIA_COMMAND_GetExposure        (INPUT | CPIA_MODULE_VP_CTRL | 18)
+#define CPIA_COMMAND_SetSensorMatrix    (OUTPUT | CPIA_MODULE_VP_CTRL | 19)
+#define CPIA_COMMAND_ColourBars         (OUTPUT | CPIA_MODULE_VP_CTRL | 25)
+#define CPIA_COMMAND_ReadVPRegs         (INPUT | CPIA_MODULE_VP_CTRL | 30)
+#define CPIA_COMMAND_WriteVPReg         (OUTPUT | CPIA_MODULE_VP_CTRL | 31)
+
+#define CPIA_COMMAND_GrabFrame          (OUTPUT | CPIA_MODULE_CAPTURE | 1)
+#define CPIA_COMMAND_UploadFrame        (OUTPUT | CPIA_MODULE_CAPTURE | 2)
+#define CPIA_COMMAND_SetGrabMode        (OUTPUT | CPIA_MODULE_CAPTURE | 3)
+#define CPIA_COMMAND_InitStreamCap      (OUTPUT | CPIA_MODULE_CAPTURE | 4)
+#define CPIA_COMMAND_FiniStreamCap      (OUTPUT | CPIA_MODULE_CAPTURE | 5)
+#define CPIA_COMMAND_StartStreamCap     (OUTPUT | CPIA_MODULE_CAPTURE | 6)
+#define CPIA_COMMAND_EndStreamCap       (OUTPUT | CPIA_MODULE_CAPTURE | 7)
+#define CPIA_COMMAND_SetFormat          (OUTPUT | CPIA_MODULE_CAPTURE | 8)
+#define CPIA_COMMAND_SetROI             (OUTPUT | CPIA_MODULE_CAPTURE | 9)
+#define CPIA_COMMAND_SetCompression     (OUTPUT | CPIA_MODULE_CAPTURE | 10)
+#define CPIA_COMMAND_SetCompressionTarget (OUTPUT | CPIA_MODULE_CAPTURE | 11)
+#define CPIA_COMMAND_SetYUVThresh       (OUTPUT | CPIA_MODULE_CAPTURE | 12)
+#define CPIA_COMMAND_SetCompressionParams (OUTPUT | CPIA_MODULE_CAPTURE | 13)
+#define CPIA_COMMAND_DiscardFrame       (OUTPUT | CPIA_MODULE_CAPTURE | 14)
+#define CPIA_COMMAND_GrabReset          (OUTPUT | CPIA_MODULE_CAPTURE | 15)
+
+#define CPIA_COMMAND_OutputRS232        (OUTPUT | CPIA_MODULE_DEBUG | 1)
+#define CPIA_COMMAND_AbortProcess       (OUTPUT | CPIA_MODULE_DEBUG | 4)
+#define CPIA_COMMAND_SetDramPage        (OUTPUT | CPIA_MODULE_DEBUG | 5)
+#define CPIA_COMMAND_StartDramUpload    (OUTPUT | CPIA_MODULE_DEBUG | 6)
+#define CPIA_COMMAND_StartDummyDtream   (OUTPUT | CPIA_MODULE_DEBUG | 8)
+#define CPIA_COMMAND_AbortStream        (OUTPUT | CPIA_MODULE_DEBUG | 9)
+#define CPIA_COMMAND_DownloadDRAM       (OUTPUT | CPIA_MODULE_DEBUG | 10)
+#define CPIA_COMMAND_Null               (OUTPUT | CPIA_MODULE_DEBUG | 11)
+
+#define ROUND_UP_EXP_FOR_FLICKER 15
+
+/* Constants for automatic frame rate adjustment */
+#define MAX_EXP       302
+#define MAX_EXP_102   255
+#define LOW_EXP       140
+#define VERY_LOW_EXP   70
+#define TC             94
+#define EXP_ACC_DARK   50
+#define EXP_ACC_LIGHT  90
+#define HIGH_COMP_102 160
+#define MAX_COMP      239
+#define DARK_TIME       3
+#define LIGHT_TIME      3
+
+#define FIRMWARE_VERSION(x, y) (sd->params.version.firmwareVersion == (x) && \
+                                sd->params.version.firmwareRevision == (y))
+
+/* Developer's Guide Table 5 p 3-34
+ * indexed by [mains][sensorFps.baserate][sensorFps.divisor]*/
+static u8 flicker_jumps[2][2][4] =
+{ { { 76, 38, 19, 9 }, { 92, 46, 23, 11 } },
+  { { 64, 32, 16, 8 }, { 76, 38, 19, 9} }
+};
+
+struct cam_params {
+        struct {
+                u8 firmwareVersion;
+                u8 firmwareRevision;
+                u8 vcVersion;
+                u8 vcRevision;
+        } version;
+        struct {
+                u16 vendor;
+                u16 product;
+                u16 deviceRevision;
+        } pnpID;
+        struct {
+                u8 vpVersion;
+                u8 vpRevision;
+                u16 cameraHeadID;
+        } vpVersion;
+        struct {
+                u8 systemState;
+                u8 grabState;
+                u8 streamState;
+                u8 fatalError;
+                u8 cmdError;
+                u8 debugFlags;
+                u8 vpStatus;
+                u8 errorCode;
+        } status;
+        struct {
+                u8 brightness;
+                u8 contrast;
+                u8 saturation;
+        } colourParams;
+        struct {
+                u8 gainMode;
+                u8 expMode;
+                u8 compMode;
+                u8 centreWeight;
+                u8 gain;
+                u8 fineExp;
+                u8 coarseExpLo;
+                u8 coarseExpHi;
+                u8 redComp;
+                u8 green1Comp;
+                u8 green2Comp;
+                u8 blueComp;
+        } exposure;
+        struct {
+                u8 balanceMode;
+                u8 redGain;
+                u8 greenGain;
+                u8 blueGain;
+        } colourBalance;
+        struct {
+                u8 divisor;
+                u8 baserate;
+        } sensorFps;
+        struct {
+                u8 gain1;
+                u8 gain2;
+                u8 gain4;
+                u8 gain8;
+        } apcor;
+        struct {
+                u8 disabled;
+                u8 flickerMode;
+                u8 coarseJump;
+                u8 allowableOverExposure;
+        } flickerControl;
+        struct {
+                u8 gain1;
+                u8 gain2;
+                u8 gain4;
+                u8 gain8;
+        } vlOffset;
+        struct {
+                u8 mode;
+                u8 decimation;
+        } compression;
+        struct {
+                u8 frTargeting;
+                u8 targetFR;
+                u8 targetQ;
+        } compressionTarget;
+        struct {
+                u8 yThreshold;
+                u8 uvThreshold;
+        } yuvThreshold;
+        struct {
+                u8 hysteresis;
+                u8 threshMax;
+                u8 smallStep;
+                u8 largeStep;
+                u8 decimationHysteresis;
+                u8 frDiffStepThresh;
+                u8 qDiffStepThresh;
+                u8 decimationThreshMod;
+        } compressionParams;
+        struct {
+                u8 videoSize;           /* CIF/QCIF */
+                u8 subSample;
+                u8 yuvOrder;
+        } format;
+        struct {                        /* Intel QX3 specific data */
+                u8 qx3_detected;        /* a QX3 is present */
+                u8 toplight;            /* top light lit , R/W */
+                u8 bottomlight;         /* bottom light lit, R/W */
+                u8 button;              /* snapshot button pressed (R/O) */
+                u8 cradled;             /* microscope is in cradle (R/O) */
+        } qx3;
+        struct {
+                u8 colStart;            /* skip first 8*colStart pixels */
+                u8 colEnd;              /* finish at 8*colEnd pixels */
+                u8 rowStart;            /* skip first 4*rowStart lines */
+                u8 rowEnd;              /* finish at 4*rowEnd lines */
+        } roi;
+        u8 ecpTiming;
+        u8 streamStartLine;
+};
+
+/* specific webcam descriptor */
+struct sd {
+        struct gspca_dev gspca_dev;             /* !! must be the first item */
+        struct cam_params params;               /* camera settings */
+
+        atomic_t cam_exposure;
+        atomic_t fps;
+        int exposure_count;
+        u8 exposure_status;
+        u8 mainsFreq;                           /* 0 = 50hz, 1 = 60hz */
+        u8 first_frame;
+        u8 freq;
+};
+
+/* V4L2 controls supported by the driver */
+static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val);
+static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val);
+static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val);
+static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val);
+static int sd_setsaturation(struct gspca_dev *gspca_dev, __s32 val);
+static int sd_getsaturation(struct gspca_dev *gspca_dev, __s32 *val);
+static int sd_setfreq(struct gspca_dev *gspca_dev, __s32 val);
+static int sd_getfreq(struct gspca_dev *gspca_dev, __s32 *val);
+static int sd_setcomptarget(struct gspca_dev *gspca_dev, __s32 val);
+static int sd_getcomptarget(struct gspca_dev *gspca_dev, __s32 *val);
+
+static struct ctrl sd_ctrls[] = {
+        {
+            {
+                .id      = V4L2_CID_BRIGHTNESS,
+                .type    = V4L2_CTRL_TYPE_INTEGER,
+                .name    = "Brightness",
+                .minimum = 0,
+                .maximum = 100,
+                .step = 1,
+#define BRIGHTNESS_DEF 50
+                .default_value = BRIGHTNESS_DEF,
+                .flags = 0,
+            },
+            .set = sd_setbrightness,
+            .get = sd_getbrightness,
+        },
+        {
+            {
+                .id      = V4L2_CID_CONTRAST,
+                .type    = V4L2_CTRL_TYPE_INTEGER,
+                .name    = "Contrast",
+                .minimum = 0,
+                .maximum = 96,
+                .step    = 8,
+#define CONTRAST_DEF 48
+                .default_value = CONTRAST_DEF,
+            },
+            .set = sd_setcontrast,
+            .get = sd_getcontrast,
+        },
+        {
+            {
+                .id      = V4L2_CID_SATURATION,
+                .type    = V4L2_CTRL_TYPE_INTEGER,
+                .name    = "Saturation",
+                .minimum = 0,
+                .maximum = 100,
+                .step    = 1,
+#define SATURATION_DEF 50
+                .default_value = SATURATION_DEF,
+            },
+            .set = sd_setsaturation,
+            .get = sd_getsaturation,
+        },
+        {
+                {
+                        .id      = V4L2_CID_POWER_LINE_FREQUENCY,
+                        .type    = V4L2_CTRL_TYPE_MENU,
+                        .name    = "Light frequency filter",
+                        .minimum = 0,
+                        .maximum = 2,   /* 0: 0, 1: 50Hz, 2:60Hz */
+                        .step    = 1,
+#define FREQ_DEF 1
+                        .default_value = FREQ_DEF,
+                },
+                .set = sd_setfreq,
+                .get = sd_getfreq,
+        },
+        {
+                {
+#define V4L2_CID_COMP_TARGET V4L2_CID_PRIVATE_BASE
+                        .id      = V4L2_CID_COMP_TARGET,
+                        .type    = V4L2_CTRL_TYPE_MENU,
+                        .name    = "Compression Target",
+                        .minimum = 0,
+                        .maximum = 1,
+                        .step    = 1,
+#define COMP_TARGET_DEF CPIA_COMPRESSION_TARGET_QUALITY
+                        .default_value = COMP_TARGET_DEF,
+                },
+                .set = sd_setcomptarget,
+                .get = sd_getcomptarget,
+        },
+};
+
+static const struct v4l2_pix_format mode[] = {
+        {160, 120, V4L2_PIX_FMT_CPIA1, V4L2_FIELD_NONE,
+                /* The sizeimage is trial and error, as with low framerates
+                   the camera will pad out usb frames, making the image
+                   data larger then strictly necessary */
+                .bytesperline = 160,
+                .sizeimage = 65536,
+                .colorspace = V4L2_COLORSPACE_SRGB,
+                .priv = 3},
+        {176, 144, V4L2_PIX_FMT_CPIA1, V4L2_FIELD_NONE,
+                .bytesperline = 172,
+                .sizeimage = 65536,
+                .colorspace = V4L2_COLORSPACE_SRGB,
+                .priv = 2},
+        {320, 240, V4L2_PIX_FMT_CPIA1, V4L2_FIELD_NONE,
+                .bytesperline = 320,
+                .sizeimage = 262144,
+                .colorspace = V4L2_COLORSPACE_SRGB,
+                .priv = 1},
+        {352, 288, V4L2_PIX_FMT_CPIA1, V4L2_FIELD_NONE,
+                .bytesperline = 352,
+                .sizeimage = 262144,
+                .colorspace = V4L2_COLORSPACE_SRGB,
+                .priv = 0},
+};
+
+/**********************************************************************
+ *
+ * General functions
+ *
+ **********************************************************************/
+
+static int cpia_usb_transferCmd(struct gspca_dev *gspca_dev, u8 *command)
+{
+        u8 requesttype;
+        unsigned int pipe;
+        int ret, databytes = command[6] | (command[7] << 8);
+        /* Sometimes we see spurious EPIPE errors */
+        int retries = 3;
+
+        if (command[0] == DATA_IN) {
+                pipe = usb_rcvctrlpipe(gspca_dev->dev, 0);
+                requesttype = USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE;
+        } else if (command[0] == DATA_OUT) {
+                pipe = usb_sndctrlpipe(gspca_dev->dev, 0);
+                requesttype = USB_TYPE_VENDOR | USB_RECIP_DEVICE;
+        } else {
+                PDEBUG(D_ERR, "Unexpected first byte of command: %x",
+                       command[0]);
+                return -EINVAL;
+        }
+
+retry:
+        ret = usb_control_msg(gspca_dev->dev, pipe,
+                              command[1],
+                              requesttype,
+                              command[2] | (command[3] << 8),
+                              command[4] | (command[5] << 8),
+                              gspca_dev->usb_buf, databytes, 1000);
+
+        if (ret < 0)
+                PDEBUG(D_ERR, "usb_control_msg %02x, error %d", command[1],
+                       ret);
+
+        if (ret == -EPIPE && retries > 0) {
+                retries--;
+                goto retry;
+        }
+
+        return (ret < 0) ? ret : 0;
+}
+
+/* send an arbitrary command to the camera */
+static int do_command(struct gspca_dev *gspca_dev, u16 command,
+                      u8 a, u8 b, u8 c, u8 d)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        int ret, datasize;
+        u8 cmd[8];
+
+        switch (command) {
+        case CPIA_COMMAND_GetCPIAVersion:
+        case CPIA_COMMAND_GetPnPID:
+        case CPIA_COMMAND_GetCameraStatus:
+        case CPIA_COMMAND_GetVPVersion:
+        case CPIA_COMMAND_GetColourParams:
+        case CPIA_COMMAND_GetColourBalance:
+        case CPIA_COMMAND_GetExposure:
+                datasize = 8;
+                break;
+        case CPIA_COMMAND_ReadMCPorts:
+        case CPIA_COMMAND_ReadVCRegs:
+                datasize = 4;
+                break;
+        default:
+                datasize = 0;
+                break;
+        }
+
+        cmd[0] = command >> 8;
+        cmd[1] = command & 0xff;
+        cmd[2] = a;
+        cmd[3] = b;
+        cmd[4] = c;
+        cmd[5] = d;
+        cmd[6] = datasize;
+        cmd[7] = 0;
+
+        ret = cpia_usb_transferCmd(gspca_dev, cmd);
+        if (ret)
+                return ret;
+
+        switch (command) {
+        case CPIA_COMMAND_GetCPIAVersion:
+                sd->params.version.firmwareVersion = gspca_dev->usb_buf[0];
+                sd->params.version.firmwareRevision = gspca_dev->usb_buf[1];
+                sd->params.version.vcVersion = gspca_dev->usb_buf[2];
+                sd->params.version.vcRevision = gspca_dev->usb_buf[3];
+                break;
+        case CPIA_COMMAND_GetPnPID:
+                sd->params.pnpID.vendor =
+                        gspca_dev->usb_buf[0] | (gspca_dev->usb_buf[1] << 8);
+                sd->params.pnpID.product =
+                        gspca_dev->usb_buf[2] | (gspca_dev->usb_buf[3] << 8);
+                sd->params.pnpID.deviceRevision =
+                        gspca_dev->usb_buf[4] | (gspca_dev->usb_buf[5] << 8);
+                break;
+        case CPIA_COMMAND_GetCameraStatus:
+                sd->params.status.systemState = gspca_dev->usb_buf[0];
+                sd->params.status.grabState = gspca_dev->usb_buf[1];
+                sd->params.status.streamState = gspca_dev->usb_buf[2];
+                sd->params.status.fatalError = gspca_dev->usb_buf[3];
+                sd->params.status.cmdError = gspca_dev->usb_buf[4];
+                sd->params.status.debugFlags = gspca_dev->usb_buf[5];
+                sd->params.status.vpStatus = gspca_dev->usb_buf[6];
+                sd->params.status.errorCode = gspca_dev->usb_buf[7];
+                break;
+        case CPIA_COMMAND_GetVPVersion:
+                sd->params.vpVersion.vpVersion = gspca_dev->usb_buf[0];
+                sd->params.vpVersion.vpRevision = gspca_dev->usb_buf[1];
+                sd->params.vpVersion.cameraHeadID =
+                        gspca_dev->usb_buf[2] | (gspca_dev->usb_buf[3] << 8);
+                break;
+        case CPIA_COMMAND_GetColourParams:
+                sd->params.colourParams.brightness = gspca_dev->usb_buf[0];
+                sd->params.colourParams.contrast = gspca_dev->usb_buf[1];
+                sd->params.colourParams.saturation = gspca_dev->usb_buf[2];
+                break;
+        case CPIA_COMMAND_GetColourBalance:
+                sd->params.colourBalance.redGain = gspca_dev->usb_buf[0];
+                sd->params.colourBalance.greenGain = gspca_dev->usb_buf[1];
+                sd->params.colourBalance.blueGain = gspca_dev->usb_buf[2];
+                break;
+        case CPIA_COMMAND_GetExposure:
+                sd->params.exposure.gain = gspca_dev->usb_buf[0];
+                sd->params.exposure.fineExp = gspca_dev->usb_buf[1];
+                sd->params.exposure.coarseExpLo = gspca_dev->usb_buf[2];
+                sd->params.exposure.coarseExpHi = gspca_dev->usb_buf[3];
+                sd->params.exposure.redComp = gspca_dev->usb_buf[4];
+                sd->params.exposure.green1Comp = gspca_dev->usb_buf[5];
+                sd->params.exposure.green2Comp = gspca_dev->usb_buf[6];
+                sd->params.exposure.blueComp = gspca_dev->usb_buf[7];
+                break;
+
+        case CPIA_COMMAND_ReadMCPorts:
+                if (!sd->params.qx3.qx3_detected)
+                        break;
+                /* test button press */
+                sd->params.qx3.button = ((gspca_dev->usb_buf[1] & 0x02) == 0);
+                if (sd->params.qx3.button) {
+                        /* button pressed - unlock the latch */
+                        do_command(gspca_dev, CPIA_COMMAND_WriteMCPort,
+                                   3, 0xDF, 0xDF, 0);
+                        do_command(gspca_dev, CPIA_COMMAND_WriteMCPort,
+                                   3, 0xFF, 0xFF, 0);
+                }
+
+                /* test whether microscope is cradled */
+                sd->params.qx3.cradled = ((gspca_dev->usb_buf[2] & 0x40) == 0);
+                break;
+        }
+
+        return 0;
+}
+
+/* send a command to the camera with an additional data transaction */
+static int do_command_extended(struct gspca_dev *gspca_dev, u16 command,
+                               u8 a, u8 b, u8 c, u8 d,
+                               u8 e, u8 f, u8 g, u8 h,
+                               u8 i, u8 j, u8 k, u8 l)
+{
+        u8 cmd[8];
+
+        cmd[0] = command >> 8;
+        cmd[1] = command & 0xff;
+        cmd[2] = a;
+        cmd[3] = b;
+        cmd[4] = c;
+        cmd[5] = d;
+        cmd[6] = 8;
+        cmd[7] = 0;
+        gspca_dev->usb_buf[0] = e;
+        gspca_dev->usb_buf[1] = f;
+        gspca_dev->usb_buf[2] = g;
+        gspca_dev->usb_buf[3] = h;
+        gspca_dev->usb_buf[4] = i;
+        gspca_dev->usb_buf[5] = j;
+        gspca_dev->usb_buf[6] = k;
+        gspca_dev->usb_buf[7] = l;
+
+        return cpia_usb_transferCmd(gspca_dev, cmd);
+}
+
+/*  find_over_exposure
+ *  Finds a suitable value of OverExposure for use with SetFlickerCtrl
+ *  Some calculation is required because this value changes with the brightness
+ *  set with SetColourParameters
+ *
+ *  Parameters: Brightness - last brightness value set with SetColourParameters
+ *
+ *  Returns: OverExposure value to use with SetFlickerCtrl
+ */
+#define FLICKER_MAX_EXPOSURE                    250
+#define FLICKER_ALLOWABLE_OVER_EXPOSURE         146
+#define FLICKER_BRIGHTNESS_CONSTANT             59
+static int find_over_exposure(int brightness)
+{
+        int MaxAllowableOverExposure, OverExposure;
+
+        MaxAllowableOverExposure = FLICKER_MAX_EXPOSURE - brightness -
+                                   FLICKER_BRIGHTNESS_CONSTANT;
+
+        if (MaxAllowableOverExposure < FLICKER_ALLOWABLE_OVER_EXPOSURE)
+                OverExposure = MaxAllowableOverExposure;
+        else
+                OverExposure = FLICKER_ALLOWABLE_OVER_EXPOSURE;
+
+        return OverExposure;
+}
+#undef FLICKER_MAX_EXPOSURE
+#undef FLICKER_ALLOWABLE_OVER_EXPOSURE
+#undef FLICKER_BRIGHTNESS_CONSTANT
+
+/* initialise cam_data structure  */
+static void reset_camera_params(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        struct cam_params *params = &sd->params;
+
+        /* The following parameter values are the defaults from
+         * "Software Developer's Guide for CPiA Cameras".  Any changes
+         * to the defaults are noted in comments. */
+        params->colourParams.brightness = BRIGHTNESS_DEF;
+        params->colourParams.contrast = CONTRAST_DEF;
+        params->colourParams.saturation = SATURATION_DEF;
+        params->exposure.gainMode = 4;
+        params->exposure.expMode = 2;           /* AEC */
+        params->exposure.compMode = 1;
+        params->exposure.centreWeight = 1;
+        params->exposure.gain = 0;
+        params->exposure.fineExp = 0;
+        params->exposure.coarseExpLo = 185;
+        params->exposure.coarseExpHi = 0;
+        params->exposure.redComp = COMP_RED;
+        params->exposure.green1Comp = COMP_GREEN1;
+        params->exposure.green2Comp = COMP_GREEN2;
+        params->exposure.blueComp = COMP_BLUE;
+        params->colourBalance.balanceMode = 2;  /* ACB */
+        params->colourBalance.redGain = 32;
+        params->colourBalance.greenGain = 6;
+        params->colourBalance.blueGain = 92;
+        params->apcor.gain1 = 0x18;
+        params->apcor.gain2 = 0x16;
+        params->apcor.gain4 = 0x24;
+        params->apcor.gain8 = 0x34;
+        params->flickerControl.flickerMode = 0;
+        params->flickerControl.disabled = 1;
+
+        params->flickerControl.coarseJump =
+                flicker_jumps[sd->mainsFreq]
+                             [params->sensorFps.baserate]
+                             [params->sensorFps.divisor];
+        params->flickerControl.allowableOverExposure =
+                find_over_exposure(params->colourParams.brightness);
+        params->vlOffset.gain1 = 20;
+        params->vlOffset.gain2 = 24;
+        params->vlOffset.gain4 = 26;
+        params->vlOffset.gain8 = 26;
+        params->compressionParams.hysteresis = 3;
+        params->compressionParams.threshMax = 11;
+        params->compressionParams.smallStep = 1;
+        params->compressionParams.largeStep = 3;
+        params->compressionParams.decimationHysteresis = 2;
+        params->compressionParams.frDiffStepThresh = 5;
+        params->compressionParams.qDiffStepThresh = 3;
+        params->compressionParams.decimationThreshMod = 2;
+        /* End of default values from Software Developer's Guide */
+
+        /* Set Sensor FPS to 15fps. This seems better than 30fps
+         * for indoor lighting. */
+        params->sensorFps.divisor = 1;
+        params->sensorFps.baserate = 1;
+
+        params->yuvThreshold.yThreshold = 6; /* From windows driver */
+        params->yuvThreshold.uvThreshold = 6; /* From windows driver */
+
+        params->format.subSample = SUBSAMPLE_420;
+        params->format.yuvOrder = YUVORDER_YUYV;
+
+        params->compression.mode = CPIA_COMPRESSION_AUTO;
+        params->compression.decimation = NO_DECIMATION;
+
+        params->compressionTarget.frTargeting = COMP_TARGET_DEF;
+        params->compressionTarget.targetFR = 15; /* From windows driver */
+        params->compressionTarget.targetQ = 5; /* From windows driver */
+
+        params->qx3.qx3_detected = 0;
+        params->qx3.toplight = 0;
+        params->qx3.bottomlight = 0;
+        params->qx3.button = 0;
+        params->qx3.cradled = 0;
+}
+
+static void printstatus(struct cam_params *params)
+{
+        PDEBUG(D_PROBE, "status: %02x %02x %02x %02x %02x %02x %02x %02x",
+               params->status.systemState, params->status.grabState,
+               params->status.streamState, params->status.fatalError,
+               params->status.cmdError, params->status.debugFlags,
+               params->status.vpStatus, params->status.errorCode);
+}
+
+static int goto_low_power(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        int ret;
+
+        ret = do_command(gspca_dev, CPIA_COMMAND_GotoLoPower, 0, 0, 0, 0);
+        if (ret)
+                return ret;
+
+        do_command(gspca_dev, CPIA_COMMAND_GetCameraStatus, 0, 0, 0, 0);
+        if (ret)
+                return ret;
+
+        if (sd->params.status.systemState != LO_POWER_STATE) {
+                if (sd->params.status.systemState != WARM_BOOT_STATE) {
+                        PDEBUG(D_ERR,
+                               "unexpected state after lo power cmd: %02x",
+                               sd->params.status.systemState);
+                        printstatus(&sd->params);
+                }
+                return -EIO;
+        }
+
+        PDEBUG(D_CONF, "camera now in LOW power state");
+        return 0;
+}
+
+static int goto_high_power(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        int ret;
+
+        ret = do_command(gspca_dev, CPIA_COMMAND_GotoHiPower, 0, 0, 0, 0);
+        if (ret)
+                return ret;
+
+        msleep_interruptible(40);       /* windows driver does it too */
+
+        if (signal_pending(current))
+                return -EINTR;
+
+        do_command(gspca_dev, CPIA_COMMAND_GetCameraStatus, 0, 0, 0, 0);
+        if (ret)
+                return ret;
+
+        if (sd->params.status.systemState != HI_POWER_STATE) {
+                PDEBUG(D_ERR, "unexpected state after hi power cmd: %02x",
+                               sd->params.status.systemState);
+                printstatus(&sd->params);
+                return -EIO;
+        }
+
+        PDEBUG(D_CONF, "camera now in HIGH power state");
+        return 0;
+}
+
+static int get_version_information(struct gspca_dev *gspca_dev)
+{
+        int ret;
+
+        /* GetCPIAVersion */
+        ret = do_command(gspca_dev, CPIA_COMMAND_GetCPIAVersion, 0, 0, 0, 0);
+        if (ret)
+                return ret;
+
+        /* GetPnPID */
+        return do_command(gspca_dev, CPIA_COMMAND_GetPnPID, 0, 0, 0, 0);
+}
+
+static int save_camera_state(struct gspca_dev *gspca_dev)
+{
+        int ret;
+
+        ret = do_command(gspca_dev, CPIA_COMMAND_GetColourBalance, 0, 0, 0, 0);
+        if (ret)
+                return ret;
+
+        return do_command(gspca_dev, CPIA_COMMAND_GetExposure, 0, 0, 0, 0);
+}
+
+int command_setformat(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        int ret;
+
+        ret = do_command(gspca_dev, CPIA_COMMAND_SetFormat,
+                         sd->params.format.videoSize,
+                         sd->params.format.subSample,
+                         sd->params.format.yuvOrder, 0);
+        if (ret)
+                return ret;
+
+        return do_command(gspca_dev, CPIA_COMMAND_SetROI,
+                          sd->params.roi.colStart, sd->params.roi.colEnd,
+                          sd->params.roi.rowStart, sd->params.roi.rowEnd);
+}
+
+int command_setcolourparams(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        return do_command(gspca_dev, CPIA_COMMAND_SetColourParams,
+                          sd->params.colourParams.brightness,
+                          sd->params.colourParams.contrast,
+                          sd->params.colourParams.saturation, 0);
+}
+
+int command_setapcor(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        return do_command(gspca_dev, CPIA_COMMAND_SetApcor,
+                          sd->params.apcor.gain1,
+                          sd->params.apcor.gain2,
+                          sd->params.apcor.gain4,
+                          sd->params.apcor.gain8);
+}
+
+int command_setvloffset(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        return do_command(gspca_dev, CPIA_COMMAND_SetVLOffset,
+                          sd->params.vlOffset.gain1,
+                          sd->params.vlOffset.gain2,
+                          sd->params.vlOffset.gain4,
+                          sd->params.vlOffset.gain8);
+}
+
+int command_setexposure(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        int ret;
+
+        ret = do_command_extended(gspca_dev, CPIA_COMMAND_SetExposure,
+                                  sd->params.exposure.gainMode,
+                                  1,
+                                  sd->params.exposure.compMode,
+                                  sd->params.exposure.centreWeight,
+                                  sd->params.exposure.gain,
+                                  sd->params.exposure.fineExp,
+                                  sd->params.exposure.coarseExpLo,
+                                  sd->params.exposure.coarseExpHi,
+                                  sd->params.exposure.redComp,
+                                  sd->params.exposure.green1Comp,
+                                  sd->params.exposure.green2Comp,
+                                  sd->params.exposure.blueComp);
+        if (ret)
+                return ret;
+
+        if (sd->params.exposure.expMode != 1) {
+                ret = do_command_extended(gspca_dev, CPIA_COMMAND_SetExposure,
+                                          0,
+                                          sd->params.exposure.expMode,
+                                          0, 0,
+                                          sd->params.exposure.gain,
+                                          sd->params.exposure.fineExp,
+                                          sd->params.exposure.coarseExpLo,
+                                          sd->params.exposure.coarseExpHi,
+                                          0, 0, 0, 0);
+        }
+
+        return ret;
+}
+
+int command_setcolourbalance(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        if (sd->params.colourBalance.balanceMode == 1) {
+                int ret;
+
+                ret = do_command(gspca_dev, CPIA_COMMAND_SetColourBalance,
+                                 1,
+                                 sd->params.colourBalance.redGain,
+                                 sd->params.colourBalance.greenGain,
+                                 sd->params.colourBalance.blueGain);
+                if (ret)
+                        return ret;
+
+                return do_command(gspca_dev, CPIA_COMMAND_SetColourBalance,
+                                  3, 0, 0, 0);
+        }
+        if (sd->params.colourBalance.balanceMode == 2) {
+                return do_command(gspca_dev, CPIA_COMMAND_SetColourBalance,
+                                  2, 0, 0, 0);
+        }
+        if (sd->params.colourBalance.balanceMode == 3) {
+                return do_command(gspca_dev, CPIA_COMMAND_SetColourBalance,
+                                  3, 0, 0, 0);
+        }
+
+        return -EINVAL;
+}
+
+int command_setcompressiontarget(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        return do_command(gspca_dev, CPIA_COMMAND_SetCompressionTarget,
+                          sd->params.compressionTarget.frTargeting,
+                          sd->params.compressionTarget.targetFR,
+                          sd->params.compressionTarget.targetQ, 0);
+}
+
+int command_setyuvtresh(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        return do_command(gspca_dev, CPIA_COMMAND_SetYUVThresh,
+                          sd->params.yuvThreshold.yThreshold,
+                          sd->params.yuvThreshold.uvThreshold, 0, 0);
+}
+
+int command_setcompressionparams(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        return do_command_extended(gspca_dev,
+                            CPIA_COMMAND_SetCompressionParams,
+                            0, 0, 0, 0,
+                            sd->params.compressionParams.hysteresis,
+                            sd->params.compressionParams.threshMax,
+                            sd->params.compressionParams.smallStep,
+                            sd->params.compressionParams.largeStep,
+                            sd->params.compressionParams.decimationHysteresis,
+                            sd->params.compressionParams.frDiffStepThresh,
+                            sd->params.compressionParams.qDiffStepThresh,
+                            sd->params.compressionParams.decimationThreshMod);
+}
+
+int command_setcompression(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        return do_command(gspca_dev, CPIA_COMMAND_SetCompression,
+                          sd->params.compression.mode,
+                          sd->params.compression.decimation, 0, 0);
+}
+
+int command_setsensorfps(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        return do_command(gspca_dev, CPIA_COMMAND_SetSensorFPS,
+                          sd->params.sensorFps.divisor,
+                          sd->params.sensorFps.baserate, 0, 0);
+}
+
+int command_setflickerctrl(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        return do_command(gspca_dev, CPIA_COMMAND_SetFlickerCtrl,
+                          sd->params.flickerControl.flickerMode,
+                          sd->params.flickerControl.coarseJump,
+                          sd->params.flickerControl.allowableOverExposure,
+                          0);
+}
+
+int command_setecptiming(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        return do_command(gspca_dev, CPIA_COMMAND_SetECPTiming,
+                          sd->params.ecpTiming, 0, 0, 0);
+}
+
+int command_pause(struct gspca_dev *gspca_dev)
+{
+        return do_command(gspca_dev, CPIA_COMMAND_EndStreamCap, 0, 0, 0, 0);
+}
+
+int command_resume(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        return do_command(gspca_dev, CPIA_COMMAND_InitStreamCap,
+                          0, sd->params.streamStartLine, 0, 0);
+}
+
+int command_setlights(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        int ret, p1, p2;
+
+        if (!sd->params.qx3.qx3_detected)
+                return 0;
+
+        p1 = (sd->params.qx3.bottomlight == 0) << 1;
+        p2 = (sd->params.qx3.toplight == 0) << 3;
+
+        ret = do_command(gspca_dev, CPIA_COMMAND_WriteVCReg,
+                         0x90, 0x8F, 0x50, 0);
+        if (ret)
+                return ret;
+
+        return do_command(gspca_dev, CPIA_COMMAND_WriteMCPort, 2, 0,
+                          p1 | p2 | 0xE0, 0);
+}
+
+static int set_flicker(struct gspca_dev *gspca_dev, int on, int apply)
+{
+        /* Everything in here is from the Windows driver */
+/* define for compgain calculation */
+#if 0
+#define COMPGAIN(base, curexp, newexp) \
+    (u8) ((((float) base - 128.0) * ((float) curexp / (float) newexp)) + 128.5)
+#define EXP_FROM_COMP(basecomp, curcomp, curexp) \
+    (u16)((float)curexp * (float)(u8)(curcomp + 128) / \
+    (float)(u8)(basecomp - 128))
+#else
+  /* equivalent functions without floating point math */
+#define COMPGAIN(base, curexp, newexp) \
+    (u8)(128 + (((u32)(2*(base-128)*curexp + newexp)) / (2 * newexp)))
+#define EXP_FROM_COMP(basecomp, curcomp, curexp) \
+    (u16)(((u32)(curexp * (u8)(curcomp + 128)) / (u8)(basecomp - 128)))
+#endif
+
+        struct sd *sd = (struct sd *) gspca_dev;
+        int currentexp = sd->params.exposure.coarseExpLo +
+                         sd->params.exposure.coarseExpHi * 256;
+        int ret, startexp;
+
+        if (on) {
+                int cj = sd->params.flickerControl.coarseJump;
+                sd->params.flickerControl.flickerMode = 1;
+                sd->params.flickerControl.disabled = 0;
+                if (sd->params.exposure.expMode != 2) {
+                        sd->params.exposure.expMode = 2;
+                        sd->exposure_status = EXPOSURE_NORMAL;
+                }
+                currentexp = currentexp << sd->params.exposure.gain;
+                sd->params.exposure.gain = 0;
+                /* round down current exposure to nearest value */
+                startexp = (currentexp + ROUND_UP_EXP_FOR_FLICKER) / cj;
+                if (startexp < 1)
+                        startexp = 1;
+                startexp = (startexp * cj) - 1;
+                if (FIRMWARE_VERSION(1, 2))
+                        while (startexp > MAX_EXP_102)
+                                startexp -= cj;
+                else
+                        while (startexp > MAX_EXP)
+                                startexp -= cj;
+                sd->params.exposure.coarseExpLo = startexp & 0xff;
+                sd->params.exposure.coarseExpHi = startexp >> 8;
+                if (currentexp > startexp) {
+                        if (currentexp > (2 * startexp))
+                                currentexp = 2 * startexp;
+                        sd->params.exposure.redComp =
+                                COMPGAIN(COMP_RED, currentexp, startexp);
+                        sd->params.exposure.green1Comp =
+                                COMPGAIN(COMP_GREEN1, currentexp, startexp);
+                        sd->params.exposure.green2Comp =
+                                COMPGAIN(COMP_GREEN2, currentexp, startexp);
+                        sd->params.exposure.blueComp =
+                                COMPGAIN(COMP_BLUE, currentexp, startexp);
+                } else {
+                        sd->params.exposure.redComp = COMP_RED;
+                        sd->params.exposure.green1Comp = COMP_GREEN1;
+                        sd->params.exposure.green2Comp = COMP_GREEN2;
+                        sd->params.exposure.blueComp = COMP_BLUE;
+                }
+                if (FIRMWARE_VERSION(1, 2))
+                        sd->params.exposure.compMode = 0;
+                else
+                        sd->params.exposure.compMode = 1;
+
+                sd->params.apcor.gain1 = 0x18;
+                sd->params.apcor.gain2 = 0x18;
+                sd->params.apcor.gain4 = 0x16;
+                sd->params.apcor.gain8 = 0x14;
+        } else {
+                sd->params.flickerControl.flickerMode = 0;
+                sd->params.flickerControl.disabled = 1;
+                /* Average equivalent coarse for each comp channel */
+                startexp = EXP_FROM_COMP(COMP_RED,
+                                sd->params.exposure.redComp, currentexp);
+                startexp += EXP_FROM_COMP(COMP_GREEN1,
+                                sd->params.exposure.green1Comp, currentexp);
+                startexp += EXP_FROM_COMP(COMP_GREEN2,
+                                sd->params.exposure.green2Comp, currentexp);
+                startexp += EXP_FROM_COMP(COMP_BLUE,
+                                sd->params.exposure.blueComp, currentexp);
+                startexp = startexp >> 2;
+                while (startexp > MAX_EXP && sd->params.exposure.gain <
+                       sd->params.exposure.gainMode - 1) {
+                        startexp = startexp >> 1;
+                        ++sd->params.exposure.gain;
+                }
+                if (FIRMWARE_VERSION(1, 2) && startexp > MAX_EXP_102)
+                        startexp = MAX_EXP_102;
+                if (startexp > MAX_EXP)
+                        startexp = MAX_EXP;
+                sd->params.exposure.coarseExpLo = startexp & 0xff;
+                sd->params.exposure.coarseExpHi = startexp >> 8;
+                sd->params.exposure.redComp = COMP_RED;
+                sd->params.exposure.green1Comp = COMP_GREEN1;
+                sd->params.exposure.green2Comp = COMP_GREEN2;
+                sd->params.exposure.blueComp = COMP_BLUE;
+                sd->params.exposure.compMode = 1;
+                sd->params.apcor.gain1 = 0x18;
+                sd->params.apcor.gain2 = 0x16;
+                sd->params.apcor.gain4 = 0x24;
+                sd->params.apcor.gain8 = 0x34;
+        }
+        sd->params.vlOffset.gain1 = 20;
+        sd->params.vlOffset.gain2 = 24;
+        sd->params.vlOffset.gain4 = 26;
+        sd->params.vlOffset.gain8 = 26;
+
+        if (apply) {
+                ret = command_setexposure(gspca_dev);
+                if (ret)
+                        return ret;
+
+                ret = command_setapcor(gspca_dev);
+                if (ret)
+                        return ret;
+
+                ret = command_setvloffset(gspca_dev);
+                if (ret)
+                        return ret;
+
+                ret = command_setflickerctrl(gspca_dev);
+                if (ret)
+                        return ret;
+        }
+
+        return 0;
+#undef EXP_FROM_COMP
+#undef COMPGAIN
+}
+
+/* monitor the exposure and adjust the sensor frame rate if needed */
+static void monitor_exposure(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        u8 exp_acc, bcomp, gain, coarseL, cmd[8];
+        int ret, light_exp, dark_exp, very_dark_exp;
+        int old_exposure, new_exposure, framerate;
+        int setfps = 0, setexp = 0, setflicker = 0;
+
+        /* get necessary stats and register settings from camera */
+        /* do_command can't handle this, so do it ourselves */
+        cmd[0] = CPIA_COMMAND_ReadVPRegs >> 8;
+        cmd[1] = CPIA_COMMAND_ReadVPRegs & 0xff;
+        cmd[2] = 30;
+        cmd[3] = 4;
+        cmd[4] = 9;
+        cmd[5] = 8;
+        cmd[6] = 8;
+        cmd[7] = 0;
+        ret = cpia_usb_transferCmd(gspca_dev, cmd);
+        if (ret) {
+                PDEBUG(D_ERR, "ReadVPRegs(30,4,9,8) - failed: %d", ret);
+                return;
+        }
+        exp_acc = gspca_dev->usb_buf[0];
+        bcomp = gspca_dev->usb_buf[1];
+        gain = gspca_dev->usb_buf[2];
+        coarseL = gspca_dev->usb_buf[3];
+
+        light_exp = sd->params.colourParams.brightness +
+                    TC - 50 + EXP_ACC_LIGHT;
+        if (light_exp > 255)
+                light_exp = 255;
+        dark_exp = sd->params.colourParams.brightness +
+                   TC - 50 - EXP_ACC_DARK;
+        if (dark_exp < 0)
+                dark_exp = 0;
+        very_dark_exp = dark_exp / 2;
+
+        old_exposure = sd->params.exposure.coarseExpHi * 256 +
+                       sd->params.exposure.coarseExpLo;
+
+        if (!sd->params.flickerControl.disabled) {
+                /* Flicker control on */
+                int max_comp = FIRMWARE_VERSION(1, 2) ? MAX_COMP :
+                                                        HIGH_COMP_102;
+                bcomp += 128;   /* decode */
+                if (bcomp >= max_comp && exp_acc < dark_exp) {
+                        /* dark */
+                        if (exp_acc < very_dark_exp) {
+                                /* very dark */
+                                if (sd->exposure_status == EXPOSURE_VERY_DARK)
+                                        ++sd->exposure_count;
+                                else {
+                                        sd->exposure_status =
+                                                EXPOSURE_VERY_DARK;
+                                        sd->exposure_count = 1;
+                                }
+                        } else {
+                                /* just dark */
+                                if (sd->exposure_status == EXPOSURE_DARK)
+                                        ++sd->exposure_count;
+                                else {
+                                        sd->exposure_status = EXPOSURE_DARK;
+                                        sd->exposure_count = 1;
+                                }
+                        }
+                } else if (old_exposure <= LOW_EXP || exp_acc > light_exp) {
+                        /* light */
+                        if (old_exposure <= VERY_LOW_EXP) {
+                                /* very light */
+                                if (sd->exposure_status == EXPOSURE_VERY_LIGHT)
+                                        ++sd->exposure_count;
+                                else {
+                                        sd->exposure_status =
+                                                EXPOSURE_VERY_LIGHT;
+                                        sd->exposure_count = 1;
+                                }
+                        } else {
+                                /* just light */
+                                if (sd->exposure_status == EXPOSURE_LIGHT)
+                                        ++sd->exposure_count;
+                                else {
+                                        sd->exposure_status = EXPOSURE_LIGHT;
+                                        sd->exposure_count = 1;
+                                }
+                        }
+                } else {
+                        /* not dark or light */
+                        sd->exposure_status = EXPOSURE_NORMAL;
+                }
+        } else {
+                /* Flicker control off */
+                if (old_exposure >= MAX_EXP && exp_acc < dark_exp) {
+                        /* dark */
+                        if (exp_acc < very_dark_exp) {
+                                /* very dark */
+                                if (sd->exposure_status == EXPOSURE_VERY_DARK)
+                                        ++sd->exposure_count;
+                                else {
+                                        sd->exposure_status =
+                                                EXPOSURE_VERY_DARK;
+                                        sd->exposure_count = 1;
+                                }
+                        } else {
+                                /* just dark */
+                                if (sd->exposure_status == EXPOSURE_DARK)
+                                        ++sd->exposure_count;
+                                else {
+                                        sd->exposure_status = EXPOSURE_DARK;
+                                        sd->exposure_count = 1;
+                                }
+                        }
+                } else if (old_exposure <= LOW_EXP || exp_acc > light_exp) {
+                        /* light */
+                        if (old_exposure <= VERY_LOW_EXP) {
+                                /* very light */
+                                if (sd->exposure_status == EXPOSURE_VERY_LIGHT)
+                                        ++sd->exposure_count;
+                                else {
+                                        sd->exposure_status =
+                                                EXPOSURE_VERY_LIGHT;
+                                        sd->exposure_count = 1;
+                                }
+                        } else {
+                                /* just light */
+                                if (sd->exposure_status == EXPOSURE_LIGHT)
+                                        ++sd->exposure_count;
+                                else {
+                                        sd->exposure_status = EXPOSURE_LIGHT;
+                                        sd->exposure_count = 1;
+                                }
+                        }
+                } else {
+                        /* not dark or light */
+                        sd->exposure_status = EXPOSURE_NORMAL;
+                }
+        }
+
+        framerate = atomic_read(&sd->fps);
+        if (framerate > 30 || framerate < 1)
+                framerate = 1;
+
+        if (!sd->params.flickerControl.disabled) {
+                /* Flicker control on */
+                if ((sd->exposure_status == EXPOSURE_VERY_DARK ||
+                     sd->exposure_status == EXPOSURE_DARK) &&
+                    sd->exposure_count >= DARK_TIME * framerate &&
+                    sd->params.sensorFps.divisor < 3) {
+
+                        /* dark for too long */
+                        ++sd->params.sensorFps.divisor;
+                        setfps = 1;
+
+                        sd->params.flickerControl.coarseJump =
+                                flicker_jumps[sd->mainsFreq]
+                                             [sd->params.sensorFps.baserate]
+                                             [sd->params.sensorFps.divisor];
+                        setflicker = 1;
+
+                        new_exposure = sd->params.flickerControl.coarseJump-1;
+                        while (new_exposure < old_exposure / 2)
+                                new_exposure +=
+                                        sd->params.flickerControl.coarseJump;
+                        sd->params.exposure.coarseExpLo = new_exposure & 0xff;
+                        sd->params.exposure.coarseExpHi = new_exposure >> 8;
+                        setexp = 1;
+                        sd->exposure_status = EXPOSURE_NORMAL;
+                        PDEBUG(D_CONF, "Automatically decreasing sensor_fps");
+
+                } else if ((sd->exposure_status == EXPOSURE_VERY_LIGHT ||
+                            sd->exposure_status == EXPOSURE_LIGHT) &&
+                           sd->exposure_count >= LIGHT_TIME * framerate &&
+                           sd->params.sensorFps.divisor > 0) {
+
+                        /* light for too long */
+                        int max_exp = FIRMWARE_VERSION(1, 2) ? MAX_EXP_102 :
+                                                               MAX_EXP;
+                        --sd->params.sensorFps.divisor;
+                        setfps = 1;
+
+                        sd->params.flickerControl.coarseJump =
+                                flicker_jumps[sd->mainsFreq]
+                                             [sd->params.sensorFps.baserate]
+                                             [sd->params.sensorFps.divisor];
+                        setflicker = 1;
+
+                        new_exposure = sd->params.flickerControl.coarseJump-1;
+                        while (new_exposure < 2 * old_exposure &&
+                               new_exposure +
+                               sd->params.flickerControl.coarseJump < max_exp)
+                                new_exposure +=
+                                        sd->params.flickerControl.coarseJump;
+                        sd->params.exposure.coarseExpLo = new_exposure & 0xff;
+                        sd->params.exposure.coarseExpHi = new_exposure >> 8;
+                        setexp = 1;
+                        sd->exposure_status = EXPOSURE_NORMAL;
+                        PDEBUG(D_CONF, "Automatically increasing sensor_fps");
+                }
+        } else {
+                /* Flicker control off */
+                if ((sd->exposure_status == EXPOSURE_VERY_DARK ||
+                     sd->exposure_status == EXPOSURE_DARK) &&
+                    sd->exposure_count >= DARK_TIME * framerate &&
+                    sd->params.sensorFps.divisor < 3) {
+
+                        /* dark for too long */
+                        ++sd->params.sensorFps.divisor;
+                        setfps = 1;
+
+                        if (sd->params.exposure.gain > 0) {
+                                --sd->params.exposure.gain;
+                                setexp = 1;
+                        }
+                        sd->exposure_status = EXPOSURE_NORMAL;
+                        PDEBUG(D_CONF, "Automatically decreasing sensor_fps");
+
+                } else if ((sd->exposure_status == EXPOSURE_VERY_LIGHT ||
+                            sd->exposure_status == EXPOSURE_LIGHT) &&
+                           sd->exposure_count >= LIGHT_TIME * framerate &&
+                           sd->params.sensorFps.divisor > 0) {
+
+                        /* light for too long */
+                        --sd->params.sensorFps.divisor;
+                        setfps = 1;
+
+                        if (sd->params.exposure.gain <
+                            sd->params.exposure.gainMode - 1) {
+                                ++sd->params.exposure.gain;
+                                setexp = 1;
+                        }
+                        sd->exposure_status = EXPOSURE_NORMAL;
+                        PDEBUG(D_CONF, "Automatically increasing sensor_fps");
+                }
+        }
+
+        if (setexp)
+                command_setexposure(gspca_dev);
+
+        if (setfps)
+                command_setsensorfps(gspca_dev);
+
+        if (setflicker)
+                command_setflickerctrl(gspca_dev);
+}
+
+/*-----------------------------------------------------------------*/
+/* if flicker is switched off, this function switches it back on.It checks,
+   however, that conditions are suitable before restarting it.
+   This should only be called for firmware version 1.2.
+
+   It also adjust the colour balance when an exposure step is detected - as
+   long as flicker is running
+*/
+static void restart_flicker(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        int cam_exposure, old_exp;
+
+        if (!FIRMWARE_VERSION(1, 2))
+                return;
+
+        cam_exposure = atomic_read(&sd->cam_exposure);
+
+        if (sd->params.flickerControl.flickerMode == 0 ||
+            cam_exposure == 0)
+                return;
+
+        old_exp = sd->params.exposure.coarseExpLo +
+                  sd->params.exposure.coarseExpHi*256;
+        /*
+          see how far away camera exposure is from a valid
+          flicker exposure value
+        */
+        cam_exposure %= sd->params.flickerControl.coarseJump;
+        if (!sd->params.flickerControl.disabled &&
+            cam_exposure <= sd->params.flickerControl.coarseJump - 3) {
+                /* Flicker control auto-disabled */
+                sd->params.flickerControl.disabled = 1;
+        }
+
+        if (sd->params.flickerControl.disabled &&
+            old_exp > sd->params.flickerControl.coarseJump +
+                      ROUND_UP_EXP_FOR_FLICKER) {
+                /* exposure is now high enough to switch
+                   flicker control back on */
+                set_flicker(gspca_dev, 1, 1);
+        }
+}
+
+/* this function is called at probe time */
+static int sd_config(struct gspca_dev *gspca_dev,
+                        const struct usb_device_id *id)
+{
+        struct cam *cam;
+
+        reset_camera_params(gspca_dev);
+
+        PDEBUG(D_PROBE, "cpia CPiA camera detected (vid/pid 0x%04X:0x%04X)",
+               id->idVendor, id->idProduct);
+
+        cam = &gspca_dev->cam;
+        cam->cam_mode = mode;
+        cam->nmodes = ARRAY_SIZE(mode);
+
+        sd_setfreq(gspca_dev, FREQ_DEF);
+
+        return 0;
+}
+
+/* -- start the camera -- */
+static int sd_start(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        int priv, ret;
+
+        /* Start the camera in low power mode */
+        if (goto_low_power(gspca_dev)) {
+                if (sd->params.status.systemState != WARM_BOOT_STATE) {
+                        PDEBUG(D_ERR, "unexpected systemstate: %02x",
+                               sd->params.status.systemState);
+                        printstatus(&sd->params);
+                        return -ENODEV;
+                }
+
+                /* FIXME: this is just dirty trial and error */
+                ret = goto_high_power(gspca_dev);
+                if (ret)
+                        return ret;
+
+                ret = do_command(gspca_dev, CPIA_COMMAND_DiscardFrame,
+                                 0, 0, 0, 0);
+                if (ret)
+                        return ret;
+
+                ret = goto_low_power(gspca_dev);
+                if (ret)
+                        return ret;
+        }
+
+        /* procedure described in developer's guide p3-28 */
+
+        /* Check the firmware version. */
+        sd->params.version.firmwareVersion = 0;
+        get_version_information(gspca_dev);
+        if (sd->params.version.firmwareVersion != 1) {
+                PDEBUG(D_ERR, "only firmware version 1 is supported (got: %d)",
+                       sd->params.version.firmwareVersion);
+                return -ENODEV;
+        }
+
+        /* A bug in firmware 1-02 limits gainMode to 2 */
+        if (sd->params.version.firmwareRevision <= 2 &&
+            sd->params.exposure.gainMode > 2) {
+                sd->params.exposure.gainMode = 2;
+        }
+
+        /* set QX3 detected flag */
+        sd->params.qx3.qx3_detected = (sd->params.pnpID.vendor == 0x0813 &&
+                                       sd->params.pnpID.product == 0x0001);
+
+        /* The fatal error checking should be done after
+         * the camera powers up (developer's guide p 3-38) */
+
+        /* Set streamState before transition to high power to avoid bug
+         * in firmware 1-02 */
+        ret = do_command(gspca_dev, CPIA_COMMAND_ModifyCameraStatus,
+                         STREAMSTATE, 0, STREAM_NOT_READY, 0);
+        if (ret)
+                return ret;
+
+        /* GotoHiPower */
+        ret = goto_high_power(gspca_dev);
+        if (ret)
+                return ret;
+
+        /* Check the camera status */
+        ret = do_command(gspca_dev, CPIA_COMMAND_GetCameraStatus, 0, 0, 0, 0);
+        if (ret)
+                return ret;
+
+        if (sd->params.status.fatalError) {
+                PDEBUG(D_ERR, "fatal_error: %04x, vp_status: %04x",
+                       sd->params.status.fatalError,
+                       sd->params.status.vpStatus);
+                return -EIO;
+        }
+
+        /* VPVersion can't be retrieved before the camera is in HiPower,
+         * so get it here instead of in get_version_information. */
+        ret = do_command(gspca_dev, CPIA_COMMAND_GetVPVersion, 0, 0, 0, 0);
+        if (ret)
+                return ret;
+
+        /* Determine video mode settings */
+        sd->params.streamStartLine = 120;
+
+        priv = gspca_dev->cam.cam_mode[gspca_dev->curr_mode].priv;
+        if (priv & 0x01) { /* crop */
+                sd->params.roi.colStart = 2;
+                sd->params.roi.rowStart = 6;
+        } else {
+                sd->params.roi.colStart = 0;
+                sd->params.roi.rowStart = 0;
+        }
+
+        if (priv & 0x02) { /* quarter */
+                sd->params.format.videoSize = VIDEOSIZE_QCIF;
+                sd->params.roi.colStart /= 2;
+                sd->params.roi.rowStart /= 2;
+                sd->params.streamStartLine /= 2;
+        } else
+                sd->params.format.videoSize = VIDEOSIZE_CIF;
+
+        sd->params.roi.colEnd = sd->params.roi.colStart +
+                                (gspca_dev->width >> 3);
+        sd->params.roi.rowEnd = sd->params.roi.rowStart +
+                                (gspca_dev->height >> 2);
+
+        /* And now set the camera to a known state */
+        ret = do_command(gspca_dev, CPIA_COMMAND_SetGrabMode,
+                         CPIA_GRAB_CONTINEOUS, 0, 0, 0);
+        if (ret)
+                return ret;
+        /* We start with compression disabled, as we need one uncompressed
+           frame to handle later compressed frames */
+        ret = do_command(gspca_dev, CPIA_COMMAND_SetCompression,
+                         CPIA_COMPRESSION_NONE,
+                         NO_DECIMATION, 0, 0);
+        if (ret)
+                return ret;
+        ret = command_setcompressiontarget(gspca_dev);
+        if (ret)
+                return ret;
+        ret = command_setcolourparams(gspca_dev);
+        if (ret)
+                return ret;
+        ret = command_setformat(gspca_dev);
+        if (ret)
+                return ret;
+        ret = command_setyuvtresh(gspca_dev);
+        if (ret)
+                return ret;
+        ret = command_setecptiming(gspca_dev);
+        if (ret)
+                return ret;
+        ret = command_setcompressionparams(gspca_dev);
+        if (ret)
+                return ret;
+        ret = command_setexposure(gspca_dev);
+        if (ret)
+                return ret;
+        ret = command_setcolourbalance(gspca_dev);
+        if (ret)
+                return ret;
+        ret = command_setsensorfps(gspca_dev);
+        if (ret)
+                return ret;
+        ret = command_setapcor(gspca_dev);
+        if (ret)
+                return ret;
+        ret = command_setflickerctrl(gspca_dev);
+        if (ret)
+                return ret;
+        ret = command_setvloffset(gspca_dev);
+        if (ret)
+                return ret;
+
+        /* Start stream */
+        ret = command_resume(gspca_dev);
+        if (ret)
+                return ret;
+
+        /* Wait 6 frames before turning compression on for the sensor to get
+           all settings and AEC/ACB to settle */
+        sd->first_frame = 6;
+        sd->exposure_status = EXPOSURE_NORMAL;
+        sd->exposure_count = 0;
+        atomic_set(&sd->cam_exposure, 0);
+        atomic_set(&sd->fps, 0);
+
+        return 0;
+}
+
+static void sd_stopN(struct gspca_dev *gspca_dev)
+{
+        command_pause(gspca_dev);
+
+        /* save camera state for later open (developers guide ch 3.5.3) */
+        save_camera_state(gspca_dev);
+
+        /* GotoLoPower */
+        goto_low_power(gspca_dev);
+
+        /* Update the camera status */
+        do_command(gspca_dev, CPIA_COMMAND_GetCameraStatus, 0, 0, 0, 0);
+}
+
+/* this function is called at probe and resume time */
+static int sd_init(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        int ret;
+
+        /* Start / Stop the camera to make sure we are talking to
+           a supported camera, and to get some information from it
+           to print. */
+        ret = sd_start(gspca_dev);
+        if (ret)
+                return ret;
+
+        sd_stopN(gspca_dev);
+
+        PDEBUG(D_PROBE, "CPIA Version:             %d.%02d (%d.%d)",
+                        sd->params.version.firmwareVersion,
+                        sd->params.version.firmwareRevision,
+                        sd->params.version.vcVersion,
+                        sd->params.version.vcRevision);
+        PDEBUG(D_PROBE, "CPIA PnP-ID:              %04x:%04x:%04x",
+                        sd->params.pnpID.vendor, sd->params.pnpID.product,
+                        sd->params.pnpID.deviceRevision);
+        PDEBUG(D_PROBE, "VP-Version:               %d.%d %04x",
+                        sd->params.vpVersion.vpVersion,
+                        sd->params.vpVersion.vpRevision,
+                        sd->params.vpVersion.cameraHeadID);
+
+        return 0;
+}
+
+static void sd_pkt_scan(struct gspca_dev *gspca_dev,
+                        u8 *data,
+                        int len)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        /* Check for SOF */
+        if (len >= 64 &&
+            data[0] == MAGIC_0 && data[1] == MAGIC_1 &&
+            data[16] == sd->params.format.videoSize &&
+            data[17] == sd->params.format.subSample &&
+            data[18] == sd->params.format.yuvOrder &&
+            data[24] == sd->params.roi.colStart &&
+            data[25] == sd->params.roi.colEnd &&
+            data[26] == sd->params.roi.rowStart &&
+            data[27] == sd->params.roi.rowEnd) {
+                struct gspca_frame *frame = gspca_get_i_frame(gspca_dev);
+
+                atomic_set(&sd->cam_exposure, data[39] * 2);
+                atomic_set(&sd->fps, data[41]);
+
+                if (frame == NULL) {
+                        gspca_dev->last_packet_type = DISCARD_PACKET;
+                        return;
+                }
+
+                /* Check for proper EOF for last frame */
+                if ((frame->data_end - frame->data) > 4 &&
+                    frame->data_end[-4] == 0xff &&
+                    frame->data_end[-3] == 0xff &&
+                    frame->data_end[-2] == 0xff &&
+                    frame->data_end[-1] == 0xff)
+                        gspca_frame_add(gspca_dev, LAST_PACKET,
+                                                NULL, 0);
+
+                gspca_frame_add(gspca_dev, FIRST_PACKET, data, len);
+                return;
+        }
+
+        gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
+}
+
+static void sd_dq_callback(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        /* Set the normal compression settings once we have captured a
+           few uncompressed frames (and AEC has hopefully settled) */
+        if (sd->first_frame) {
+                sd->first_frame--;
+                if (sd->first_frame == 0)
+                        command_setcompression(gspca_dev);
+        }
+
+        /* Switch flicker control back on if it got turned off */
+        restart_flicker(gspca_dev);
+
+        /* If AEC is enabled, monitor the exposure and
+           adjust the sensor frame rate if needed */
+        if (sd->params.exposure.expMode == 2)
+                monitor_exposure(gspca_dev);
+
+        /* Update our knowledge of the camera state */
+        do_command(gspca_dev, CPIA_COMMAND_GetExposure, 0, 0, 0, 0);
+        if (sd->params.qx3.qx3_detected)
+                do_command(gspca_dev, CPIA_COMMAND_ReadMCPorts, 0, 0, 0, 0);
+}
+
+static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        int ret;
+
+        sd->params.colourParams.brightness = val;
+        sd->params.flickerControl.allowableOverExposure =
+                find_over_exposure(sd->params.colourParams.brightness);
+        if (gspca_dev->streaming) {
+                ret = command_setcolourparams(gspca_dev);
+                if (ret)
+                        return ret;
+                return command_setflickerctrl(gspca_dev);
+        }
+        return 0;
+}
+
+static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        *val = sd->params.colourParams.brightness;
+        return 0;
+}
+
+static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        sd->params.colourParams.contrast = val;
+        if (gspca_dev->streaming)
+                return command_setcolourparams(gspca_dev);
+
+        return 0;
+}
+
+static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        *val = sd->params.colourParams.contrast;
+        return 0;
+}
+
+static int sd_setsaturation(struct gspca_dev *gspca_dev, __s32 val)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        sd->params.colourParams.saturation = val;
+        if (gspca_dev->streaming)
+                return command_setcolourparams(gspca_dev);
+
+        return 0;
+}
+
+static int sd_getsaturation(struct gspca_dev *gspca_dev, __s32 *val)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        *val = sd->params.colourParams.saturation;
+        return 0;
+}
+
+static int sd_setfreq(struct gspca_dev *gspca_dev, __s32 val)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        int on;
+
+        switch (val) {
+        case 0:         /* V4L2_CID_POWER_LINE_FREQUENCY_DISABLED */
+                on = 0;
+                break;
+        case 1:         /* V4L2_CID_POWER_LINE_FREQUENCY_50HZ */
+                on = 1;
+                sd->mainsFreq = 0;
+                break;
+        case 2:         /* V4L2_CID_POWER_LINE_FREQUENCY_60HZ */
+                on = 1;
+                sd->mainsFreq = 1;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        sd->freq = val;
+        sd->params.flickerControl.coarseJump =
+                flicker_jumps[sd->mainsFreq]
+                             [sd->params.sensorFps.baserate]
+                             [sd->params.sensorFps.divisor];
+
+        return set_flicker(gspca_dev, on, gspca_dev->streaming);
+}
+
+static int sd_getfreq(struct gspca_dev *gspca_dev, __s32 *val)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        *val = sd->freq;
+        return 0;
+}
+
+static int sd_setcomptarget(struct gspca_dev *gspca_dev, __s32 val)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        sd->params.compressionTarget.frTargeting = val;
+        if (gspca_dev->streaming)
+                return command_setcompressiontarget(gspca_dev);
+
+        return 0;
+}
+
+static int sd_getcomptarget(struct gspca_dev *gspca_dev, __s32 *val)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        *val = sd->params.compressionTarget.frTargeting;
+        return 0;
+}
+
+static int sd_querymenu(struct gspca_dev *gspca_dev,
+                        struct v4l2_querymenu *menu)
+{
+        switch (menu->id) {
+        case V4L2_CID_POWER_LINE_FREQUENCY:
+                switch (menu->index) {
+                case 0:         /* V4L2_CID_POWER_LINE_FREQUENCY_DISABLED */
+                        strcpy((char *) menu->name, "NoFliker");
+                        return 0;
+                case 1:         /* V4L2_CID_POWER_LINE_FREQUENCY_50HZ */
+                        strcpy((char *) menu->name, "50 Hz");
+                        return 0;
+                case 2:         /* V4L2_CID_POWER_LINE_FREQUENCY_60HZ */
+                        strcpy((char *) menu->name, "60 Hz");
+                        return 0;
+                }
+                break;
+        case V4L2_CID_COMP_TARGET:
+                switch (menu->index) {
+                case CPIA_COMPRESSION_TARGET_QUALITY:
+                        strcpy((char *) menu->name, "Quality");
+                        return 0;
+                case CPIA_COMPRESSION_TARGET_FRAMERATE:
+                        strcpy((char *) menu->name, "Framerate");
+                        return 0;
+                }
+                break;
+        }
+        return -EINVAL;
+}
+
+/* sub-driver description */
+static const struct sd_desc sd_desc = {
+        .name = MODULE_NAME,
+        .ctrls = sd_ctrls,
+        .nctrls = ARRAY_SIZE(sd_ctrls),
+        .config = sd_config,
+        .init = sd_init,
+        .start = sd_start,
+        .stopN = sd_stopN,
+        .dq_callback = sd_dq_callback,
+        .pkt_scan = sd_pkt_scan,
+        .querymenu = sd_querymenu,
+};
+
+/* -- module initialisation -- */
+static const __devinitdata struct usb_device_id device_table[] = {
+        {USB_DEVICE(0x0553, 0x0002)},
+        {USB_DEVICE(0x0813, 0x0001)},
+        {}
+};
+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);
+}
+
+static struct usb_driver sd_driver = {
+        .name = MODULE_NAME,
+        .id_table = device_table,
+        .probe = sd_probe,
+        .disconnect = gspca_disconnect,
+#ifdef CONFIG_PM
+        .suspend = gspca_suspend,
+        .resume = gspca_resume,
+#endif
+};
+
+/* -- module insert / remove -- */
+static int __init sd_mod_init(void)
+{
+        int ret;
+        ret = usb_register(&sd_driver);
+        if (ret < 0)
+                return ret;
+        PDEBUG(D_PROBE, "registered");
+        return 0;
+}
+static void __exit sd_mod_exit(void)
+{
+        usb_deregister(&sd_driver);
+        PDEBUG(D_PROBE, "deregistered");
+}
+
+module_init(sd_mod_init);
+module_exit(sd_mod_exit);
diff --git a/drivers/media/video/gspca/etoms.c b/drivers/media/video/gspca/etoms.c
index fdf4c0ec5e7a..ecd4d743d2bc 100644
--- a/drivers/media/video/gspca/etoms.c
+++ b/drivers/media/video/gspca/etoms.c
@@ -52,7 +52,7 @@ static int sd_getcolors(struct gspca_dev *gspca_dev, __s32 *val);
 static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val);
 static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val);
 
-static struct ctrl sd_ctrls[] = {
+static const struct ctrl sd_ctrls[] = {
         {
          {
           .id = V4L2_CID_BRIGHTNESS,
@@ -851,7 +851,7 @@ static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val)
 }
 
 /* sub-driver description */
-static struct sd_desc sd_desc = {
+static const struct sd_desc sd_desc = {
         .name = MODULE_NAME,
         .ctrls = sd_ctrls,
         .nctrls = ARRAY_SIZE(sd_ctrls),
diff --git a/drivers/media/video/gspca/gl860/gl860.c b/drivers/media/video/gspca/gl860/gl860.c
index 4878c8f66543..9e42476c0eaf 100644
--- a/drivers/media/video/gspca/gl860/gl860.c
+++ b/drivers/media/video/gspca/gl860/gl860.c
@@ -161,7 +161,7 @@ static int gl860_build_control_table(struct gspca_dev *gspca_dev)
 
 /*==================== sud-driver structure initialisation =================*/
 
-static struct sd_desc sd_desc_mi1320 = {
+static const struct sd_desc sd_desc_mi1320 = {
         .name        = MODULE_NAME,
         .ctrls       = sd_ctrls_mi1320,
         .nctrls      = GL860_NCTRLS,
@@ -174,7 +174,7 @@ static struct sd_desc sd_desc_mi1320 = {
         .dq_callback = sd_callback,
 };
 
-static struct sd_desc sd_desc_mi2020 = {
+static const struct sd_desc sd_desc_mi2020 = {
         .name        = MODULE_NAME,
         .ctrls       = sd_ctrls_mi2020,
         .nctrls      = GL860_NCTRLS,
@@ -187,7 +187,7 @@ static struct sd_desc sd_desc_mi2020 = {
         .dq_callback = sd_callback,
 };
 
-static struct sd_desc sd_desc_mi2020b = {
+static const struct sd_desc sd_desc_mi2020b = {
         .name        = MODULE_NAME,
         .ctrls       = sd_ctrls_mi2020b,
         .nctrls      = GL860_NCTRLS,
@@ -200,7 +200,7 @@ static struct sd_desc sd_desc_mi2020b = {
         .dq_callback = sd_callback,
 };
 
-static struct sd_desc sd_desc_ov2640 = {
+static const struct sd_desc sd_desc_ov2640 = {
         .name        = MODULE_NAME,
         .ctrls       = sd_ctrls_ov2640,
         .nctrls      = GL860_NCTRLS,
@@ -213,7 +213,7 @@ static struct sd_desc sd_desc_ov2640 = {
         .dq_callback = sd_callback,
 };
 
-static struct sd_desc sd_desc_ov9655 = {
+static const struct sd_desc sd_desc_ov9655 = {
         .name        = MODULE_NAME,
         .ctrls       = sd_ctrls_ov9655,
         .nctrls      = GL860_NCTRLS,
diff --git a/drivers/media/video/gspca/gspca.c b/drivers/media/video/gspca/gspca.c
index bd6214d4ab3b..222af479150b 100644
--- a/drivers/media/video/gspca/gspca.c
+++ b/drivers/media/video/gspca/gspca.c
@@ -3,6 +3,9 @@
  *
  * Copyright (C) 2008-2009 Jean-Francois Moine (http://moinejf.free.fr)
  *
+ * Camera button input handling by Márton Németh
+ * Copyright (C) 2009-2010 Márton Németh <nm127@freemail.hu>
+ *
  * 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
@@ -37,6 +40,11 @@
 
 #include "gspca.h"
 
+#ifdef CONFIG_INPUT
+#include <linux/input.h>
+#include <linux/usb/input.h>
+#endif
+
 /* global values */
 #define DEF_NURBS 3             /* default number of URBs */
 #if DEF_NURBS > MAX_NURBS
@@ -47,7 +55,7 @@ MODULE_AUTHOR("Jean-Francois Moine <http://moinejf.free.fr>");
 MODULE_DESCRIPTION("GSPCA USB Camera Driver");
 MODULE_LICENSE("GPL");
 
-#define DRIVER_VERSION_NUMBER   KERNEL_VERSION(2, 8, 0)
+#define DRIVER_VERSION_NUMBER   KERNEL_VERSION(2, 9, 0)
 
 #ifdef GSPCA_DEBUG
 int gspca_debug = D_ERR | D_PROBE;
@@ -104,15 +112,185 @@ static const struct vm_operations_struct gspca_vm_ops = {
         .close          = gspca_vm_close,
 };
 
+/*
+ * Input and interrupt endpoint handling functions
+ */
+#ifdef CONFIG_INPUT
+static void int_irq(struct urb *urb)
+{
+        struct gspca_dev *gspca_dev = (struct gspca_dev *) urb->context;
+        int ret;
+
+        ret = urb->status;
+        switch (ret) {
+        case 0:
+                if (gspca_dev->sd_desc->int_pkt_scan(gspca_dev,
+                    urb->transfer_buffer, urb->actual_length) < 0) {
+                        PDEBUG(D_ERR, "Unknown packet received");
+                }
+                break;
+
+        case -ENOENT:
+        case -ECONNRESET:
+        case -ENODEV:
+        case -ESHUTDOWN:
+                /* Stop is requested either by software or hardware is gone,
+                 * keep the ret value non-zero and don't resubmit later.
+                 */
+                break;
+
+        default:
+                PDEBUG(D_ERR, "URB error %i, resubmitting", urb->status);
+                urb->status = 0;
+                ret = 0;
+        }
+
+        if (ret == 0) {
+                ret = usb_submit_urb(urb, GFP_ATOMIC);
+                if (ret < 0)
+                        PDEBUG(D_ERR, "Resubmit URB failed with error %i", ret);
+        }
+}
+
+static int gspca_input_connect(struct gspca_dev *dev)
+{
+        struct input_dev *input_dev;
+        int err = 0;
+
+        dev->input_dev = NULL;
+        if (dev->sd_desc->int_pkt_scan || dev->sd_desc->other_input)  {
+                input_dev = input_allocate_device();
+                if (!input_dev)
+                        return -ENOMEM;
+
+                usb_make_path(dev->dev, dev->phys, sizeof(dev->phys));
+                strlcat(dev->phys, "/input0", sizeof(dev->phys));
+
+                input_dev->name = dev->sd_desc->name;
+                input_dev->phys = dev->phys;
+
+                usb_to_input_id(dev->dev, &input_dev->id);
+
+                input_dev->evbit[0] = BIT_MASK(EV_KEY);
+                input_dev->keybit[BIT_WORD(KEY_CAMERA)] = BIT_MASK(KEY_CAMERA);
+                input_dev->dev.parent = &dev->dev->dev;
+
+                err = input_register_device(input_dev);
+                if (err) {
+                        PDEBUG(D_ERR, "Input device registration failed "
+                                "with error %i", err);
+                        input_dev->dev.parent = NULL;
+                        input_free_device(input_dev);
+                } else {
+                        dev->input_dev = input_dev;
+                }
+        }
+
+        return err;
+}
+
+static int alloc_and_submit_int_urb(struct gspca_dev *gspca_dev,
+                          struct usb_endpoint_descriptor *ep)
+{
+        unsigned int buffer_len;
+        int interval;
+        struct urb *urb;
+        struct usb_device *dev;
+        void *buffer = NULL;
+        int ret = -EINVAL;
+
+        buffer_len = ep->wMaxPacketSize;
+        interval = ep->bInterval;
+        PDEBUG(D_PROBE, "found int in endpoint: 0x%x, "
+                "buffer_len=%u, interval=%u",
+                ep->bEndpointAddress, buffer_len, interval);
+
+        dev = gspca_dev->dev;
+
+        urb = usb_alloc_urb(0, GFP_KERNEL);
+        if (!urb) {
+                ret = -ENOMEM;
+                goto error;
+        }
+
+        buffer = usb_buffer_alloc(dev, ep->wMaxPacketSize,
+                                GFP_KERNEL, &urb->transfer_dma);
+        if (!buffer) {
+                ret = -ENOMEM;
+                goto error_buffer;
+        }
+        usb_fill_int_urb(urb, dev,
+                usb_rcvintpipe(dev, ep->bEndpointAddress),
+                buffer, buffer_len,
+                int_irq, (void *)gspca_dev, interval);
+        gspca_dev->int_urb = urb;
+        ret = usb_submit_urb(urb, GFP_KERNEL);
+        if (ret < 0) {
+                PDEBUG(D_ERR, "submit URB failed with error %i", ret);
+                goto error_submit;
+        }
+        return ret;
+
+error_submit:
+        usb_buffer_free(dev,
+                        urb->transfer_buffer_length,
+                        urb->transfer_buffer,
+                        urb->transfer_dma);
+error_buffer:
+        usb_free_urb(urb);
+error:
+        return ret;
+}
+
+static void gspca_input_create_urb(struct gspca_dev *gspca_dev)
+{
+        struct usb_interface *intf;
+        struct usb_host_interface *intf_desc;
+        struct usb_endpoint_descriptor *ep;
+        int i;
+
+        if (gspca_dev->sd_desc->int_pkt_scan)  {
+                intf = usb_ifnum_to_if(gspca_dev->dev, gspca_dev->iface);
+                intf_desc = intf->cur_altsetting;
+                for (i = 0; i < intf_desc->desc.bNumEndpoints; i++) {
+                        ep = &intf_desc->endpoint[i].desc;
+                        if (usb_endpoint_dir_in(ep) &&
+                            usb_endpoint_xfer_int(ep)) {
+
+                                alloc_and_submit_int_urb(gspca_dev, ep);
+                                break;
+                        }
+                }
+        }
+}
+
+static void gspca_input_destroy_urb(struct gspca_dev *gspca_dev)
+{
+        struct urb *urb;
+
+        urb = gspca_dev->int_urb;
+        if (urb) {
+                gspca_dev->int_urb = NULL;
+                usb_kill_urb(urb);
+                usb_buffer_free(gspca_dev->dev,
+                                urb->transfer_buffer_length,
+                                urb->transfer_buffer,
+                                urb->transfer_dma);
+                usb_free_urb(urb);
+        }
+}
+#else
+#define gspca_input_connect(gspca_dev)          0
+#define gspca_input_create_urb(gspca_dev)
+#define gspca_input_destroy_urb(gspca_dev)
+#endif
+
 /* get the current input frame buffer */
 struct gspca_frame *gspca_get_i_frame(struct gspca_dev *gspca_dev)
 {
         struct gspca_frame *frame;
-        int i;
 
-        i = gspca_dev->fr_i;
-        i = gspca_dev->fr_queue[i];
-        frame = &gspca_dev->frame[i];
+        frame = gspca_dev->cur_frame;
         if ((frame->v4l2_buf.flags & BUF_ALL_FLAGS)
                                 != V4L2_BUF_FLAG_QUEUED)
                 return NULL;
@@ -486,11 +664,13 @@ static struct usb_host_endpoint *get_ep(struct gspca_dev *gspca_dev)
                         i, ep->desc.bEndpointAddress);
         gspca_dev->alt = i;             /* memorize the current alt setting */
         if (gspca_dev->nbalt > 1) {
+                gspca_input_destroy_urb(gspca_dev);
                 ret = usb_set_interface(gspca_dev->dev, gspca_dev->iface, i);
                 if (ret < 0) {
                         err("set alt %d err %d", i, ret);
-                        return NULL;
+                        ep = NULL;
                 }
+                gspca_input_create_urb(gspca_dev);
         }
         return ep;
 }
@@ -534,26 +714,22 @@ static int create_urbs(struct gspca_dev *gspca_dev,
                         nurbs = 1;
         }
 
-        gspca_dev->nurbs = nurbs;
         for (n = 0; n < nurbs; n++) {
                 urb = usb_alloc_urb(npkt, GFP_KERNEL);
                 if (!urb) {
                         err("usb_alloc_urb failed");
-                        destroy_urbs(gspca_dev);
                         return -ENOMEM;
                 }
+                gspca_dev->urb[n] = urb;
                 urb->transfer_buffer = usb_buffer_alloc(gspca_dev->dev,
                                                 bsize,
                                                 GFP_KERNEL,
                                                 &urb->transfer_dma);
 
                 if (urb->transfer_buffer == NULL) {
-                        usb_free_urb(urb);
-                        err("usb_buffer_urb failed");
-                        destroy_urbs(gspca_dev);
+                        err("usb_buffer_alloc failed");
                         return -ENOMEM;
                 }
-                gspca_dev->urb[n] = urb;
                 urb->dev = gspca_dev->dev;
                 urb->context = gspca_dev;
                 urb->transfer_buffer_length = bsize;
@@ -585,6 +761,7 @@ static int create_urbs(struct gspca_dev *gspca_dev,
 static int gspca_init_transfer(struct gspca_dev *gspca_dev)
 {
         struct usb_host_endpoint *ep;
+        struct urb *urb;
         int n, ret;
 
         if (mutex_lock_interruptible(&gspca_dev->usb_lock))
@@ -595,6 +772,8 @@ static int gspca_init_transfer(struct gspca_dev *gspca_dev)
                 goto out;
         }
 
+        gspca_dev->usb_err = 0;
+
         /* set the higher alternate setting and
          * loop until urb submit succeeds */
         if (gspca_dev->cam.reverse_alts)
@@ -613,10 +792,15 @@ static int gspca_init_transfer(struct gspca_dev *gspca_dev)
                 goto out;
         }
         for (;;) {
-                PDEBUG(D_STREAM, "init transfer alt %d", gspca_dev->alt);
-                ret = create_urbs(gspca_dev, ep);
-                if (ret < 0)
-                        goto out;
+                if (!gspca_dev->cam.no_urb_create) {
+                        PDEBUG(D_STREAM, "init transfer alt %d",
+                                gspca_dev->alt);
+                        ret = create_urbs(gspca_dev, ep);
+                        if (ret < 0) {
+                                destroy_urbs(gspca_dev);
+                                goto out;
+                        }
+                }
 
                 /* clear the bulk endpoint */
                 if (gspca_dev->cam.bulk)
@@ -636,8 +820,11 @@ static int gspca_init_transfer(struct gspca_dev *gspca_dev)
                         break;
 
                 /* submit the URBs */
-                for (n = 0; n < gspca_dev->nurbs; n++) {
-                        ret = usb_submit_urb(gspca_dev->urb[n], GFP_KERNEL);
+                for (n = 0; n < MAX_NURBS; n++) {
+                        urb = gspca_dev->urb[n];
+                        if (urb == NULL)
+                                break;
+                        ret = usb_submit_urb(urb, GFP_KERNEL);
                         if (ret < 0)
                                 break;
                 }
@@ -694,7 +881,9 @@ static void gspca_stream_off(struct gspca_dev *gspca_dev)
                 if (gspca_dev->sd_desc->stopN)
                         gspca_dev->sd_desc->stopN(gspca_dev);
                 destroy_urbs(gspca_dev);
+                gspca_input_destroy_urb(gspca_dev);
                 gspca_set_alt0(gspca_dev);
+                gspca_input_create_urb(gspca_dev);
         }
 
         /* always call stop0 to free the subdriver's resources */
@@ -2060,11 +2249,12 @@ int gspca_dev_probe(struct usb_interface *intf,
                 PDEBUG(D_ERR, "Too many config");
                 return -ENODEV;
         }
+
+        /* the USB video interface must be the first one */
         interface = &intf->cur_altsetting->desc;
-        if (interface->bInterfaceNumber > 0) {
-                PDEBUG(D_ERR, "intf != 0");
+        if (dev->config->desc.bNumInterfaces != 1 &&
+            interface->bInterfaceNumber != 0)
                 return -ENODEV;
-        }
 
         /* create the device */
         if (dev_size < sizeof *gspca_dev)
@@ -2096,6 +2286,10 @@ int gspca_dev_probe(struct usb_interface *intf,
                 goto out;
         gspca_set_default_mode(gspca_dev);
 
+        ret = gspca_input_connect(gspca_dev);
+        if (ret)
+                goto out;
+
         mutex_init(&gspca_dev->usb_lock);
         mutex_init(&gspca_dev->read_lock);
         mutex_init(&gspca_dev->queue_lock);
@@ -2116,8 +2310,15 @@ int gspca_dev_probe(struct usb_interface *intf,
 
         usb_set_intfdata(intf, gspca_dev);
         PDEBUG(D_PROBE, "%s created", video_device_node_name(&gspca_dev->vdev));
+
+        gspca_input_create_urb(gspca_dev);
+
         return 0;
 out:
+#ifdef CONFIG_INPUT
+        if (gspca_dev->input_dev)
+                input_unregister_device(gspca_dev->input_dev);
+#endif
         kfree(gspca_dev->usb_buf);
         kfree(gspca_dev);
         return ret;
@@ -2133,6 +2334,9 @@ EXPORT_SYMBOL(gspca_dev_probe);
 void gspca_disconnect(struct usb_interface *intf)
 {
         struct gspca_dev *gspca_dev = usb_get_intfdata(intf);
+#ifdef CONFIG_INPUT
+        struct input_dev *input_dev;
+#endif
 
         PDEBUG(D_PROBE, "%s disconnect",
                 video_device_node_name(&gspca_dev->vdev));
@@ -2144,6 +2348,15 @@ void gspca_disconnect(struct usb_interface *intf)
                 wake_up_interruptible(&gspca_dev->wq);
         }
 
+#ifdef CONFIG_INPUT
+        gspca_input_destroy_urb(gspca_dev);
+        input_dev = gspca_dev->input_dev;
+        if (input_dev) {
+                gspca_dev->input_dev = NULL;
+                input_unregister_device(input_dev);
+        }
+#endif
+
         /* the device is freed at exit of this function */
         gspca_dev->dev = NULL;
         mutex_unlock(&gspca_dev->usb_lock);
@@ -2169,6 +2382,7 @@ int gspca_suspend(struct usb_interface *intf, pm_message_t message)
         if (gspca_dev->sd_desc->stopN)
                 gspca_dev->sd_desc->stopN(gspca_dev);
         destroy_urbs(gspca_dev);
+        gspca_input_destroy_urb(gspca_dev);
         gspca_set_alt0(gspca_dev);
         if (gspca_dev->sd_desc->stop0)
                 gspca_dev->sd_desc->stop0(gspca_dev);
@@ -2182,6 +2396,7 @@ int gspca_resume(struct usb_interface *intf)
 
         gspca_dev->frozen = 0;
         gspca_dev->sd_desc->init(gspca_dev);
+        gspca_input_create_urb(gspca_dev);
         if (gspca_dev->streaming)
                 return gspca_init_transfer(gspca_dev);
         return 0;
@@ -2205,6 +2420,8 @@ int gspca_auto_gain_n_exposure(struct gspca_dev *gspca_dev, int avg_lum,
         int retval = 0;
 
         for (i = 0; i < gspca_dev->sd_desc->nctrls; i++) {
+                if (gspca_dev->ctrl_dis & (1 << i))
+                        continue;
                 if (gspca_dev->sd_desc->ctrls[i].qctrl.id == V4L2_CID_GAIN)
                         gain_ctrl = &gspca_dev->sd_desc->ctrls[i];
                 if (gspca_dev->sd_desc->ctrls[i].qctrl.id == V4L2_CID_EXPOSURE)
diff --git a/drivers/media/video/gspca/gspca.h b/drivers/media/video/gspca/gspca.h
index 59c7941da999..02c696a22be0 100644
--- a/drivers/media/video/gspca/gspca.h
+++ b/drivers/media/video/gspca/gspca.h
@@ -48,26 +48,27 @@ extern int gspca_debug;
 
 /* used to list framerates supported by a camera mode (resolution) */
 struct framerates {
-        int *rates;
+        const u8 *rates;
         int nrates;
 };
 
 /* device information - set at probe time */
 struct cam {
-        int bulk_size;          /* buffer size when image transfer by bulk */
         const struct v4l2_pix_format *cam_mode; /* size nmodes */
-        char nmodes;
         const struct framerates *mode_framerates; /* must have size nmode,
                                                    * just like cam_mode */
-        __u8 bulk_nurbs;        /* number of URBs in bulk mode
+        u32 bulk_size;          /* buffer size when image transfer by bulk */
+        u32 input_flags;        /* value for ENUM_INPUT status flags */
+        u8 nmodes;              /* size of cam_mode */
+        u8 no_urb_create;       /* don't create transfer URBs */
+        u8 bulk_nurbs;          /* number of URBs in bulk mode
                                  * - cannot be > MAX_NURBS
                                  * - when 0 and bulk_size != 0 means
                                  *   1 URB and submit done by subdriver */
         u8 bulk;                /* image transfer by 0:isoc / 1:bulk */
         u8 npkt;                /* number of packets in an ISOC message
                                  * 0 is the default value: 32 packets */
-        u32 input_flags;        /* value for ENUM_INPUT status flags */
-        char reverse_alts;      /* Alt settings are in high to low order */
+        u8 reverse_alts;        /* Alt settings are in high to low order */
 };
 
 struct gspca_dev;
@@ -90,6 +91,9 @@ typedef int (*cam_qmnu_op) (struct gspca_dev *,
 typedef void (*cam_pkt_op) (struct gspca_dev *gspca_dev,
                                 u8 *data,
                                 int len);
+typedef int (*cam_int_pkt_op) (struct gspca_dev *gspca_dev,
+                                u8 *data,
+                                int len);
 
 struct ctrl {
         struct v4l2_queryctrl qctrl;
@@ -125,6 +129,12 @@ struct sd_desc {
         cam_reg_op get_register;
 #endif
         cam_ident_op get_chip_ident;
+#ifdef CONFIG_INPUT
+        cam_int_pkt_op int_pkt_scan;
+        /* other_input makes the gspca core create gspca_dev->input even when
+           int_pkt_scan is NULL, for cams with non interrupt driven buttons */
+        u8 other_input;
+#endif
 };
 
 /* packet types when moving from iso buf to frame buf */
@@ -147,6 +157,10 @@ struct gspca_dev {
         struct module *module;          /* subdriver handling the device */
         struct usb_device *dev;
         struct file *capt_file;         /* file doing video capture */
+#ifdef CONFIG_INPUT
+        struct input_dev *input_dev;
+        char phys[64];                  /* physical device path */
+#endif
 
         struct cam cam;                         /* device information */
         const struct sd_desc *sd_desc;          /* subdriver description */
@@ -156,6 +170,9 @@ struct gspca_dev {
 #define USB_BUF_SZ 64
         __u8 *usb_buf;                          /* buffer for USB exchanges */
         struct urb *urb[MAX_NURBS];
+#ifdef CONFIG_INPUT
+        struct urb *int_urb;
+#endif
 
         __u8 *frbuf;                            /* buffer for nframes */
         struct gspca_frame frame[GSPCA_MAX_FRAMES];
@@ -187,7 +204,6 @@ struct gspca_dev {
         char users;                     /* number of opens */
         char present;                   /* device connected */
         char nbufread;                  /* number of buffers for read() */
-        char nurbs;                     /* number of allocated URBs */
         char memory;                    /* memory type (V4L2_MEMORY_xxx) */
         __u8 iface;                     /* USB interface number */
         __u8 alt;                       /* USB alternate setting */
diff --git a/drivers/media/video/gspca/m5602/m5602_mt9m111.c b/drivers/media/video/gspca/m5602/m5602_mt9m111.c
index 8d071dff6944..c0722fa64606 100644
--- a/drivers/media/video/gspca/m5602/m5602_mt9m111.c
+++ b/drivers/media/video/gspca/m5602/m5602_mt9m111.c
@@ -48,7 +48,7 @@ static struct v4l2_pix_format mt9m111_modes[] = {
         }
 };
 
-const static struct ctrl mt9m111_ctrls[] = {
+static const struct ctrl mt9m111_ctrls[] = {
 #define VFLIP_IDX 0
         {
                 {
@@ -171,7 +171,7 @@ int mt9m111_probe(struct sd *sd)
                 return -ENODEV;
         }
 
-        info("Probing for a mt9m111 sensor");
+        PDEBUG(D_PROBE, "Probing for a mt9m111 sensor");
 
         /* Do the preinit */
         for (i = 0; i < ARRAY_SIZE(preinit_mt9m111); i++) {
diff --git a/drivers/media/video/gspca/m5602/m5602_ov7660.c b/drivers/media/video/gspca/m5602/m5602_ov7660.c
index 2a28b74cb3f9..62c1cbf06666 100644
--- a/drivers/media/video/gspca/m5602/m5602_ov7660.c
+++ b/drivers/media/video/gspca/m5602/m5602_ov7660.c
@@ -33,7 +33,7 @@ static int ov7660_set_hflip(struct gspca_dev *gspca_dev, __s32 val);
 static int ov7660_get_vflip(struct gspca_dev *gspca_dev, __s32 *val);
 static int ov7660_set_vflip(struct gspca_dev *gspca_dev, __s32 val);
 
-const static struct ctrl ov7660_ctrls[] = {
+static const struct ctrl ov7660_ctrls[] = {
 #define GAIN_IDX 1
         {
                 {
diff --git a/drivers/media/video/gspca/m5602/m5602_ov7660.h b/drivers/media/video/gspca/m5602/m5602_ov7660.h
index f5588ebe667c..4d9dcf29da2e 100644
--- a/drivers/media/video/gspca/m5602/m5602_ov7660.h
+++ b/drivers/media/video/gspca/m5602/m5602_ov7660.h
@@ -94,7 +94,7 @@ int ov7660_start(struct sd *sd);
 int ov7660_stop(struct sd *sd);
 void ov7660_disconnect(struct sd *sd);
 
-const static struct m5602_sensor ov7660 = {
+static const struct m5602_sensor ov7660 = {
         .name = "ov7660",
         .i2c_slave_id = 0x42,
         .i2c_regW = 1,
diff --git a/drivers/media/video/gspca/m5602/m5602_ov9650.c b/drivers/media/video/gspca/m5602/m5602_ov9650.c
index 923cdd5f7a6b..069ba0044f8b 100644
--- a/drivers/media/video/gspca/m5602/m5602_ov9650.c
+++ b/drivers/media/video/gspca/m5602/m5602_ov9650.c
@@ -307,7 +307,7 @@ int ov9650_probe(struct sd *sd)
                 return -ENODEV;
         }
 
-        info("Probing for an ov9650 sensor");
+        PDEBUG(D_PROBE, "Probing for an ov9650 sensor");
 
         /* Run the pre-init before probing the sensor */
         for (i = 0; i < ARRAY_SIZE(preinit_ov9650) && !err; i++) {
diff --git a/drivers/media/video/gspca/m5602/m5602_po1030.c b/drivers/media/video/gspca/m5602/m5602_po1030.c
index 8d74d8065b79..925b87d66f40 100644
--- a/drivers/media/video/gspca/m5602/m5602_po1030.c
+++ b/drivers/media/video/gspca/m5602/m5602_po1030.c
@@ -205,7 +205,7 @@ int po1030_probe(struct sd *sd)
                 return -ENODEV;
         }
 
-        info("Probing for a po1030 sensor");
+        PDEBUG(D_PROBE, "Probing for a po1030 sensor");
 
         /* Run the pre-init to actually probe the unit */
         for (i = 0; i < ARRAY_SIZE(preinit_po1030); i++) {
diff --git a/drivers/media/video/gspca/m5602/m5602_s5k4aa.c b/drivers/media/video/gspca/m5602/m5602_s5k4aa.c
index 1b536f7d30cf..da0a38c78708 100644
--- a/drivers/media/video/gspca/m5602/m5602_s5k4aa.c
+++ b/drivers/media/video/gspca/m5602/m5602_s5k4aa.c
@@ -248,7 +248,7 @@ int s5k4aa_probe(struct sd *sd)
                 return -ENODEV;
         }
 
-        info("Probing for a s5k4aa sensor");
+        PDEBUG(D_PROBE, "Probing for a s5k4aa sensor");
 
         /* Preinit the sensor */
         for (i = 0; i < ARRAY_SIZE(preinit_s5k4aa) && !err; i++) {
diff --git a/drivers/media/video/gspca/m5602/m5602_s5k83a.c b/drivers/media/video/gspca/m5602/m5602_s5k83a.c
index 6b89f33a4ce0..fbd91545497a 100644
--- a/drivers/media/video/gspca/m5602/m5602_s5k83a.c
+++ b/drivers/media/video/gspca/m5602/m5602_s5k83a.c
@@ -143,7 +143,7 @@ int s5k83a_probe(struct sd *sd)
                 return -ENODEV;
         }
 
-        info("Probing for a s5k83a sensor");
+        PDEBUG(D_PROBE, "Probing for a s5k83a sensor");
 
         /* Preinit the sensor */
         for (i = 0; i < ARRAY_SIZE(preinit_s5k83a) && !err; i++) {
diff --git a/drivers/media/video/gspca/mars.c b/drivers/media/video/gspca/mars.c
index 9cf8d68c71bf..3d9229e22b25 100644
--- a/drivers/media/video/gspca/mars.c
+++ b/drivers/media/video/gspca/mars.c
@@ -54,7 +54,7 @@ static int sd_getgamma(struct gspca_dev *gspca_dev, __s32 *val);
 static int sd_setsharpness(struct gspca_dev *gspca_dev, __s32 val);
 static int sd_getsharpness(struct gspca_dev *gspca_dev, __s32 *val);
 
-static struct ctrl sd_ctrls[] = {
+static const struct ctrl sd_ctrls[] = {
         {
             {
                 .id      = V4L2_CID_BRIGHTNESS,
diff --git a/drivers/media/video/gspca/mr97310a.c b/drivers/media/video/gspca/mr97310a.c
index 9154870e07d2..33744e724eaa 100644
--- a/drivers/media/video/gspca/mr97310a.c
+++ b/drivers/media/video/gspca/mr97310a.c
@@ -57,6 +57,14 @@
 #define MR97310A_GAIN_MAX               31
 #define MR97310A_GAIN_DEFAULT           25
 
+#define MR97310A_CONTRAST_MIN           0
+#define MR97310A_CONTRAST_MAX           31
+#define MR97310A_CONTRAST_DEFAULT       23
+
+#define MR97310A_CS_GAIN_MIN            0
+#define MR97310A_CS_GAIN_MAX            0x7ff
+#define MR97310A_CS_GAIN_DEFAULT        0x110
+
 #define MR97310A_MIN_CLOCKDIV_MIN       3
 #define MR97310A_MIN_CLOCKDIV_MAX       8
 #define MR97310A_MIN_CLOCKDIV_DEFAULT   3
@@ -82,7 +90,8 @@ struct sd {
 
         int brightness;
         u16 exposure;
-        u8 gain;
+        u32 gain;
+        u8 contrast;
         u8 min_clockdiv;
 };
 
@@ -98,6 +107,8 @@ static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val);
 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val);
 static int sd_setexposure(struct gspca_dev *gspca_dev, __s32 val);
 static int sd_getexposure(struct gspca_dev *gspca_dev, __s32 *val);
+static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val);
+static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val);
 static int sd_setgain(struct gspca_dev *gspca_dev, __s32 val);
 static int sd_getgain(struct gspca_dev *gspca_dev, __s32 *val);
 static int sd_setmin_clockdiv(struct gspca_dev *gspca_dev, __s32 val);
@@ -105,11 +116,13 @@ static int sd_getmin_clockdiv(struct gspca_dev *gspca_dev, __s32 *val);
 static void setbrightness(struct gspca_dev *gspca_dev);
 static void setexposure(struct gspca_dev *gspca_dev);
 static void setgain(struct gspca_dev *gspca_dev);
+static void setcontrast(struct gspca_dev *gspca_dev);
 
 /* V4L2 controls supported by the driver */
-static struct ctrl sd_ctrls[] = {
+static const struct ctrl sd_ctrls[] = {
 /* Separate brightness control description for Argus QuickClix as it has
-   different limits from the other mr97310a cameras */
+ * different limits from the other mr97310a cameras, and separate gain
+ * control for Sakar CyberPix camera. */
         {
 #define NORM_BRIGHTNESS_IDX 0
                 {
@@ -171,7 +184,37 @@ static struct ctrl sd_ctrls[] = {
                 .get = sd_getgain,
         },
         {
-#define MIN_CLOCKDIV_IDX 4
+#define SAKAR_CS_GAIN_IDX 4
+                {
+                        .id = V4L2_CID_GAIN,
+                        .type = V4L2_CTRL_TYPE_INTEGER,
+                        .name = "Gain",
+                        .minimum = MR97310A_CS_GAIN_MIN,
+                        .maximum = MR97310A_CS_GAIN_MAX,
+                        .step = 1,
+                        .default_value = MR97310A_CS_GAIN_DEFAULT,
+                        .flags = 0,
+                },
+                .set = sd_setgain,
+                .get = sd_getgain,
+        },
+        {
+#define CONTRAST_IDX 5
+                {
+                        .id = V4L2_CID_CONTRAST,
+                        .type = V4L2_CTRL_TYPE_INTEGER,
+                        .name = "Contrast",
+                        .minimum = MR97310A_CONTRAST_MIN,
+                        .maximum = MR97310A_CONTRAST_MAX,
+                        .step = 1,
+                        .default_value = MR97310A_CONTRAST_DEFAULT,
+                        .flags = 0,
+                },
+                .set = sd_setcontrast,
+                .get = sd_getcontrast,
+        },
+        {
+#define MIN_CLOCKDIV_IDX 6
                 {
                         .id = V4L2_CID_PRIVATE_BASE,
                         .type = V4L2_CTRL_TYPE_INTEGER,
@@ -327,7 +370,6 @@ static int zero_the_pointer(struct gspca_dev *gspca_dev)
         if (err_code < 0)
                 return err_code;
 
-        err_code = mr_write(gspca_dev, 1);
         data[0] = 0x19;
         data[1] = 0x51;
         err_code = mr_write(gspca_dev, 2);
@@ -437,6 +479,7 @@ static int sd_config(struct gspca_dev *gspca_dev,
 {
         struct sd *sd = (struct sd *) gspca_dev;
         struct cam *cam;
+        int gain_default = MR97310A_GAIN_DEFAULT;
         int err_code;
 
         cam = &gspca_dev->cam;
@@ -460,12 +503,14 @@ static int sd_config(struct gspca_dev *gspca_dev,
         if (err_code < 0)
                 return err_code;
 
+        /* Now, the query for sensor type. */
+        err_code = cam_get_response16(gspca_dev, 0x07, 1);
+        if (err_code < 0)
+                return err_code;
+
         if (id->idProduct == 0x0110 || id->idProduct == 0x010e) {
                 sd->cam_type = CAM_TYPE_CIF;
                 cam->nmodes--;
-                err_code = cam_get_response16(gspca_dev, 0x06, 1);
-                if (err_code < 0)
-                        return err_code;
                 /*
                  * All but one of the known CIF cameras share the same USB ID,
                  * but two different init routines are in use, and the control
@@ -473,12 +518,12 @@ static int sd_config(struct gspca_dev *gspca_dev,
                  * of the two known varieties is connected!
                  *
                  * A list of known CIF cameras follows. They all report either
-                 * 0002 for type 0 or 0003 for type 1.
+                 * 0200 for type 0 or 0300 for type 1.
                  * If you have another to report, please do
                  *
                  * Name         sd->sensor_type         reported by
                  *
-                 * Sakar Spy-shot       0               T. Kilgore
+                 * Sakar 56379 Spy-shot 0               T. Kilgore
                  * Innovage             0               T. Kilgore
                  * Vivitar Mini         0               H. De Goede
                  * Vivitar Mini         0               E. Rodriguez
@@ -487,7 +532,7 @@ static int sd_config(struct gspca_dev *gspca_dev,
                  * Philips dig. keych.  1               T. Kilgore
                  * Trust Spyc@m 100     1               A. Jacobs
                  */
-                switch (gspca_dev->usb_buf[1]) {
+                switch (gspca_dev->usb_buf[0]) {
                 case 2:
                         sd->sensor_type = 0;
                         break;
@@ -504,20 +549,19 @@ static int sd_config(struct gspca_dev *gspca_dev,
         } else {
                 sd->cam_type = CAM_TYPE_VGA;
 
-                err_code = cam_get_response16(gspca_dev, 0x07, 1);
-                if (err_code < 0)
-                        return err_code;
-
                 /*
-                 * Here is a table of the responses to the previous command
-                 * from the known MR97310A VGA cameras.
+                 * Here is a table of the responses to the query for sensor
+                 * type, from the known MR97310A VGA cameras. Six different
+                 * cameras of which five share the same USB ID.
                  *
                  * Name                 gspca_dev->usb_buf[]    sd->sensor_type
                  *                              sd->do_lcd_stop
                  * Aiptek Pencam VGA+   0300            0               1
-                 * ION digital          0350            0               1
+                 * ION digital          0300            0               1
                  * Argus DC-1620        0450            1               0
                  * Argus QuickClix      0420            1               1
+                 * Sakar 77379 Digital  0350            0               1
+                 * Sakar 1638x CyberPix 0120            0               2
                  *
                  * Based upon these results, we assume default settings
                  * and then correct as necessary, as follows.
@@ -527,10 +571,12 @@ static int sd_config(struct gspca_dev *gspca_dev,
                 sd->sensor_type = 1;
                 sd->do_lcd_stop = 0;
                 sd->adj_colors = 0;
-                if ((gspca_dev->usb_buf[0] != 0x03) &&
+                if (gspca_dev->usb_buf[0] == 0x01) {
+                        sd->sensor_type = 2;
+                } else if ((gspca_dev->usb_buf[0] != 0x03) &&
                                         (gspca_dev->usb_buf[0] != 0x04)) {
                         PDEBUG(D_ERR, "Unknown VGA Sensor id Byte 0: %02x",
-                                        gspca_dev->usb_buf[1]);
+                                        gspca_dev->usb_buf[0]);
                         PDEBUG(D_ERR, "Defaults assumed, may not work");
                         PDEBUG(D_ERR, "Please report this");
                 }
@@ -560,7 +606,7 @@ static int sd_config(struct gspca_dev *gspca_dev,
                 PDEBUG(D_PROBE, "MR97310A VGA camera detected, sensor: %d",
                        sd->sensor_type);
         }
-        /* Stop streaming as we've started it to probe the sensor type. */
+        /* Stop streaming as we've started it only to probe the sensor type. */
         sd_stopN(gspca_dev);
 
         if (force_sensor_type != -1) {
@@ -574,9 +620,13 @@ static int sd_config(struct gspca_dev *gspca_dev,
                 /* No brightness for sensor_type 0 */
                 if (sd->sensor_type == 0)
                         gspca_dev->ctrl_dis = (1 << NORM_BRIGHTNESS_IDX) |
-                                              (1 << ARGUS_QC_BRIGHTNESS_IDX);
+                                              (1 << ARGUS_QC_BRIGHTNESS_IDX) |
+                                              (1 << CONTRAST_IDX) |
+                                              (1 << SAKAR_CS_GAIN_IDX);
                 else
                         gspca_dev->ctrl_dis = (1 << ARGUS_QC_BRIGHTNESS_IDX) |
+                                              (1 << CONTRAST_IDX) |
+                                              (1 << SAKAR_CS_GAIN_IDX) |
                                               (1 << MIN_CLOCKDIV_IDX);
         } else {
                 /* All controls need to be disabled if VGA sensor_type is 0 */
@@ -585,17 +635,30 @@ static int sd_config(struct gspca_dev *gspca_dev,
                                               (1 << ARGUS_QC_BRIGHTNESS_IDX) |
                                               (1 << EXPOSURE_IDX) |
                                               (1 << GAIN_IDX) |
+                                              (1 << CONTRAST_IDX) |
+                                              (1 << SAKAR_CS_GAIN_IDX) |
                                               (1 << MIN_CLOCKDIV_IDX);
-                else if (sd->do_lcd_stop)
+                else if (sd->sensor_type == 2) {
+                        gspca_dev->ctrl_dis = (1 << NORM_BRIGHTNESS_IDX) |
+                                              (1 << ARGUS_QC_BRIGHTNESS_IDX) |
+                                              (1 << GAIN_IDX) |
+                                              (1 << MIN_CLOCKDIV_IDX);
+                        gain_default = MR97310A_CS_GAIN_DEFAULT;
+                } else if (sd->do_lcd_stop)
                         /* Argus QuickClix has different brightness limits */
-                        gspca_dev->ctrl_dis = (1 << NORM_BRIGHTNESS_IDX);
+                        gspca_dev->ctrl_dis = (1 << NORM_BRIGHTNESS_IDX) |
+                                              (1 << CONTRAST_IDX) |
+                                              (1 << SAKAR_CS_GAIN_IDX);
                 else
-                        gspca_dev->ctrl_dis = (1 << ARGUS_QC_BRIGHTNESS_IDX);
+                        gspca_dev->ctrl_dis = (1 << ARGUS_QC_BRIGHTNESS_IDX) |
+                                              (1 << CONTRAST_IDX) |
+                                              (1 << SAKAR_CS_GAIN_IDX);
         }
 
         sd->brightness = MR97310A_BRIGHTNESS_DEFAULT;
         sd->exposure = MR97310A_EXPOSURE_DEFAULT;
-        sd->gain = MR97310A_GAIN_DEFAULT;
+        sd->gain = gain_default;
+        sd->contrast = MR97310A_CONTRAST_DEFAULT;
         sd->min_clockdiv = MR97310A_MIN_CLOCKDIV_DEFAULT;
 
         return 0;
@@ -697,6 +760,12 @@ static int start_cif_cam(struct gspca_dev *gspca_dev)
                         {0x13, 0x00, {0x01}, 1},
                         {0, 0, {0}, 0}
                 };
+                /* Without this command the cam won't work with USB-UHCI */
+                gspca_dev->usb_buf[0] = 0x0a;
+                gspca_dev->usb_buf[1] = 0x00;
+                err_code = mr_write(gspca_dev, 2);
+                if (err_code < 0)
+                        return err_code;
                 err_code = sensor_write_regs(gspca_dev, cif_sensor1_init_data,
                                          ARRAY_SIZE(cif_sensor1_init_data));
         }
@@ -717,6 +786,10 @@ static int start_vga_cam(struct gspca_dev *gspca_dev)
                 data[5]  = 0x00;
                 data[10] = 0x91;
         }
+        if (sd->sensor_type == 2) {
+                data[5]  = 0x00;
+                data[10] = 0x18;
+        }
 
         switch (gspca_dev->width) {
         case 160:
@@ -731,6 +804,10 @@ static int start_vga_cam(struct gspca_dev *gspca_dev)
                 data[4] = 0x78;  /* reg 3, V size/4 */
                 data[6] = 0x04;  /* reg 5, H start */
                 data[8] = 0x03;  /* reg 7, V start */
+                if (sd->sensor_type == 2) {
+                        data[6] = 2;
+                        data[8] = 1;
+                }
                 if (sd->do_lcd_stop)
                         data[8] = 0x04;  /* Bayer tile shifted */
                 break;
@@ -753,7 +830,6 @@ static int start_vga_cam(struct gspca_dev *gspca_dev)
                 return err_code;
 
         if (!sd->sensor_type) {
-                /* The only known sensor_type 0 cam is the Argus DC-1620 */
                 const struct sensor_w_data vga_sensor0_init_data[] = {
                         {0x01, 0x00, {0x0c, 0x00, 0x04}, 3},
                         {0x14, 0x00, {0x01, 0xe4, 0x02, 0x84}, 4},
@@ -764,7 +840,7 @@ static int start_vga_cam(struct gspca_dev *gspca_dev)
                 };
                 err_code = sensor_write_regs(gspca_dev, vga_sensor0_init_data,
                                          ARRAY_SIZE(vga_sensor0_init_data));
-        } else {        /* sd->sensor_type = 1 */
+        } else if (sd->sensor_type == 1) {
                 const struct sensor_w_data color_adj[] = {
                         {0x02, 0x00, {0x06, 0x59, 0x0c, 0x16, 0x00,
                                 /* adjusted blue, green, red gain correct
@@ -802,6 +878,48 @@ static int start_vga_cam(struct gspca_dev *gspca_dev)
 
                 err_code = sensor_write_regs(gspca_dev, vga_sensor1_init_data,
                                          ARRAY_SIZE(vga_sensor1_init_data));
+        } else {        /* sensor type == 2 */
+                const struct sensor_w_data vga_sensor2_init_data[] = {
+
+                        {0x01, 0x00, {0x48}, 1},
+                        {0x02, 0x00, {0x22}, 1},
+                        /* Reg 3 msb and 4 is lsb of the exposure setting*/
+                        {0x05, 0x00, {0x10}, 1},
+                        {0x06, 0x00, {0x00}, 1},
+                        {0x07, 0x00, {0x00}, 1},
+                        {0x08, 0x00, {0x00}, 1},
+                        {0x09, 0x00, {0x00}, 1},
+                        /* The following are used in the gain control
+                         * which is BTW completely borked in the OEM driver
+                         * The values for each color go from 0 to 0x7ff
+                         *{0x0a, 0x00, {0x01}, 1},  green1 gain msb
+                         *{0x0b, 0x00, {0x10}, 1},  green1 gain lsb
+                         *{0x0c, 0x00, {0x01}, 1},  red gain msb
+                         *{0x0d, 0x00, {0x10}, 1},  red gain lsb
+                         *{0x0e, 0x00, {0x01}, 1},  blue gain msb
+                         *{0x0f, 0x00, {0x10}, 1},  blue gain lsb
+                         *{0x10, 0x00, {0x01}, 1}, green2 gain msb
+                         *{0x11, 0x00, {0x10}, 1}, green2 gain lsb
+                         */
+                        {0x12, 0x00, {0x00}, 1},
+                        {0x13, 0x00, {0x04}, 1}, /* weird effect on colors */
+                        {0x14, 0x00, {0x00}, 1},
+                        {0x15, 0x00, {0x06}, 1},
+                        {0x16, 0x00, {0x01}, 1},
+                        {0x17, 0x00, {0xe2}, 1}, /* vertical alignment */
+                        {0x18, 0x00, {0x02}, 1},
+                        {0x19, 0x00, {0x82}, 1}, /* don't mess with */
+                        {0x1a, 0x00, {0x00}, 1},
+                        {0x1b, 0x00, {0x20}, 1},
+                        /* {0x1c, 0x00, {0x17}, 1}, contrast control */
+                        {0x1d, 0x00, {0x80}, 1}, /* moving causes a mess */
+                        {0x1e, 0x00, {0x08}, 1}, /* moving jams the camera */
+                        {0x1f, 0x00, {0x0c}, 1},
+                        {0x20, 0x00, {0x00}, 1},
+                        {0, 0, {0}, 0}
+                };
+                err_code = sensor_write_regs(gspca_dev, vga_sensor2_init_data,
+                                         ARRAY_SIZE(vga_sensor2_init_data));
         }
         return err_code;
 }
@@ -834,6 +952,7 @@ static int sd_start(struct gspca_dev *gspca_dev)
                 return err_code;
 
         setbrightness(gspca_dev);
+        setcontrast(gspca_dev);
         setexposure(gspca_dev);
         setgain(gspca_dev);
 
@@ -893,7 +1012,7 @@ static void setbrightness(struct gspca_dev *gspca_dev)
 static void setexposure(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
-        int exposure;
+        int exposure = MR97310A_EXPOSURE_DEFAULT;
         u8 buf[2];
 
         if (gspca_dev->ctrl_dis & (1 << EXPOSURE_IDX))
@@ -905,6 +1024,11 @@ static void setexposure(struct gspca_dev *gspca_dev)
                 exposure = (sd->exposure * 9267) / 10000 + 300;
                 sensor_write1(gspca_dev, 3, exposure >> 4);
                 sensor_write1(gspca_dev, 4, exposure & 0x0f);
+        } else if (sd->sensor_type == 2) {
+                exposure = sd->exposure;
+                exposure >>= 3;
+                sensor_write1(gspca_dev, 3, exposure >> 8);
+                sensor_write1(gspca_dev, 4, exposure & 0xff);
         } else {
                 /* We have both a clock divider and an exposure register.
                    We first calculate the clock divider, as that determines
@@ -943,17 +1067,34 @@ static void setexposure(struct gspca_dev *gspca_dev)
 static void setgain(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
+        u8 gainreg;
 
-        if (gspca_dev->ctrl_dis & (1 << GAIN_IDX))
+        if ((gspca_dev->ctrl_dis & (1 << GAIN_IDX)) &&
+            (gspca_dev->ctrl_dis & (1 << SAKAR_CS_GAIN_IDX)))
                 return;
 
-        if (sd->cam_type == CAM_TYPE_CIF && sd->sensor_type == 1) {
+        if (sd->cam_type == CAM_TYPE_CIF && sd->sensor_type == 1)
                 sensor_write1(gspca_dev, 0x0e, sd->gain);
-        } else {
+        else if (sd->cam_type == CAM_TYPE_VGA && sd->sensor_type == 2)
+                for (gainreg = 0x0a; gainreg < 0x11; gainreg += 2) {
+                        sensor_write1(gspca_dev, gainreg, sd->gain >> 8);
+                        sensor_write1(gspca_dev, gainreg + 1, sd->gain & 0xff);
+                }
+        else
                 sensor_write1(gspca_dev, 0x10, sd->gain);
-        }
 }
 
+static void setcontrast(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        if (gspca_dev->ctrl_dis & (1 << CONTRAST_IDX))
+                return;
+
+        sensor_write1(gspca_dev, 0x1c, sd->contrast);
+}
+
+
 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
 {
         struct sd *sd = (struct sd *) gspca_dev;
@@ -1008,6 +1149,25 @@ static int sd_getgain(struct gspca_dev *gspca_dev, __s32 *val)
         return 0;
 }
 
+static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        sd->contrast = val;
+        if (gspca_dev->streaming)
+                setcontrast(gspca_dev);
+        return 0;
+}
+
+
+static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        *val = sd->contrast;
+        return 0;
+}
+
 static int sd_setmin_clockdiv(struct gspca_dev *gspca_dev, __s32 val)
 {
         struct sd *sd = (struct sd *) gspca_dev;
diff --git a/drivers/media/video/gspca/ov519.c b/drivers/media/video/gspca/ov519.c
index b4f965731244..bc4ced6c013b 100644
--- a/drivers/media/video/gspca/ov519.c
+++ b/drivers/media/video/gspca/ov519.c
@@ -38,6 +38,7 @@
  */
 #define MODULE_NAME "ov519"
 
+#include <linux/input.h>
 #include "gspca.h"
 
 MODULE_AUTHOR("Jean-Francois Moine <http://moinejf.free.fr>");
@@ -70,6 +71,9 @@ struct sd {
         char invert_led;
 #define BRIDGE_INVERT_LED       8
 
+        char snapshot_pressed;
+        char snapshot_needs_reset;
+
         /* Determined by sensor type */
         __u8 sif;
 
@@ -99,10 +103,12 @@ struct sd {
 #define SEN_OV66308AF 5
 #define SEN_OV7610 6
 #define SEN_OV7620 7
-#define SEN_OV7640 8
-#define SEN_OV7670 9
-#define SEN_OV76BE 10
-#define SEN_OV8610 11
+#define SEN_OV7620AE 8
+#define SEN_OV7640 9
+#define SEN_OV7648 10
+#define SEN_OV7670 11
+#define SEN_OV76BE 12
+#define SEN_OV8610 13
 
         u8 sensor_addr;
         int sensor_width;
@@ -139,6 +145,7 @@ static void setautobrightness(struct sd *sd);
 static void setfreq(struct sd *sd);
 
 static const struct ctrl sd_ctrls[] = {
+#define BRIGHTNESS_IDX 0
         {
             {
                 .id      = V4L2_CID_BRIGHTNESS,
@@ -153,6 +160,7 @@ static const struct ctrl sd_ctrls[] = {
             .set = sd_setbrightness,
             .get = sd_getbrightness,
         },
+#define CONTRAST_IDX 1
         {
             {
                 .id      = V4L2_CID_CONTRAST,
@@ -167,6 +175,7 @@ static const struct ctrl sd_ctrls[] = {
             .set = sd_setcontrast,
             .get = sd_getcontrast,
         },
+#define COLOR_IDX 2
         {
             {
                 .id      = V4L2_CID_SATURATION,
@@ -2554,7 +2563,7 @@ static int ov7xx0_configure(struct sd *sd)
                 /* I don't know what's different about the 76BE yet. */
                 if (i2c_r(sd, 0x15) & 1) {
                         PDEBUG(D_PROBE, "Sensor is an OV7620AE");
-                        sd->sensor = SEN_OV7620;
+                        sd->sensor = SEN_OV7620AE;
                 } else {
                         PDEBUG(D_PROBE, "Sensor is an OV76BE");
                         sd->sensor = SEN_OV76BE;
@@ -2588,7 +2597,7 @@ static int ov7xx0_configure(struct sd *sd)
                                 break;
                         case 0x48:
                                 PDEBUG(D_PROBE, "Sensor is an OV7648");
-                                sd->sensor = SEN_OV7640; /* FIXME */
+                                sd->sensor = SEN_OV7648;
                                 break;
                         default:
                                 PDEBUG(D_PROBE, "Unknown sensor: 0x76%x", low);
@@ -2680,6 +2689,36 @@ static void ov51x_led_control(struct sd *sd, int on)
         }
 }
 
+static void sd_reset_snapshot(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        if (!sd->snapshot_needs_reset)
+                return;
+
+        /* Note it is important that we clear sd->snapshot_needs_reset,
+           before actually clearing the snapshot state in the bridge
+           otherwise we might race with the pkt_scan interrupt handler */
+        sd->snapshot_needs_reset = 0;
+
+        switch (sd->bridge) {
+        case BRIDGE_OV511:
+        case BRIDGE_OV511PLUS:
+                reg_w(sd, R51x_SYS_SNAP, 0x02);
+                reg_w(sd, R51x_SYS_SNAP, 0x00);
+                break;
+        case BRIDGE_OV518:
+        case BRIDGE_OV518PLUS:
+                reg_w(sd, R51x_SYS_SNAP, 0x02); /* Reset */
+                reg_w(sd, R51x_SYS_SNAP, 0x01); /* Enable */
+                break;
+        case BRIDGE_OV519:
+                reg_w(sd, R51x_SYS_RESET, 0x40);
+                reg_w(sd, R51x_SYS_RESET, 0x00);
+                break;
+        }
+}
+
 static int ov51x_upload_quan_tables(struct sd *sd)
 {
         const unsigned char yQuanTable511[] = {
@@ -3115,7 +3154,11 @@ static int sd_config(struct gspca_dev *gspca_dev,
                                       (1 << OV7670_FREQ_IDX);
         }
         sd->quality = QUALITY_DEF;
-        if (sd->sensor == SEN_OV7640 || sd->sensor == SEN_OV7670)
+        if (sd->sensor == SEN_OV7640 ||
+            sd->sensor == SEN_OV7648)
+                gspca_dev->ctrl_dis |= (1 << AUTOBRIGHT_IDX) |
+                                       (1 << CONTRAST_IDX);
+        if (sd->sensor == SEN_OV7670)
                 gspca_dev->ctrl_dis |= 1 << AUTOBRIGHT_IDX;
         /* OV8610 Frequency filter control should work but needs testing */
         if (sd->sensor == SEN_OV8610)
@@ -3169,10 +3212,12 @@ static int sd_init(struct gspca_dev *gspca_dev)
                         return -EIO;
                 break;
         case SEN_OV7620:
+        case SEN_OV7620AE:
                 if (write_i2c_regvals(sd, norm_7620, ARRAY_SIZE(norm_7620)))
                         return -EIO;
                 break;
         case SEN_OV7640:
+        case SEN_OV7648:
                 if (write_i2c_regvals(sd, norm_7640, ARRAY_SIZE(norm_7640)))
                         return -EIO;
                 break;
@@ -3246,7 +3291,9 @@ static int ov511_mode_init_regs(struct sd *sd)
         /* Note once the FIXME's in mode_init_ov_sensor_regs() are fixed
            for more sensors we need to do this for them too */
         case SEN_OV7620:
+        case SEN_OV7620AE:
         case SEN_OV7640:
+        case SEN_OV7648:
         case SEN_OV76BE:
                 if (sd->gspca_dev.width == 320)
                         interlaced = 1;
@@ -3377,7 +3424,7 @@ static int ov518_mode_init_regs(struct sd *sd)
 
         if (sd->bridge == BRIDGE_OV518PLUS) {
                 switch (sd->sensor) {
-                case SEN_OV7620:
+                case SEN_OV7620AE:
                         if (sd->gspca_dev.width == 320) {
                                 reg_w(sd, 0x20, 0x00);
                                 reg_w(sd, 0x21, 0x19);
@@ -3386,6 +3433,10 @@ static int ov518_mode_init_regs(struct sd *sd)
                                 reg_w(sd, 0x21, 0x1f);
                         }
                         break;
+                case SEN_OV7620:
+                        reg_w(sd, 0x20, 0x00);
+                        reg_w(sd, 0x21, 0x19);
+                        break;
                 default:
                         reg_w(sd, 0x21, 0x19);
                 }
@@ -3488,7 +3539,8 @@ static int ov519_mode_init_regs(struct sd *sd)
                 if (write_regvals(sd, mode_init_519,
                                   ARRAY_SIZE(mode_init_519)))
                         return -EIO;
-                if (sd->sensor == SEN_OV7640) {
+                if (sd->sensor == SEN_OV7640 ||
+                    sd->sensor == SEN_OV7648) {
                         /* Select 8-bit input mode */
                         reg_w_mask(sd, OV519_R20_DFR, 0x10, 0x10);
                 }
@@ -3503,6 +3555,9 @@ static int ov519_mode_init_regs(struct sd *sd)
         if (sd->sensor == SEN_OV7670 &&
             sd->gspca_dev.cam.cam_mode[sd->gspca_dev.curr_mode].priv)
                 reg_w(sd, OV519_R12_X_OFFSETL, 0x04);
+        else if (sd->sensor == SEN_OV7648 &&
+            sd->gspca_dev.cam.cam_mode[sd->gspca_dev.curr_mode].priv)
+                reg_w(sd, OV519_R12_X_OFFSETL, 0x01);
         else
                 reg_w(sd, OV519_R12_X_OFFSETL, 0x00);
         reg_w(sd, OV519_R13_X_OFFSETH,  0x00);
@@ -3520,6 +3575,7 @@ static int ov519_mode_init_regs(struct sd *sd)
         sd->clockdiv = 0;
         switch (sd->sensor) {
         case SEN_OV7640:
+        case SEN_OV7648:
                 switch (sd->frame_rate) {
                 default:
 /*              case 30: */
@@ -3649,6 +3705,7 @@ static int mode_init_ov_sensor_regs(struct sd *sd)
                 i2c_w_mask(sd, 0x12, 0x04, 0x06); /* AWB: 1 Test pattern: 0 */
                 break;
         case SEN_OV7620:
+        case SEN_OV7620AE:
         case SEN_OV76BE:
                 i2c_w_mask(sd, 0x14, qvga ? 0x20 : 0x00, 0x20);
                 i2c_w_mask(sd, 0x28, qvga ? 0x00 : 0x20, 0x20);
@@ -3663,13 +3720,16 @@ static int mode_init_ov_sensor_regs(struct sd *sd)
                         i2c_w(sd, 0x35, qvga ? 0x1e : 0x9e);
                 break;
         case SEN_OV7640:
+        case SEN_OV7648:
                 i2c_w_mask(sd, 0x14, qvga ? 0x20 : 0x00, 0x20);
                 i2c_w_mask(sd, 0x28, qvga ? 0x00 : 0x20, 0x20);
-/*              i2c_w(sd, 0x24, qvga ? 0x20 : 0x3a); */
-/*              i2c_w(sd, 0x25, qvga ? 0x30 : 0x60); */
-/*              i2c_w_mask(sd, 0x2d, qvga ? 0x40 : 0x00, 0x40); */
-/*              i2c_w_mask(sd, 0x67, qvga ? 0xf0 : 0x90, 0xf0); */
-/*              i2c_w_mask(sd, 0x74, qvga ? 0x20 : 0x00, 0x20); */
+                /* Setting this undocumented bit in qvga mode removes a very
+                   annoying vertical shaking of the image */
+                i2c_w_mask(sd, 0x2d, qvga ? 0x40 : 0x00, 0x40);
+                /* Unknown */
+                i2c_w_mask(sd, 0x67, qvga ? 0xf0 : 0x90, 0xf0);
+                /* Allow higher automatic gain (to allow higher framerates) */
+                i2c_w_mask(sd, 0x74, qvga ? 0x20 : 0x00, 0x20);
                 i2c_w_mask(sd, 0x12, 0x04, 0x04); /* AWB: 1 */
                 break;
         case SEN_OV7670:
@@ -3795,11 +3855,13 @@ static int set_ov_sensor_window(struct sd *sd)
                 }
                 break;
         case SEN_OV7620:
+        case SEN_OV7620AE:
                 hwsbase = 0x2f;         /* From 7620.SET (spec is wrong) */
                 hwebase = 0x2f;
                 vwsbase = vwebase = 0x05;
                 break;
         case SEN_OV7640:
+        case SEN_OV7648:
                 hwsbase = 0x1a;
                 hwebase = 0x1a;
                 vwsbase = vwebase = 0x03;
@@ -3893,6 +3955,12 @@ static int sd_start(struct gspca_dev *gspca_dev)
         setautobrightness(sd);
         setfreq(sd);
 
+        /* Force clear snapshot state in case the snapshot button was
+           pressed while we weren't streaming */
+        sd->snapshot_needs_reset = 1;
+        sd_reset_snapshot(gspca_dev);
+        sd->snapshot_pressed = 0;
+
         ret = ov51x_restart(sd);
         if (ret < 0)
                 goto out;
@@ -3919,6 +3987,34 @@ static void sd_stop0(struct gspca_dev *gspca_dev)
                 w9968cf_stop0(sd);
 }
 
+static void ov51x_handle_button(struct gspca_dev *gspca_dev, u8 state)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        if (sd->snapshot_pressed != state) {
+#ifdef CONFIG_INPUT
+                input_report_key(gspca_dev->input_dev, KEY_CAMERA, state);
+                input_sync(gspca_dev->input_dev);
+#endif
+                if (state)
+                        sd->snapshot_needs_reset = 1;
+
+                sd->snapshot_pressed = state;
+        } else {
+                /* On the ov511 / ov519 we need to reset the button state
+                   multiple times, as resetting does not work as long as the
+                   button stays pressed */
+                switch (sd->bridge) {
+                case BRIDGE_OV511:
+                case BRIDGE_OV511PLUS:
+                case BRIDGE_OV519:
+                        if (state)
+                                sd->snapshot_needs_reset = 1;
+                        break;
+                }
+        }
+}
+
 static void ov511_pkt_scan(struct gspca_dev *gspca_dev,
                         u8 *in,                 /* isoc packet */
                         int len)                /* iso packet length */
@@ -3940,6 +4036,7 @@ static void ov511_pkt_scan(struct gspca_dev *gspca_dev,
          */
         if (!(in[0] | in[1] | in[2] | in[3] | in[4] | in[5] | in[6] | in[7]) &&
             (in[8] & 0x08)) {
+                ov51x_handle_button(gspca_dev, (in[8] >> 2) & 1);
                 if (in[8] & 0x80) {
                         /* Frame end */
                         if ((in[9] + 1) * 8 != gspca_dev->width ||
@@ -3977,6 +4074,7 @@ static void ov518_pkt_scan(struct gspca_dev *gspca_dev,
         /* A false positive here is likely, until OVT gives me
          * the definitive SOF/EOF format */
         if ((!(data[0] | data[1] | data[2] | data[3] | data[5])) && data[6]) {
+                ov51x_handle_button(gspca_dev, (data[6] >> 1) & 1);
                 gspca_frame_add(gspca_dev, LAST_PACKET, NULL, 0);
                 gspca_frame_add(gspca_dev, FIRST_PACKET, NULL, 0);
                 sd->packet_nr = 0;
@@ -4024,6 +4122,9 @@ static void ov519_pkt_scan(struct gspca_dev *gspca_dev,
         if (data[0] == 0xff && data[1] == 0xff && data[2] == 0xff) {
                 switch (data[3]) {
                 case 0x50:              /* start of frame */
+                        /* Don't check the button state here, as the state
+                           usually (always ?) changes at EOF and checking it
+                           here leads to unnecessary snapshot state resets. */
 #define HDRSZ 16
                         data += HDRSZ;
                         len -= HDRSZ;
@@ -4035,6 +4136,7 @@ static void ov519_pkt_scan(struct gspca_dev *gspca_dev,
                                 gspca_dev->last_packet_type = DISCARD_PACKET;
                         return;
                 case 0x51:              /* end of frame */
+                        ov51x_handle_button(gspca_dev, data[11] & 1);
                         if (data[9] != 0)
                                 gspca_dev->last_packet_type = DISCARD_PACKET;
                         gspca_frame_add(gspca_dev, LAST_PACKET,
@@ -4103,9 +4205,11 @@ static void setbrightness(struct gspca_dev *gspca_dev)
         case SEN_OV6630:
         case SEN_OV66308AF:
         case SEN_OV7640:
+        case SEN_OV7648:
                 i2c_w(sd, OV7610_REG_BRT, val);
                 break;
         case SEN_OV7620:
+        case SEN_OV7620AE:
                 /* 7620 doesn't like manual changes when in auto mode */
                 if (!sd->autobrightness)
                         i2c_w(sd, OV7610_REG_BRT, val);
@@ -4142,7 +4246,8 @@ static void setcontrast(struct gspca_dev *gspca_dev)
                 i2c_w(sd, 0x64, ctab[val >> 5]);
                 break;
             }
-        case SEN_OV7620: {
+        case SEN_OV7620:
+        case SEN_OV7620AE: {
                 static const __u8 ctab[] = {
                         0x01, 0x05, 0x09, 0x11, 0x15, 0x35, 0x37, 0x57,
                         0x5b, 0xa5, 0xa7, 0xc7, 0xc9, 0xcf, 0xef, 0xff
@@ -4152,10 +4257,6 @@ static void setcontrast(struct gspca_dev *gspca_dev)
                 i2c_w(sd, 0x64, ctab[val >> 4]);
                 break;
             }
-        case SEN_OV7640:
-                /* Use gain control instead. */
-                i2c_w(sd, OV7610_REG_GAIN, val >> 2);
-                break;
         case SEN_OV7670:
                 /* check that this isn't just the same as ov7610 */
                 i2c_w(sd, OV7670_REG_CONTRAS, val >> 1);
@@ -4179,6 +4280,7 @@ static void setcolors(struct gspca_dev *gspca_dev)
                 i2c_w(sd, OV7610_REG_SAT, val);
                 break;
         case SEN_OV7620:
+        case SEN_OV7620AE:
                 /* Use UV gamma control instead. Bits 0 & 7 are reserved. */
 /*              rc = ov_i2c_write(sd->dev, 0x62, (val >> 9) & 0x7e);
                 if (rc < 0)
@@ -4186,6 +4288,7 @@ static void setcolors(struct gspca_dev *gspca_dev)
                 i2c_w(sd, OV7610_REG_SAT, val);
                 break;
         case SEN_OV7640:
+        case SEN_OV7648:
                 i2c_w(sd, OV7610_REG_SAT, val & 0xf0);
                 break;
         case SEN_OV7670:
@@ -4198,7 +4301,8 @@ static void setcolors(struct gspca_dev *gspca_dev)
 
 static void setautobrightness(struct sd *sd)
 {
-        if (sd->sensor == SEN_OV7640 || sd->sensor == SEN_OV7670 ||
+        if (sd->sensor == SEN_OV7640 || sd->sensor == SEN_OV7648 ||
+            sd->sensor == SEN_OV7670 ||
             sd->sensor == SEN_OV2610 || sd->sensor == SEN_OV3610)
                 return;
 
@@ -4475,9 +4579,13 @@ static const struct sd_desc sd_desc = {
         .stopN = sd_stopN,
         .stop0 = sd_stop0,
         .pkt_scan = sd_pkt_scan,
+        .dq_callback = sd_reset_snapshot,
         .querymenu = sd_querymenu,
         .get_jcomp = sd_get_jcomp,
         .set_jcomp = sd_set_jcomp,
+#ifdef CONFIG_INPUT
+        .other_input = 1,
+#endif
 };
 
 /* -- module initialisation -- */
@@ -4494,7 +4602,8 @@ static const __devinitdata struct usb_device_id device_table[] = {
          .driver_info = BRIDGE_OV519 | BRIDGE_INVERT_LED },
         {USB_DEVICE(0x045e, 0x028c), .driver_info = BRIDGE_OV519 },
         {USB_DEVICE(0x054c, 0x0154), .driver_info = BRIDGE_OV519 },
-        {USB_DEVICE(0x054c, 0x0155), .driver_info = BRIDGE_OV519 },
+        {USB_DEVICE(0x054c, 0x0155),
+         .driver_info = BRIDGE_OV519 | BRIDGE_INVERT_LED },
         {USB_DEVICE(0x05a9, 0x0511), .driver_info = BRIDGE_OV511 },
         {USB_DEVICE(0x05a9, 0x0518), .driver_info = BRIDGE_OV518 },
         {USB_DEVICE(0x05a9, 0x0519), .driver_info = BRIDGE_OV519 },
diff --git a/drivers/media/video/gspca/ov534.c b/drivers/media/video/gspca/ov534.c
index 0a6b8f07a69d..957e05e2d08f 100644
--- a/drivers/media/video/gspca/ov534.c
+++ b/drivers/media/video/gspca/ov534.c
@@ -1,5 +1,5 @@
 /*
- * ov534 gspca driver
+ * ov534-ov772x gspca driver
  *
  * Copyright (C) 2008 Antonio Ospite <ospite@studenti.unina.it>
  * Copyright (C) 2008 Jim Paris <jim@jtan.com>
@@ -68,12 +68,7 @@ struct sd {
         s8 sharpness;
         u8 hflip;
         u8 vflip;
-        u8 satur;
-        u8 lightfreq;
 
-        u8 sensor;
-#define SENSOR_OV772X 0
-#define SENSOR_OV965X 1
 };
 
 /* V4L2 controls supported by the driver */
@@ -101,12 +96,8 @@ static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val);
 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val);
 static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val);
 static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val);
-static int sd_setsatur(struct gspca_dev *gspca_dev, __s32 val);
-static int sd_getsatur(struct gspca_dev *gspca_dev, __s32 *val);
-static int sd_setfreq(struct gspca_dev *gspca_dev, __s32 val);
-static int sd_getfreq(struct gspca_dev *gspca_dev, __s32 *val);
 
-static struct ctrl sd_ctrls_ov772x[] = {
+static const struct ctrl sd_ctrls[] = {
     {                                                   /* 0 */
         {
                 .id      = V4L2_CID_BRIGHTNESS,
@@ -115,8 +106,8 @@ static struct ctrl sd_ctrls_ov772x[] = {
                 .minimum = 0,
                 .maximum = 255,
                 .step    = 1,
-#define BRIGHTNESS_77_DEF 20
-                .default_value = BRIGHTNESS_77_DEF,
+#define BRIGHTNESS_DEF 20
+                .default_value = BRIGHTNESS_DEF,
         },
         .set = sd_setbrightness,
         .get = sd_getbrightness,
@@ -129,8 +120,8 @@ static struct ctrl sd_ctrls_ov772x[] = {
                 .minimum = 0,
                 .maximum = 255,
                 .step    = 1,
-#define CONTRAST_77_DEF 37
-                .default_value = CONTRAST_77_DEF,
+#define CONTRAST_DEF 37
+                .default_value = CONTRAST_DEF,
         },
         .set = sd_setcontrast,
         .get = sd_getcontrast,
@@ -157,8 +148,8 @@ static struct ctrl sd_ctrls_ov772x[] = {
             .minimum = 0,
             .maximum = 255,
             .step    = 1,
-#define EXPO_77_DEF 120
-            .default_value = EXPO_77_DEF,
+#define EXPO_DEF 120
+            .default_value = EXPO_DEF,
         },
         .set = sd_setexposure,
         .get = sd_getexposure,
@@ -213,13 +204,13 @@ static struct ctrl sd_ctrls_ov772x[] = {
             .minimum = 0,
             .maximum = 1,
             .step    = 1,
-#define AUTOGAIN_77_DEF 0
-            .default_value = AUTOGAIN_77_DEF,
+#define AUTOGAIN_DEF 0
+            .default_value = AUTOGAIN_DEF,
         },
         .set = sd_setautogain,
         .get = sd_getautogain,
     },
-#define AWB_77_IDX 8
+#define AWB_IDX 8
     {                                                   /* 8 */
         {
                 .id      = V4L2_CID_AUTO_WHITE_BALANCE,
@@ -242,8 +233,8 @@ static struct ctrl sd_ctrls_ov772x[] = {
             .minimum = 0,
             .maximum = 63,
             .step    = 1,
-#define SHARPNESS_77_DEF 0
-            .default_value = SHARPNESS_77_DEF,
+#define SHARPNESS_DEF 0
+            .default_value = SHARPNESS_DEF,
         },
         .set = sd_setsharpness,
         .get = sd_getsharpness,
@@ -277,107 +268,6 @@ static struct ctrl sd_ctrls_ov772x[] = {
         .get = sd_getvflip,
     },
 };
-static struct ctrl sd_ctrls_ov965x[] = {
-    {                                                   /* 0 */
-        {
-                .id      = V4L2_CID_BRIGHTNESS,
-                .type    = V4L2_CTRL_TYPE_INTEGER,
-                .name    = "Brightness",
-                .minimum = 0,
-                .maximum = 15,
-                .step    = 1,
-#define BRIGHTNESS_96_DEF 7
-                .default_value = BRIGHTNESS_96_DEF,
-        },
-        .set = sd_setbrightness,
-        .get = sd_getbrightness,
-    },
-    {                                                   /* 1 */
-        {
-                .id      = V4L2_CID_CONTRAST,
-                .type    = V4L2_CTRL_TYPE_INTEGER,
-                .name    = "Contrast",
-                .minimum = 0,
-                .maximum = 15,
-                .step    = 1,
-#define CONTRAST_96_DEF 3
-                .default_value = CONTRAST_96_DEF,
-        },
-        .set = sd_setcontrast,
-        .get = sd_getcontrast,
-    },
-    {                                                   /* 2 */
-        {
-            .id      = V4L2_CID_AUTOGAIN,
-            .type    = V4L2_CTRL_TYPE_BOOLEAN,
-            .name    = "Autogain",
-            .minimum = 0,
-            .maximum = 1,
-            .step    = 1,
-#define AUTOGAIN_96_DEF 1
-            .default_value = AUTOGAIN_96_DEF,
-        },
-        .set = sd_setautogain,
-        .get = sd_getautogain,
-    },
-#define EXPO_96_IDX 3
-    {                                                   /* 3 */
-        {
-            .id      = V4L2_CID_EXPOSURE,
-            .type    = V4L2_CTRL_TYPE_INTEGER,
-            .name    = "Exposure",
-            .minimum = 0,
-            .maximum = 3,
-            .step    = 1,
-#define EXPO_96_DEF 0
-            .default_value = EXPO_96_DEF,
-        },
-        .set = sd_setexposure,
-        .get = sd_getexposure,
-    },
-    {                                                   /* 4 */
-        {
-            .id      = V4L2_CID_SHARPNESS,
-            .type    = V4L2_CTRL_TYPE_INTEGER,
-            .name    = "Sharpness",
-            .minimum = -1,              /* -1 = auto */
-            .maximum = 4,
-            .step    = 1,
-#define SHARPNESS_96_DEF -1
-            .default_value = SHARPNESS_96_DEF,
-        },
-        .set = sd_setsharpness,
-        .get = sd_getsharpness,
-    },
-    {                                                   /* 5 */
-        {
-                .id      = V4L2_CID_SATURATION,
-                .type    = V4L2_CTRL_TYPE_INTEGER,
-                .name    = "Saturation",
-                .minimum = 0,
-                .maximum = 4,
-                .step    = 1,
-#define SATUR_DEF 2
-                .default_value = SATUR_DEF,
-        },
-        .set = sd_setsatur,
-        .get = sd_getsatur,
-    },
-    {
-        {
-                .id      = V4L2_CID_POWER_LINE_FREQUENCY,
-                .type    = V4L2_CTRL_TYPE_MENU,
-                .name    = "Light frequency filter",
-                .minimum = 0,
-                .maximum = 2,   /* 0: 0, 1: 50Hz, 2:60Hz */
-                .step    = 1,
-#define FREQ_DEF 0
-                .default_value = FREQ_DEF,
-        },
-        .set = sd_setfreq,
-        .get = sd_getfreq,
-    },
-};
 
 static const struct v4l2_pix_format ov772x_mode[] = {
         {320, 240, V4L2_PIX_FMT_YUYV, V4L2_FIELD_NONE,
@@ -392,35 +282,21 @@ static const struct v4l2_pix_format ov772x_mode[] = {
          .priv = 0},
 };
 
-static const struct v4l2_pix_format ov965x_mode[] = {
-        {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
-         .bytesperline = 320,
-         .sizeimage = 320 * 240 * 3 / 8 + 590,
-         .colorspace = V4L2_COLORSPACE_JPEG,
-         .priv = 4},
-        {640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
-         .bytesperline = 640,
-         .sizeimage = 640 * 480 * 3 / 8 + 590,
-         .colorspace = V4L2_COLORSPACE_JPEG,
-         .priv = 3},
-        {800, 600, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
-         .bytesperline = 800,
-         .sizeimage = 800 * 600 * 3 / 8 + 590,
-         .colorspace = V4L2_COLORSPACE_JPEG,
-         .priv = 2},
-        {1024, 768, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
-         .bytesperline = 1024,
-         .sizeimage = 1024 * 768 * 3 / 8 + 590,
-         .colorspace = V4L2_COLORSPACE_JPEG,
-         .priv = 1},
-        {1280, 1024, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
-         .bytesperline = 1280,
-         .sizeimage = 1280 * 1024 * 3 / 8 + 590,
-         .colorspace = V4L2_COLORSPACE_JPEG,
-         .priv = 0},
+static const u8 qvga_rates[] = {125, 100, 75, 60, 50, 40, 30};
+static const u8 vga_rates[] = {60, 50, 40, 30, 15};
+
+static const struct framerates ov772x_framerates[] = {
+        { /* 320x240 */
+                .rates = qvga_rates,
+                .nrates = ARRAY_SIZE(qvga_rates),
+        },
+        { /* 640x480 */
+                .rates = vga_rates,
+                .nrates = ARRAY_SIZE(vga_rates),
+        },
 };
 
-static const u8 bridge_init_ov772x[][2] = {
+static const u8 bridge_init[][2] = {
         { 0xc2, 0x0c },
         { 0x88, 0xf8 },
         { 0xc3, 0x69 },
@@ -478,7 +354,7 @@ static const u8 bridge_init_ov772x[][2] = {
         { 0xc1, 0x3c },
         { 0xc2, 0x0c },
 };
-static const u8 sensor_init_ov772x[][2] = {
+static const u8 sensor_init[][2] = {
         { 0x12, 0x80 },
         { 0x11, 0x01 },
 /*fixme: better have a delay?*/
@@ -571,7 +447,7 @@ static const u8 sensor_init_ov772x[][2] = {
         { 0x8e, 0x00 },         /* De-noise threshold */
         { 0x0c, 0xd0 }
 };
-static const u8 bridge_start_ov772x_vga[][2] = {
+static const u8 bridge_start_vga[][2] = {
         {0x1c, 0x00},
         {0x1d, 0x40},
         {0x1d, 0x02},
@@ -582,7 +458,7 @@ static const u8 bridge_start_ov772x_vga[][2] = {
         {0xc0, 0x50},
         {0xc1, 0x3c},
 };
-static const u8 sensor_start_ov772x_vga[][2] = {
+static const u8 sensor_start_vga[][2] = {
         {0x12, 0x00},
         {0x17, 0x26},
         {0x18, 0xa0},
@@ -592,7 +468,7 @@ static const u8 sensor_start_ov772x_vga[][2] = {
         {0x2c, 0xf0},
         {0x65, 0x20},
 };
-static const u8 bridge_start_ov772x_qvga[][2] = {
+static const u8 bridge_start_qvga[][2] = {
         {0x1c, 0x00},
         {0x1d, 0x40},
         {0x1d, 0x02},
@@ -603,7 +479,7 @@ static const u8 bridge_start_ov772x_qvga[][2] = {
         {0xc0, 0x28},
         {0xc1, 0x1e},
 };
-static const u8 sensor_start_ov772x_qvga[][2] = {
+static const u8 sensor_start_qvga[][2] = {
         {0x12, 0x40},
         {0x17, 0x3f},
         {0x18, 0x50},
@@ -614,571 +490,6 @@ static const u8 sensor_start_ov772x_qvga[][2] = {
         {0x65, 0x2f},
 };
 
-static const u8 bridge_init_ov965x[][2] = {
-        {0x88, 0xf8},
-        {0x89, 0xff},
-        {0x76, 0x03},
-        {0x92, 0x03},
-        {0x95, 0x10},
-        {0xe2, 0x00},
-        {0xe7, 0x3e},
-        {0x8d, 0x1c},
-        {0x8e, 0x00},
-        {0x8f, 0x00},
-        {0x1f, 0x00},
-        {0xc3, 0xf9},
-        {0x89, 0xff},
-        {0x88, 0xf8},
-        {0x76, 0x03},
-        {0x92, 0x01},
-        {0x93, 0x18},
-        {0x1c, 0x0a},
-        {0x1d, 0x48},
-        {0xc0, 0x50},
-        {0xc1, 0x3c},
-        {0x34, 0x05},
-        {0xc2, 0x0c},
-        {0xc3, 0xf9},
-        {0x34, 0x05},
-        {0xe7, 0x2e},
-        {0x31, 0xf9},
-        {0x35, 0x02},
-        {0xd9, 0x10},
-        {0x25, 0x42},
-        {0x94, 0x11},
-};
-
-static const u8 sensor_init_ov965x[][2] = {
-        {0x12, 0x80},   /* com7 - SSCB reset */
-        {0x00, 0x00},   /* gain */
-        {0x01, 0x80},   /* blue */
-        {0x02, 0x80},   /* red */
-        {0x03, 0x1b},   /* vref */
-        {0x04, 0x03},   /* com1 - exposure low bits */
-        {0x0b, 0x57},   /* ver */
-        {0x0e, 0x61},   /* com5 */
-        {0x0f, 0x42},   /* com6 */
-        {0x11, 0x00},   /* clkrc */
-        {0x12, 0x02},   /* com7 - 15fps VGA YUYV */
-        {0x13, 0xe7},   /* com8 - everything (AGC, AWB and AEC) */
-        {0x14, 0x28},   /* com9 */
-        {0x16, 0x24},   /* reg16 */
-        {0x17, 0x1d},   /* hstart*/
-        {0x18, 0xbd},   /* hstop */
-        {0x19, 0x01},   /* vstrt */
-        {0x1a, 0x81},   /* vstop*/
-        {0x1e, 0x04},   /* mvfp */
-        {0x24, 0x3c},   /* aew */
-        {0x25, 0x36},   /* aeb */
-        {0x26, 0x71},   /* vpt */
-        {0x27, 0x08},   /* bbias */
-        {0x28, 0x08},   /* gbbias */
-        {0x29, 0x15},   /* gr com */
-        {0x2a, 0x00},   /* exhch */
-        {0x2b, 0x00},   /* exhcl */
-        {0x2c, 0x08},   /* rbias */
-        {0x32, 0xff},   /* href */
-        {0x33, 0x00},   /* chlf */
-        {0x34, 0x3f},   /* aref1 */
-        {0x35, 0x00},   /* aref2 */
-        {0x36, 0xf8},   /* aref3 */
-        {0x38, 0x72},   /* adc2 */
-        {0x39, 0x57},   /* aref4 */
-        {0x3a, 0x80},   /* tslb - yuyv */
-        {0x3b, 0xc4},   /* com11 - night mode 1/4 frame rate */
-        {0x3d, 0x99},   /* com13 */
-        {0x3f, 0xc1},   /* edge */
-        {0x40, 0xc0},   /* com15 */
-        {0x41, 0x40},   /* com16 */
-        {0x42, 0xc0},   /* com17 */
-        {0x43, 0x0a},   /* rsvd */
-        {0x44, 0xf0},
-        {0x45, 0x46},
-        {0x46, 0x62},
-        {0x47, 0x2a},
-        {0x48, 0x3c},
-        {0x4a, 0xfc},
-        {0x4b, 0xfc},
-        {0x4c, 0x7f},
-        {0x4d, 0x7f},
-        {0x4e, 0x7f},
-        {0x4f, 0x98},   /* matrix */
-        {0x50, 0x98},
-        {0x51, 0x00},
-        {0x52, 0x28},
-        {0x53, 0x70},
-        {0x54, 0x98},
-        {0x58, 0x1a},   /* matrix coef sign */
-        {0x59, 0x85},   /* AWB control */
-        {0x5a, 0xa9},
-        {0x5b, 0x64},
-        {0x5c, 0x84},
-        {0x5d, 0x53},
-        {0x5e, 0x0e},
-        {0x5f, 0xf0},   /* AWB blue limit */
-        {0x60, 0xf0},   /* AWB red limit */
-        {0x61, 0xf0},   /* AWB green limit */
-        {0x62, 0x00},   /* lcc1 */
-        {0x63, 0x00},   /* lcc2 */
-        {0x64, 0x02},   /* lcc3 */
-        {0x65, 0x16},   /* lcc4 */
-        {0x66, 0x01},   /* lcc5 */
-        {0x69, 0x02},   /* hv */
-        {0x6b, 0x5a},   /* dbvl */
-        {0x6c, 0x04},
-        {0x6d, 0x55},
-        {0x6e, 0x00},
-        {0x6f, 0x9d},
-        {0x70, 0x21},   /* dnsth */
-        {0x71, 0x78},
-        {0x72, 0x00},   /* poidx */
-        {0x73, 0x01},   /* pckdv */
-        {0x74, 0x3a},   /* xindx */
-        {0x75, 0x35},   /* yindx */
-        {0x76, 0x01},
-        {0x77, 0x02},
-        {0x7a, 0x12},   /* gamma curve */
-        {0x7b, 0x08},
-        {0x7c, 0x16},
-        {0x7d, 0x30},
-        {0x7e, 0x5e},
-        {0x7f, 0x72},
-        {0x80, 0x82},
-        {0x81, 0x8e},
-        {0x82, 0x9a},
-        {0x83, 0xa4},
-        {0x84, 0xac},
-        {0x85, 0xb8},
-        {0x86, 0xc3},
-        {0x87, 0xd6},
-        {0x88, 0xe6},
-        {0x89, 0xf2},
-        {0x8a, 0x03},
-        {0x8c, 0x89},   /* com19 */
-        {0x14, 0x28},   /* com9 */
-        {0x90, 0x7d},
-        {0x91, 0x7b},
-        {0x9d, 0x03},   /* lcc6 */
-        {0x9e, 0x04},   /* lcc7 */
-        {0x9f, 0x7a},
-        {0xa0, 0x79},
-        {0xa1, 0x40},   /* aechm */
-        {0xa4, 0x50},   /* com21 */
-        {0xa5, 0x68},   /* com26 */
-        {0xa6, 0x4a},   /* AWB green */
-        {0xa8, 0xc1},   /* refa8 */
-        {0xa9, 0xef},   /* refa9 */
-        {0xaa, 0x92},
-        {0xab, 0x04},
-        {0xac, 0x80},   /* black level control */
-        {0xad, 0x80},
-        {0xae, 0x80},
-        {0xaf, 0x80},
-        {0xb2, 0xf2},
-        {0xb3, 0x20},
-        {0xb4, 0x20},   /* ctrlb4 */
-        {0xb5, 0x00},
-        {0xb6, 0xaf},
-        {0xbb, 0xae},
-        {0xbc, 0x7f},   /* ADC channel offsets */
-        {0xdb, 0x7f},
-        {0xbe, 0x7f},
-        {0xbf, 0x7f},
-        {0xc0, 0xe2},
-        {0xc1, 0xc0},
-        {0xc2, 0x01},
-        {0xc3, 0x4e},
-        {0xc6, 0x85},
-        {0xc7, 0x80},   /* com24 */
-        {0xc9, 0xe0},
-        {0xca, 0xe8},
-        {0xcb, 0xf0},
-        {0xcc, 0xd8},
-        {0xcd, 0xf1},
-        {0x4f, 0x98},   /* matrix */
-        {0x50, 0x98},
-        {0x51, 0x00},
-        {0x52, 0x28},
-        {0x53, 0x70},
-        {0x54, 0x98},
-        {0x58, 0x1a},
-        {0xff, 0x41},   /* read 41, write ff 00 */
-        {0x41, 0x40},   /* com16 */
-
-        {0xc5, 0x03},   /* 60 Hz banding filter */
-        {0x6a, 0x02},   /* 50 Hz banding filter */
-
-        {0x12, 0x62},   /* com7 - 30fps VGA YUV */
-        {0x36, 0xfa},   /* aref3 */
-        {0x69, 0x0a},   /* hv */
-        {0x8c, 0x89},   /* com22 */
-        {0x14, 0x28},   /* com9 */
-        {0x3e, 0x0c},
-        {0x41, 0x40},   /* com16 */
-        {0x72, 0x00},
-        {0x73, 0x00},
-        {0x74, 0x3a},
-        {0x75, 0x35},
-        {0x76, 0x01},
-        {0xc7, 0x80},
-        {0x03, 0x12},   /* vref */
-        {0x17, 0x16},   /* hstart */
-        {0x18, 0x02},   /* hstop */
-        {0x19, 0x01},   /* vstrt */
-        {0x1a, 0x3d},   /* vstop */
-        {0x32, 0xff},   /* href */
-        {0xc0, 0xaa},
-};
-
-static const u8 bridge_init_ov965x_2[][2] = {
-        {0x94, 0xaa},
-        {0xf1, 0x60},
-        {0xe5, 0x04},
-        {0xc0, 0x50},
-        {0xc1, 0x3c},
-        {0x8c, 0x00},
-        {0x8d, 0x1c},
-        {0x34, 0x05},
-
-        {0xc2, 0x0c},
-        {0xc3, 0xf9},
-        {0xda, 0x01},
-        {0x50, 0x00},
-        {0x51, 0xa0},
-        {0x52, 0x3c},
-        {0x53, 0x00},
-        {0x54, 0x00},
-        {0x55, 0x00},
-        {0x57, 0x00},
-        {0x5c, 0x00},
-        {0x5a, 0xa0},
-        {0x5b, 0x78},
-        {0x35, 0x02},
-        {0xd9, 0x10},
-        {0x94, 0x11},
-};
-
-static const u8 sensor_init_ov965x_2[][2] = {
-        {0x3b, 0xc4},
-        {0x1e, 0x04},   /* mvfp */
-        {0x13, 0xe0},   /* com8 */
-        {0x00, 0x00},   /* gain */
-        {0x13, 0xe7},   /* com8 - everything (AGC, AWB and AEC) */
-        {0x11, 0x03},   /* clkrc */
-        {0x6b, 0x5a},   /* dblv */
-        {0x6a, 0x05},
-        {0xc5, 0x07},
-        {0xa2, 0x4b},
-        {0xa3, 0x3e},
-        {0x2d, 0x00},
-        {0xff, 0x42},   /* read 42, write ff 00 */
-        {0x42, 0xc0},   /* com17 */
-        {0x2d, 0x00},
-        {0xff, 0x42},   /* read 42, write ff 00 */
-        {0x42, 0xc1},   /* com17 */
-/* sharpness */
-        {0x3f, 0x01},
-        {0xff, 0x42},   /* read 42, write ff 00 */
-        {0x42, 0xc1},   /* com17 */
-/* saturation */
-        {0x4f, 0x98},   /* matrix */
-        {0x50, 0x98},
-        {0x51, 0x00},
-        {0x52, 0x28},
-        {0x53, 0x70},
-        {0x54, 0x98},
-        {0x58, 0x1a},
-        {0xff, 0x41},   /* read 41, write ff 00 */
-        {0x41, 0x40},   /* com16 */
-/* contrast */
-        {0x56, 0x40},
-/* brightness */
-        {0x55, 0x8f},
-/* expo */
-        {0x10, 0x25},   /* aech - exposure high bits */
-        {0xff, 0x13},   /* read 13, write ff 00 */
-        {0x13, 0xe7},   /* com8 - everything (AGC, AWB and AEC) */
-};
-
-static const u8 sensor_start_ov965x_1_vga[][2] = {      /* same for qvga */
-        {0x12, 0x62},   /* com7 - 30fps VGA YUV */
-        {0x36, 0xfa},   /* aref3 */
-        {0x69, 0x0a},   /* hv */
-        {0x8c, 0x89},   /* com22 */
-        {0x14, 0x28},   /* com9 */
-        {0x3e, 0x0c},   /* com14 */
-        {0x41, 0x40},   /* com16 */
-        {0x72, 0x00},
-        {0x73, 0x00},
-        {0x74, 0x3a},
-        {0x75, 0x35},
-        {0x76, 0x01},
-        {0xc7, 0x80},   /* com24 */
-        {0x03, 0x12},   /* vref */
-        {0x17, 0x16},   /* hstart */
-        {0x18, 0x02},   /* hstop */
-        {0x19, 0x01},   /* vstrt */
-        {0x1a, 0x3d},   /* vstop */
-        {0x32, 0xff},   /* href */
-        {0xc0, 0xaa},
-};
-
-static const u8 sensor_start_ov965x_1_svga[][2] = {
-        {0x12, 0x02},   /* com7 - YUYV - VGA 15 full resolution */
-        {0x36, 0xf8},   /* aref3 */
-        {0x69, 0x02},   /* hv */
-        {0x8c, 0x0d},   /* com22 */
-        {0x3e, 0x0c},   /* com14 */
-        {0x41, 0x40},   /* com16 */
-        {0x72, 0x00},
-        {0x73, 0x01},
-        {0x74, 0x3a},
-        {0x75, 0x35},
-        {0x76, 0x01},
-        {0xc7, 0x80},   /* com24 */
-        {0x03, 0x1b},   /* vref */
-        {0x17, 0x1d},   /* hstart */
-        {0x18, 0xbd},   /* hstop */
-        {0x19, 0x01},   /* vstrt */
-        {0x1a, 0x81},   /* vstop */
-        {0x32, 0xff},   /* href */
-        {0xc0, 0xe2},
-};
-
-static const u8 sensor_start_ov965x_1_xga[][2] = {
-        {0x12, 0x02},   /* com7 */
-        {0x36, 0xf8},   /* aref3 */
-        {0x69, 0x02},   /* hv */
-        {0x8c, 0x89},   /* com22 */
-        {0x14, 0x28},   /* com9 */
-        {0x3e, 0x0c},   /* com14 */
-        {0x41, 0x40},   /* com16 */
-        {0x72, 0x00},
-        {0x73, 0x01},
-        {0x74, 0x3a},
-        {0x75, 0x35},
-        {0x76, 0x01},
-        {0xc7, 0x80},   /* com24 */
-        {0x03, 0x1b},   /* vref */
-        {0x17, 0x1d},   /* hstart */
-        {0x18, 0xbd},   /* hstop */
-        {0x19, 0x01},   /* vstrt */
-        {0x1a, 0x81},   /* vstop */
-        {0x32, 0xff},   /* href */
-        {0xc0, 0xe2},
-};
-
-static const u8 sensor_start_ov965x_1_sxga[][2] = {
-        {0x12, 0x02},   /* com7 */
-        {0x36, 0xf8},   /* aref3 */
-        {0x69, 0x02},   /* hv */
-        {0x8c, 0x89},   /* com22 */
-        {0x14, 0x28},   /* com9 */
-        {0x3e, 0x0c},   /* com14 */
-        {0x41, 0x40},   /* com16 */
-        {0x72, 0x00},
-        {0x73, 0x01},
-        {0x74, 0x3a},
-        {0x75, 0x35},
-        {0x76, 0x01},
-        {0xc7, 0x80},   /* com24 */
-        {0x03, 0x1b},   /* vref */
-        {0x17, 0x1d},   /* hstart */
-        {0x18, 0x02},   /* hstop */
-        {0x19, 0x01},   /* vstrt */
-        {0x1a, 0x81},   /* vstop */
-        {0x32, 0xff},   /* href */
-        {0xc0, 0xe2},
-};
-
-static const u8 bridge_start_ov965x_qvga[][2] = {
-        {0x94, 0xaa},
-        {0xf1, 0x60},
-        {0xe5, 0x04},
-        {0xc0, 0x50},
-        {0xc1, 0x3c},
-        {0x8c, 0x00},
-        {0x8d, 0x1c},
-        {0x34, 0x05},
-
-        {0xc2, 0x4c},
-        {0xc3, 0xf9},
-        {0xda, 0x00},
-        {0x50, 0x00},
-        {0x51, 0xa0},
-        {0x52, 0x78},
-        {0x53, 0x00},
-        {0x54, 0x00},
-        {0x55, 0x00},
-        {0x57, 0x00},
-        {0x5c, 0x00},
-        {0x5a, 0x50},
-        {0x5b, 0x3c},
-        {0x35, 0x02},
-        {0xd9, 0x10},
-        {0x94, 0x11},
-};
-
-static const u8 bridge_start_ov965x_vga[][2] = {
-        {0x94, 0xaa},
-        {0xf1, 0x60},
-        {0xe5, 0x04},
-        {0xc0, 0x50},
-        {0xc1, 0x3c},
-        {0x8c, 0x00},
-        {0x8d, 0x1c},
-        {0x34, 0x05},
-        {0xc2, 0x0c},
-        {0xc3, 0xf9},
-        {0xda, 0x01},
-        {0x50, 0x00},
-        {0x51, 0xa0},
-        {0x52, 0x3c},
-        {0x53, 0x00},
-        {0x54, 0x00},
-        {0x55, 0x00},
-        {0x57, 0x00},
-        {0x5c, 0x00},
-        {0x5a, 0xa0},
-        {0x5b, 0x78},
-        {0x35, 0x02},
-        {0xd9, 0x10},
-        {0x94, 0x11},
-};
-
-static const u8 bridge_start_ov965x_svga[][2] = {
-        {0x94, 0xaa},
-        {0xf1, 0x60},
-        {0xe5, 0x04},
-        {0xc0, 0xa0},
-        {0xc1, 0x80},
-        {0x8c, 0x00},
-        {0x8d, 0x1c},
-        {0x34, 0x05},
-        {0xc2, 0x4c},
-        {0xc3, 0xf9},
-        {0x50, 0x00},
-        {0x51, 0x40},
-        {0x52, 0x00},
-        {0x53, 0x00},
-        {0x54, 0x00},
-        {0x55, 0x88},
-        {0x57, 0x00},
-        {0x5c, 0x00},
-        {0x5a, 0xc8},
-        {0x5b, 0x96},
-        {0x35, 0x02},
-        {0xd9, 0x10},
-        {0xda, 0x00},
-        {0x94, 0x11},
-};
-
-static const u8 bridge_start_ov965x_xga[][2] = {
-        {0x94, 0xaa},
-        {0xf1, 0x60},
-        {0xe5, 0x04},
-        {0xc0, 0xa0},
-        {0xc1, 0x80},
-        {0x8c, 0x00},
-        {0x8d, 0x1c},
-        {0x34, 0x05},
-        {0xc2, 0x4c},
-        {0xc3, 0xf9},
-        {0x50, 0x00},
-        {0x51, 0x40},
-        {0x52, 0x00},
-        {0x53, 0x00},
-        {0x54, 0x00},
-        {0x55, 0x88},
-        {0x57, 0x00},
-        {0x5c, 0x01},
-        {0x5a, 0x00},
-        {0x5b, 0xc0},
-        {0x35, 0x02},
-        {0xd9, 0x10},
-        {0xda, 0x01},
-        {0x94, 0x11},
-};
-
-static const u8 bridge_start_ov965x_sxga[][2] = {
-        {0x94, 0xaa},
-        {0xf1, 0x60},
-        {0xe5, 0x04},
-        {0xc0, 0xa0},
-        {0xc1, 0x80},
-        {0x8c, 0x00},
-        {0x8d, 0x1c},
-        {0x34, 0x05},
-        {0xc2, 0x0c},
-        {0xc3, 0xf9},
-        {0xda, 0x00},
-        {0x35, 0x02},
-        {0xd9, 0x10},
-        {0x94, 0x11},
-};
-
-static const u8 sensor_start_ov965x_2_qvga[][2] = {
-        {0x3b, 0xe4},   /* com11 - night mode 1/4 frame rate */
-        {0x1e, 0x04},   /* mvfp */
-        {0x13, 0xe0},   /* com8 */
-        {0x00, 0x00},
-        {0x13, 0xe7},   /* com8 - everything (AGC, AWB and AEC) */
-        {0x11, 0x01},   /* clkrc */
-        {0x6b, 0x5a},   /* dblv */
-        {0x6a, 0x02},   /* 50 Hz banding filter */
-        {0xc5, 0x03},   /* 60 Hz banding filter */
-        {0xa2, 0x96},   /* bd50 */
-        {0xa3, 0x7d},   /* bd60 */
-
-        {0xff, 0x13},   /* read 13, write ff 00 */
-        {0x13, 0xe7},
-        {0x3a, 0x80},   /* tslb - yuyv */
-};
-
-static const u8 sensor_start_ov965x_2_vga[][2] = {
-        {0x3b, 0xc4},   /* com11 - night mode 1/4 frame rate */
-        {0x1e, 0x04},   /* mvfp */
-        {0x13, 0xe0},   /* com8 */
-        {0x00, 0x00},
-        {0x13, 0xe7},   /* com8 - everything (AGC, AWB and AEC) */
-        {0x11, 0x03},   /* clkrc */
-        {0x6b, 0x5a},   /* dblv */
-        {0x6a, 0x05},   /* 50 Hz banding filter */
-        {0xc5, 0x07},   /* 60 Hz banding filter */
-        {0xa2, 0x4b},   /* bd50 */
-        {0xa3, 0x3e},   /* bd60 */
-
-        {0x2d, 0x00},   /* advfl */
-};
-
-static const u8 sensor_start_ov965x_2_svga[][2] = {     /* same for xga */
-        {0x3b, 0xc4},   /* com11 - night mode 1/4 frame rate */
-        {0x1e, 0x04},   /* mvfp */
-        {0x13, 0xe0},   /* com8 */
-        {0x00, 0x00},
-        {0x13, 0xe7},   /* com8 - everything (AGC, AWB and AEC) */
-        {0x11, 0x01},   /* clkrc */
-        {0x6b, 0x5a},   /* dblv */
-        {0x6a, 0x0c},   /* 50 Hz banding filter */
-        {0xc5, 0x0f},   /* 60 Hz banding filter */
-        {0xa2, 0x4e},   /* bd50 */
-        {0xa3, 0x41},   /* bd60 */
-};
-
-static const u8 sensor_start_ov965x_2_sxga[][2] = {
-        {0x13, 0xe0},   /* com8 */
-        {0x00, 0x00},
-        {0x13, 0xe7},   /* com8 - everything (AGC, AWB and AEC) */
-        {0x3b, 0xc4},   /* com11 - night mode 1/4 frame rate */
-        {0x1e, 0x04},   /* mvfp */
-        {0x11, 0x01},   /* clkrc */
-        {0x6b, 0x5a},   /* dblv */
-        {0x6a, 0x0c},   /* 50 Hz banding filter */
-        {0xc5, 0x0f},   /* 60 Hz banding filter */
-        {0xa2, 0x4e},   /* bd50 */
-        {0xa3, 0x41},   /* bd60 */
-};
-
 static void ov534_reg_write(struct gspca_dev *gspca_dev, u16 reg, u8 val)
 {
         struct usb_device *udev = gspca_dev->dev;
@@ -1360,14 +671,14 @@ static void set_frame_rate(struct gspca_dev *gspca_dev)
         PDEBUG(D_PROBE, "frame_rate: %d", r->fps);
 }
 
-static void setbrightness_77(struct gspca_dev *gspca_dev)
+static void setbrightness(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
 
         sccb_reg_write(gspca_dev, 0x9B, sd->brightness);
 }
 
-static void setcontrast_77(struct gspca_dev *gspca_dev)
+static void setcontrast(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
 
@@ -1401,7 +712,7 @@ static void setgain(struct gspca_dev *gspca_dev)
         sccb_reg_write(gspca_dev, 0x00, val);
 }
 
-static void setexposure_77(struct gspca_dev *gspca_dev)
+static void setexposure(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
         u8 val;
@@ -1432,7 +743,7 @@ static void sethue(struct gspca_dev *gspca_dev)
         sccb_reg_write(gspca_dev, 0x01, sd->hue);
 }
 
-static void setautogain_77(struct gspca_dev *gspca_dev)
+static void setautogain(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
 
@@ -1457,7 +768,7 @@ static void setawb(struct gspca_dev *gspca_dev)
                 sccb_reg_write(gspca_dev, 0x63, 0xaa);  /* AWB off */
 }
 
-static void setsharpness_77(struct gspca_dev *gspca_dev)
+static void setsharpness(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
         u8 val;
@@ -1491,132 +802,6 @@ static void setvflip(struct gspca_dev *gspca_dev)
                                 sccb_reg_read(gspca_dev, 0x0c) & 0x7f);
 }
 
-/* ov965x specific controls */
-static void setbrightness_96(struct gspca_dev *gspca_dev)
-{
-        struct sd *sd = (struct sd *) gspca_dev;
-        u8 val;
-
-        val = sd->brightness;
-        if (val < 8)
-                val = 15 - val;         /* f .. 8 */
-        else
-                val = val - 8;          /* 0 .. 7 */
-        sccb_reg_write(gspca_dev, 0x55, /* brtn - brightness adjustment */
-                        0x0f | (val << 4));
-}
-
-static void setcontrast_96(struct gspca_dev *gspca_dev)
-{
-        struct sd *sd = (struct sd *) gspca_dev;
-
-        sccb_reg_write(gspca_dev, 0x56, /* cnst1 - contrast 1 ctrl coeff */
-                        sd->contrast << 4);
-}
-
-static void setexposure_96(struct gspca_dev *gspca_dev)
-{
-        struct sd *sd = (struct sd *) gspca_dev;
-        u8 val;
-        static const u8 expo[4] = {0x00, 0x25, 0x38, 0x5e};
-
-        sccb_reg_write(gspca_dev, 0x10,                 /* aec[9:2] */
-                        expo[sd->exposure]);
-        val = sccb_reg_read(gspca_dev, 0x13);           /* com8 */
-        sccb_reg_write(gspca_dev, 0xff, 0x00);
-        sccb_reg_write(gspca_dev, 0x13, val);
-        val = sccb_reg_read(gspca_dev, 0xa1);           /* aech */
-        sccb_reg_write(gspca_dev, 0xff, 0x00);
-        sccb_reg_write(gspca_dev, 0xa1, val & 0xe0);    /* aec[15:10] = 0 */
-}
-
-static void setsharpness_96(struct gspca_dev *gspca_dev)
-{
-        struct sd *sd = (struct sd *) gspca_dev;
-        s8 val;
-
-        val = sd->sharpness;
-        if (val < 0) {                          /* auto */
-                val = sccb_reg_read(gspca_dev, 0x42);   /* com17 */
-                sccb_reg_write(gspca_dev, 0xff, 0x00);
-                sccb_reg_write(gspca_dev, 0x42, val | 0x40);
-                                /* Edge enhancement strength auto adjust */
-                return;
-        }
-        if (val != 0)
-                val = 1 << (val - 1);
-        sccb_reg_write(gspca_dev, 0x3f, /* edge - edge enhance. factor */
-                        val);
-        val = sccb_reg_read(gspca_dev, 0x42);           /* com17 */
-        sccb_reg_write(gspca_dev, 0xff, 0x00);
-        sccb_reg_write(gspca_dev, 0x42, val & 0xbf);
-}
-
-static void setautogain_96(struct gspca_dev *gspca_dev)
-{
-        struct sd *sd = (struct sd *) gspca_dev;
-        u8 val;
-
-/*fixme: should adjust agc/awb/aec by different controls */
-        val = sd->autogain;
-        val = sccb_reg_read(gspca_dev, 0x13);           /* com8 */
-        sccb_reg_write(gspca_dev, 0xff, 0x00);
-        if (sd->autogain)
-                val |= 0x05;            /* agc & aec */
-        else
-                val &= 0xfa;
-        sccb_reg_write(gspca_dev, 0x13, val);
-}
-
-static void setsatur(struct gspca_dev *gspca_dev)
-{
-        struct sd *sd = (struct sd *) gspca_dev;
-        u8 val1, val2, val3;
-        static const u8 matrix[5][2] = {
-                {0x14, 0x38},
-                {0x1e, 0x54},
-                {0x28, 0x70},
-                {0x32, 0x8c},
-                {0x48, 0x90}
-        };
-
-        val1 = matrix[sd->satur][0];
-        val2 = matrix[sd->satur][1];
-        val3 = val1 + val2;
-        sccb_reg_write(gspca_dev, 0x4f, val3);  /* matrix coeff */
-        sccb_reg_write(gspca_dev, 0x50, val3);
-        sccb_reg_write(gspca_dev, 0x51, 0x00);
-        sccb_reg_write(gspca_dev, 0x52, val1);
-        sccb_reg_write(gspca_dev, 0x53, val2);
-        sccb_reg_write(gspca_dev, 0x54, val3);
-        sccb_reg_write(gspca_dev, 0x58, 0x1a);  /* mtxs - coeff signs */
-        val1 = sccb_reg_read(gspca_dev, 0x41);  /* com16 */
-        sccb_reg_write(gspca_dev, 0xff, 0x00);
-        sccb_reg_write(gspca_dev, 0x41, val1);
-}
-
-static void setfreq(struct gspca_dev *gspca_dev)
-{
-        struct sd *sd = (struct sd *) gspca_dev;
-        u8 val;
-
-        val = sccb_reg_read(gspca_dev, 0x13);           /* com8 */
-        sccb_reg_write(gspca_dev, 0xff, 0x00);
-        if (sd->lightfreq == 0) {
-                sccb_reg_write(gspca_dev, 0x13, val & 0xdf);
-                return;
-        }
-        sccb_reg_write(gspca_dev, 0x13, val | 0x20);
-
-        val = sccb_reg_read(gspca_dev, 0x42);           /* com17 */
-        sccb_reg_write(gspca_dev, 0xff, 0x00);
-        if (sd->lightfreq == 1)
-                val |= 0x01;
-        else
-                val &= 0xfe;
-        sccb_reg_write(gspca_dev, 0x42, val);
-}
-
 /* this function is called at probe time */
 static int sd_config(struct gspca_dev *gspca_dev,
                      const struct usb_device_id *id)
@@ -1624,77 +809,50 @@ static int sd_config(struct gspca_dev *gspca_dev,
         struct sd *sd = (struct sd *) gspca_dev;
         struct cam *cam;
 
-        sd->sensor = id->driver_info;
-
         cam = &gspca_dev->cam;
 
-        if (sd->sensor == SENSOR_OV772X) {
-                cam->cam_mode = ov772x_mode;
-                cam->nmodes = ARRAY_SIZE(ov772x_mode);
+        cam->cam_mode = ov772x_mode;
+        cam->nmodes = ARRAY_SIZE(ov772x_mode);
+        cam->mode_framerates = ov772x_framerates;
 
-                cam->bulk = 1;
-                cam->bulk_size = 16384;
-                cam->bulk_nurbs = 2;
-        } else {                /* ov965x */
-                cam->cam_mode = ov965x_mode;
-                cam->nmodes = ARRAY_SIZE(ov965x_mode);
-        }
+        cam->bulk = 1;
+        cam->bulk_size = 16384;
+        cam->bulk_nurbs = 2;
 
         sd->frame_rate = 30;
 
-        if (sd->sensor == SENSOR_OV772X) {
-                sd->brightness = BRIGHTNESS_77_DEF;
-                sd->contrast = CONTRAST_77_DEF;
-                sd->gain = GAIN_DEF;
-                sd->exposure = EXPO_77_DEF;
-                sd->redblc = RED_BALANCE_DEF;
-                sd->blueblc = BLUE_BALANCE_DEF;
-                sd->hue = HUE_DEF;
-#if AUTOGAIN_77_DEF != 0
-                sd->autogain = AUTOGAIN_77_DEF;
+        sd->brightness = BRIGHTNESS_DEF;
+        sd->contrast = CONTRAST_DEF;
+        sd->gain = GAIN_DEF;
+        sd->exposure = EXPO_DEF;
+        sd->redblc = RED_BALANCE_DEF;
+        sd->blueblc = BLUE_BALANCE_DEF;
+        sd->hue = HUE_DEF;
+#if AUTOGAIN_DEF != 0
+        sd->autogain = AUTOGAIN_DEF;
 #else
-                gspca_dev->ctrl_inac |= (1 << AWB_77_IDX);
+        gspca_dev->ctrl_inac |= (1 << AWB_IDX);
 #endif
 #if AWB_DEF != 0
-                sd->awb = AWB_DEF
+        sd->awb = AWB_DEF
 #endif
-#if SHARPNESS_77_DEF != 0
-                sd->sharpness = SHARPNESS_77_DEF;
+#if SHARPNESS_DEF != 0
+        sd->sharpness = SHARPNESS_DEF;
 #endif
 #if HFLIP_DEF != 0
-                sd->hflip = HFLIP_DEF;
+        sd->hflip = HFLIP_DEF;
 #endif
 #if VFLIP_DEF != 0
-                sd->vflip = VFLIP_DEF;
-#endif
-        } else {
-                sd->brightness = BRIGHTNESS_96_DEF;
-                sd->contrast = CONTRAST_96_DEF;
-#if AUTOGAIN_96_DEF != 0
-                sd->autogain = AUTOGAIN_96_DEF;
-                gspca_dev->ctrl_inac |= (1 << EXPO_96_IDX);
+        sd->vflip = VFLIP_DEF;
 #endif
-#if EXPO_96_DEF != 0
-                sd->exposure = EXPO_96_DEF;
-#endif
-#if SHARPNESS_96_DEF != 0
-                sd->sharpness = SHARPNESS_96_DEF;
-#endif
-                sd->satur = SATUR_DEF;
-                sd->lightfreq = FREQ_DEF;
-        }
+
         return 0;
 }
 
 /* this function is called at probe and resume time */
 static int sd_init(struct gspca_dev *gspca_dev)
 {
-        struct sd *sd = (struct sd *) gspca_dev;
         u16 sensor_id;
-        static const u8 sensor_addr[2] = {
-                0x42,                   /* 0 SENSOR_OV772X */
-                0x60,                   /* 1 SENSOR_OV965X */
-        };
 
         /* reset bridge */
         ov534_reg_write(gspca_dev, 0xe7, 0x3a);
@@ -1702,8 +860,7 @@ static int sd_init(struct gspca_dev *gspca_dev)
         msleep(100);
 
         /* initialize the sensor address */
-        ov534_reg_write(gspca_dev, OV534_REG_ADDRESS,
-                                sensor_addr[sd->sensor]);
+        ov534_reg_write(gspca_dev, OV534_REG_ADDRESS, 0x42);
 
         /* reset sensor */
         sccb_reg_write(gspca_dev, 0x12, 0x80);
@@ -1717,64 +874,46 @@ static int sd_init(struct gspca_dev *gspca_dev)
         PDEBUG(D_PROBE, "Sensor ID: %04x", sensor_id);
 
         /* initialize */
-        switch (sd->sensor) {
-        case SENSOR_OV772X:
-                reg_w_array(gspca_dev, bridge_init_ov772x,
-                                ARRAY_SIZE(bridge_init_ov772x));
-                ov534_set_led(gspca_dev, 1);
-                sccb_w_array(gspca_dev, sensor_init_ov772x,
-                                ARRAY_SIZE(sensor_init_ov772x));
-                ov534_reg_write(gspca_dev, 0xe0, 0x09);
-                ov534_set_led(gspca_dev, 0);
-                set_frame_rate(gspca_dev);
-                break;
-        default:
-/*      case SENSOR_OV965X: */
-                reg_w_array(gspca_dev, bridge_init_ov965x,
-                                ARRAY_SIZE(bridge_init_ov965x));
-                sccb_w_array(gspca_dev, sensor_init_ov965x,
-                                ARRAY_SIZE(sensor_init_ov965x));
-                reg_w_array(gspca_dev, bridge_init_ov965x_2,
-                                ARRAY_SIZE(bridge_init_ov965x_2));
-                sccb_w_array(gspca_dev, sensor_init_ov965x_2,
-                                ARRAY_SIZE(sensor_init_ov965x_2));
-                ov534_reg_write(gspca_dev, 0xe0, 0x00);
-                ov534_reg_write(gspca_dev, 0xe0, 0x01);
-                ov534_set_led(gspca_dev, 0);
-                ov534_reg_write(gspca_dev, 0xe0, 0x00);
-        }
+        reg_w_array(gspca_dev, bridge_init,
+                        ARRAY_SIZE(bridge_init));
+        ov534_set_led(gspca_dev, 1);
+        sccb_w_array(gspca_dev, sensor_init,
+                        ARRAY_SIZE(sensor_init));
+        ov534_reg_write(gspca_dev, 0xe0, 0x09);
+        ov534_set_led(gspca_dev, 0);
+        set_frame_rate(gspca_dev);
 
         return 0;
 }
 
-static int sd_start_ov772x(struct gspca_dev *gspca_dev)
+static int sd_start(struct gspca_dev *gspca_dev)
 {
         int mode;
 
         mode = gspca_dev->cam.cam_mode[gspca_dev->curr_mode].priv;
         if (mode != 0) {        /* 320x240 */
-                reg_w_array(gspca_dev, bridge_start_ov772x_qvga,
-                                ARRAY_SIZE(bridge_start_ov772x_qvga));
-                sccb_w_array(gspca_dev, sensor_start_ov772x_qvga,
-                                ARRAY_SIZE(sensor_start_ov772x_qvga));
+                reg_w_array(gspca_dev, bridge_start_qvga,
+                                ARRAY_SIZE(bridge_start_qvga));
+                sccb_w_array(gspca_dev, sensor_start_qvga,
+                                ARRAY_SIZE(sensor_start_qvga));
         } else {                /* 640x480 */
-                reg_w_array(gspca_dev, bridge_start_ov772x_vga,
-                                ARRAY_SIZE(bridge_start_ov772x_vga));
-                sccb_w_array(gspca_dev, sensor_start_ov772x_vga,
-                                ARRAY_SIZE(sensor_start_ov772x_vga));
+                reg_w_array(gspca_dev, bridge_start_vga,
+                                ARRAY_SIZE(bridge_start_vga));
+                sccb_w_array(gspca_dev, sensor_start_vga,
+                                ARRAY_SIZE(sensor_start_vga));
         }
         set_frame_rate(gspca_dev);
 
-        setautogain_77(gspca_dev);
+        setautogain(gspca_dev);
         setawb(gspca_dev);
         setgain(gspca_dev);
         setredblc(gspca_dev);
         setblueblc(gspca_dev);
         sethue(gspca_dev);
-        setexposure_77(gspca_dev);
-        setbrightness_77(gspca_dev);
-        setcontrast_77(gspca_dev);
-        setsharpness_77(gspca_dev);
+        setexposure(gspca_dev);
+        setbrightness(gspca_dev);
+        setcontrast(gspca_dev);
+        setsharpness(gspca_dev);
         setvflip(gspca_dev);
         sethflip(gspca_dev);
 
@@ -1783,81 +922,12 @@ static int sd_start_ov772x(struct gspca_dev *gspca_dev)
         return 0;
 }
 
-static int sd_start_ov965x(struct gspca_dev *gspca_dev)
-{
-        int mode;
-
-        mode = gspca_dev->cam.cam_mode[gspca_dev->curr_mode].priv;
-        switch (mode) {
-        default:
-/*      case 4:                  * 320x240 */
-                sccb_w_array(gspca_dev, sensor_start_ov965x_1_vga,
-                                ARRAY_SIZE(sensor_start_ov965x_1_vga));
-                reg_w_array(gspca_dev, bridge_start_ov965x_qvga,
-                                ARRAY_SIZE(bridge_start_ov965x_qvga));
-                sccb_w_array(gspca_dev, sensor_start_ov965x_2_qvga,
-                                ARRAY_SIZE(sensor_start_ov965x_2_qvga));
-                break;
-        case 3:                 /* 640x480 */
-                sccb_w_array(gspca_dev, sensor_start_ov965x_1_vga,
-                                ARRAY_SIZE(sensor_start_ov965x_1_vga));
-                reg_w_array(gspca_dev, bridge_start_ov965x_vga,
-                                ARRAY_SIZE(bridge_start_ov965x_vga));
-                sccb_w_array(gspca_dev, sensor_start_ov965x_2_vga,
-                                ARRAY_SIZE(sensor_start_ov965x_2_vga));
-                break;
-        case 2:                 /* 800x600 */
-                sccb_w_array(gspca_dev, sensor_start_ov965x_1_svga,
-                                ARRAY_SIZE(sensor_start_ov965x_1_svga));
-                reg_w_array(gspca_dev, bridge_start_ov965x_svga,
-                                ARRAY_SIZE(bridge_start_ov965x_svga));
-                sccb_w_array(gspca_dev, sensor_start_ov965x_2_svga,
-                                ARRAY_SIZE(sensor_start_ov965x_2_svga));
-                break;
-        case 1:                 /* 1024x768 */
-                sccb_w_array(gspca_dev, sensor_start_ov965x_1_xga,
-                                ARRAY_SIZE(sensor_start_ov965x_1_xga));
-                reg_w_array(gspca_dev, bridge_start_ov965x_xga,
-                                ARRAY_SIZE(bridge_start_ov965x_xga));
-                sccb_w_array(gspca_dev, sensor_start_ov965x_2_svga,
-                                ARRAY_SIZE(sensor_start_ov965x_2_svga));
-                break;
-        case 0:                 /* 1280x1024 */
-                sccb_w_array(gspca_dev, sensor_start_ov965x_1_sxga,
-                                ARRAY_SIZE(sensor_start_ov965x_1_sxga));
-                reg_w_array(gspca_dev, bridge_start_ov965x_sxga,
-                                ARRAY_SIZE(bridge_start_ov965x_sxga));
-                sccb_w_array(gspca_dev, sensor_start_ov965x_2_sxga,
-                                ARRAY_SIZE(sensor_start_ov965x_2_sxga));
-                break;
-        }
-        setfreq(gspca_dev);
-        setautogain_96(gspca_dev);
-        setbrightness_96(gspca_dev);
-        setcontrast_96(gspca_dev);
-        setexposure_96(gspca_dev);
-        setsharpness_96(gspca_dev);
-        setsatur(gspca_dev);
-
-        ov534_reg_write(gspca_dev, 0xe0, 0x00);
-        ov534_reg_write(gspca_dev, 0xe0, 0x00);
-        ov534_set_led(gspca_dev, 1);
-        return 0;
-}
-
-static void sd_stopN_ov772x(struct gspca_dev *gspca_dev)
+static void sd_stopN(struct gspca_dev *gspca_dev)
 {
         ov534_reg_write(gspca_dev, 0xe0, 0x09);
         ov534_set_led(gspca_dev, 0);
 }
 
-static void sd_stopN_ov965x(struct gspca_dev *gspca_dev)
-{
-        ov534_reg_write(gspca_dev, 0xe0, 0x01);
-        ov534_set_led(gspca_dev, 0);
-        ov534_reg_write(gspca_dev, 0xe0, 0x00);
-}
-
 /* Values for bmHeaderInfo (Video and Still Image Payload Headers, 2.4.3.3) */
 #define UVC_STREAM_EOH  (1 << 7)
 #define UVC_STREAM_ERR  (1 << 6)
@@ -1875,11 +945,9 @@ static void sd_pkt_scan(struct gspca_dev *gspca_dev,
         __u32 this_pts;
         u16 this_fid;
         int remaining_len = len;
-        int payload_len;
 
-        payload_len = gspca_dev->cam.bulk ? 2048 : 2040;
         do {
-                len = min(remaining_len, payload_len);
+                len = min(remaining_len, 2048);
 
                 /* Payloads are prefixed with a UVC-style header.  We
                    consider a frame to start when the FID toggles, or the PTS
@@ -1918,7 +986,17 @@ static void sd_pkt_scan(struct gspca_dev *gspca_dev,
                                         data + 12, len - 12);
                 /* If this packet is marked as EOF, end the frame */
                 } else if (data[1] & UVC_STREAM_EOF) {
+                        struct gspca_frame *frame;
+
                         sd->last_pts = 0;
+                        frame = gspca_get_i_frame(gspca_dev);
+                        if (frame == NULL)
+                                goto discard;
+                        if (frame->data_end - frame->data + (len - 12) !=
+                            gspca_dev->width * gspca_dev->height * 2) {
+                                PDEBUG(D_PACK, "wrong sized frame");
+                                goto discard;
+                        }
                         gspca_frame_add(gspca_dev, LAST_PACKET,
                                         data + 12, len - 12);
                 } else {
@@ -1965,12 +1043,8 @@ static int sd_setexposure(struct gspca_dev *gspca_dev, __s32 val)
         struct sd *sd = (struct sd *) gspca_dev;
 
         sd->exposure = val;
-        if (gspca_dev->streaming) {
-                if (sd->sensor == SENSOR_OV772X)
-                        setexposure_77(gspca_dev);
-                else
-                        setexposure_96(gspca_dev);
-        }
+        if (gspca_dev->streaming)
+                setexposure(gspca_dev);
         return 0;
 }
 
@@ -1987,12 +1061,8 @@ static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
         struct sd *sd = (struct sd *) gspca_dev;
 
         sd->brightness = val;
-        if (gspca_dev->streaming) {
-                if (sd->sensor == SENSOR_OV772X)
-                        setbrightness_77(gspca_dev);
-                else
-                        setbrightness_96(gspca_dev);
-        }
+        if (gspca_dev->streaming)
+                setbrightness(gspca_dev);
         return 0;
 }
 
@@ -2009,12 +1079,8 @@ static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val)
         struct sd *sd = (struct sd *) gspca_dev;
 
         sd->contrast = val;
-        if (gspca_dev->streaming) {
-                if (sd->sensor == SENSOR_OV772X)
-                        setcontrast_77(gspca_dev);
-                else
-                        setcontrast_96(gspca_dev);
-        }
+        if (gspca_dev->streaming)
+                setcontrast(gspca_dev);
         return 0;
 }
 
@@ -2026,41 +1092,6 @@ static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val)
         return 0;
 }
 
-static int sd_setsatur(struct gspca_dev *gspca_dev, __s32 val)
-{
-        struct sd *sd = (struct sd *) gspca_dev;
-
-        sd->satur = val;
-        if (gspca_dev->streaming)
-                setsatur(gspca_dev);
-        return 0;
-}
-
-static int sd_getsatur(struct gspca_dev *gspca_dev, __s32 *val)
-{
-        struct sd *sd = (struct sd *) gspca_dev;
-
-        *val = sd->satur;
-        return 0;
-}
-static int sd_setfreq(struct gspca_dev *gspca_dev, __s32 val)
-{
-        struct sd *sd = (struct sd *) gspca_dev;
-
-        sd->lightfreq = val;
-        if (gspca_dev->streaming)
-                setfreq(gspca_dev);
-        return 0;
-}
-
-static int sd_getfreq(struct gspca_dev *gspca_dev, __s32 *val)
-{
-        struct sd *sd = (struct sd *) gspca_dev;
-
-        *val = sd->lightfreq;
-        return 0;
-}
-
 static int sd_setredblc(struct gspca_dev *gspca_dev, __s32 val)
 {
         struct sd *sd = (struct sd *) gspca_dev;
@@ -2122,22 +1153,14 @@ static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val)
         sd->autogain = val;
 
         if (gspca_dev->streaming) {
-                if (sd->sensor == SENSOR_OV772X) {
-
-                        /* the auto white balance control works only
-                         * when auto gain is set */
-                        if (val)
-                                gspca_dev->ctrl_inac &= ~(1 << AWB_77_IDX);
-                        else
-                                gspca_dev->ctrl_inac |= (1 << AWB_77_IDX);
-                        setautogain_77(gspca_dev);
-                } else {
-                        if (val)
-                                gspca_dev->ctrl_inac |= (1 << EXPO_96_IDX);
-                        else
-                                gspca_dev->ctrl_inac &= ~(1 << EXPO_96_IDX);
-                        setautogain_96(gspca_dev);
-                }
+
+                /* the auto white balance control works only
+                 * when auto gain is set */
+                if (val)
+                        gspca_dev->ctrl_inac &= ~(1 << AWB_IDX);
+                else
+                        gspca_dev->ctrl_inac |= (1 << AWB_IDX);
+                setautogain(gspca_dev);
         }
         return 0;
 }
@@ -2173,12 +1196,8 @@ static int sd_setsharpness(struct gspca_dev *gspca_dev, __s32 val)
         struct sd *sd = (struct sd *) gspca_dev;
 
         sd->sharpness = val;
-        if (gspca_dev->streaming) {
-                if (sd->sensor == SENSOR_OV772X)
-                        setsharpness_77(gspca_dev);
-                else
-                        setsharpness_96(gspca_dev);
-        }
+        if (gspca_dev->streaming)
+                setsharpness(gspca_dev);
         return 0;
 }
 
@@ -2257,7 +1276,7 @@ static int sd_set_streamparm(struct gspca_dev *gspca_dev,
 
         /* Set requested framerate */
         sd->frame_rate = tpf->denominator / tpf->numerator;
-        if (gspca_dev->streaming && sd->sensor == SENSOR_OV772X)
+        if (gspca_dev->streaming)
                 set_frame_rate(gspca_dev);
 
         /* Return the actual framerate */
@@ -2267,57 +1286,23 @@ static int sd_set_streamparm(struct gspca_dev *gspca_dev,
         return 0;
 }
 
-static int sd_querymenu(struct gspca_dev *gspca_dev,
-                        struct v4l2_querymenu *menu)
-{
-        switch (menu->id) {
-        case V4L2_CID_POWER_LINE_FREQUENCY:
-                switch (menu->index) {
-                case 0:         /* V4L2_CID_POWER_LINE_FREQUENCY_DISABLED */
-                        strcpy((char *) menu->name, "NoFliker");
-                        return 0;
-                case 1:         /* V4L2_CID_POWER_LINE_FREQUENCY_50HZ */
-                        strcpy((char *) menu->name, "50 Hz");
-                        return 0;
-                case 2:         /* V4L2_CID_POWER_LINE_FREQUENCY_60HZ */
-                        strcpy((char *) menu->name, "60 Hz");
-                        return 0;
-                }
-                break;
-        }
-        return -EINVAL;
-}
-
 /* sub-driver description */
-static const struct sd_desc sd_desc_ov772x = {
+static const struct sd_desc sd_desc = {
         .name     = MODULE_NAME,
-        .ctrls    = sd_ctrls_ov772x,
-        .nctrls   = ARRAY_SIZE(sd_ctrls_ov772x),
+        .ctrls    = sd_ctrls,
+        .nctrls   = ARRAY_SIZE(sd_ctrls),
         .config   = sd_config,
         .init     = sd_init,
-        .start    = sd_start_ov772x,
-        .stopN    = sd_stopN_ov772x,
+        .start    = sd_start,
+        .stopN    = sd_stopN,
         .pkt_scan = sd_pkt_scan,
         .get_streamparm = sd_get_streamparm,
         .set_streamparm = sd_set_streamparm,
 };
 
-static const struct sd_desc sd_desc_ov965x = {
-        .name     = MODULE_NAME,
-        .ctrls    = sd_ctrls_ov965x,
-        .nctrls   = ARRAY_SIZE(sd_ctrls_ov965x),
-        .config   = sd_config,
-        .init     = sd_init,
-        .start    = sd_start_ov965x,
-        .stopN    = sd_stopN_ov965x,
-        .pkt_scan = sd_pkt_scan,
-        .querymenu = sd_querymenu,
-};
-
 /* -- module initialisation -- */
 static const __devinitdata struct usb_device_id device_table[] = {
-        {USB_DEVICE(0x06f8, 0x3003), .driver_info = SENSOR_OV965X},
-        {USB_DEVICE(0x1415, 0x2000), .driver_info = SENSOR_OV772X},
+        {USB_DEVICE(0x1415, 0x2000)},
         {}
 };
 
@@ -2326,11 +1311,7 @@ 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,
-                                id->driver_info == SENSOR_OV772X
-                                        ? &sd_desc_ov772x
-                                        : &sd_desc_ov965x,
-                                sizeof(struct sd),
+        return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
                                 THIS_MODULE);
 }
 
diff --git a/drivers/media/video/gspca/ov534_9.c b/drivers/media/video/gspca/ov534_9.c
new file mode 100644
index 000000000000..bbe5a030e3b4
--- /dev/null
+++ b/drivers/media/video/gspca/ov534_9.c
@@ -0,0 +1,1477 @@
+/*
+ * ov534-ov965x gspca driver
+ *
+ * Copyright (C) 2009-2010 Jean-Francois Moine http://moinejf.free.fr
+ * Copyright (C) 2008 Antonio Ospite <ospite@studenti.unina.it>
+ * Copyright (C) 2008 Jim Paris <jim@jtan.com>
+ *
+ * Based on a prototype written by Mark Ferrell <majortrips@gmail.com>
+ * USB protocol reverse engineered by Jim Paris <jim@jtan.com>
+ * https://jim.sh/svn/jim/devl/playstation/ps3/eye/test/
+ *
+ * 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
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#define MODULE_NAME "ov534_9"
+
+#include "gspca.h"
+
+#define OV534_REG_ADDRESS       0xf1    /* sensor address */
+#define OV534_REG_SUBADDR       0xf2
+#define OV534_REG_WRITE         0xf3
+#define OV534_REG_READ          0xf4
+#define OV534_REG_OPERATION     0xf5
+#define OV534_REG_STATUS        0xf6
+
+#define OV534_OP_WRITE_3        0x37
+#define OV534_OP_WRITE_2        0x33
+#define OV534_OP_READ_2         0xf9
+
+#define CTRL_TIMEOUT 500
+
+MODULE_AUTHOR("Jean-Francois Moine <moinejf@free.fr>");
+MODULE_DESCRIPTION("GSPCA/OV534_9 USB Camera Driver");
+MODULE_LICENSE("GPL");
+
+/* specific webcam descriptor */
+struct sd {
+        struct gspca_dev gspca_dev;     /* !! must be the first item */
+        __u32 last_pts;
+        u8 last_fid;
+
+        u8 brightness;
+        u8 contrast;
+        u8 autogain;
+        u8 exposure;
+        s8 sharpness;
+        u8 satur;
+        u8 freq;
+};
+
+/* V4L2 controls supported by the driver */
+static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val);
+static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val);
+static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val);
+static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val);
+static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val);
+static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val);
+static int sd_setexposure(struct gspca_dev *gspca_dev, __s32 val);
+static int sd_getexposure(struct gspca_dev *gspca_dev, __s32 *val);
+static int sd_setsharpness(struct gspca_dev *gspca_dev, __s32 val);
+static int sd_getsharpness(struct gspca_dev *gspca_dev, __s32 *val);
+static int sd_setsatur(struct gspca_dev *gspca_dev, __s32 val);
+static int sd_getsatur(struct gspca_dev *gspca_dev, __s32 *val);
+static int sd_setfreq(struct gspca_dev *gspca_dev, __s32 val);
+static int sd_getfreq(struct gspca_dev *gspca_dev, __s32 *val);
+
+static const struct ctrl sd_ctrls[] = {
+    {                                                   /* 0 */
+        {
+                .id      = V4L2_CID_BRIGHTNESS,
+                .type    = V4L2_CTRL_TYPE_INTEGER,
+                .name    = "Brightness",
+                .minimum = 0,
+                .maximum = 15,
+                .step    = 1,
+#define BRIGHTNESS_DEF 7
+                .default_value = BRIGHTNESS_DEF,
+        },
+        .set = sd_setbrightness,
+        .get = sd_getbrightness,
+    },
+    {                                                   /* 1 */
+        {
+                .id      = V4L2_CID_CONTRAST,
+                .type    = V4L2_CTRL_TYPE_INTEGER,
+                .name    = "Contrast",
+                .minimum = 0,
+                .maximum = 15,
+                .step    = 1,
+#define CONTRAST_DEF 3
+                .default_value = CONTRAST_DEF,
+        },
+        .set = sd_setcontrast,
+        .get = sd_getcontrast,
+    },
+    {                                                   /* 2 */
+        {
+                .id      = V4L2_CID_AUTOGAIN,
+                .type    = V4L2_CTRL_TYPE_BOOLEAN,
+                .name    = "Autogain",
+                .minimum = 0,
+                .maximum = 1,
+                .step    = 1,
+#define AUTOGAIN_DEF 1
+                .default_value = AUTOGAIN_DEF,
+        },
+        .set = sd_setautogain,
+        .get = sd_getautogain,
+    },
+#define EXPO_IDX 3
+    {                                                   /* 3 */
+        {
+                .id      = V4L2_CID_EXPOSURE,
+                .type    = V4L2_CTRL_TYPE_INTEGER,
+                .name    = "Exposure",
+                .minimum = 0,
+                .maximum = 3,
+                .step    = 1,
+#define EXPO_DEF 0
+                .default_value = EXPO_DEF,
+        },
+        .set = sd_setexposure,
+        .get = sd_getexposure,
+    },
+    {                                                   /* 4 */
+        {
+                .id      = V4L2_CID_SHARPNESS,
+                .type    = V4L2_CTRL_TYPE_INTEGER,
+                .name    = "Sharpness",
+                .minimum = -1,          /* -1 = auto */
+                .maximum = 4,
+                .step    = 1,
+#define SHARPNESS_DEF -1
+                .default_value = SHARPNESS_DEF,
+        },
+        .set = sd_setsharpness,
+        .get = sd_getsharpness,
+    },
+    {                                                   /* 5 */
+        {
+                .id      = V4L2_CID_SATURATION,
+                .type    = V4L2_CTRL_TYPE_INTEGER,
+                .name    = "Saturation",
+                .minimum = 0,
+                .maximum = 4,
+                .step    = 1,
+#define SATUR_DEF 2
+                .default_value = SATUR_DEF,
+        },
+        .set = sd_setsatur,
+        .get = sd_getsatur,
+    },
+    {
+        {
+                .id      = V4L2_CID_POWER_LINE_FREQUENCY,
+                .type    = V4L2_CTRL_TYPE_MENU,
+                .name    = "Light frequency filter",
+                .minimum = 0,
+                .maximum = 2,   /* 0: 0, 1: 50Hz, 2:60Hz */
+                .step    = 1,
+#define FREQ_DEF 0
+                .default_value = FREQ_DEF,
+        },
+        .set = sd_setfreq,
+        .get = sd_getfreq,
+    },
+};
+
+static const struct v4l2_pix_format ov965x_mode[] = {
+#define QVGA_MODE 0
+        {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
+                .bytesperline = 320,
+                .sizeimage = 320 * 240 * 3 / 8 + 590,
+                .colorspace = V4L2_COLORSPACE_JPEG},
+#define VGA_MODE 1
+        {640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
+                .bytesperline = 640,
+                .sizeimage = 640 * 480 * 3 / 8 + 590,
+                .colorspace = V4L2_COLORSPACE_JPEG},
+#define SVGA_MODE 2
+        {800, 600, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
+                .bytesperline = 800,
+                .sizeimage = 800 * 600 * 3 / 8 + 590,
+                .colorspace = V4L2_COLORSPACE_JPEG},
+#define XGA_MODE 3
+        {1024, 768, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
+                .bytesperline = 1024,
+                .sizeimage = 1024 * 768 * 3 / 8 + 590,
+                .colorspace = V4L2_COLORSPACE_JPEG},
+#define SXGA_MODE 4
+        {1280, 1024, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
+                .bytesperline = 1280,
+                .sizeimage = 1280 * 1024 * 3 / 8 + 590,
+                .colorspace = V4L2_COLORSPACE_JPEG},
+};
+
+static const u8 bridge_init[][2] = {
+        {0x88, 0xf8},
+        {0x89, 0xff},
+        {0x76, 0x03},
+        {0x92, 0x03},
+        {0x95, 0x10},
+        {0xe2, 0x00},
+        {0xe7, 0x3e},
+        {0x8d, 0x1c},
+        {0x8e, 0x00},
+        {0x8f, 0x00},
+        {0x1f, 0x00},
+        {0xc3, 0xf9},
+        {0x89, 0xff},
+        {0x88, 0xf8},
+        {0x76, 0x03},
+        {0x92, 0x01},
+        {0x93, 0x18},
+        {0x1c, 0x0a},
+        {0x1d, 0x48},
+        {0xc0, 0x50},
+        {0xc1, 0x3c},
+        {0x34, 0x05},
+        {0xc2, 0x0c},
+        {0xc3, 0xf9},
+        {0x34, 0x05},
+        {0xe7, 0x2e},
+        {0x31, 0xf9},
+        {0x35, 0x02},
+        {0xd9, 0x10},
+        {0x25, 0x42},
+        {0x94, 0x11},
+};
+
+static const u8 sensor_init[][2] = {
+        {0x12, 0x80},   /* com7 - SSCB reset */
+        {0x00, 0x00},   /* gain */
+        {0x01, 0x80},   /* blue */
+        {0x02, 0x80},   /* red */
+        {0x03, 0x1b},   /* vref */
+        {0x04, 0x03},   /* com1 - exposure low bits */
+        {0x0b, 0x57},   /* ver */
+        {0x0e, 0x61},   /* com5 */
+        {0x0f, 0x42},   /* com6 */
+        {0x11, 0x00},   /* clkrc */
+        {0x12, 0x02},   /* com7 - 15fps VGA YUYV */
+        {0x13, 0xe7},   /* com8 - everything (AGC, AWB and AEC) */
+        {0x14, 0x28},   /* com9 */
+        {0x16, 0x24},   /* reg16 */
+        {0x17, 0x1d},   /* hstart*/
+        {0x18, 0xbd},   /* hstop */
+        {0x19, 0x01},   /* vstrt */
+        {0x1a, 0x81},   /* vstop*/
+        {0x1e, 0x04},   /* mvfp */
+        {0x24, 0x3c},   /* aew */
+        {0x25, 0x36},   /* aeb */
+        {0x26, 0x71},   /* vpt */
+        {0x27, 0x08},   /* bbias */
+        {0x28, 0x08},   /* gbbias */
+        {0x29, 0x15},   /* gr com */
+        {0x2a, 0x00},   /* exhch */
+        {0x2b, 0x00},   /* exhcl */
+        {0x2c, 0x08},   /* rbias */
+        {0x32, 0xff},   /* href */
+        {0x33, 0x00},   /* chlf */
+        {0x34, 0x3f},   /* aref1 */
+        {0x35, 0x00},   /* aref2 */
+        {0x36, 0xf8},   /* aref3 */
+        {0x38, 0x72},   /* adc2 */
+        {0x39, 0x57},   /* aref4 */
+        {0x3a, 0x80},   /* tslb - yuyv */
+        {0x3b, 0xc4},   /* com11 - night mode 1/4 frame rate */
+        {0x3d, 0x99},   /* com13 */
+        {0x3f, 0xc1},   /* edge */
+        {0x40, 0xc0},   /* com15 */
+        {0x41, 0x40},   /* com16 */
+        {0x42, 0xc0},   /* com17 */
+        {0x43, 0x0a},   /* rsvd */
+        {0x44, 0xf0},
+        {0x45, 0x46},
+        {0x46, 0x62},
+        {0x47, 0x2a},
+        {0x48, 0x3c},
+        {0x4a, 0xfc},
+        {0x4b, 0xfc},
+        {0x4c, 0x7f},
+        {0x4d, 0x7f},
+        {0x4e, 0x7f},
+        {0x4f, 0x98},   /* matrix */
+        {0x50, 0x98},
+        {0x51, 0x00},
+        {0x52, 0x28},
+        {0x53, 0x70},
+        {0x54, 0x98},
+        {0x58, 0x1a},   /* matrix coef sign */
+        {0x59, 0x85},   /* AWB control */
+        {0x5a, 0xa9},
+        {0x5b, 0x64},
+        {0x5c, 0x84},
+        {0x5d, 0x53},
+        {0x5e, 0x0e},
+        {0x5f, 0xf0},   /* AWB blue limit */
+        {0x60, 0xf0},   /* AWB red limit */
+        {0x61, 0xf0},   /* AWB green limit */
+        {0x62, 0x00},   /* lcc1 */
+        {0x63, 0x00},   /* lcc2 */
+        {0x64, 0x02},   /* lcc3 */
+        {0x65, 0x16},   /* lcc4 */
+        {0x66, 0x01},   /* lcc5 */
+        {0x69, 0x02},   /* hv */
+        {0x6b, 0x5a},   /* dbvl */
+        {0x6c, 0x04},
+        {0x6d, 0x55},
+        {0x6e, 0x00},
+        {0x6f, 0x9d},
+        {0x70, 0x21},   /* dnsth */
+        {0x71, 0x78},
+        {0x72, 0x00},   /* poidx */
+        {0x73, 0x01},   /* pckdv */
+        {0x74, 0x3a},   /* xindx */
+        {0x75, 0x35},   /* yindx */
+        {0x76, 0x01},
+        {0x77, 0x02},
+        {0x7a, 0x12},   /* gamma curve */
+        {0x7b, 0x08},
+        {0x7c, 0x16},
+        {0x7d, 0x30},
+        {0x7e, 0x5e},
+        {0x7f, 0x72},
+        {0x80, 0x82},
+        {0x81, 0x8e},
+        {0x82, 0x9a},
+        {0x83, 0xa4},
+        {0x84, 0xac},
+        {0x85, 0xb8},
+        {0x86, 0xc3},
+        {0x87, 0xd6},
+        {0x88, 0xe6},
+        {0x89, 0xf2},
+        {0x8a, 0x03},
+        {0x8c, 0x89},   /* com19 */
+        {0x14, 0x28},   /* com9 */
+        {0x90, 0x7d},
+        {0x91, 0x7b},
+        {0x9d, 0x03},   /* lcc6 */
+        {0x9e, 0x04},   /* lcc7 */
+        {0x9f, 0x7a},
+        {0xa0, 0x79},
+        {0xa1, 0x40},   /* aechm */
+        {0xa4, 0x50},   /* com21 */
+        {0xa5, 0x68},   /* com26 */
+        {0xa6, 0x4a},   /* AWB green */
+        {0xa8, 0xc1},   /* refa8 */
+        {0xa9, 0xef},   /* refa9 */
+        {0xaa, 0x92},
+        {0xab, 0x04},
+        {0xac, 0x80},   /* black level control */
+        {0xad, 0x80},
+        {0xae, 0x80},
+        {0xaf, 0x80},
+        {0xb2, 0xf2},
+        {0xb3, 0x20},
+        {0xb4, 0x20},   /* ctrlb4 */
+        {0xb5, 0x00},
+        {0xb6, 0xaf},
+        {0xbb, 0xae},
+        {0xbc, 0x7f},   /* ADC channel offsets */
+        {0xdb, 0x7f},
+        {0xbe, 0x7f},
+        {0xbf, 0x7f},
+        {0xc0, 0xe2},
+        {0xc1, 0xc0},
+        {0xc2, 0x01},
+        {0xc3, 0x4e},
+        {0xc6, 0x85},
+        {0xc7, 0x80},   /* com24 */
+        {0xc9, 0xe0},
+        {0xca, 0xe8},
+        {0xcb, 0xf0},
+        {0xcc, 0xd8},
+        {0xcd, 0xf1},
+        {0x4f, 0x98},   /* matrix */
+        {0x50, 0x98},
+        {0x51, 0x00},
+        {0x52, 0x28},
+        {0x53, 0x70},
+        {0x54, 0x98},
+        {0x58, 0x1a},
+        {0xff, 0x41},   /* read 41, write ff 00 */
+        {0x41, 0x40},   /* com16 */
+
+        {0xc5, 0x03},   /* 60 Hz banding filter */
+        {0x6a, 0x02},   /* 50 Hz banding filter */
+
+        {0x12, 0x62},   /* com7 - 30fps VGA YUV */
+        {0x36, 0xfa},   /* aref3 */
+        {0x69, 0x0a},   /* hv */
+        {0x8c, 0x89},   /* com22 */
+        {0x14, 0x28},   /* com9 */
+        {0x3e, 0x0c},
+        {0x41, 0x40},   /* com16 */
+        {0x72, 0x00},
+        {0x73, 0x00},
+        {0x74, 0x3a},
+        {0x75, 0x35},
+        {0x76, 0x01},
+        {0xc7, 0x80},
+        {0x03, 0x12},   /* vref */
+        {0x17, 0x16},   /* hstart */
+        {0x18, 0x02},   /* hstop */
+        {0x19, 0x01},   /* vstrt */
+        {0x1a, 0x3d},   /* vstop */
+        {0x32, 0xff},   /* href */
+        {0xc0, 0xaa},
+};
+
+static const u8 bridge_init_2[][2] = {
+        {0x94, 0xaa},
+        {0xf1, 0x60},
+        {0xe5, 0x04},
+        {0xc0, 0x50},
+        {0xc1, 0x3c},
+        {0x8c, 0x00},
+        {0x8d, 0x1c},
+        {0x34, 0x05},
+
+        {0xc2, 0x0c},
+        {0xc3, 0xf9},
+        {0xda, 0x01},
+        {0x50, 0x00},
+        {0x51, 0xa0},
+        {0x52, 0x3c},
+        {0x53, 0x00},
+        {0x54, 0x00},
+        {0x55, 0x00},
+        {0x57, 0x00},
+        {0x5c, 0x00},
+        {0x5a, 0xa0},
+        {0x5b, 0x78},
+        {0x35, 0x02},
+        {0xd9, 0x10},
+        {0x94, 0x11},
+};
+
+static const u8 sensor_init_2[][2] = {
+        {0x3b, 0xc4},
+        {0x1e, 0x04},   /* mvfp */
+        {0x13, 0xe0},   /* com8 */
+        {0x00, 0x00},   /* gain */
+        {0x13, 0xe7},   /* com8 - everything (AGC, AWB and AEC) */
+        {0x11, 0x03},   /* clkrc */
+        {0x6b, 0x5a},   /* dblv */
+        {0x6a, 0x05},
+        {0xc5, 0x07},
+        {0xa2, 0x4b},
+        {0xa3, 0x3e},
+        {0x2d, 0x00},
+        {0xff, 0x42},   /* read 42, write ff 00 */
+        {0x42, 0xc0},   /* com17 */
+        {0x2d, 0x00},
+        {0xff, 0x42},   /* read 42, write ff 00 */
+        {0x42, 0xc1},   /* com17 */
+/* sharpness */
+        {0x3f, 0x01},
+        {0xff, 0x42},   /* read 42, write ff 00 */
+        {0x42, 0xc1},   /* com17 */
+/* saturation */
+        {0x4f, 0x98},   /* matrix */
+        {0x50, 0x98},
+        {0x51, 0x00},
+        {0x52, 0x28},
+        {0x53, 0x70},
+        {0x54, 0x98},
+        {0x58, 0x1a},
+        {0xff, 0x41},   /* read 41, write ff 00 */
+        {0x41, 0x40},   /* com16 */
+/* contrast */
+        {0x56, 0x40},
+/* brightness */
+        {0x55, 0x8f},
+/* expo */
+        {0x10, 0x25},   /* aech - exposure high bits */
+        {0xff, 0x13},   /* read 13, write ff 00 */
+        {0x13, 0xe7},   /* com8 - everything (AGC, AWB and AEC) */
+};
+
+static const u8 sensor_start_1_vga[][2] = {     /* same for qvga */
+        {0x12, 0x62},   /* com7 - 30fps VGA YUV */
+        {0x36, 0xfa},   /* aref3 */
+        {0x69, 0x0a},   /* hv */
+        {0x8c, 0x89},   /* com22 */
+        {0x14, 0x28},   /* com9 */
+        {0x3e, 0x0c},   /* com14 */
+        {0x41, 0x40},   /* com16 */
+        {0x72, 0x00},
+        {0x73, 0x00},
+        {0x74, 0x3a},
+        {0x75, 0x35},
+        {0x76, 0x01},
+        {0xc7, 0x80},   /* com24 */
+        {0x03, 0x12},   /* vref */
+        {0x17, 0x16},   /* hstart */
+        {0x18, 0x02},   /* hstop */
+        {0x19, 0x01},   /* vstrt */
+        {0x1a, 0x3d},   /* vstop */
+        {0x32, 0xff},   /* href */
+        {0xc0, 0xaa},
+};
+
+static const u8 sensor_start_1_svga[][2] = {
+        {0x12, 0x02},   /* com7 - YUYV - VGA 15 full resolution */
+        {0x36, 0xf8},   /* aref3 */
+        {0x69, 0x02},   /* hv */
+        {0x8c, 0x0d},   /* com22 */
+        {0x3e, 0x0c},   /* com14 */
+        {0x41, 0x40},   /* com16 */
+        {0x72, 0x00},
+        {0x73, 0x01},
+        {0x74, 0x3a},
+        {0x75, 0x35},
+        {0x76, 0x01},
+        {0xc7, 0x80},   /* com24 */
+        {0x03, 0x1b},   /* vref */
+        {0x17, 0x1d},   /* hstart */
+        {0x18, 0xbd},   /* hstop */
+        {0x19, 0x01},   /* vstrt */
+        {0x1a, 0x81},   /* vstop */
+        {0x32, 0xff},   /* href */
+        {0xc0, 0xe2},
+};
+
+static const u8 sensor_start_1_xga[][2] = {
+        {0x12, 0x02},   /* com7 */
+        {0x36, 0xf8},   /* aref3 */
+        {0x69, 0x02},   /* hv */
+        {0x8c, 0x89},   /* com22 */
+        {0x14, 0x28},   /* com9 */
+        {0x3e, 0x0c},   /* com14 */
+        {0x41, 0x40},   /* com16 */
+        {0x72, 0x00},
+        {0x73, 0x01},
+        {0x74, 0x3a},
+        {0x75, 0x35},
+        {0x76, 0x01},
+        {0xc7, 0x80},   /* com24 */
+        {0x03, 0x1b},   /* vref */
+        {0x17, 0x1d},   /* hstart */
+        {0x18, 0xbd},   /* hstop */
+        {0x19, 0x01},   /* vstrt */
+        {0x1a, 0x81},   /* vstop */
+        {0x32, 0xff},   /* href */
+        {0xc0, 0xe2},
+};
+
+static const u8 sensor_start_1_sxga[][2] = {
+        {0x12, 0x02},   /* com7 */
+        {0x36, 0xf8},   /* aref3 */
+        {0x69, 0x02},   /* hv */
+        {0x8c, 0x89},   /* com22 */
+        {0x14, 0x28},   /* com9 */
+        {0x3e, 0x0c},   /* com14 */
+        {0x41, 0x40},   /* com16 */
+        {0x72, 0x00},
+        {0x73, 0x01},
+        {0x74, 0x3a},
+        {0x75, 0x35},
+        {0x76, 0x01},
+        {0xc7, 0x80},   /* com24 */
+        {0x03, 0x1b},   /* vref */
+        {0x17, 0x1d},   /* hstart */
+        {0x18, 0x02},   /* hstop */
+        {0x19, 0x01},   /* vstrt */
+        {0x1a, 0x81},   /* vstop */
+        {0x32, 0xff},   /* href */
+        {0xc0, 0xe2},
+};
+
+static const u8 bridge_start_qvga[][2] = {
+        {0x94, 0xaa},
+        {0xf1, 0x60},
+        {0xe5, 0x04},
+        {0xc0, 0x50},
+        {0xc1, 0x3c},
+        {0x8c, 0x00},
+        {0x8d, 0x1c},
+        {0x34, 0x05},
+
+        {0xc2, 0x4c},
+        {0xc3, 0xf9},
+        {0xda, 0x00},
+        {0x50, 0x00},
+        {0x51, 0xa0},
+        {0x52, 0x78},
+        {0x53, 0x00},
+        {0x54, 0x00},
+        {0x55, 0x00},
+        {0x57, 0x00},
+        {0x5c, 0x00},
+        {0x5a, 0x50},
+        {0x5b, 0x3c},
+        {0x35, 0x02},
+        {0xd9, 0x10},
+        {0x94, 0x11},
+};
+
+static const u8 bridge_start_vga[][2] = {
+        {0x94, 0xaa},
+        {0xf1, 0x60},
+        {0xe5, 0x04},
+        {0xc0, 0x50},
+        {0xc1, 0x3c},
+        {0x8c, 0x00},
+        {0x8d, 0x1c},
+        {0x34, 0x05},
+        {0xc2, 0x0c},
+        {0xc3, 0xf9},
+        {0xda, 0x01},
+        {0x50, 0x00},
+        {0x51, 0xa0},
+        {0x52, 0x3c},
+        {0x53, 0x00},
+        {0x54, 0x00},
+        {0x55, 0x00},
+        {0x57, 0x00},
+        {0x5c, 0x00},
+        {0x5a, 0xa0},
+        {0x5b, 0x78},
+        {0x35, 0x02},
+        {0xd9, 0x10},
+        {0x94, 0x11},
+};
+
+static const u8 bridge_start_svga[][2] = {
+        {0x94, 0xaa},
+        {0xf1, 0x60},
+        {0xe5, 0x04},
+        {0xc0, 0xa0},
+        {0xc1, 0x80},
+        {0x8c, 0x00},
+        {0x8d, 0x1c},
+        {0x34, 0x05},
+        {0xc2, 0x4c},
+        {0xc3, 0xf9},
+        {0x50, 0x00},
+        {0x51, 0x40},
+        {0x52, 0x00},
+        {0x53, 0x00},
+        {0x54, 0x00},
+        {0x55, 0x88},
+        {0x57, 0x00},
+        {0x5c, 0x00},
+        {0x5a, 0xc8},
+        {0x5b, 0x96},
+        {0x35, 0x02},
+        {0xd9, 0x10},
+        {0xda, 0x00},
+        {0x94, 0x11},
+};
+
+static const u8 bridge_start_xga[][2] = {
+        {0x94, 0xaa},
+        {0xf1, 0x60},
+        {0xe5, 0x04},
+        {0xc0, 0xa0},
+        {0xc1, 0x80},
+        {0x8c, 0x00},
+        {0x8d, 0x1c},
+        {0x34, 0x05},
+        {0xc2, 0x4c},
+        {0xc3, 0xf9},
+        {0x50, 0x00},
+        {0x51, 0x40},
+        {0x52, 0x00},
+        {0x53, 0x00},
+        {0x54, 0x00},
+        {0x55, 0x88},
+        {0x57, 0x00},
+        {0x5c, 0x01},
+        {0x5a, 0x00},
+        {0x5b, 0xc0},
+        {0x35, 0x02},
+        {0xd9, 0x10},
+        {0xda, 0x01},
+        {0x94, 0x11},
+};
+
+static const u8 bridge_start_sxga[][2] = {
+        {0x94, 0xaa},
+        {0xf1, 0x60},
+        {0xe5, 0x04},
+        {0xc0, 0xa0},
+        {0xc1, 0x80},
+        {0x8c, 0x00},
+        {0x8d, 0x1c},
+        {0x34, 0x05},
+        {0xc2, 0x0c},
+        {0xc3, 0xf9},
+        {0xda, 0x00},
+        {0x35, 0x02},
+        {0xd9, 0x10},
+        {0x94, 0x11},
+};
+
+static const u8 sensor_start_2_qvga[][2] = {
+        {0x3b, 0xe4},   /* com11 - night mode 1/4 frame rate */
+        {0x1e, 0x04},   /* mvfp */
+        {0x13, 0xe0},   /* com8 */
+        {0x00, 0x00},
+        {0x13, 0xe7},   /* com8 - everything (AGC, AWB and AEC) */
+        {0x11, 0x01},   /* clkrc */
+        {0x6b, 0x5a},   /* dblv */
+        {0x6a, 0x02},   /* 50 Hz banding filter */
+        {0xc5, 0x03},   /* 60 Hz banding filter */
+        {0xa2, 0x96},   /* bd50 */
+        {0xa3, 0x7d},   /* bd60 */
+
+        {0xff, 0x13},   /* read 13, write ff 00 */
+        {0x13, 0xe7},
+        {0x3a, 0x80},   /* tslb - yuyv */
+};
+
+static const u8 sensor_start_2_vga[][2] = {
+        {0x3b, 0xc4},   /* com11 - night mode 1/4 frame rate */
+        {0x1e, 0x04},   /* mvfp */
+        {0x13, 0xe0},   /* com8 */
+        {0x00, 0x00},
+        {0x13, 0xe7},   /* com8 - everything (AGC, AWB and AEC) */
+        {0x11, 0x03},   /* clkrc */
+        {0x6b, 0x5a},   /* dblv */
+        {0x6a, 0x05},   /* 50 Hz banding filter */
+        {0xc5, 0x07},   /* 60 Hz banding filter */
+        {0xa2, 0x4b},   /* bd50 */
+        {0xa3, 0x3e},   /* bd60 */
+
+        {0x2d, 0x00},   /* advfl */
+};
+
+static const u8 sensor_start_2_svga[][2] = {    /* same for xga */
+        {0x3b, 0xc4},   /* com11 - night mode 1/4 frame rate */
+        {0x1e, 0x04},   /* mvfp */
+        {0x13, 0xe0},   /* com8 */
+        {0x00, 0x00},
+        {0x13, 0xe7},   /* com8 - everything (AGC, AWB and AEC) */
+        {0x11, 0x01},   /* clkrc */
+        {0x6b, 0x5a},   /* dblv */
+        {0x6a, 0x0c},   /* 50 Hz banding filter */
+        {0xc5, 0x0f},   /* 60 Hz banding filter */
+        {0xa2, 0x4e},   /* bd50 */
+        {0xa3, 0x41},   /* bd60 */
+};
+
+static const u8 sensor_start_2_sxga[][2] = {
+        {0x13, 0xe0},   /* com8 */
+        {0x00, 0x00},
+        {0x13, 0xe7},   /* com8 - everything (AGC, AWB and AEC) */
+        {0x3b, 0xc4},   /* com11 - night mode 1/4 frame rate */
+        {0x1e, 0x04},   /* mvfp */
+        {0x11, 0x01},   /* clkrc */
+        {0x6b, 0x5a},   /* dblv */
+        {0x6a, 0x0c},   /* 50 Hz banding filter */
+        {0xc5, 0x0f},   /* 60 Hz banding filter */
+        {0xa2, 0x4e},   /* bd50 */
+        {0xa3, 0x41},   /* bd60 */
+};
+
+static void reg_w_i(struct gspca_dev *gspca_dev, u16 reg, u8 val)
+{
+        struct usb_device *udev = gspca_dev->dev;
+        int ret;
+
+        if (gspca_dev->usb_err < 0)
+                return;
+        gspca_dev->usb_buf[0] = val;
+        ret = usb_control_msg(udev,
+                              usb_sndctrlpipe(udev, 0),
+                              0x01,
+                              USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+                              0x00, reg, gspca_dev->usb_buf, 1, CTRL_TIMEOUT);
+        if (ret < 0) {
+                PDEBUG(D_ERR, "reg_w failed %d", ret);
+                gspca_dev->usb_err = ret;
+        }
+}
+
+static void reg_w(struct gspca_dev *gspca_dev, u16 reg, u8 val)
+{
+        PDEBUG(D_USBO, "reg_w [%04x] = %02x", reg, val);
+        reg_w_i(gspca_dev, reg, val);
+}
+
+static u8 reg_r(struct gspca_dev *gspca_dev, u16 reg)
+{
+        struct usb_device *udev = gspca_dev->dev;
+        int ret;
+
+        if (gspca_dev->usb_err < 0)
+                return 0;
+        ret = usb_control_msg(udev,
+                              usb_rcvctrlpipe(udev, 0),
+                              0x01,
+                              USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+                              0x00, reg, gspca_dev->usb_buf, 1, CTRL_TIMEOUT);
+        PDEBUG(D_USBI, "reg_r [%04x] -> %02x", reg, gspca_dev->usb_buf[0]);
+        if (ret < 0) {
+                PDEBUG(D_ERR, "reg_r err %d", ret);
+                gspca_dev->usb_err = ret;
+        }
+        return gspca_dev->usb_buf[0];
+}
+
+static int sccb_check_status(struct gspca_dev *gspca_dev)
+{
+        u8 data;
+        int i;
+
+        for (i = 0; i < 5; i++) {
+                data = reg_r(gspca_dev, OV534_REG_STATUS);
+
+                switch (data) {
+                case 0x00:
+                        return 1;
+                case 0x04:
+                        return 0;
+                case 0x03:
+                        break;
+                default:
+                        PDEBUG(D_USBI|D_USBO,
+                                "sccb status 0x%02x, attempt %d/5",
+                                data, i + 1);
+                }
+        }
+        return 0;
+}
+
+static void sccb_write(struct gspca_dev *gspca_dev, u8 reg, u8 val)
+{
+        PDEBUG(D_USBO, "sccb_write [%02x] = %02x", reg, val);
+        reg_w_i(gspca_dev, OV534_REG_SUBADDR, reg);
+        reg_w_i(gspca_dev, OV534_REG_WRITE, val);
+        reg_w_i(gspca_dev, OV534_REG_OPERATION, OV534_OP_WRITE_3);
+
+        if (!sccb_check_status(gspca_dev))
+                PDEBUG(D_ERR, "sccb_write failed");
+}
+
+static u8 sccb_read(struct gspca_dev *gspca_dev, u16 reg)
+{
+        reg_w(gspca_dev, OV534_REG_SUBADDR, reg);
+        reg_w(gspca_dev, OV534_REG_OPERATION, OV534_OP_WRITE_2);
+        if (!sccb_check_status(gspca_dev))
+                PDEBUG(D_ERR, "sccb_read failed 1");
+
+        reg_w(gspca_dev, OV534_REG_OPERATION, OV534_OP_READ_2);
+        if (!sccb_check_status(gspca_dev))
+                PDEBUG(D_ERR, "sccb_read failed 2");
+
+        return reg_r(gspca_dev, OV534_REG_READ);
+}
+
+/* output a bridge sequence (reg - val) */
+static void reg_w_array(struct gspca_dev *gspca_dev,
+                        const u8 (*data)[2], int len)
+{
+        while (--len >= 0) {
+                reg_w(gspca_dev, (*data)[0], (*data)[1]);
+                data++;
+        }
+}
+
+/* output a sensor sequence (reg - val) */
+static void sccb_w_array(struct gspca_dev *gspca_dev,
+                        const u8 (*data)[2], int len)
+{
+        while (--len >= 0) {
+                if ((*data)[0] != 0xff) {
+                        sccb_write(gspca_dev, (*data)[0], (*data)[1]);
+                } else {
+                        sccb_read(gspca_dev, (*data)[1]);
+                        sccb_write(gspca_dev, 0xff, 0x00);
+                }
+                data++;
+        }
+}
+
+/* Two bits control LED: 0x21 bit 7 and 0x23 bit 7.
+ * (direction and output)? */
+static void set_led(struct gspca_dev *gspca_dev, int status)
+{
+        u8 data;
+
+        PDEBUG(D_CONF, "led status: %d", status);
+
+        data = reg_r(gspca_dev, 0x21);
+        data |= 0x80;
+        reg_w(gspca_dev, 0x21, data);
+
+        data = reg_r(gspca_dev, 0x23);
+        if (status)
+                data |= 0x80;
+        else
+                data &= ~0x80;
+
+        reg_w(gspca_dev, 0x23, data);
+
+        if (!status) {
+                data = reg_r(gspca_dev, 0x21);
+                data &= ~0x80;
+                reg_w(gspca_dev, 0x21, data);
+        }
+}
+
+static void setbrightness(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        u8 val;
+
+        val = sd->brightness;
+        if (val < 8)
+                val = 15 - val;         /* f .. 8 */
+        else
+                val = val - 8;          /* 0 .. 7 */
+        sccb_write(gspca_dev, 0x55,     /* brtn - brightness adjustment */
+                        0x0f | (val << 4));
+}
+
+static void setcontrast(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        sccb_write(gspca_dev, 0x56,     /* cnst1 - contrast 1 ctrl coeff */
+                        sd->contrast << 4);
+}
+
+static void setautogain(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        u8 val;
+
+/*fixme: should adjust agc/awb/aec by different controls */
+        val = sd->autogain;
+        val = sccb_read(gspca_dev, 0x13);               /* com8 */
+        sccb_write(gspca_dev, 0xff, 0x00);
+        if (sd->autogain)
+                val |= 0x05;            /* agc & aec */
+        else
+                val &= 0xfa;
+        sccb_write(gspca_dev, 0x13, val);
+}
+
+static void setexposure(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        u8 val;
+        static const u8 expo[4] = {0x00, 0x25, 0x38, 0x5e};
+
+        sccb_write(gspca_dev, 0x10,                     /* aec[9:2] */
+                        expo[sd->exposure]);
+
+        val = sccb_read(gspca_dev, 0x13);               /* com8 */
+        sccb_write(gspca_dev, 0xff, 0x00);
+        sccb_write(gspca_dev, 0x13, val);
+
+        val = sccb_read(gspca_dev, 0xa1);               /* aech */
+        sccb_write(gspca_dev, 0xff, 0x00);
+        sccb_write(gspca_dev, 0xa1, val & 0xe0);        /* aec[15:10] = 0 */
+}
+
+static void setsharpness(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        s8 val;
+
+        val = sd->sharpness;
+        if (val < 0) {                          /* auto */
+                val = sccb_read(gspca_dev, 0x42);       /* com17 */
+                sccb_write(gspca_dev, 0xff, 0x00);
+                sccb_write(gspca_dev, 0x42, val | 0x40);
+                                /* Edge enhancement strength auto adjust */
+                return;
+        }
+        if (val != 0)
+                val = 1 << (val - 1);
+        sccb_write(gspca_dev, 0x3f,     /* edge - edge enhance. factor */
+                        val);
+        val = sccb_read(gspca_dev, 0x42);               /* com17 */
+        sccb_write(gspca_dev, 0xff, 0x00);
+        sccb_write(gspca_dev, 0x42, val & 0xbf);
+}
+
+static void setsatur(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        u8 val1, val2, val3;
+        static const u8 matrix[5][2] = {
+                {0x14, 0x38},
+                {0x1e, 0x54},
+                {0x28, 0x70},
+                {0x32, 0x8c},
+                {0x48, 0x90}
+        };
+
+        val1 = matrix[sd->satur][0];
+        val2 = matrix[sd->satur][1];
+        val3 = val1 + val2;
+        sccb_write(gspca_dev, 0x4f, val3);      /* matrix coeff */
+        sccb_write(gspca_dev, 0x50, val3);
+        sccb_write(gspca_dev, 0x51, 0x00);
+        sccb_write(gspca_dev, 0x52, val1);
+        sccb_write(gspca_dev, 0x53, val2);
+        sccb_write(gspca_dev, 0x54, val3);
+        sccb_write(gspca_dev, 0x58, 0x1a);      /* mtxs - coeff signs */
+
+        val1 = sccb_read(gspca_dev, 0x41);      /* com16 */
+        sccb_write(gspca_dev, 0xff, 0x00);
+        sccb_write(gspca_dev, 0x41, val1);
+}
+
+static void setfreq(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        u8 val;
+
+        val = sccb_read(gspca_dev, 0x13);               /* com8 */
+        sccb_write(gspca_dev, 0xff, 0x00);
+        if (sd->freq == 0) {
+                sccb_write(gspca_dev, 0x13, val & 0xdf);
+                return;
+        }
+        sccb_write(gspca_dev, 0x13, val | 0x20);
+
+        val = sccb_read(gspca_dev, 0x42);               /* com17 */
+        sccb_write(gspca_dev, 0xff, 0x00);
+        if (sd->freq == 1)
+                val |= 0x01;
+        else
+                val &= 0xfe;
+        sccb_write(gspca_dev, 0x42, val);
+}
+
+/* this function is called at probe time */
+static int sd_config(struct gspca_dev *gspca_dev,
+                     const struct usb_device_id *id)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        struct cam *cam;
+
+        cam = &gspca_dev->cam;
+
+        cam->cam_mode = ov965x_mode;
+        cam->nmodes = ARRAY_SIZE(ov965x_mode);
+
+        sd->brightness = BRIGHTNESS_DEF;
+        sd->contrast = CONTRAST_DEF;
+#if AUTOGAIN_DEF != 0
+        sd->autogain = AUTOGAIN_DEF;
+        gspca_dev->ctrl_inac |= (1 << EXPO_IDX);
+#endif
+#if EXPO_DEF != 0
+        sd->exposure = EXPO_DEF;
+#endif
+#if SHARPNESS_DEF != 0
+        sd->sharpness = SHARPNESS_DEF;
+#endif
+        sd->satur = SATUR_DEF;
+        sd->freq = FREQ_DEF;
+
+        return 0;
+}
+
+/* this function is called at probe and resume time */
+static int sd_init(struct gspca_dev *gspca_dev)
+{
+        u16 sensor_id;
+
+        /* reset bridge */
+        reg_w(gspca_dev, 0xe7, 0x3a);
+        reg_w(gspca_dev, 0xe0, 0x08);
+        msleep(100);
+
+        /* initialize the sensor address */
+        reg_w(gspca_dev, OV534_REG_ADDRESS, 0x60);
+
+        /* reset sensor */
+        sccb_write(gspca_dev, 0x12, 0x80);
+        msleep(10);
+
+        /* probe the sensor */
+        sccb_read(gspca_dev, 0x0a);
+        sensor_id = sccb_read(gspca_dev, 0x0a) << 8;
+        sccb_read(gspca_dev, 0x0b);
+        sensor_id |= sccb_read(gspca_dev, 0x0b);
+        PDEBUG(D_PROBE, "Sensor ID: %04x", sensor_id);
+
+        /* initialize */
+        reg_w_array(gspca_dev, bridge_init,
+                        ARRAY_SIZE(bridge_init));
+        sccb_w_array(gspca_dev, sensor_init,
+                        ARRAY_SIZE(sensor_init));
+        reg_w_array(gspca_dev, bridge_init_2,
+                        ARRAY_SIZE(bridge_init_2));
+        sccb_w_array(gspca_dev, sensor_init_2,
+                        ARRAY_SIZE(sensor_init_2));
+        reg_w(gspca_dev, 0xe0, 0x00);
+        reg_w(gspca_dev, 0xe0, 0x01);
+        set_led(gspca_dev, 0);
+        reg_w(gspca_dev, 0xe0, 0x00);
+
+        return gspca_dev->usb_err;
+}
+
+static int sd_start(struct gspca_dev *gspca_dev)
+{
+        switch (gspca_dev->curr_mode) {
+        case QVGA_MODE:                 /* 320x240 */
+                sccb_w_array(gspca_dev, sensor_start_1_vga,
+                                ARRAY_SIZE(sensor_start_1_vga));
+                reg_w_array(gspca_dev, bridge_start_qvga,
+                                ARRAY_SIZE(bridge_start_qvga));
+                sccb_w_array(gspca_dev, sensor_start_2_qvga,
+                                ARRAY_SIZE(sensor_start_2_qvga));
+                break;
+        case VGA_MODE:                  /* 640x480 */
+                sccb_w_array(gspca_dev, sensor_start_1_vga,
+                                ARRAY_SIZE(sensor_start_1_vga));
+                reg_w_array(gspca_dev, bridge_start_vga,
+                                ARRAY_SIZE(bridge_start_vga));
+                sccb_w_array(gspca_dev, sensor_start_2_vga,
+                                ARRAY_SIZE(sensor_start_2_vga));
+                break;
+        case SVGA_MODE:                 /* 800x600 */
+                sccb_w_array(gspca_dev, sensor_start_1_svga,
+                                ARRAY_SIZE(sensor_start_1_svga));
+                reg_w_array(gspca_dev, bridge_start_svga,
+                                ARRAY_SIZE(bridge_start_svga));
+                sccb_w_array(gspca_dev, sensor_start_2_svga,
+                                ARRAY_SIZE(sensor_start_2_svga));
+                break;
+        case XGA_MODE:                  /* 1024x768 */
+                sccb_w_array(gspca_dev, sensor_start_1_xga,
+                                ARRAY_SIZE(sensor_start_1_xga));
+                reg_w_array(gspca_dev, bridge_start_xga,
+                                ARRAY_SIZE(bridge_start_xga));
+                sccb_w_array(gspca_dev, sensor_start_2_svga,
+                                ARRAY_SIZE(sensor_start_2_svga));
+                break;
+        default:
+/*      case SXGA_MODE:                  * 1280x1024 */
+                sccb_w_array(gspca_dev, sensor_start_1_sxga,
+                                ARRAY_SIZE(sensor_start_1_sxga));
+                reg_w_array(gspca_dev, bridge_start_sxga,
+                                ARRAY_SIZE(bridge_start_sxga));
+                sccb_w_array(gspca_dev, sensor_start_2_sxga,
+                                ARRAY_SIZE(sensor_start_2_sxga));
+                break;
+        }
+        setfreq(gspca_dev);
+        setautogain(gspca_dev);
+        setbrightness(gspca_dev);
+        setcontrast(gspca_dev);
+        setexposure(gspca_dev);
+        setsharpness(gspca_dev);
+        setsatur(gspca_dev);
+
+        reg_w(gspca_dev, 0xe0, 0x00);
+        reg_w(gspca_dev, 0xe0, 0x00);
+        set_led(gspca_dev, 1);
+        return gspca_dev->usb_err;
+}
+
+static void sd_stopN(struct gspca_dev *gspca_dev)
+{
+        reg_w(gspca_dev, 0xe0, 0x01);
+        set_led(gspca_dev, 0);
+        reg_w(gspca_dev, 0xe0, 0x00);
+}
+
+/* Values for bmHeaderInfo (Video and Still Image Payload Headers, 2.4.3.3) */
+#define UVC_STREAM_EOH  (1 << 7)
+#define UVC_STREAM_ERR  (1 << 6)
+#define UVC_STREAM_STI  (1 << 5)
+#define UVC_STREAM_RES  (1 << 4)
+#define UVC_STREAM_SCR  (1 << 3)
+#define UVC_STREAM_PTS  (1 << 2)
+#define UVC_STREAM_EOF  (1 << 1)
+#define UVC_STREAM_FID  (1 << 0)
+
+static void sd_pkt_scan(struct gspca_dev *gspca_dev,
+                        u8 *data, int len)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        __u32 this_pts;
+        u8 this_fid;
+        int remaining_len = len;
+
+        do {
+                len = min(remaining_len, 2040);
+
+                /* Payloads are prefixed with a UVC-style header.  We
+                   consider a frame to start when the FID toggles, or the PTS
+                   changes.  A frame ends when EOF is set, and we've received
+                   the correct number of bytes. */
+
+                /* Verify UVC header.  Header length is always 12 */
+                if (data[0] != 12 || len < 12) {
+                        PDEBUG(D_PACK, "bad header");
+                        goto discard;
+                }
+
+                /* Check errors */
+                if (data[1] & UVC_STREAM_ERR) {
+                        PDEBUG(D_PACK, "payload error");
+                        goto discard;
+                }
+
+                /* Extract PTS and FID */
+                if (!(data[1] & UVC_STREAM_PTS)) {
+                        PDEBUG(D_PACK, "PTS not present");
+                        goto discard;
+                }
+                this_pts = (data[5] << 24) | (data[4] << 16)
+                                                | (data[3] << 8) | data[2];
+                this_fid = data[1] & UVC_STREAM_FID;
+
+                /* If PTS or FID has changed, start a new frame. */
+                if (this_pts != sd->last_pts || this_fid != sd->last_fid) {
+                        if (gspca_dev->last_packet_type == INTER_PACKET)
+                                gspca_frame_add(gspca_dev, LAST_PACKET,
+                                                NULL, 0);
+                        sd->last_pts = this_pts;
+                        sd->last_fid = this_fid;
+                        gspca_frame_add(gspca_dev, FIRST_PACKET,
+                                        data + 12, len - 12);
+                /* If this packet is marked as EOF, end the frame */
+                } else if (data[1] & UVC_STREAM_EOF) {
+                        sd->last_pts = 0;
+                        gspca_frame_add(gspca_dev, LAST_PACKET,
+                                        data + 12, len - 12);
+                } else {
+
+                        /* Add the data from this payload */
+                        gspca_frame_add(gspca_dev, INTER_PACKET,
+                                        data + 12, len - 12);
+                }
+
+                /* Done this payload */
+                goto scan_next;
+
+discard:
+                /* Discard data until a new frame starts. */
+                gspca_dev->last_packet_type = DISCARD_PACKET;
+
+scan_next:
+                remaining_len -= len;
+                data += len;
+        } while (remaining_len > 0);
+}
+
+/* controls */
+static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        sd->brightness = val;
+        if (gspca_dev->streaming)
+                setbrightness(gspca_dev);
+        return gspca_dev->usb_err;
+}
+
+static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        *val = sd->brightness;
+        return 0;
+}
+
+static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        sd->contrast = val;
+        if (gspca_dev->streaming)
+                setcontrast(gspca_dev);
+        return gspca_dev->usb_err;
+}
+
+static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        *val = sd->contrast;
+        return 0;
+}
+
+static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        sd->autogain = val;
+
+        if (gspca_dev->streaming) {
+                if (val)
+                        gspca_dev->ctrl_inac |= (1 << EXPO_IDX);
+                else
+                        gspca_dev->ctrl_inac &= ~(1 << EXPO_IDX);
+                setautogain(gspca_dev);
+        }
+        return gspca_dev->usb_err;
+}
+
+static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        *val = sd->autogain;
+        return 0;
+}
+
+static int sd_setexposure(struct gspca_dev *gspca_dev, __s32 val)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        sd->exposure = val;
+        if (gspca_dev->streaming)
+                setexposure(gspca_dev);
+        return gspca_dev->usb_err;
+}
+
+static int sd_getexposure(struct gspca_dev *gspca_dev, __s32 *val)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        *val = sd->exposure;
+        return 0;
+}
+
+static int sd_setsharpness(struct gspca_dev *gspca_dev, __s32 val)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        sd->sharpness = val;
+        if (gspca_dev->streaming)
+                setsharpness(gspca_dev);
+        return gspca_dev->usb_err;
+}
+
+static int sd_getsharpness(struct gspca_dev *gspca_dev, __s32 *val)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        *val = sd->sharpness;
+        return 0;
+}
+
+static int sd_setsatur(struct gspca_dev *gspca_dev, __s32 val)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        sd->satur = val;
+        if (gspca_dev->streaming)
+                setsatur(gspca_dev);
+        return gspca_dev->usb_err;
+}
+
+static int sd_getsatur(struct gspca_dev *gspca_dev, __s32 *val)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        *val = sd->satur;
+        return 0;
+}
+static int sd_setfreq(struct gspca_dev *gspca_dev, __s32 val)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        sd->freq = val;
+        if (gspca_dev->streaming)
+                setfreq(gspca_dev);
+        return gspca_dev->usb_err;
+}
+
+static int sd_getfreq(struct gspca_dev *gspca_dev, __s32 *val)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        *val = sd->freq;
+        return 0;
+}
+
+static int sd_querymenu(struct gspca_dev *gspca_dev,
+                        struct v4l2_querymenu *menu)
+{
+        switch (menu->id) {
+        case V4L2_CID_POWER_LINE_FREQUENCY:
+                switch (menu->index) {
+                case 0:         /* V4L2_CID_POWER_LINE_FREQUENCY_DISABLED */
+                        strcpy((char *) menu->name, "NoFliker");
+                        return 0;
+                case 1:         /* V4L2_CID_POWER_LINE_FREQUENCY_50HZ */
+                        strcpy((char *) menu->name, "50 Hz");
+                        return 0;
+                case 2:         /* V4L2_CID_POWER_LINE_FREQUENCY_60HZ */
+                        strcpy((char *) menu->name, "60 Hz");
+                        return 0;
+                }
+                break;
+        }
+        return -EINVAL;
+}
+
+/* sub-driver description */
+static const struct sd_desc sd_desc = {
+        .name     = MODULE_NAME,
+        .ctrls    = sd_ctrls,
+        .nctrls   = ARRAY_SIZE(sd_ctrls),
+        .config   = sd_config,
+        .init     = sd_init,
+        .start    = sd_start,
+        .stopN    = sd_stopN,
+        .pkt_scan = sd_pkt_scan,
+        .querymenu = sd_querymenu,
+};
+
+/* -- module initialisation -- */
+static const __devinitdata struct usb_device_id device_table[] = {
+        {USB_DEVICE(0x06f8, 0x3003)},
+        {}
+};
+
+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);
+}
+
+static struct usb_driver sd_driver = {
+        .name       = MODULE_NAME,
+        .id_table   = device_table,
+        .probe      = sd_probe,
+        .disconnect = gspca_disconnect,
+#ifdef CONFIG_PM
+        .suspend    = gspca_suspend,
+        .resume     = gspca_resume,
+#endif
+};
+
+/* -- module insert / remove -- */
+static int __init sd_mod_init(void)
+{
+        int ret;
+
+        ret = usb_register(&sd_driver);
+        if (ret < 0)
+                return ret;
+        PDEBUG(D_PROBE, "registered");
+        return 0;
+}
+
+static void __exit sd_mod_exit(void)
+{
+        usb_deregister(&sd_driver);
+        PDEBUG(D_PROBE, "deregistered");
+}
+
+module_init(sd_mod_init);
+module_exit(sd_mod_exit);
diff --git a/drivers/media/video/gspca/pac207.c b/drivers/media/video/gspca/pac207.c
index 4706a823add0..0c87c3490b1e 100644
--- a/drivers/media/video/gspca/pac207.c
+++ b/drivers/media/video/gspca/pac207.c
@@ -25,6 +25,7 @@
 
 #define MODULE_NAME "pac207"
 
+#include <linux/input.h>
 #include "gspca.h"
 
 MODULE_AUTHOR("Hans de Goede <hdgoede@redhat.com>");
@@ -77,7 +78,7 @@ static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val);
 static int sd_setgain(struct gspca_dev *gspca_dev, __s32 val);
 static int sd_getgain(struct gspca_dev *gspca_dev, __s32 *val);
 
-static struct ctrl sd_ctrls[] = {
+static const struct ctrl sd_ctrls[] = {
 #define SD_BRIGHTNESS 0
         {
             {
@@ -495,6 +496,25 @@ static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val)
         return 0;
 }
 
+#ifdef CONFIG_INPUT
+static int sd_int_pkt_scan(struct gspca_dev *gspca_dev,
+                        u8 *data,               /* interrupt packet data */
+                        int len)                /* interrput packet length */
+{
+        int ret = -EINVAL;
+
+        if (len == 2 && data[0] == 0x5a && data[1] == 0x5a) {
+                input_report_key(gspca_dev->input_dev, KEY_CAMERA, 1);
+                input_sync(gspca_dev->input_dev);
+                input_report_key(gspca_dev->input_dev, KEY_CAMERA, 0);
+                input_sync(gspca_dev->input_dev);
+                ret = 0;
+        }
+
+        return ret;
+}
+#endif
+
 /* sub-driver description */
 static const struct sd_desc sd_desc = {
         .name = MODULE_NAME,
@@ -506,6 +526,9 @@ static const struct sd_desc sd_desc = {
         .stopN = sd_stopN,
         .dq_callback = pac207_do_auto_gain,
         .pkt_scan = sd_pkt_scan,
+#ifdef CONFIG_INPUT
+        .int_pkt_scan = sd_int_pkt_scan,
+#endif
 };
 
 /* -- module initialisation -- */
diff --git a/drivers/media/video/gspca/pac7302.c b/drivers/media/video/gspca/pac7302.c
index de0b66c4b56e..2a68220d1ada 100644
--- a/drivers/media/video/gspca/pac7302.c
+++ b/drivers/media/video/gspca/pac7302.c
@@ -4,7 +4,9 @@
  *
  * V4L2 by Jean-Francois Moine <http://moinejf.free.fr>
  *
- * Separated from Pixart PAC7311 library by Márton Németh <nm127@freemail.hu>
+ * Separated from Pixart PAC7311 library by Márton Németh
+ * Camera button input handling by Márton Németh <nm127@freemail.hu>
+ * Copyright (C) 2009-2010 Márton Németh <nm127@freemail.hu>
  *
  * 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
@@ -22,33 +24,26 @@
  */
 
 /* Some documentation about various registers as determined by trial and error.
-   When the register addresses differ between the 7202 and the 7311 the 2
-   different addresses are written as 7302addr/7311addr, when one of the 2
-   addresses is a - sign that register description is not valid for the
-   matching IC.
 
    Register page 1:
 
    Address      Description
-   -/0x08       Unknown compressor related, must always be 8 except when not
-                in 640x480 resolution and page 4 reg 2 <= 3 then set it to 9 !
-   -/0x1b       Auto white balance related, bit 0 is AWB enable (inverted)
-                bits 345 seem to toggle per color gains on/off (inverted)
    0x78         Global control, bit 6 controls the LED (inverted)
-   -/0x80       JPEG compression ratio ? Best not touched
 
-   Register page 3/4:
+   Register page 3:
 
    Address      Description
-   0x02         Clock divider 2-63, fps =~ 60 / val. Must be a multiple of 3 on
+   0x02         Clock divider 3-63, fps = 90 / val. Must be a multiple of 3 on
                 the 7302, so one of 3, 6, 9, ..., except when between 6 and 12?
-   -/0x0f       Master gain 1-245, low value = high gain
-   0x10/-       Master gain 0-31
-   -/0x10       Another gain 0-15, limited influence (1-2x gain I guess)
+   0x03         Variable framerate ctrl reg2==3: 0 -> ~30 fps, 255 -> ~22fps
+   0x04         Another var framerate ctrl reg2==3, reg3==0: 0 -> ~30 fps,
+                63 -> ~27 fps, the 2 msb's must always be 1 !!
+   0x05         Another var framerate ctrl reg2==3, reg3==0, reg4==0xc0:
+                1 -> ~30 fps, 2 -> ~20 fps
+   0x0e         Exposure bits 0-7, 0-448, 0 = use full frame time
+   0x0f         Exposure bit 8, 0-448, 448 = no exposure at all
+   0x10         Master gain 0-31
    0x21         Bitfield: 0-1 unused, 2-3 vflip/hflip, 4-5 unknown, 6-7 unused
-   -/0x27       Seems to toggle various gains on / off, Setting bit 7 seems to
-                completely disable the analog amplification block. Set to 0x68
-                for max gain, 0x14 for minimal gain.
 
    The registers are accessed in the following functions:
 
@@ -68,6 +63,7 @@
 
 #define MODULE_NAME "pac7302"
 
+#include <linux/input.h>
 #include <media/v4l2-chip-ident.h>
 #include "gspca.h"
 
@@ -86,8 +82,8 @@ struct sd {
         unsigned char red_balance;
         unsigned char blue_balance;
         unsigned char gain;
-        unsigned char exposure;
         unsigned char autogain;
+        unsigned short exposure;
         __u8 hflip;
         __u8 vflip;
         u8 flags;
@@ -124,8 +120,7 @@ static int sd_getgain(struct gspca_dev *gspca_dev, __s32 *val);
 static int sd_setexposure(struct gspca_dev *gspca_dev, __s32 val);
 static int sd_getexposure(struct gspca_dev *gspca_dev, __s32 *val);
 
-static struct ctrl sd_ctrls[] = {
-/* This control is pac7302 only */
+static const struct ctrl sd_ctrls[] = {
         {
             {
                 .id      = V4L2_CID_BRIGHTNESS,
@@ -141,7 +136,6 @@ static struct ctrl sd_ctrls[] = {
             .set = sd_setbrightness,
             .get = sd_getbrightness,
         },
-/* This control is for both the 7302 and the 7311 */
         {
             {
                 .id      = V4L2_CID_CONTRAST,
@@ -157,7 +151,6 @@ static struct ctrl sd_ctrls[] = {
             .set = sd_setcontrast,
             .get = sd_getcontrast,
         },
-/* This control is pac7302 only */
         {
             {
                 .id      = V4L2_CID_SATURATION,
@@ -215,7 +208,6 @@ static struct ctrl sd_ctrls[] = {
             .set = sd_setbluebalance,
             .get = sd_getbluebalance,
         },
-/* All controls below are for both the 7302 and the 7311 */
         {
             {
                 .id      = V4L2_CID_GAIN,
@@ -238,11 +230,10 @@ static struct ctrl sd_ctrls[] = {
                 .type    = V4L2_CTRL_TYPE_INTEGER,
                 .name    = "Exposure",
                 .minimum = 0,
-#define EXPOSURE_MAX 255
-                .maximum = EXPOSURE_MAX,
+                .maximum = 1023,
                 .step    = 1,
-#define EXPOSURE_DEF  16 /*  32 ms / 30 fps */
-#define EXPOSURE_KNEE 50 /* 100 ms / 10 fps */
+#define EXPOSURE_DEF  66  /*  33 ms / 30 fps */
+#define EXPOSURE_KNEE 133 /*  66 ms / 15 fps */
                 .default_value = EXPOSURE_DEF,
             },
             .set = sd_setexposure,
@@ -301,7 +292,6 @@ static const struct v4l2_pix_format vga_mode[] = {
 };
 
 #define LOAD_PAGE3              255
-#define LOAD_PAGE4              254
 #define END_OF_SEQUENCE         0
 
 /* pac 7302 */
@@ -379,7 +369,7 @@ static const __u8 start_7302[] = {
 #define SKIP            0xaa
 /* page 3 - the value SKIP says skip the index - see reg_w_page() */
 static const __u8 page3_7302[] = {
-        0x90, 0x40, 0x03, 0x50, 0xc2, 0x01, 0x14, 0x16,
+        0x90, 0x40, 0x03, 0x00, 0xc0, 0x01, 0x14, 0x16,
         0x14, 0x12, 0x00, 0x00, 0x00, 0x02, 0x33, 0x00,
         0x0f, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x00, 0x00, 0x00, 0x47, 0x01, 0xb3, 0x01, 0x00,
@@ -388,7 +378,7 @@ static const __u8 page3_7302[] = {
         0xa4, 0xb8, 0xe0, 0x2a, 0xf6, 0x00, 0x00, 0x00,
         0x00, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x00, 0xfc, 0x00, 0xf2, 0x1f, 0x04, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0xc0, 0xc0, 0x10, 0x00, 0x00,
+        SKIP, 0x00, 0x00, 0xc0, 0xc0, 0x10, 0x00, 0x00,
         0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x00, 0x40, 0xff, 0x03, 0x19, 0x00, 0x00, 0x00,
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@@ -401,12 +391,14 @@ static const __u8 page3_7302[] = {
         0x00
 };
 
-static int reg_w_buf(struct gspca_dev *gspca_dev,
+static void reg_w_buf(struct gspca_dev *gspca_dev,
                   __u8 index,
                   const char *buffer, int len)
 {
         int ret;
 
+        if (gspca_dev->usb_err < 0)
+                return;
         memcpy(gspca_dev->usb_buf, buffer, len);
         ret = usb_control_msg(gspca_dev->dev,
                         usb_sndctrlpipe(gspca_dev->dev, 0),
@@ -415,20 +407,23 @@ static int reg_w_buf(struct gspca_dev *gspca_dev,
                         0,              /* value */
                         index, gspca_dev->usb_buf, len,
                         500);
-        if (ret < 0)
+        if (ret < 0) {
                 PDEBUG(D_ERR, "reg_w_buf(): "
                 "Failed to write registers to index 0x%x, error %i",
                 index, ret);
-        return ret;
+                gspca_dev->usb_err = ret;
+        }
 }
 
 
-static int reg_w(struct gspca_dev *gspca_dev,
+static void reg_w(struct gspca_dev *gspca_dev,
                   __u8 index,
                   __u8 value)
 {
         int ret;
 
+        if (gspca_dev->usb_err < 0)
+                return;
         gspca_dev->usb_buf[0] = value;
         ret = usb_control_msg(gspca_dev->dev,
                         usb_sndctrlpipe(gspca_dev->dev, 0),
@@ -436,32 +431,32 @@ static int reg_w(struct gspca_dev *gspca_dev,
                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
                         0, index, gspca_dev->usb_buf, 1,
                         500);
-        if (ret < 0)
+        if (ret < 0) {
                 PDEBUG(D_ERR, "reg_w(): "
                 "Failed to write register to index 0x%x, value 0x%x, error %i",
                 index, value, ret);
-        return ret;
+                gspca_dev->usb_err = ret;
+        }
 }
 
-static int reg_w_seq(struct gspca_dev *gspca_dev,
+static void reg_w_seq(struct gspca_dev *gspca_dev,
                 const __u8 *seq, int len)
 {
-        int ret = 0;
         while (--len >= 0) {
-                if (0 <= ret)
-                        ret = reg_w(gspca_dev, seq[0], seq[1]);
+                reg_w(gspca_dev, seq[0], seq[1]);
                 seq += 2;
         }
-        return ret;
 }
 
 /* load the beginning of a page */
-static int reg_w_page(struct gspca_dev *gspca_dev,
+static void reg_w_page(struct gspca_dev *gspca_dev,
                         const __u8 *page, int len)
 {
         int index;
         int ret = 0;
 
+        if (gspca_dev->usb_err < 0)
+                return;
         for (index = 0; index < len; index++) {
                 if (page[index] == SKIP)                /* skip this index */
                         continue;
@@ -477,56 +472,47 @@ static int reg_w_page(struct gspca_dev *gspca_dev,
                         "Failed to write register to index 0x%x, "
                         "value 0x%x, error %i",
                         index, page[index], ret);
+                        gspca_dev->usb_err = ret;
                         break;
                 }
         }
-        return ret;
 }
 
 /* output a variable sequence */
-static int reg_w_var(struct gspca_dev *gspca_dev,
+static void reg_w_var(struct gspca_dev *gspca_dev,
                         const __u8 *seq,
-                        const __u8 *page3, unsigned int page3_len,
-                        const __u8 *page4, unsigned int page4_len)
+                        const __u8 *page3, unsigned int page3_len)
 {
         int index, len;
-        int ret = 0;
 
         for (;;) {
                 index = *seq++;
                 len = *seq++;
                 switch (len) {
                 case END_OF_SEQUENCE:
-                        return ret;
-                case LOAD_PAGE4:
-                        ret = reg_w_page(gspca_dev, page4, page4_len);
-                        break;
+                        return;
                 case LOAD_PAGE3:
-                        ret = reg_w_page(gspca_dev, page3, page3_len);
+                        reg_w_page(gspca_dev, page3, page3_len);
                         break;
                 default:
                         if (len > USB_BUF_SZ) {
                                 PDEBUG(D_ERR|D_STREAM,
                                         "Incorrect variable sequence");
-                                return -EINVAL;
+                                return;
                         }
                         while (len > 0) {
                                 if (len < 8) {
-                                        ret = reg_w_buf(gspca_dev,
+                                        reg_w_buf(gspca_dev,
                                                 index, seq, len);
-                                        if (ret < 0)
-                                                return ret;
                                         seq += len;
                                         break;
                                 }
-                                ret = reg_w_buf(gspca_dev, index, seq, 8);
+                                reg_w_buf(gspca_dev, index, seq, 8);
                                 seq += 8;
                                 index += 8;
                                 len -= 8;
                         }
                 }
-                if (ret < 0)
-                        return ret;
         }
         /* not reached */
 }
@@ -560,11 +546,10 @@ static int sd_config(struct gspca_dev *gspca_dev,
 }
 
 /* This function is used by pac7302 only */
-static int setbrightcont(struct gspca_dev *gspca_dev)
+static void setbrightcont(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
         int i, v;
-        int ret;
         static const __u8 max[10] =
                 {0x29, 0x33, 0x42, 0x5a, 0x6e, 0x80, 0x9f, 0xbb,
                  0xd4, 0xec};
@@ -572,7 +557,7 @@ static int setbrightcont(struct gspca_dev *gspca_dev)
                 {0x35, 0x33, 0x33, 0x2f, 0x2a, 0x25, 0x1e, 0x17,
                  0x11, 0x0b};
 
-        ret = reg_w(gspca_dev, 0xff, 0x00);     /* page 0 */
+        reg_w(gspca_dev, 0xff, 0x00);           /* page 0 */
         for (i = 0; i < 10; i++) {
                 v = max[i];
                 v += (sd->brightness - BRIGHTNESS_MAX)
@@ -582,136 +567,121 @@ static int setbrightcont(struct gspca_dev *gspca_dev)
                         v = 0;
                 else if (v > 0xff)
                         v = 0xff;
-                if (0 <= ret)
-                        ret = reg_w(gspca_dev, 0xa2 + i, v);
+                reg_w(gspca_dev, 0xa2 + i, v);
         }
-        if (0 <= ret)
-                ret = reg_w(gspca_dev, 0xdc, 0x01);
-        return ret;
+        reg_w(gspca_dev, 0xdc, 0x01);
 }
 
 /* This function is used by pac7302 only */
-static int setcolors(struct gspca_dev *gspca_dev)
+static void setcolors(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
         int i, v;
-        int ret;
         static const int a[9] =
                 {217, -212, 0, -101, 170, -67, -38, -315, 355};
         static const int b[9] =
                 {19, 106, 0, 19, 106, 1, 19, 106, 1};
 
-        ret = reg_w(gspca_dev, 0xff, 0x03);     /* page 3 */
-        if (0 <= ret)
-                ret = reg_w(gspca_dev, 0x11, 0x01);
-        if (0 <= ret)
-                ret = reg_w(gspca_dev, 0xff, 0x00);     /* page 0 */
+        reg_w(gspca_dev, 0xff, 0x03);                   /* page 3 */
+        reg_w(gspca_dev, 0x11, 0x01);
+        reg_w(gspca_dev, 0xff, 0x00);                   /* page 0 */
         for (i = 0; i < 9; i++) {
                 v = a[i] * sd->colors / COLOR_MAX + b[i];
-                if (0 <= ret)
-                        ret = reg_w(gspca_dev, 0x0f + 2 * i, (v >> 8) & 0x07);
-                if (0 <= ret)
-                        ret = reg_w(gspca_dev, 0x0f + 2 * i + 1, v);
+                reg_w(gspca_dev, 0x0f + 2 * i, (v >> 8) & 0x07);
+                reg_w(gspca_dev, 0x0f + 2 * i + 1, v);
         }
-        if (0 <= ret)
-                ret = reg_w(gspca_dev, 0xdc, 0x01);
+        reg_w(gspca_dev, 0xdc, 0x01);
         PDEBUG(D_CONF|D_STREAM, "color: %i", sd->colors);
-        return ret;
 }
 
-static int setwhitebalance(struct gspca_dev *gspca_dev)
+static void setwhitebalance(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
-        int ret;
 
-        ret = reg_w(gspca_dev, 0xff, 0x00);     /* page 0 */
-        if (0 <= ret)
-                ret = reg_w(gspca_dev, 0xc6, sd->white_balance);
+        reg_w(gspca_dev, 0xff, 0x00);           /* page 0 */
+        reg_w(gspca_dev, 0xc6, sd->white_balance);
 
-        if (0 <= ret)
-                ret = reg_w(gspca_dev, 0xdc, 0x01);
+        reg_w(gspca_dev, 0xdc, 0x01);
         PDEBUG(D_CONF|D_STREAM, "white_balance: %i", sd->white_balance);
-        return ret;
 }
 
-static int setredbalance(struct gspca_dev *gspca_dev)
+static void setredbalance(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
-        int ret;
 
-        ret = reg_w(gspca_dev, 0xff, 0x00);     /* page 0 */
-        if (0 <= ret)
-                ret = reg_w(gspca_dev, 0xc5, sd->red_balance);
+        reg_w(gspca_dev, 0xff, 0x00);           /* page 0 */
+        reg_w(gspca_dev, 0xc5, sd->red_balance);
 
-        if (0 <= ret)
-                ret = reg_w(gspca_dev, 0xdc, 0x01);
+        reg_w(gspca_dev, 0xdc, 0x01);
         PDEBUG(D_CONF|D_STREAM, "red_balance: %i", sd->red_balance);
-        return ret;
 }
 
-static int setbluebalance(struct gspca_dev *gspca_dev)
+static void setbluebalance(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
-        int ret;
 
-        ret = reg_w(gspca_dev, 0xff, 0x00);     /* page 0 */
-        if (0 <= ret)
-                ret = reg_w(gspca_dev, 0xc7, sd->blue_balance);
+        reg_w(gspca_dev, 0xff, 0x00);                   /* page 0 */
+        reg_w(gspca_dev, 0xc7, sd->blue_balance);
 
-        if (0 <= ret)
-                ret = reg_w(gspca_dev, 0xdc, 0x01);
+        reg_w(gspca_dev, 0xdc, 0x01);
         PDEBUG(D_CONF|D_STREAM, "blue_balance: %i", sd->blue_balance);
-        return ret;
 }
 
-static int setgain(struct gspca_dev *gspca_dev)
+static void setgain(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
-        int ret;
 
-        ret = reg_w(gspca_dev, 0xff, 0x03);             /* page 3 */
-        if (0 <= ret)
-                ret = reg_w(gspca_dev, 0x10, sd->gain >> 3);
+        reg_w(gspca_dev, 0xff, 0x03);                   /* page 3 */
+        reg_w(gspca_dev, 0x10, sd->gain >> 3);
 
         /* load registers to sensor (Bit 0, auto clear) */
-        if (0 <= ret)
-                ret = reg_w(gspca_dev, 0x11, 0x01);
-        return ret;
+        reg_w(gspca_dev, 0x11, 0x01);
 }
 
-static int setexposure(struct gspca_dev *gspca_dev)
+static void setexposure(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
-        int ret;
-        __u8 reg;
-
-        /* register 2 of frame 3/4 contains the clock divider configuring the
-           no fps according to the formula: 60 / reg. sd->exposure is the
-           desired exposure time in ms. */
-        reg = 120 * sd->exposure / 1000;
-        if (reg < 2)
-                reg = 2;
-        else if (reg > 63)
-                reg = 63;
-
-        /* On the pac7302 reg2 MUST be a multiple of 3, so round it to
-           the nearest multiple of 3, except when between 6 and 12? */
-        if (reg < 6 || reg > 12)
-                reg = ((reg + 1) / 3) * 3;
-        ret = reg_w(gspca_dev, 0xff, 0x03);             /* page 3 */
-        if (0 <= ret)
-                ret = reg_w(gspca_dev, 0x02, reg);
+        __u8 clockdiv;
+        __u16 exposure;
+
+        /* register 2 of frame 3 contains the clock divider configuring the
+           no fps according to the formula: 90 / reg. sd->exposure is the
+           desired exposure time in 0.5 ms. */
+        clockdiv = (90 * sd->exposure + 1999) / 2000;
+
+        /* Note clockdiv = 3 also works, but when running at 30 fps, depending
+           on the scene being recorded, the camera switches to another
+           quantization table for certain JPEG blocks, and we don't know how
+           to decompress these blocks. So we cap the framerate at 15 fps */
+        if (clockdiv < 6)
+                clockdiv = 6;
+        else if (clockdiv > 63)
+                clockdiv = 63;
+
+        /* reg2 MUST be a multiple of 3, except when between 6 and 12?
+           Always round up, otherwise we cannot get the desired frametime
+           using the partial frame time exposure control */
+        if (clockdiv < 6 || clockdiv > 12)
+                clockdiv = ((clockdiv + 2) / 3) * 3;
+
+        /* frame exposure time in ms = 1000 * clockdiv / 90    ->
+        exposure = (sd->exposure / 2) * 448 / (1000 * clockdiv / 90) */
+        exposure = (sd->exposure * 45 * 448) / (1000 * clockdiv);
+        /* 0 = use full frametime, 448 = no exposure, reverse it */
+        exposure = 448 - exposure;
+
+        reg_w(gspca_dev, 0xff, 0x03);                   /* page 3 */
+        reg_w(gspca_dev, 0x02, clockdiv);
+        reg_w(gspca_dev, 0x0e, exposure & 0xff);
+        reg_w(gspca_dev, 0x0f, exposure >> 8);
 
         /* load registers to sensor (Bit 0, auto clear) */
-        if (0 <= ret)
-                ret = reg_w(gspca_dev, 0x11, 0x01);
-        return ret;
+        reg_w(gspca_dev, 0x11, 0x01);
 }
 
-static int sethvflip(struct gspca_dev *gspca_dev)
+static void sethvflip(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
-        int ret;
         u8 data, hflip, vflip;
 
         hflip = sd->hflip;
@@ -721,48 +691,37 @@ static int sethvflip(struct gspca_dev *gspca_dev)
         if (sd->flags & FL_VFLIP)
                 vflip = !vflip;
 
-        ret = reg_w(gspca_dev, 0xff, 0x03);             /* page 3 */
+        reg_w(gspca_dev, 0xff, 0x03);                   /* page 3 */
         data = (hflip ? 0x08 : 0x00) | (vflip ? 0x04 : 0x00);
-        if (0 <= ret)
-                ret = reg_w(gspca_dev, 0x21, data);
+        reg_w(gspca_dev, 0x21, data);
+
         /* load registers to sensor (Bit 0, auto clear) */
-        if (0 <= ret)
-                ret = reg_w(gspca_dev, 0x11, 0x01);
-        return ret;
+        reg_w(gspca_dev, 0x11, 0x01);
 }
 
 /* this function is called at probe and resume time for pac7302 */
 static int sd_init(struct gspca_dev *gspca_dev)
 {
-        return reg_w_seq(gspca_dev, init_7302, sizeof(init_7302)/2);
+        reg_w_seq(gspca_dev, init_7302, sizeof(init_7302)/2);
+        return gspca_dev->usb_err;
 }
 
 static int sd_start(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
-        int ret = 0;
 
         sd->sof_read = 0;
 
-        ret = reg_w_var(gspca_dev, start_7302,
-                page3_7302, sizeof(page3_7302),
-                NULL, 0);
-        if (0 <= ret)
-                ret = setbrightcont(gspca_dev);
-        if (0 <= ret)
-                ret = setcolors(gspca_dev);
-        if (0 <= ret)
-                ret = setwhitebalance(gspca_dev);
-        if (0 <= ret)
-                ret = setredbalance(gspca_dev);
-        if (0 <= ret)
-                ret = setbluebalance(gspca_dev);
-        if (0 <= ret)
-                ret = setgain(gspca_dev);
-        if (0 <= ret)
-                ret = setexposure(gspca_dev);
-        if (0 <= ret)
-                ret = sethvflip(gspca_dev);
+        reg_w_var(gspca_dev, start_7302,
+                page3_7302, sizeof(page3_7302));
+        setbrightcont(gspca_dev);
+        setcolors(gspca_dev);
+        setwhitebalance(gspca_dev);
+        setredbalance(gspca_dev);
+        setbluebalance(gspca_dev);
+        setgain(gspca_dev);
+        setexposure(gspca_dev);
+        sethvflip(gspca_dev);
 
         /* only resolution 640x480 is supported for pac7302 */
 
@@ -771,34 +730,27 @@ static int sd_start(struct gspca_dev *gspca_dev)
         atomic_set(&sd->avg_lum, -1);
 
         /* start stream */
-        if (0 <= ret)
-                ret = reg_w(gspca_dev, 0xff, 0x01);
-        if (0 <= ret)
-                ret = reg_w(gspca_dev, 0x78, 0x01);
+        reg_w(gspca_dev, 0xff, 0x01);
+        reg_w(gspca_dev, 0x78, 0x01);
 
-        return ret;
+        return gspca_dev->usb_err;
 }
 
 static void sd_stopN(struct gspca_dev *gspca_dev)
 {
-        int ret;
 
         /* stop stream */
-        ret = reg_w(gspca_dev, 0xff, 0x01);
-        if (0 <= ret)
-                ret = reg_w(gspca_dev, 0x78, 0x00);
+        reg_w(gspca_dev, 0xff, 0x01);
+        reg_w(gspca_dev, 0x78, 0x00);
 }
 
 /* called on streamoff with alt 0 and on disconnect for pac7302 */
 static void sd_stop0(struct gspca_dev *gspca_dev)
 {
-        int ret;
-
         if (!gspca_dev->present)
                 return;
-        ret = reg_w(gspca_dev, 0xff, 0x01);
-        if (0 <= ret)
-                ret = reg_w(gspca_dev, 0x78, 0x40);
+        reg_w(gspca_dev, 0xff, 0x01);
+        reg_w(gspca_dev, 0x78, 0x40);
 }
 
 /* Include pac common sof detection functions */
@@ -808,22 +760,13 @@ static void do_autogain(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
         int avg_lum = atomic_read(&sd->avg_lum);
-        int desired_lum, deadzone;
+        int desired_lum;
+        const int deadzone = 30;
 
         if (avg_lum == -1)
                 return;
 
-        desired_lum = 270 + sd->brightness * 4;
-        /* Hack hack, with the 7202 the first exposure step is
-           pretty large, so if we're about to make the first
-           exposure increase make the deadzone large to avoid
-           oscilating */
-        if (desired_lum > avg_lum && sd->gain == GAIN_DEF &&
-                        sd->exposure > EXPOSURE_DEF &&
-                        sd->exposure < 42)
-                deadzone = 90;
-        else
-                deadzone = 30;
+        desired_lum = 270 + sd->brightness;
 
         if (sd->autogain_ignore_frames > 0)
                 sd->autogain_ignore_frames--;
@@ -947,7 +890,7 @@ static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
         sd->brightness = val;
         if (gspca_dev->streaming)
                 setbrightcont(gspca_dev);
-        return 0;
+        return gspca_dev->usb_err;
 }
 
 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val)
@@ -966,7 +909,7 @@ static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val)
         if (gspca_dev->streaming) {
                 setbrightcont(gspca_dev);
         }
-        return 0;
+        return gspca_dev->usb_err;
 }
 
 static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val)
@@ -984,7 +927,7 @@ static int sd_setcolors(struct gspca_dev *gspca_dev, __s32 val)
         sd->colors = val;
         if (gspca_dev->streaming)
                 setcolors(gspca_dev);
-        return 0;
+        return gspca_dev->usb_err;
 }
 
 static int sd_getcolors(struct gspca_dev *gspca_dev, __s32 *val)
@@ -998,14 +941,11 @@ static int sd_getcolors(struct gspca_dev *gspca_dev, __s32 *val)
 static int sd_setwhitebalance(struct gspca_dev *gspca_dev, __s32 val)
 {
         struct sd *sd = (struct sd *) gspca_dev;
-        int ret = 0;
 
         sd->white_balance = val;
         if (gspca_dev->streaming)
-                ret = setwhitebalance(gspca_dev);
-        if (0 <= ret)
-                ret = 0;
-        return ret;
+                setwhitebalance(gspca_dev);
+        return gspca_dev->usb_err;
 }
 
 static int sd_getwhitebalance(struct gspca_dev *gspca_dev, __s32 *val)
@@ -1019,14 +959,11 @@ static int sd_getwhitebalance(struct gspca_dev *gspca_dev, __s32 *val)
 static int sd_setredbalance(struct gspca_dev *gspca_dev, __s32 val)
 {
         struct sd *sd = (struct sd *) gspca_dev;
-        int ret = 0;
 
         sd->red_balance = val;
         if (gspca_dev->streaming)
-                ret = setredbalance(gspca_dev);
-        if (0 <= ret)
-                ret = 0;
-        return ret;
+                setredbalance(gspca_dev);
+        return gspca_dev->usb_err;
 }
 
 static int sd_getredbalance(struct gspca_dev *gspca_dev, __s32 *val)
@@ -1040,14 +977,11 @@ static int sd_getredbalance(struct gspca_dev *gspca_dev, __s32 *val)
 static int sd_setbluebalance(struct gspca_dev *gspca_dev, __s32 val)
 {
         struct sd *sd = (struct sd *) gspca_dev;
-        int ret = 0;
 
         sd->blue_balance = val;
         if (gspca_dev->streaming)
-                ret = setbluebalance(gspca_dev);
-        if (0 <= ret)
-                ret = 0;
-        return ret;
+                setbluebalance(gspca_dev);
+        return gspca_dev->usb_err;
 }
 
 static int sd_getbluebalance(struct gspca_dev *gspca_dev, __s32 *val)
@@ -1065,7 +999,7 @@ static int sd_setgain(struct gspca_dev *gspca_dev, __s32 val)
         sd->gain = val;
         if (gspca_dev->streaming)
                 setgain(gspca_dev);
-        return 0;
+        return gspca_dev->usb_err;
 }
 
 static int sd_getgain(struct gspca_dev *gspca_dev, __s32 *val)
@@ -1083,7 +1017,7 @@ static int sd_setexposure(struct gspca_dev *gspca_dev, __s32 val)
         sd->exposure = val;
         if (gspca_dev->streaming)
                 setexposure(gspca_dev);
-        return 0;
+        return gspca_dev->usb_err;
 }
 
 static int sd_getexposure(struct gspca_dev *gspca_dev, __s32 *val)
@@ -1114,7 +1048,7 @@ static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val)
                 }
         }
 
-        return 0;
+        return gspca_dev->usb_err;
 }
 
 static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val)
@@ -1132,7 +1066,7 @@ static int sd_sethflip(struct gspca_dev *gspca_dev, __s32 val)
         sd->hflip = val;
         if (gspca_dev->streaming)
                 sethvflip(gspca_dev);
-        return 0;
+        return gspca_dev->usb_err;
 }
 
 static int sd_gethflip(struct gspca_dev *gspca_dev, __s32 *val)
@@ -1150,7 +1084,7 @@ static int sd_setvflip(struct gspca_dev *gspca_dev, __s32 val)
         sd->vflip = val;
         if (gspca_dev->streaming)
                 sethvflip(gspca_dev);
-        return 0;
+        return gspca_dev->usb_err;
 }
 
 static int sd_getvflip(struct gspca_dev *gspca_dev, __s32 *val)
@@ -1165,7 +1099,6 @@ static int sd_getvflip(struct gspca_dev *gspca_dev, __s32 *val)
 static int sd_dbg_s_register(struct gspca_dev *gspca_dev,
                         struct v4l2_dbg_register *reg)
 {
-        int ret = -EINVAL;
         __u8 index;
         __u8 value;
 
@@ -1185,14 +1118,12 @@ static int sd_dbg_s_register(struct gspca_dev *gspca_dev,
                 /* Note that there shall be no access to other page
                    by any other function between the page swith and
                    the actual register write */
-                ret = reg_w(gspca_dev, 0xff, 0x00);     /* page 0 */
-                if (0 <= ret)
-                        ret = reg_w(gspca_dev, index, value);
+                reg_w(gspca_dev, 0xff, 0x00);           /* page 0 */
+                reg_w(gspca_dev, index, value);
 
-                if (0 <= ret)
-                        ret = reg_w(gspca_dev, 0xdc, 0x01);
+                reg_w(gspca_dev, 0xdc, 0x01);
         }
-        return ret;
+        return gspca_dev->usb_err;
 }
 
 static int sd_chip_ident(struct gspca_dev *gspca_dev,
@@ -1210,8 +1141,39 @@ static int sd_chip_ident(struct gspca_dev *gspca_dev,
 }
 #endif
 
+#ifdef CONFIG_INPUT
+static int sd_int_pkt_scan(struct gspca_dev *gspca_dev,
+                        u8 *data,               /* interrupt packet data */
+                        int len)                /* interrput packet length */
+{
+        int ret = -EINVAL;
+        u8 data0, data1;
+
+        if (len == 2) {
+                data0 = data[0];
+                data1 = data[1];
+                if ((data0 == 0x00 && data1 == 0x11) ||
+                    (data0 == 0x22 && data1 == 0x33) ||
+                    (data0 == 0x44 && data1 == 0x55) ||
+                    (data0 == 0x66 && data1 == 0x77) ||
+                    (data0 == 0x88 && data1 == 0x99) ||
+                    (data0 == 0xaa && data1 == 0xbb) ||
+                    (data0 == 0xcc && data1 == 0xdd) ||
+                    (data0 == 0xee && data1 == 0xff)) {
+                        input_report_key(gspca_dev->input_dev, KEY_CAMERA, 1);
+                        input_sync(gspca_dev->input_dev);
+                        input_report_key(gspca_dev->input_dev, KEY_CAMERA, 0);
+                        input_sync(gspca_dev->input_dev);
+                        ret = 0;
+                }
+        }
+
+        return ret;
+}
+#endif
+
 /* sub-driver description for pac7302 */
-static struct sd_desc sd_desc = {
+static const struct sd_desc sd_desc = {
         .name = MODULE_NAME,
         .ctrls = sd_ctrls,
         .nctrls = ARRAY_SIZE(sd_ctrls),
@@ -1226,6 +1188,9 @@ static struct sd_desc sd_desc = {
         .set_register = sd_dbg_s_register,
         .get_chip_ident = sd_chip_ident,
 #endif
+#ifdef CONFIG_INPUT
+        .int_pkt_scan = sd_int_pkt_scan,
+#endif
 };
 
 /* -- module initialisation -- */
diff --git a/drivers/media/video/gspca/pac7311.c b/drivers/media/video/gspca/pac7311.c
index 42cfcdfd8f4f..44fed9686729 100644
--- a/drivers/media/video/gspca/pac7311.c
+++ b/drivers/media/video/gspca/pac7311.c
@@ -51,6 +51,7 @@
 
 #define MODULE_NAME "pac7311"
 
+#include <linux/input.h>
 #include "gspca.h"
 
 MODULE_AUTHOR("Thomas Kaiser thomas@kaiser-linux.li");
@@ -88,7 +89,7 @@ static int sd_getgain(struct gspca_dev *gspca_dev, __s32 *val);
 static int sd_setexposure(struct gspca_dev *gspca_dev, __s32 val);
 static int sd_getexposure(struct gspca_dev *gspca_dev, __s32 *val);
 
-static struct ctrl sd_ctrls[] = {
+static const struct ctrl sd_ctrls[] = {
 /* This control is for both the 7302 and the 7311 */
         {
             {
@@ -200,7 +201,6 @@ static const struct v4l2_pix_format vga_mode[] = {
                 .priv = 0},
 };
 
-#define LOAD_PAGE3              255
 #define LOAD_PAGE4              254
 #define END_OF_SEQUENCE         0
 
@@ -259,12 +259,14 @@ static const __u8 page4_7311[] = {
         0x23, 0x28, 0x04, 0x11, 0x00, 0x00
 };
 
-static int reg_w_buf(struct gspca_dev *gspca_dev,
+static void reg_w_buf(struct gspca_dev *gspca_dev,
                   __u8 index,
                   const char *buffer, int len)
 {
         int ret;
 
+        if (gspca_dev->usb_err < 0)
+                return;
         memcpy(gspca_dev->usb_buf, buffer, len);
         ret = usb_control_msg(gspca_dev->dev,
                         usb_sndctrlpipe(gspca_dev->dev, 0),
@@ -273,20 +275,23 @@ static int reg_w_buf(struct gspca_dev *gspca_dev,
                         0,              /* value */
                         index, gspca_dev->usb_buf, len,
                         500);
-        if (ret < 0)
+        if (ret < 0) {
                 PDEBUG(D_ERR, "reg_w_buf(): "
                 "Failed to write registers to index 0x%x, error %i",
                 index, ret);
-        return ret;
+                gspca_dev->usb_err = ret;
+        }
 }
 
 
-static int reg_w(struct gspca_dev *gspca_dev,
+static void reg_w(struct gspca_dev *gspca_dev,
                   __u8 index,
                   __u8 value)
 {
         int ret;
 
+        if (gspca_dev->usb_err < 0)
+                return;
         gspca_dev->usb_buf[0] = value;
         ret = usb_control_msg(gspca_dev->dev,
                         usb_sndctrlpipe(gspca_dev->dev, 0),
@@ -294,32 +299,32 @@ static int reg_w(struct gspca_dev *gspca_dev,
                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
                         0, index, gspca_dev->usb_buf, 1,
                         500);
-        if (ret < 0)
+        if (ret < 0) {
                 PDEBUG(D_ERR, "reg_w(): "
                 "Failed to write register to index 0x%x, value 0x%x, error %i",
                 index, value, ret);
-        return ret;
+                gspca_dev->usb_err = ret;
+        }
 }
 
-static int reg_w_seq(struct gspca_dev *gspca_dev,
+static void reg_w_seq(struct gspca_dev *gspca_dev,
                 const __u8 *seq, int len)
 {
-        int ret = 0;
         while (--len >= 0) {
-                if (0 <= ret)
-                        ret = reg_w(gspca_dev, seq[0], seq[1]);
+                reg_w(gspca_dev, seq[0], seq[1]);
                 seq += 2;
         }
-        return ret;
 }
 
 /* load the beginning of a page */
-static int reg_w_page(struct gspca_dev *gspca_dev,
+static void reg_w_page(struct gspca_dev *gspca_dev,
                         const __u8 *page, int len)
 {
         int index;
         int ret = 0;
 
+        if (gspca_dev->usb_err < 0)
+                return;
         for (index = 0; index < len; index++) {
                 if (page[index] == SKIP)                /* skip this index */
                         continue;
@@ -335,56 +340,47 @@ static int reg_w_page(struct gspca_dev *gspca_dev,
                         "Failed to write register to index 0x%x, "
                         "value 0x%x, error %i",
                         index, page[index], ret);
+                        gspca_dev->usb_err = ret;
                         break;
                 }
         }
-        return ret;
 }
 
 /* output a variable sequence */
-static int reg_w_var(struct gspca_dev *gspca_dev,
+static void reg_w_var(struct gspca_dev *gspca_dev,
                         const __u8 *seq,
-                        const __u8 *page3, unsigned int page3_len,
                         const __u8 *page4, unsigned int page4_len)
 {
         int index, len;
-        int ret = 0;
 
         for (;;) {
                 index = *seq++;
                 len = *seq++;
                 switch (len) {
                 case END_OF_SEQUENCE:
-                        return ret;
+                        return;
                 case LOAD_PAGE4:
-                        ret = reg_w_page(gspca_dev, page4, page4_len);
-                        break;
-                case LOAD_PAGE3:
-                        ret = reg_w_page(gspca_dev, page3, page3_len);
+                        reg_w_page(gspca_dev, page4, page4_len);
                         break;
                 default:
                         if (len > USB_BUF_SZ) {
                                 PDEBUG(D_ERR|D_STREAM,
                                         "Incorrect variable sequence");
-                                return -EINVAL;
+                                return;
                         }
                         while (len > 0) {
                                 if (len < 8) {
-                                        ret = reg_w_buf(gspca_dev,
+                                        reg_w_buf(gspca_dev,
                                                 index, seq, len);
-                                        if (ret < 0)
-                                                return ret;
                                         seq += len;
                                         break;
                                 }
-                                ret = reg_w_buf(gspca_dev, index, seq, 8);
+                                reg_w_buf(gspca_dev, index, seq, 8);
                                 seq += 8;
                                 index += 8;
                                 len -= 8;
                         }
                 }
-                if (ret < 0)
-                        return ret;
         }
         /* not reached */
 }
@@ -412,46 +408,36 @@ static int sd_config(struct gspca_dev *gspca_dev,
 }
 
 /* This function is used by pac7311 only */
-static int setcontrast(struct gspca_dev *gspca_dev)
+static void setcontrast(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
-        int ret;
 
-        ret = reg_w(gspca_dev, 0xff, 0x04);
-        if (0 <= ret)
-                ret = reg_w(gspca_dev, 0x10, sd->contrast >> 4);
+        reg_w(gspca_dev, 0xff, 0x04);
+        reg_w(gspca_dev, 0x10, sd->contrast >> 4);
         /* load registers to sensor (Bit 0, auto clear) */
-        if (0 <= ret)
-                ret = reg_w(gspca_dev, 0x11, 0x01);
-        return ret;
+        reg_w(gspca_dev, 0x11, 0x01);
 }
 
-static int setgain(struct gspca_dev *gspca_dev)
+static void setgain(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
         int gain = GAIN_MAX - sd->gain;
-        int ret;
 
         if (gain < 1)
                 gain = 1;
         else if (gain > 245)
                 gain = 245;
-        ret = reg_w(gspca_dev, 0xff, 0x04);             /* page 4 */
-        if (0 <= ret)
-                ret = reg_w(gspca_dev, 0x0e, 0x00);
-        if (0 <= ret)
-                ret = reg_w(gspca_dev, 0x0f, gain);
+        reg_w(gspca_dev, 0xff, 0x04);                   /* page 4 */
+        reg_w(gspca_dev, 0x0e, 0x00);
+        reg_w(gspca_dev, 0x0f, gain);
 
         /* load registers to sensor (Bit 0, auto clear) */
-        if (0 <= ret)
-                ret = reg_w(gspca_dev, 0x11, 0x01);
-        return ret;
+        reg_w(gspca_dev, 0x11, 0x01);
 }
 
-static int setexposure(struct gspca_dev *gspca_dev)
+static void setexposure(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
-        int ret;
         __u8 reg;
 
         /* register 2 of frame 3/4 contains the clock divider configuring the
@@ -463,94 +449,72 @@ static int setexposure(struct gspca_dev *gspca_dev)
         else if (reg > 63)
                 reg = 63;
 
-        ret = reg_w(gspca_dev, 0xff, 0x04);             /* page 4 */
-        if (0 <= ret)
-                ret = reg_w(gspca_dev, 0x02, reg);
+        reg_w(gspca_dev, 0xff, 0x04);                   /* page 4 */
+        reg_w(gspca_dev, 0x02, reg);
+
         /* Page 1 register 8 must always be 0x08 except when not in
            640x480 mode and Page3/4 reg 2 <= 3 then it must be 9 */
-        if (0 <= ret)
-                ret = reg_w(gspca_dev, 0xff, 0x01);
+        reg_w(gspca_dev, 0xff, 0x01);
         if (gspca_dev->cam.cam_mode[(int)gspca_dev->curr_mode].priv &&
                         reg <= 3) {
-                if (0 <= ret)
-                        ret = reg_w(gspca_dev, 0x08, 0x09);
+                reg_w(gspca_dev, 0x08, 0x09);
         } else {
-                if (0 <= ret)
-                        ret = reg_w(gspca_dev, 0x08, 0x08);
+                reg_w(gspca_dev, 0x08, 0x08);
         }
 
         /* load registers to sensor (Bit 0, auto clear) */
-        if (0 <= ret)
-                ret = reg_w(gspca_dev, 0x11, 0x01);
-        return ret;
+        reg_w(gspca_dev, 0x11, 0x01);
 }
 
-static int sethvflip(struct gspca_dev *gspca_dev)
+static void sethvflip(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
-        int ret;
         __u8 data;
 
-        ret = reg_w(gspca_dev, 0xff, 0x04);             /* page 4 */
+        reg_w(gspca_dev, 0xff, 0x04);                   /* page 4 */
         data = (sd->hflip ? 0x04 : 0x00) | (sd->vflip ? 0x08 : 0x00);
-        if (0 <= ret)
-                ret = reg_w(gspca_dev, 0x21, data);
+        reg_w(gspca_dev, 0x21, data);
+
         /* load registers to sensor (Bit 0, auto clear) */
-        if (0 <= ret)
-                ret = reg_w(gspca_dev, 0x11, 0x01);
-        return ret;
+        reg_w(gspca_dev, 0x11, 0x01);
 }
 
 /* this function is called at probe and resume time for pac7311 */
 static int sd_init(struct gspca_dev *gspca_dev)
 {
-        return reg_w_seq(gspca_dev, init_7311, sizeof(init_7311)/2);
+        reg_w_seq(gspca_dev, init_7311, sizeof(init_7311)/2);
+        return gspca_dev->usb_err;
 }
 
 static int sd_start(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
-        int ret;
 
         sd->sof_read = 0;
 
-        ret = reg_w_var(gspca_dev, start_7311,
-                NULL, 0,
+        reg_w_var(gspca_dev, start_7311,
                 page4_7311, sizeof(page4_7311));
-        if (0 <= ret)
-                ret = setcontrast(gspca_dev);
-        if (0 <= ret)
-                ret = setgain(gspca_dev);
-        if (0 <= ret)
-                ret = setexposure(gspca_dev);
-        if (0 <= ret)
-                ret = sethvflip(gspca_dev);
+        setcontrast(gspca_dev);
+        setgain(gspca_dev);
+        setexposure(gspca_dev);
+        sethvflip(gspca_dev);
 
         /* set correct resolution */
         switch (gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv) {
         case 2:                                 /* 160x120 pac7311 */
-                if (0 <= ret)
-                        ret = reg_w(gspca_dev, 0xff, 0x01);
-                if (0 <= ret)
-                        ret = reg_w(gspca_dev, 0x17, 0x20);
-                if (0 <= ret)
-                        ret = reg_w(gspca_dev, 0x87, 0x10);
+                reg_w(gspca_dev, 0xff, 0x01);
+                reg_w(gspca_dev, 0x17, 0x20);
+                reg_w(gspca_dev, 0x87, 0x10);
                 break;
         case 1:                                 /* 320x240 pac7311 */
-                if (0 <= ret)
-                        ret = reg_w(gspca_dev, 0xff, 0x01);
-                if (0 <= ret)
-                        ret = reg_w(gspca_dev, 0x17, 0x30);
-                if (0 <= ret)
-                        ret = reg_w(gspca_dev, 0x87, 0x11);
+                reg_w(gspca_dev, 0xff, 0x01);
+                reg_w(gspca_dev, 0x17, 0x30);
+                reg_w(gspca_dev, 0x87, 0x11);
                 break;
         case 0:                                 /* 640x480 */
-                if (0 <= ret)
-                        ret = reg_w(gspca_dev, 0xff, 0x01);
-                if (0 <= ret)
-                        ret = reg_w(gspca_dev, 0x17, 0x00);
-                if (0 <= ret)
-                        ret = reg_w(gspca_dev, 0x87, 0x12);
+                reg_w(gspca_dev, 0xff, 0x01);
+                reg_w(gspca_dev, 0x17, 0x00);
+                reg_w(gspca_dev, 0x87, 0x12);
                 break;
         }
 
@@ -559,37 +523,24 @@ static int sd_start(struct gspca_dev *gspca_dev)
         atomic_set(&sd->avg_lum, -1);
 
         /* start stream */
-        if (0 <= ret)
-                ret = reg_w(gspca_dev, 0xff, 0x01);
-        if (0 <= ret)
-                ret = reg_w(gspca_dev, 0x78, 0x05);
+        reg_w(gspca_dev, 0xff, 0x01);
+        reg_w(gspca_dev, 0x78, 0x05);
 
-        return ret;
+        return gspca_dev->usb_err;
 }
 
 static void sd_stopN(struct gspca_dev *gspca_dev)
 {
-        int ret;
-
-        ret = reg_w(gspca_dev, 0xff, 0x04);
-        if (0 <= ret)
-                ret = reg_w(gspca_dev, 0x27, 0x80);
-        if (0 <= ret)
-                ret = reg_w(gspca_dev, 0x28, 0xca);
-        if (0 <= ret)
-                ret = reg_w(gspca_dev, 0x29, 0x53);
-        if (0 <= ret)
-                ret = reg_w(gspca_dev, 0x2a, 0x0e);
-        if (0 <= ret)
-                ret = reg_w(gspca_dev, 0xff, 0x01);
-        if (0 <= ret)
-                ret = reg_w(gspca_dev, 0x3e, 0x20);
-        if (0 <= ret)
-                ret = reg_w(gspca_dev, 0x78, 0x44); /* Bit_0=start stream, Bit_6=LED */
-        if (0 <= ret)
-                ret = reg_w(gspca_dev, 0x78, 0x44); /* Bit_0=start stream, Bit_6=LED */
-        if (0 <= ret)
-                ret = reg_w(gspca_dev, 0x78, 0x44); /* Bit_0=start stream, Bit_6=LED */
+        reg_w(gspca_dev, 0xff, 0x04);
+        reg_w(gspca_dev, 0x27, 0x80);
+        reg_w(gspca_dev, 0x28, 0xca);
+        reg_w(gspca_dev, 0x29, 0x53);
+        reg_w(gspca_dev, 0x2a, 0x0e);
+        reg_w(gspca_dev, 0xff, 0x01);
+        reg_w(gspca_dev, 0x3e, 0x20);
+        reg_w(gspca_dev, 0x78, 0x44); /* Bit_0=start stream, Bit_6=LED */
+        reg_w(gspca_dev, 0x78, 0x44); /* Bit_0=start stream, Bit_6=LED */
+        reg_w(gspca_dev, 0x78, 0x44); /* Bit_0=start stream, Bit_6=LED */
 }
 
 /* called on streamoff with alt 0 and on disconnect for 7311 */
@@ -734,7 +685,7 @@ static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val)
         if (gspca_dev->streaming) {
                 setcontrast(gspca_dev);
         }
-        return 0;
+        return gspca_dev->usb_err;
 }
 
 static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val)
@@ -752,7 +703,7 @@ static int sd_setgain(struct gspca_dev *gspca_dev, __s32 val)
         sd->gain = val;
         if (gspca_dev->streaming)
                 setgain(gspca_dev);
-        return 0;
+        return gspca_dev->usb_err;
 }
 
 static int sd_getgain(struct gspca_dev *gspca_dev, __s32 *val)
@@ -770,7 +721,7 @@ static int sd_setexposure(struct gspca_dev *gspca_dev, __s32 val)
         sd->exposure = val;
         if (gspca_dev->streaming)
                 setexposure(gspca_dev);
-        return 0;
+        return gspca_dev->usb_err;
 }
 
 static int sd_getexposure(struct gspca_dev *gspca_dev, __s32 *val)
@@ -801,7 +752,7 @@ static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val)
                 }
         }
 
-        return 0;
+        return gspca_dev->usb_err;
 }
 
 static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val)
@@ -819,7 +770,7 @@ static int sd_sethflip(struct gspca_dev *gspca_dev, __s32 val)
         sd->hflip = val;
         if (gspca_dev->streaming)
                 sethvflip(gspca_dev);
-        return 0;
+        return gspca_dev->usb_err;
 }
 
 static int sd_gethflip(struct gspca_dev *gspca_dev, __s32 *val)
@@ -837,7 +788,7 @@ static int sd_setvflip(struct gspca_dev *gspca_dev, __s32 val)
         sd->vflip = val;
         if (gspca_dev->streaming)
                 sethvflip(gspca_dev);
-        return 0;
+        return gspca_dev->usb_err;
 }
 
 static int sd_getvflip(struct gspca_dev *gspca_dev, __s32 *val)
@@ -848,8 +799,39 @@ static int sd_getvflip(struct gspca_dev *gspca_dev, __s32 *val)
         return 0;
 }
 
+#ifdef CONFIG_INPUT
+static int sd_int_pkt_scan(struct gspca_dev *gspca_dev,
+                        u8 *data,               /* interrupt packet data */
+                        int len)                /* interrupt packet length */
+{
+        int ret = -EINVAL;
+        u8 data0, data1;
+
+        if (len == 2) {
+                data0 = data[0];
+                data1 = data[1];
+                if ((data0 == 0x00 && data1 == 0x11) ||
+                    (data0 == 0x22 && data1 == 0x33) ||
+                    (data0 == 0x44 && data1 == 0x55) ||
+                    (data0 == 0x66 && data1 == 0x77) ||
+                    (data0 == 0x88 && data1 == 0x99) ||
+                    (data0 == 0xaa && data1 == 0xbb) ||
+                    (data0 == 0xcc && data1 == 0xdd) ||
+                    (data0 == 0xee && data1 == 0xff)) {
+                        input_report_key(gspca_dev->input_dev, KEY_CAMERA, 1);
+                        input_sync(gspca_dev->input_dev);
+                        input_report_key(gspca_dev->input_dev, KEY_CAMERA, 0);
+                        input_sync(gspca_dev->input_dev);
+                        ret = 0;
+                }
+        }
+
+        return ret;
+}
+#endif
+
 /* sub-driver description for pac7311 */
-static struct sd_desc sd_desc = {
+static const struct sd_desc sd_desc = {
         .name = MODULE_NAME,
         .ctrls = sd_ctrls,
         .nctrls = ARRAY_SIZE(sd_ctrls),
@@ -860,6 +842,9 @@ static struct sd_desc sd_desc = {
         .stop0 = sd_stop0,
         .pkt_scan = sd_pkt_scan,
         .dq_callback = do_autogain,
+#ifdef CONFIG_INPUT
+        .int_pkt_scan = sd_int_pkt_scan,
+#endif
 };
 
 /* -- module initialisation -- */
diff --git a/drivers/media/video/gspca/pac_common.h b/drivers/media/video/gspca/pac_common.h
index 20f67d9b8c06..8462a7c1a338 100644
--- a/drivers/media/video/gspca/pac_common.h
+++ b/drivers/media/video/gspca/pac_common.h
@@ -24,11 +24,10 @@
  */
 
 /* We calculate the autogain at the end of the transfer of a frame, at this
-   moment a frame with the old settings is being transmitted, and a frame is
-   being captured with the old settings. So if we adjust the autogain we must
-   ignore atleast the 2 next frames for the new settings to come into effect
-   before doing any other adjustments */
-#define PAC_AUTOGAIN_IGNORE_FRAMES      3
+   moment a frame with the old settings is being captured and transmitted. So
+   if we adjust the gain or exposure we must ignore atleast the next frame for
+   the new settings to come into effect before doing any other adjustments. */
+#define PAC_AUTOGAIN_IGNORE_FRAMES      2
 
 static const unsigned char pac_sof_marker[5] =
                 { 0xff, 0xff, 0x00, 0xff, 0x96 };
diff --git a/drivers/media/video/gspca/sn9c2028.c b/drivers/media/video/gspca/sn9c2028.c
new file mode 100644
index 000000000000..dda5fd4aa69e
--- /dev/null
+++ b/drivers/media/video/gspca/sn9c2028.c
@@ -0,0 +1,757 @@
+/*
+ * SN9C2028 library
+ *
+ * Copyright (C) 2009 Theodore Kilgore <kilgota@auburn.edu>
+ *
+ * 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
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#define MODULE_NAME "sn9c2028"
+
+#include "gspca.h"
+
+MODULE_AUTHOR("Theodore Kilgore");
+MODULE_DESCRIPTION("Sonix SN9C2028 USB Camera Driver");
+MODULE_LICENSE("GPL");
+
+/* specific webcam descriptor */
+struct sd {
+        struct gspca_dev gspca_dev;  /* !! must be the first item */
+        u8 sof_read;
+        u16 model;
+};
+
+struct init_command {
+        unsigned char instruction[6];
+        unsigned char to_read; /* length to read. 0 means no reply requested */
+};
+
+/* V4L2 controls supported by the driver */
+static struct ctrl sd_ctrls[] = {
+};
+
+/* How to change the resolution of any of the VGA cams is unknown */
+static const struct v4l2_pix_format vga_mode[] = {
+        {640, 480, V4L2_PIX_FMT_SN9C2028, V4L2_FIELD_NONE,
+                .bytesperline = 640,
+                .sizeimage = 640 * 480 * 3 / 4,
+                .colorspace = V4L2_COLORSPACE_SRGB,
+                .priv = 0},
+};
+
+/* No way to change the resolution of the CIF cams is known */
+static const struct v4l2_pix_format cif_mode[] = {
+        {352, 288, V4L2_PIX_FMT_SN9C2028, V4L2_FIELD_NONE,
+                .bytesperline = 352,
+                .sizeimage = 352 * 288 * 3 / 4,
+                .colorspace = V4L2_COLORSPACE_SRGB,
+                .priv = 0},
+};
+
+/* the bytes to write are in gspca_dev->usb_buf */
+static int sn9c2028_command(struct gspca_dev *gspca_dev, u8 *command)
+{
+        int rc;
+
+        PDEBUG(D_USBO, "sending command %02x%02x%02x%02x%02x%02x", command[0],
+               command[1], command[2], command[3], command[4], command[5]);
+
+        memcpy(gspca_dev->usb_buf, command, 6);
+        rc = usb_control_msg(gspca_dev->dev,
+                        usb_sndctrlpipe(gspca_dev->dev, 0),
+                        USB_REQ_GET_CONFIGURATION,
+                        USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
+                        2, 0, gspca_dev->usb_buf, 6, 500);
+        if (rc < 0) {
+                PDEBUG(D_ERR, "command write [%02x] error %d",
+                                gspca_dev->usb_buf[0], rc);
+                return rc;
+        }
+
+        return 0;
+}
+
+static int sn9c2028_read1(struct gspca_dev *gspca_dev)
+{
+        int rc;
+
+        rc = usb_control_msg(gspca_dev->dev,
+                        usb_rcvctrlpipe(gspca_dev->dev, 0),
+                        USB_REQ_GET_STATUS,
+                        USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
+                        1, 0, gspca_dev->usb_buf, 1, 500);
+        if (rc != 1) {
+                PDEBUG(D_ERR, "read1 error %d", rc);
+                return (rc < 0) ? rc : -EIO;
+        }
+        PDEBUG(D_USBI, "read1 response %02x", gspca_dev->usb_buf[0]);
+        return gspca_dev->usb_buf[0];
+}
+
+static int sn9c2028_read4(struct gspca_dev *gspca_dev, u8 *reading)
+{
+        int rc;
+        rc = usb_control_msg(gspca_dev->dev,
+                        usb_rcvctrlpipe(gspca_dev->dev, 0),
+                        USB_REQ_GET_STATUS,
+                        USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
+                        4, 0, gspca_dev->usb_buf, 4, 500);
+        if (rc != 4) {
+                PDEBUG(D_ERR, "read4 error %d", rc);
+                return (rc < 0) ? rc : -EIO;
+        }
+        memcpy(reading, gspca_dev->usb_buf, 4);
+        PDEBUG(D_USBI, "read4 response %02x%02x%02x%02x", reading[0],
+               reading[1], reading[2], reading[3]);
+        return rc;
+}
+
+static int sn9c2028_long_command(struct gspca_dev *gspca_dev, u8 *command)
+{
+        int i, status;
+        __u8 reading[4];
+
+        status = sn9c2028_command(gspca_dev, command);
+        if (status < 0)
+                return status;
+
+        status = -1;
+        for (i = 0; i < 256 && status < 2; i++)
+                status = sn9c2028_read1(gspca_dev);
+        if (status != 2) {
+                PDEBUG(D_ERR, "long command status read error %d", status);
+                return (status < 0) ? status : -EIO;
+        }
+
+        memset(reading, 0, 4);
+        status = sn9c2028_read4(gspca_dev, reading);
+        if (status < 0)
+                return status;
+
+        /* in general, the first byte of the response is the first byte of
+         * the command, or'ed with 8 */
+        status = sn9c2028_read1(gspca_dev);
+        if (status < 0)
+                return status;
+
+        return 0;
+}
+
+static int sn9c2028_short_command(struct gspca_dev *gspca_dev, u8 *command)
+{
+        int err_code;
+
+        err_code = sn9c2028_command(gspca_dev, command);
+        if (err_code < 0)
+                return err_code;
+
+        err_code = sn9c2028_read1(gspca_dev);
+        if (err_code < 0)
+                return err_code;
+
+        return 0;
+}
+
+/* this function is called at probe time */
+static int sd_config(struct gspca_dev *gspca_dev,
+                     const struct usb_device_id *id)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        struct cam *cam = &gspca_dev->cam;
+
+        PDEBUG(D_PROBE, "SN9C2028 camera detected (vid/pid 0x%04X:0x%04X)",
+               id->idVendor, id->idProduct);
+
+        sd->model = id->idProduct;
+
+        switch (sd->model) {
+        case 0x7005:
+                PDEBUG(D_PROBE, "Genius Smart 300 camera");
+                break;
+        case 0x8000:
+                PDEBUG(D_PROBE, "DC31VC");
+                break;
+        case 0x8001:
+                PDEBUG(D_PROBE, "Spy camera");
+                break;
+        case 0x8003:
+                PDEBUG(D_PROBE, "CIF camera");
+                break;
+        case 0x8008:
+                PDEBUG(D_PROBE, "Mini-Shotz ms-350 camera");
+                break;
+        case 0x800a:
+                PDEBUG(D_PROBE, "Vivitar 3350b type camera");
+                cam->input_flags = V4L2_IN_ST_VFLIP | V4L2_IN_ST_HFLIP;
+                break;
+        }
+
+        switch (sd->model) {
+        case 0x8000:
+        case 0x8001:
+        case 0x8003:
+                cam->cam_mode = cif_mode;
+                cam->nmodes = ARRAY_SIZE(cif_mode);
+                break;
+        default:
+                cam->cam_mode = vga_mode;
+                cam->nmodes = ARRAY_SIZE(vga_mode);
+        }
+        return 0;
+}
+
+/* this function is called at probe and resume time */
+static int sd_init(struct gspca_dev *gspca_dev)
+{
+        int status = -1;
+
+        sn9c2028_read1(gspca_dev);
+        sn9c2028_read1(gspca_dev);
+        status = sn9c2028_read1(gspca_dev);
+
+        return (status < 0) ? status : 0;
+}
+
+static int run_start_commands(struct gspca_dev *gspca_dev,
+                              struct init_command *cam_commands, int n)
+{
+        int i, err_code = -1;
+
+        for (i = 0; i < n; i++) {
+                switch (cam_commands[i].to_read) {
+                case 4:
+                        err_code = sn9c2028_long_command(gspca_dev,
+                                        cam_commands[i].instruction);
+                        break;
+                case 1:
+                        err_code = sn9c2028_short_command(gspca_dev,
+                                        cam_commands[i].instruction);
+                        break;
+                case 0:
+                        err_code = sn9c2028_command(gspca_dev,
+                                        cam_commands[i].instruction);
+                        break;
+                }
+                if (err_code < 0)
+                        return err_code;
+        }
+        return 0;
+}
+
+static int start_spy_cam(struct gspca_dev *gspca_dev)
+{
+        struct init_command spy_start_commands[] = {
+                {{0x0c, 0x01, 0x00, 0x00, 0x00, 0x00}, 4},
+                {{0x13, 0x20, 0x01, 0x00, 0x00, 0x00}, 4},
+                {{0x13, 0x21, 0x01, 0x00, 0x00, 0x00}, 4},
+                {{0x13, 0x22, 0x01, 0x04, 0x00, 0x00}, 4},
+                {{0x13, 0x23, 0x01, 0x03, 0x00, 0x00}, 4},
+                {{0x13, 0x24, 0x01, 0x00, 0x00, 0x00}, 4},
+                {{0x13, 0x25, 0x01, 0x16, 0x00, 0x00}, 4}, /* width  352 */
+                {{0x13, 0x26, 0x01, 0x12, 0x00, 0x00}, 4}, /* height 288 */
+                /* {{0x13, 0x27, 0x01, 0x28, 0x00, 0x00}, 4}, */
+                {{0x13, 0x27, 0x01, 0x68, 0x00, 0x00}, 4},
+                {{0x13, 0x28, 0x01, 0x09, 0x00, 0x00}, 4}, /* red gain ?*/
+                /* {{0x13, 0x28, 0x01, 0x00, 0x00, 0x00}, 4}, */
+                {{0x13, 0x29, 0x01, 0x00, 0x00, 0x00}, 4},
+                /* {{0x13, 0x29, 0x01, 0x0c, 0x00, 0x00}, 4}, */
+                {{0x13, 0x2a, 0x01, 0x00, 0x00, 0x00}, 4},
+                {{0x13, 0x2b, 0x01, 0x00, 0x00, 0x00}, 4},
+                /* {{0x13, 0x2c, 0x01, 0x02, 0x00, 0x00}, 4}, */
+                {{0x13, 0x2c, 0x01, 0x02, 0x00, 0x00}, 4},
+                {{0x13, 0x2d, 0x01, 0x02, 0x00, 0x00}, 4},
+                /* {{0x13, 0x2e, 0x01, 0x09, 0x00, 0x00}, 4}, */
+                {{0x13, 0x2e, 0x01, 0x09, 0x00, 0x00}, 4},
+                {{0x13, 0x2f, 0x01, 0x07, 0x00, 0x00}, 4},
+                {{0x12, 0x34, 0x01, 0x00, 0x00, 0x00}, 4},
+                {{0x13, 0x34, 0x01, 0xa1, 0x00, 0x00}, 4},
+                {{0x13, 0x35, 0x01, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x02, 0x06, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x03, 0x13, 0x00, 0x00, 0x00}, 4}, /*don't mess with*/
+                /*{{0x11, 0x04, 0x06, 0x00, 0x00, 0x00}, 4}, observed */
+                {{0x11, 0x04, 0x00, 0x00, 0x00, 0x00}, 4}, /* brighter */
+                /*{{0x11, 0x05, 0x65, 0x00, 0x00, 0x00}, 4}, observed */
+                {{0x11, 0x05, 0x00, 0x00, 0x00, 0x00}, 4}, /* brighter */
+                {{0x11, 0x06, 0xb1, 0x00, 0x00, 0x00}, 4}, /* observed */
+                {{0x11, 0x07, 0x00, 0x00, 0x00, 0x00}, 4},
+                /*{{0x11, 0x08, 0x06, 0x00, 0x00, 0x00}, 4}, observed */
+                {{0x11, 0x08, 0x0b, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x09, 0x01, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x0a, 0x01, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x0b, 0x01, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x0c, 0x01, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x0d, 0x00, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x0e, 0x04, 0x00, 0x00, 0x00}, 4},
+                /* {{0x11, 0x0f, 0x00, 0x00, 0x00, 0x00}, 4}, */
+                /* brightness or gain. 0 is default. 4 is good
+                 * indoors at night with incandescent lighting */
+                {{0x11, 0x0f, 0x04, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x10, 0x06, 0x00, 0x00, 0x00}, 4}, /*hstart or hoffs*/
+                {{0x11, 0x11, 0x06, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x12, 0x00, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x14, 0x02, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x13, 0x01, 0x00, 0x00, 0x00}, 4},
+                /* {{0x1b, 0x02, 0x06, 0x00, 0x00, 0x00}, 1}, observed */
+                {{0x1b, 0x02, 0x11, 0x00, 0x00, 0x00}, 1}, /* brighter */
+                /* {{0x1b, 0x13, 0x01, 0x00, 0x00, 0x00}, 1}, observed */
+                {{0x1b, 0x13, 0x11, 0x00, 0x00, 0x00}, 1},
+                {{0x20, 0x34, 0xa1, 0x00, 0x00, 0x00}, 1}, /* compresses */
+                /* Camera should start to capture now. */
+        };
+
+        return run_start_commands(gspca_dev, spy_start_commands,
+                                  ARRAY_SIZE(spy_start_commands));
+}
+
+static int start_cif_cam(struct gspca_dev *gspca_dev)
+{
+        struct init_command cif_start_commands[] = {
+                {{0x0c, 0x01, 0x00, 0x00, 0x00, 0x00}, 4},
+                /* The entire sequence below seems redundant */
+                /* {{0x13, 0x20, 0x01, 0x00, 0x00, 0x00}, 4},
+                {{0x13, 0x21, 0x01, 0x00, 0x00, 0x00}, 4},
+                {{0x13, 0x22, 0x01, 0x06, 0x00, 0x00}, 4},
+                {{0x13, 0x23, 0x01, 0x02, 0x00, 0x00}, 4},
+                {{0x13, 0x24, 0x01, 0x00, 0x00, 0x00}, 4},
+                {{0x13, 0x25, 0x01, 0x16, 0x00, 0x00}, 4}, width?
+                {{0x13, 0x26, 0x01, 0x12, 0x00, 0x00}, 4}, height?
+                {{0x13, 0x27, 0x01, 0x68, 0x00, 0x00}, 4}, subsample?
+                {{0x13, 0x28, 0x01, 0x00, 0x00, 0x00}, 4},
+                {{0x13, 0x29, 0x01, 0x20, 0x00, 0x00}, 4},
+                {{0x13, 0x2a, 0x01, 0x00, 0x00, 0x00}, 4},
+                {{0x13, 0x2b, 0x01, 0x00, 0x00, 0x00}, 4},
+                {{0x13, 0x2c, 0x01, 0x02, 0x00, 0x00}, 4},
+                {{0x13, 0x2d, 0x01, 0x03, 0x00, 0x00}, 4},
+                {{0x13, 0x2e, 0x01, 0x0f, 0x00, 0x00}, 4},
+                {{0x13, 0x2f, 0x01, 0x0c, 0x00, 0x00}, 4},
+                {{0x12, 0x34, 0x01, 0x00, 0x00, 0x00}, 4},
+                {{0x13, 0x34, 0x01, 0xa1, 0x00, 0x00}, 4},
+                {{0x13, 0x35, 0x01, 0x00, 0x00, 0x00}, 4},*/
+                {{0x1b, 0x21, 0x00, 0x00, 0x00, 0x00}, 1},
+                {{0x1b, 0x17, 0x00, 0x00, 0x00, 0x00}, 1},
+                {{0x1b, 0x19, 0x00, 0x00, 0x00, 0x00}, 1},
+                {{0x1b, 0x02, 0x06, 0x00, 0x00, 0x00}, 1},
+                {{0x1b, 0x03, 0x5a, 0x00, 0x00, 0x00}, 1},
+                {{0x1b, 0x04, 0x27, 0x00, 0x00, 0x00}, 1},
+                {{0x1b, 0x05, 0x01, 0x00, 0x00, 0x00}, 1},
+                {{0x1b, 0x12, 0x14, 0x00, 0x00, 0x00}, 1},
+                {{0x1b, 0x13, 0x00, 0x00, 0x00, 0x00}, 1},
+                {{0x1b, 0x14, 0x00, 0x00, 0x00, 0x00}, 1},
+                {{0x1b, 0x15, 0x00, 0x00, 0x00, 0x00}, 1},
+                {{0x1b, 0x16, 0x00, 0x00, 0x00, 0x00}, 1},
+                {{0x1b, 0x77, 0xa2, 0x00, 0x00, 0x00}, 1},
+                {{0x1b, 0x06, 0x0f, 0x00, 0x00, 0x00}, 1},
+                {{0x1b, 0x07, 0x14, 0x00, 0x00, 0x00}, 1},
+                {{0x1b, 0x08, 0x0f, 0x00, 0x00, 0x00}, 1},
+                {{0x1b, 0x09, 0x10, 0x00, 0x00, 0x00}, 1},
+                {{0x1b, 0x0e, 0x00, 0x00, 0x00, 0x00}, 1},
+                {{0x1b, 0x0f, 0x00, 0x00, 0x00, 0x00}, 1},
+                {{0x1b, 0x12, 0x07, 0x00, 0x00, 0x00}, 1},
+                {{0x1b, 0x10, 0x1f, 0x00, 0x00, 0x00}, 1},
+                {{0x1b, 0x11, 0x01, 0x00, 0x00, 0x00}, 1},
+                {{0x13, 0x25, 0x01, 0x16, 0x00, 0x00}, 1}, /* width/8 */
+                {{0x13, 0x26, 0x01, 0x12, 0x00, 0x00}, 1}, /* height/8 */
+                /* {{0x13, 0x27, 0x01, 0x68, 0x00, 0x00}, 4}, subsample?
+                 * {{0x13, 0x28, 0x01, 0x1e, 0x00, 0x00}, 4}, does nothing
+                 * {{0x13, 0x27, 0x01, 0x20, 0x00, 0x00}, 4}, */
+                /* {{0x13, 0x29, 0x01, 0x22, 0x00, 0x00}, 4},
+                 * causes subsampling
+                 * but not a change in the resolution setting! */
+                {{0x13, 0x2c, 0x01, 0x02, 0x00, 0x00}, 4},
+                {{0x13, 0x2d, 0x01, 0x01, 0x00, 0x00}, 4},
+                {{0x13, 0x2e, 0x01, 0x08, 0x00, 0x00}, 4},
+                {{0x13, 0x2f, 0x01, 0x06, 0x00, 0x00}, 4},
+                {{0x13, 0x28, 0x01, 0x00, 0x00, 0x00}, 4},
+                {{0x1b, 0x04, 0x6d, 0x00, 0x00, 0x00}, 1},
+                {{0x1b, 0x05, 0x03, 0x00, 0x00, 0x00}, 1},
+                {{0x20, 0x36, 0x06, 0x00, 0x00, 0x00}, 1},
+                {{0x1b, 0x0e, 0x01, 0x00, 0x00, 0x00}, 1},
+                {{0x12, 0x27, 0x01, 0x00, 0x00, 0x00}, 4},
+                {{0x1b, 0x0f, 0x00, 0x00, 0x00, 0x00}, 1},
+                {{0x20, 0x36, 0x05, 0x00, 0x00, 0x00}, 1},
+                {{0x1b, 0x10, 0x0f, 0x00, 0x00, 0x00}, 1},
+                {{0x1b, 0x02, 0x06, 0x00, 0x00, 0x00}, 1},
+                {{0x1b, 0x11, 0x01, 0x00, 0x00, 0x00}, 1},
+                {{0x20, 0x34, 0xa1, 0x00, 0x00, 0x00}, 1},/* use compression */
+                /* Camera should start to capture now. */
+        };
+
+        return run_start_commands(gspca_dev, cif_start_commands,
+                                  ARRAY_SIZE(cif_start_commands));
+}
+
+static int start_ms350_cam(struct gspca_dev *gspca_dev)
+{
+        struct init_command ms350_start_commands[] = {
+                {{0x0c, 0x01, 0x00, 0x00, 0x00, 0x00}, 4},
+                {{0x16, 0x01, 0x00, 0x00, 0x00, 0x00}, 4},
+                {{0x13, 0x20, 0x01, 0x00, 0x00, 0x00}, 4},
+                {{0x13, 0x21, 0x01, 0x00, 0x00, 0x00}, 4},
+                {{0x13, 0x22, 0x01, 0x04, 0x00, 0x00}, 4},
+                {{0x13, 0x23, 0x01, 0x03, 0x00, 0x00}, 4},
+                {{0x13, 0x24, 0x01, 0x00, 0x00, 0x00}, 4},
+                {{0x13, 0x25, 0x01, 0x16, 0x00, 0x00}, 4},
+                {{0x13, 0x26, 0x01, 0x12, 0x00, 0x00}, 4},
+                {{0x13, 0x27, 0x01, 0x28, 0x00, 0x00}, 4},
+                {{0x13, 0x28, 0x01, 0x09, 0x00, 0x00}, 4},
+                {{0x13, 0x29, 0x01, 0x00, 0x00, 0x00}, 4},
+                {{0x13, 0x2a, 0x01, 0x00, 0x00, 0x00}, 4},
+                {{0x13, 0x2b, 0x01, 0x00, 0x00, 0x00}, 4},
+                {{0x13, 0x2c, 0x01, 0x02, 0x00, 0x00}, 4},
+                {{0x13, 0x2d, 0x01, 0x03, 0x00, 0x00}, 4},
+                {{0x13, 0x2e, 0x01, 0x0f, 0x00, 0x00}, 4},
+                {{0x13, 0x2f, 0x01, 0x0c, 0x00, 0x00}, 4},
+                {{0x12, 0x34, 0x01, 0x00, 0x00, 0x00}, 4},
+                {{0x13, 0x34, 0x01, 0xa1, 0x00, 0x00}, 4},
+                {{0x13, 0x35, 0x01, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x00, 0x01, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x01, 0x70, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x02, 0x05, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x03, 0x5d, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x04, 0x07, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x05, 0x25, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x06, 0x00, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x07, 0x09, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x08, 0x01, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x09, 0x00, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x0a, 0x00, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x0b, 0x01, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x0c, 0x00, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x0d, 0x0c, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x0e, 0x01, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x0f, 0x00, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x10, 0x00, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x11, 0x00, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x12, 0x00, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x13, 0x63, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x15, 0x70, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x18, 0x00, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x11, 0x01, 0x00, 0x00, 0x00}, 4},
+                {{0x13, 0x25, 0x01, 0x28, 0x00, 0x00}, 4}, /* width  */
+                {{0x13, 0x26, 0x01, 0x1e, 0x00, 0x00}, 4}, /* height */
+                {{0x13, 0x28, 0x01, 0x09, 0x00, 0x00}, 4}, /* vstart? */
+                {{0x13, 0x27, 0x01, 0x28, 0x00, 0x00}, 4},
+                {{0x13, 0x29, 0x01, 0x40, 0x00, 0x00}, 4}, /* hstart? */
+                {{0x13, 0x2c, 0x01, 0x02, 0x00, 0x00}, 4},
+                {{0x13, 0x2d, 0x01, 0x03, 0x00, 0x00}, 4},
+                {{0x13, 0x2e, 0x01, 0x0f, 0x00, 0x00}, 4},
+                {{0x13, 0x2f, 0x01, 0x0c, 0x00, 0x00}, 4},
+                {{0x1b, 0x02, 0x05, 0x00, 0x00, 0x00}, 1},
+                {{0x1b, 0x11, 0x01, 0x00, 0x00, 0x00}, 1},
+                {{0x20, 0x18, 0x00, 0x00, 0x00, 0x00}, 1},
+                {{0x1b, 0x02, 0x0a, 0x00, 0x00, 0x00}, 1},
+                {{0x1b, 0x11, 0x01, 0x00, 0x00, 0x00}, 0},
+                /* Camera should start to capture now. */
+        };
+
+        return run_start_commands(gspca_dev, ms350_start_commands,
+                                  ARRAY_SIZE(ms350_start_commands));
+}
+
+static int start_genius_cam(struct gspca_dev *gspca_dev)
+{
+        struct init_command genius_start_commands[] = {
+                {{0x0c, 0x01, 0x00, 0x00, 0x00, 0x00}, 4},
+                {{0x16, 0x01, 0x00, 0x00, 0x00, 0x00}, 4},
+                {{0x10, 0x00, 0x00, 0x00, 0x00, 0x00}, 4},
+                {{0x13, 0x25, 0x01, 0x16, 0x00, 0x00}, 4},
+                {{0x13, 0x26, 0x01, 0x12, 0x00, 0x00}, 4},
+                /* "preliminary" width and height settings */
+                {{0x13, 0x28, 0x01, 0x0e, 0x00, 0x00}, 4},
+                {{0x13, 0x27, 0x01, 0x20, 0x00, 0x00}, 4},
+                {{0x13, 0x29, 0x01, 0x22, 0x00, 0x00}, 4},
+                {{0x13, 0x2c, 0x01, 0x02, 0x00, 0x00}, 4},
+                {{0x13, 0x2d, 0x01, 0x02, 0x00, 0x00}, 4},
+                {{0x13, 0x2e, 0x01, 0x09, 0x00, 0x00}, 4},
+                {{0x13, 0x2f, 0x01, 0x07, 0x00, 0x00}, 4},
+                {{0x11, 0x20, 0x00, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x21, 0x2d, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x22, 0x00, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x23, 0x03, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x10, 0x00, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x11, 0x64, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x12, 0x00, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x13, 0x91, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x14, 0x01, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x15, 0x20, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x16, 0x01, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x17, 0x60, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x20, 0x00, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x21, 0x2d, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x22, 0x00, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x23, 0x03, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x25, 0x00, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x26, 0x02, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x27, 0x88, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x30, 0x38, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x31, 0x2a, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x32, 0x2a, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x33, 0x2a, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x34, 0x02, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x5b, 0x0a, 0x00, 0x00, 0x00}, 4},
+                {{0x13, 0x25, 0x01, 0x28, 0x00, 0x00}, 4}, /* real width */
+                {{0x13, 0x26, 0x01, 0x1e, 0x00, 0x00}, 4}, /* real height */
+                {{0x13, 0x28, 0x01, 0x0e, 0x00, 0x00}, 4},
+                {{0x13, 0x27, 0x01, 0x20, 0x00, 0x00}, 4},
+                {{0x13, 0x29, 0x01, 0x62, 0x00, 0x00}, 4},
+                {{0x13, 0x2c, 0x01, 0x02, 0x00, 0x00}, 4},
+                {{0x13, 0x2d, 0x01, 0x03, 0x00, 0x00}, 4},
+                {{0x13, 0x2e, 0x01, 0x0f, 0x00, 0x00}, 4},
+                {{0x13, 0x2f, 0x01, 0x0c, 0x00, 0x00}, 4},
+                {{0x11, 0x20, 0x00, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x21, 0x2a, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x22, 0x00, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x23, 0x28, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x10, 0x00, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x11, 0x04, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x12, 0x00, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x13, 0x03, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x14, 0x01, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x15, 0xe0, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x16, 0x02, 0x00, 0x00, 0x00}, 4},
+                {{0x11, 0x17, 0x80, 0x00, 0x00, 0x00}, 4},
+                {{0x1c, 0x20, 0x00, 0x2a, 0x00, 0x00}, 1},
+                {{0x1c, 0x20, 0x00, 0x2a, 0x00, 0x00}, 1},
+                {{0x20, 0x34, 0xa1, 0x00, 0x00, 0x00}, 0}
+                /* Camera should start to capture now. */
+        };
+
+        return run_start_commands(gspca_dev, genius_start_commands,
+                                  ARRAY_SIZE(genius_start_commands));
+}
+
+static int start_vivitar_cam(struct gspca_dev *gspca_dev)
+{
+        struct init_command vivitar_start_commands[] = {
+                {{0x0c, 0x01, 0x00, 0x00, 0x00, 0x00}, 4},
+                {{0x13, 0x20, 0x01, 0x00, 0x00, 0x00}, 4},
+                {{0x13, 0x21, 0x01, 0x00, 0x00, 0x00}, 4},
+                {{0x13, 0x22, 0x01, 0x01, 0x00, 0x00}, 4},
+                {{0x13, 0x23, 0x01, 0x01, 0x00, 0x00}, 4},
+                {{0x13, 0x24, 0x01, 0x00, 0x00, 0x00}, 4},
+                {{0x13, 0x25, 0x01, 0x28, 0x00, 0x00}, 4},
+                {{0x13, 0x26, 0x01, 0x1e, 0x00, 0x00}, 4},
+                {{0x13, 0x27, 0x01, 0x20, 0x00, 0x00}, 4},
+                {{0x13, 0x28, 0x01, 0x0a, 0x00, 0x00}, 4},
+                /*
+                 * Above is changed from OEM 0x0b. Fixes Bayer tiling.
+                 * Presumably gives a vertical shift of one row.
+                 */
+                {{0x13, 0x29, 0x01, 0x20, 0x00, 0x00}, 4},
+                /* Above seems to do horizontal shift. */
+                {{0x13, 0x2a, 0x01, 0x00, 0x00, 0x00}, 4},
+                {{0x13, 0x2b, 0x01, 0x00, 0x00, 0x00}, 4},
+                {{0x13, 0x2c, 0x01, 0x02, 0x00, 0x00}, 4},
+                {{0x13, 0x2d, 0x01, 0x03, 0x00, 0x00}, 4},
+                {{0x13, 0x2e, 0x01, 0x0f, 0x00, 0x00}, 4},
+                {{0x13, 0x2f, 0x01, 0x0c, 0x00, 0x00}, 4},
+                /* Above three commands seem to relate to brightness. */
+                {{0x12, 0x34, 0x01, 0x00, 0x00, 0x00}, 4},
+                {{0x13, 0x34, 0x01, 0xa1, 0x00, 0x00}, 4},
+                {{0x13, 0x35, 0x01, 0x00, 0x00, 0x00}, 4},
+                {{0x1b, 0x12, 0x80, 0x00, 0x00, 0x00}, 1},
+                {{0x1b, 0x01, 0x77, 0x00, 0x00, 0x00}, 1},
+                {{0x1b, 0x02, 0x3a, 0x00, 0x00, 0x00}, 1},
+                {{0x1b, 0x12, 0x78, 0x00, 0x00, 0x00}, 1},
+                {{0x1b, 0x13, 0x00, 0x00, 0x00, 0x00}, 1},
+                {{0x1b, 0x14, 0x80, 0x00, 0x00, 0x00}, 1},
+                {{0x1b, 0x15, 0x34, 0x00, 0x00, 0x00}, 1},
+                {{0x1b, 0x1b, 0x04, 0x00, 0x00, 0x00}, 1},
+                {{0x1b, 0x20, 0x44, 0x00, 0x00, 0x00}, 1},
+                {{0x1b, 0x23, 0xee, 0x00, 0x00, 0x00}, 1},
+                {{0x1b, 0x26, 0xa0, 0x00, 0x00, 0x00}, 1},
+                {{0x1b, 0x27, 0x9a, 0x00, 0x00, 0x00}, 1},
+                {{0x1b, 0x28, 0xa0, 0x00, 0x00, 0x00}, 1},
+                {{0x1b, 0x29, 0x30, 0x00, 0x00, 0x00}, 1},
+                {{0x1b, 0x2a, 0x80, 0x00, 0x00, 0x00}, 1},
+                {{0x1b, 0x2b, 0x00, 0x00, 0x00, 0x00}, 1},
+                {{0x1b, 0x2f, 0x3d, 0x00, 0x00, 0x00}, 1},
+                {{0x1b, 0x30, 0x24, 0x00, 0x00, 0x00}, 1},
+                {{0x1b, 0x32, 0x86, 0x00, 0x00, 0x00}, 1},
+                {{0x1b, 0x60, 0xa9, 0x00, 0x00, 0x00}, 1},
+                {{0x1b, 0x61, 0x42, 0x00, 0x00, 0x00}, 1},
+                {{0x1b, 0x65, 0x00, 0x00, 0x00, 0x00}, 1},
+                {{0x1b, 0x69, 0x38, 0x00, 0x00, 0x00}, 1},
+                {{0x1b, 0x6f, 0x88, 0x00, 0x00, 0x00}, 1},
+                {{0x1b, 0x70, 0x0b, 0x00, 0x00, 0x00}, 1},
+                {{0x1b, 0x71, 0x00, 0x00, 0x00, 0x00}, 1},
+                {{0x1b, 0x74, 0x21, 0x00, 0x00, 0x00}, 1},
+                {{0x1b, 0x75, 0x86, 0x00, 0x00, 0x00}, 1},
+                {{0x1b, 0x76, 0x00, 0x00, 0x00, 0x00}, 1},
+                {{0x1b, 0x7d, 0xf3, 0x00, 0x00, 0x00}, 1},
+                {{0x1b, 0x17, 0x1c, 0x00, 0x00, 0x00}, 1},
+                {{0x1b, 0x18, 0xc0, 0x00, 0x00, 0x00}, 1},
+                {{0x1b, 0x19, 0x05, 0x00, 0x00, 0x00}, 1},
+                {{0x1b, 0x1a, 0xf6, 0x00, 0x00, 0x00}, 1},
+                /* {{0x13, 0x25, 0x01, 0x28, 0x00, 0x00}, 4},
+                {{0x13, 0x26, 0x01, 0x1e, 0x00, 0x00}, 4},
+                {{0x13, 0x28, 0x01, 0x0b, 0x00, 0x00}, 4}, */
+                {{0x20, 0x36, 0x06, 0x00, 0x00, 0x00}, 1},
+                {{0x1b, 0x10, 0x26, 0x00, 0x00, 0x00}, 1},
+                {{0x12, 0x27, 0x01, 0x00, 0x00, 0x00}, 4},
+                {{0x1b, 0x76, 0x03, 0x00, 0x00, 0x00}, 1},
+                {{0x20, 0x36, 0x05, 0x00, 0x00, 0x00}, 1},
+                {{0x1b, 0x00, 0x3f, 0x00, 0x00, 0x00}, 1},
+                /* Above is brightness; OEM driver setting is 0x10 */
+                {{0x12, 0x27, 0x01, 0x00, 0x00, 0x00}, 4},
+                {{0x20, 0x29, 0x30, 0x00, 0x00, 0x00}, 1},
+                {{0x20, 0x34, 0xa1, 0x00, 0x00, 0x00}, 1}
+        };
+
+        return run_start_commands(gspca_dev, vivitar_start_commands,
+                                  ARRAY_SIZE(vivitar_start_commands));
+}
+
+static int sd_start(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        int err_code;
+
+        sd->sof_read = 0;
+
+        switch (sd->model) {
+        case 0x7005:
+                err_code = start_genius_cam(gspca_dev);
+                break;
+        case 0x8001:
+                err_code = start_spy_cam(gspca_dev);
+                break;
+        case 0x8003:
+                err_code = start_cif_cam(gspca_dev);
+                break;
+        case 0x8008:
+                err_code = start_ms350_cam(gspca_dev);
+                break;
+        case 0x800a:
+                err_code = start_vivitar_cam(gspca_dev);
+                break;
+        default:
+                PDEBUG(D_ERR, "Starting unknown camera, please report this");
+                return -ENXIO;
+        }
+
+        return err_code;
+}
+
+static void sd_stopN(struct gspca_dev *gspca_dev)
+{
+        int result;
+        __u8 data[6];
+
+        result = sn9c2028_read1(gspca_dev);
+        if (result < 0)
+                PDEBUG(D_ERR, "Camera Stop read failed");
+
+        memset(data, 0, 6);
+        data[0] = 0x14;
+        result = sn9c2028_command(gspca_dev, data);
+        if (result < 0)
+                PDEBUG(D_ERR, "Camera Stop command failed");
+}
+
+/* Include sn9c2028 sof detection functions */
+#include "sn9c2028.h"
+
+static void sd_pkt_scan(struct gspca_dev *gspca_dev,
+                        __u8 *data,                     /* isoc packet */
+                        int len)                        /* iso packet length */
+{
+        unsigned char *sof;
+
+        sof = sn9c2028_find_sof(gspca_dev, data, len);
+        if (sof) {
+                int n;
+
+                /* finish decoding current frame */
+                n = sof - data;
+                if (n > sizeof sn9c2028_sof_marker)
+                        n -= sizeof sn9c2028_sof_marker;
+                else
+                        n = 0;
+                gspca_frame_add(gspca_dev, LAST_PACKET, data, n);
+                /* Start next frame. */
+                gspca_frame_add(gspca_dev, FIRST_PACKET,
+                        sn9c2028_sof_marker, sizeof sn9c2028_sof_marker);
+                len -= sof - data;
+                data = sof;
+        }
+        gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
+}
+
+/* sub-driver description */
+static const struct sd_desc sd_desc = {
+        .name = MODULE_NAME,
+        .ctrls = sd_ctrls,
+        .nctrls = ARRAY_SIZE(sd_ctrls),
+        .config = sd_config,
+        .init = sd_init,
+        .start = sd_start,
+        .stopN = sd_stopN,
+        .pkt_scan = sd_pkt_scan,
+};
+
+/* -- module initialisation -- */
+static const __devinitdata struct usb_device_id device_table[] = {
+        {USB_DEVICE(0x0458, 0x7005)}, /* Genius Smart 300, version 2 */
+        /* The Genius Smart is untested. I can't find an owner ! */
+        /* {USB_DEVICE(0x0c45, 0x8000)}, DC31VC, Don't know this camera */
+        {USB_DEVICE(0x0c45, 0x8001)}, /* Wild Planet digital spy cam */
+        {USB_DEVICE(0x0c45, 0x8003)}, /* Several small CIF cameras */
+        /* {USB_DEVICE(0x0c45, 0x8006)}, Unknown VGA camera */
+        {USB_DEVICE(0x0c45, 0x8008)}, /* Mini-Shotz ms-350 */
+        {USB_DEVICE(0x0c45, 0x800a)}, /* Vivicam 3350B */
+        {}
+};
+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);
+}
+
+static struct usb_driver sd_driver = {
+        .name = MODULE_NAME,
+        .id_table = device_table,
+        .probe = sd_probe,
+        .disconnect = gspca_disconnect,
+#ifdef CONFIG_PM
+        .suspend = gspca_suspend,
+        .resume = gspca_resume,
+#endif
+};
+
+/* -- module insert / remove -- */
+static int __init sd_mod_init(void)
+{
+        int ret;
+
+        ret = usb_register(&sd_driver);
+        if (ret < 0)
+                return ret;
+        PDEBUG(D_PROBE, "registered");
+        return 0;
+}
+
+static void __exit sd_mod_exit(void)
+{
+        usb_deregister(&sd_driver);
+        PDEBUG(D_PROBE, "deregistered");
+}
+
+module_init(sd_mod_init);
+module_exit(sd_mod_exit);
diff --git a/drivers/media/video/gspca/sn9c2028.h b/drivers/media/video/gspca/sn9c2028.h
new file mode 100644
index 000000000000..8fd1d3e05665
--- /dev/null
+++ b/drivers/media/video/gspca/sn9c2028.h
@@ -0,0 +1,51 @@
+/*
+ * SN9C2028 common functions
+ *
+ * Copyright (C) 2009 Theodore Kilgore <kilgota@auburn,edu>
+ *
+ * Based closely upon the file gspca/pac_common.h
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ */
+
+static const unsigned char sn9c2028_sof_marker[5] =
+        { 0xff, 0xff, 0x00, 0xc4, 0xc4 };
+
+static unsigned char *sn9c2028_find_sof(struct gspca_dev *gspca_dev,
+                                        unsigned char *m, int len)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        int i;
+
+        /* Search for the SOF marker (fixed part) in the header */
+        for (i = 0; i < len; i++) {
+                if (m[i] == sn9c2028_sof_marker[sd->sof_read]) {
+                        sd->sof_read++;
+                        if (sd->sof_read == sizeof(sn9c2028_sof_marker)) {
+                                PDEBUG(D_FRAM,
+                                        "SOF found, bytes to analyze: %u."
+                                        " Frame starts at byte #%u",
+                                        len, i + 1);
+                                sd->sof_read = 0;
+                                return m + i + 1;
+                        }
+                } else {
+                        sd->sof_read = 0;
+                }
+        }
+
+        return NULL;
+}
diff --git a/drivers/media/video/gspca/sn9c20x.c b/drivers/media/video/gspca/sn9c20x.c
index 0ca1c06652b1..4a1bc08f82b9 100644
--- a/drivers/media/video/gspca/sn9c20x.c
+++ b/drivers/media/video/gspca/sn9c20x.c
@@ -129,7 +129,7 @@ static int sd_getexposure(struct gspca_dev *gspca_dev, s32 *val);
 static int sd_setautoexposure(struct gspca_dev *gspca_dev, s32 val);
 static int sd_getautoexposure(struct gspca_dev *gspca_dev, s32 *val);
 
-static struct ctrl sd_ctrls[] = {
+static const struct ctrl sd_ctrls[] = {
         {
 #define BRIGHTNESS_IDX 0
             {
@@ -1506,36 +1506,36 @@ static int set_cmatrix(struct gspca_dev *gspca_dev)
         struct sd *sd = (struct sd *) gspca_dev;
         s32 hue_coord, hue_index = 180 + sd->hue;
         u8 cmatrix[21];
-        memset(cmatrix, 0, 21);
 
+        memset(cmatrix, 0, sizeof cmatrix);
         cmatrix[2] = (sd->contrast * 0x25 / 0x100) + 0x26;
         cmatrix[0] = 0x13 + (cmatrix[2] - 0x26) * 0x13 / 0x25;
         cmatrix[4] = 0x07 + (cmatrix[2] - 0x26) * 0x07 / 0x25;
         cmatrix[18] = sd->brightness - 0x80;
 
         hue_coord = (hsv_red_x[hue_index] * sd->saturation) >> 8;
-        cmatrix[6] = (unsigned char)(hue_coord & 0xff);
-        cmatrix[7] = (unsigned char)((hue_coord >> 8) & 0x0f);
+        cmatrix[6] = hue_coord;
+        cmatrix[7] = (hue_coord >> 8) & 0x0f;
 
         hue_coord = (hsv_red_y[hue_index] * sd->saturation) >> 8;
-        cmatrix[8] = (unsigned char)(hue_coord & 0xff);
-        cmatrix[9] = (unsigned char)((hue_coord >> 8) & 0x0f);
+        cmatrix[8] = hue_coord;
+        cmatrix[9] = (hue_coord >> 8) & 0x0f;
 
         hue_coord = (hsv_green_x[hue_index] * sd->saturation) >> 8;
-        cmatrix[10] = (unsigned char)(hue_coord & 0xff);
-        cmatrix[11] = (unsigned char)((hue_coord >> 8) & 0x0f);
+        cmatrix[10] = hue_coord;
+        cmatrix[11] = (hue_coord >> 8) & 0x0f;
 
         hue_coord = (hsv_green_y[hue_index] * sd->saturation) >> 8;
-        cmatrix[12] = (unsigned char)(hue_coord & 0xff);
-        cmatrix[13] = (unsigned char)((hue_coord >> 8) & 0x0f);
+        cmatrix[12] = hue_coord;
+        cmatrix[13] = (hue_coord >> 8) & 0x0f;
 
         hue_coord = (hsv_blue_x[hue_index] * sd->saturation) >> 8;
-        cmatrix[14] = (unsigned char)(hue_coord & 0xff);
-        cmatrix[15] = (unsigned char)((hue_coord >> 8) & 0x0f);
+        cmatrix[14] = hue_coord;
+        cmatrix[15] = (hue_coord >> 8) & 0x0f;
 
         hue_coord = (hsv_blue_y[hue_index] * sd->saturation) >> 8;
-        cmatrix[16] = (unsigned char)(hue_coord & 0xff);
-        cmatrix[17] = (unsigned char)((hue_coord >> 8) & 0x0f);
+        cmatrix[16] = hue_coord;
+        cmatrix[17] = (hue_coord >> 8) & 0x0f;
 
         return reg_w(gspca_dev, 0x10e1, cmatrix, 21);
 }
@@ -2015,6 +2015,7 @@ static int sd_config(struct gspca_dev *gspca_dev,
         default:
                 cam->cam_mode = vga_mode;
                 cam->nmodes = ARRAY_SIZE(vga_mode);
+                break;
         }
 
         sd->old_step = 0;
@@ -2319,7 +2320,7 @@ static void do_autogain(struct gspca_dev *gspca_dev, u16 avg_lum)
                 }
         }
         if (avg_lum > MAX_AVG_LUM) {
-                if (sd->gain >= 1) {
+                if (sd->gain > 0) {
                         sd->gain--;
                         set_gain(gspca_dev);
                 }
@@ -2347,7 +2348,7 @@ static void sd_pkt_scan(struct gspca_dev *gspca_dev,
 {
         struct sd *sd = (struct sd *) gspca_dev;
         int avg_lum;
-        static unsigned char frame_header[] =
+        static u8 frame_header[] =
                 {0xff, 0xff, 0x00, 0xc4, 0xc4, 0x96};
         if (len == 64 && memcmp(data, frame_header, 6) == 0) {
                 avg_lum = ((data[35] >> 2) & 3) |
diff --git a/drivers/media/video/gspca/sonixb.c b/drivers/media/video/gspca/sonixb.c
index ddff2b5ee5c2..785eeb4c2014 100644
--- a/drivers/media/video/gspca/sonixb.c
+++ b/drivers/media/video/gspca/sonixb.c
@@ -42,6 +42,7 @@ Reg	Use
 
 #define MODULE_NAME "sonixb"
 
+#include <linux/input.h>
 #include "gspca.h"
 
 MODULE_AUTHOR("Michel Xhaard <mxhaard@users.sourceforge.net>");
@@ -53,9 +54,11 @@ struct sd {
         struct gspca_dev gspca_dev;     /* !! must be the first item */
         atomic_t avg_lum;
         int prev_avg_lum;
+        int exp_too_low_cnt;
+        int exp_too_high_cnt;
 
+        unsigned short exposure;
         unsigned char gain;
-        unsigned char exposure;
         unsigned char brightness;
         unsigned char autogain;
         unsigned char autogain_ignore_frames;
@@ -73,8 +76,9 @@ struct sd {
 #define SENSOR_OV7630 2
 #define SENSOR_PAS106 3
 #define SENSOR_PAS202 4
-#define SENSOR_TAS5110 5
-#define SENSOR_TAS5130CXX 6
+#define SENSOR_TAS5110C 5
+#define SENSOR_TAS5110D 6
+#define SENSOR_TAS5130CXX 7
         __u8 reg11;
 };
 
@@ -95,13 +99,15 @@ struct sensor_data {
 /* sensor_data flags */
 #define F_GAIN 0x01             /* has gain */
 #define F_SIF  0x02             /* sif or vga */
+#define F_COARSE_EXPO 0x04      /* exposure control is coarse */
 
 /* priv field of struct v4l2_pix_format flags (do not use low nibble!) */
 #define MODE_RAW 0x10           /* raw bayer mode */
 #define MODE_REDUCED_SIF 0x20   /* vga mode (320x240 / 160x120) on sif cam */
 
 /* ctrl_dis helper macros */
-#define NO_EXPO ((1 << EXPOSURE_IDX) | (1 << AUTOGAIN_IDX))
+#define NO_EXPO ((1 << EXPOSURE_IDX) | (1 << COARSE_EXPOSURE_IDX) | \
+                 (1 << AUTOGAIN_IDX))
 #define NO_FREQ (1 << FREQ_IDX)
 #define NO_BRIGHTNESS (1 << BRIGHTNESS_IDX)
 
@@ -127,11 +133,10 @@ struct sensor_data {
 }
 
 /* We calculate the autogain at the end of the transfer of a frame, at this
-   moment a frame with the old settings is being transmitted, and a frame is
-   being captured with the old settings. So if we adjust the autogain we must
-   ignore atleast the 2 next frames for the new settings to come into effect
-   before doing any other adjustments */
-#define AUTOGAIN_IGNORE_FRAMES 3
+   moment a frame with the old settings is being captured and transmitted. So
+   if we adjust the gain or exposure we must ignore atleast the next frame for
+   the new settings to come into effect before doing any other adjustments. */
+#define AUTOGAIN_IGNORE_FRAMES 1
 
 /* V4L2 controls supported by the driver */
 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val);
@@ -145,7 +150,7 @@ static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val);
 static int sd_setfreq(struct gspca_dev *gspca_dev, __s32 val);
 static int sd_getfreq(struct gspca_dev *gspca_dev, __s32 *val);
 
-static struct ctrl sd_ctrls[] = {
+static const struct ctrl sd_ctrls[] = {
 #define BRIGHTNESS_IDX 0
         {
             {
@@ -171,7 +176,7 @@ static struct ctrl sd_ctrls[] = {
                 .maximum = 255,
                 .step    = 1,
 #define GAIN_DEF 127
-#define GAIN_KNEE 200
+#define GAIN_KNEE 230
                 .default_value = GAIN_DEF,
             },
             .set = sd_setgain,
@@ -183,10 +188,10 @@ static struct ctrl sd_ctrls[] = {
                         .id = V4L2_CID_EXPOSURE,
                         .type = V4L2_CTRL_TYPE_INTEGER,
                         .name = "Exposure",
-#define EXPOSURE_DEF  16 /*  32 ms / 30 fps */
-#define EXPOSURE_KNEE 50 /* 100 ms / 10 fps */
+#define EXPOSURE_DEF  66 /*  33 ms / 30 fps (except on PASXXX) */
+#define EXPOSURE_KNEE 200 /* 100 ms / 10 fps (except on PASXXX) */
                         .minimum = 0,
-                        .maximum = 255,
+                        .maximum = 1023,
                         .step = 1,
                         .default_value = EXPOSURE_DEF,
                         .flags = 0,
@@ -194,7 +199,23 @@ static struct ctrl sd_ctrls[] = {
                 .set = sd_setexposure,
                 .get = sd_getexposure,
         },
-#define AUTOGAIN_IDX 3
+#define COARSE_EXPOSURE_IDX 3
+        {
+                {
+                        .id = V4L2_CID_EXPOSURE,
+                        .type = V4L2_CTRL_TYPE_INTEGER,
+                        .name = "Exposure",
+#define COARSE_EXPOSURE_DEF  2 /* 30 fps */
+                        .minimum = 2,
+                        .maximum = 15,
+                        .step = 1,
+                        .default_value = COARSE_EXPOSURE_DEF,
+                        .flags = 0,
+                },
+                .set = sd_setexposure,
+                .get = sd_getexposure,
+        },
+#define AUTOGAIN_IDX 4
         {
                 {
                         .id = V4L2_CID_AUTOGAIN,
@@ -210,7 +231,7 @@ static struct ctrl sd_ctrls[] = {
                 .set = sd_setautogain,
                 .get = sd_getautogain,
         },
-#define FREQ_IDX 4
+#define FREQ_IDX 5
         {
                 {
                         .id      = V4L2_CID_POWER_LINE_FREQUENCY,
@@ -219,7 +240,7 @@ static struct ctrl sd_ctrls[] = {
                         .minimum = 0,
                         .maximum = 2,   /* 0: 0, 1: 50Hz, 2:60Hz */
                         .step    = 1,
-#define FREQ_DEF 1
+#define FREQ_DEF 0
                         .default_value = FREQ_DEF,
                 },
                 .set = sd_setfreq,
@@ -345,7 +366,7 @@ static const __u8 initOv7630[] = {
 };
 static const __u8 initOv7630_3[] = {
         0x44, 0x44, 0x00, 0x1a, 0x20, 0x20, 0x20, 0x80, /* r01 .. r08 */
-        0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, /* r09 .. r10 */
+        0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* r09 .. r10 */
         0x00, 0x02, 0x01, 0x0a,                         /* r11 .. r14 */
         0x28, 0x1e,                     /* H & V sizes     r15 .. r16 */
         0x68, 0x8f, MCK_INIT1,                          /* r17 .. r19 */
@@ -387,6 +408,30 @@ static const __u8 initPas106[] = {
         0x18, 0x10, 0x02, 0x02, 0x09, 0x07
 };
 /* compression 0x86 mckinit1 0x2b */
+
+/* "Known" PAS106B registers:
+  0x02 clock divider
+  0x03 Variable framerate bits 4-11
+  0x04 Var framerate bits 0-3, one must leave the 4 msb's at 0 !!
+       The variable framerate control must never be set lower then 300,
+       which sets the framerate at 90 / reg02, otherwise vsync is lost.
+  0x05 Shutter Time Line Offset, this can be used as an exposure control:
+       0 = use full frame time, 255 = no exposure at all
+       Note this may never be larger then "var-framerate control" / 2 - 2.
+       When var-framerate control is < 514, no exposure is reached at the max
+       allowed value for the framerate control value, rather then at 255.
+  0x06 Shutter Time Pixel Offset, like reg05 this influences exposure, but
+       only a very little bit, leave at 0xcd
+  0x07 offset sign bit (bit0 1 > negative offset)
+  0x08 offset
+  0x09 Blue Gain
+  0x0a Green1 Gain
+  0x0b Green2 Gain
+  0x0c Red Gain
+  0x0e Global gain
+  0x13 Write 1 to commit settings to sensor
+*/
+
 static const __u8 pas106_sensor_init[][8] = {
         /* Pixel Clock Divider 6 */
         { 0xa1, 0x40, 0x02, 0x04, 0x00, 0x00, 0x00, 0x14 },
@@ -433,37 +478,55 @@ static const __u8 initPas202[] = {
         0x44, 0x44, 0x21, 0x30, 0x00, 0x00, 0x00, 0x80, 0x40, 0x00, 0x00, 0x00,
         0x00, 0x00,
         0x00, 0x00, 0x00, 0x06, 0x03, 0x0a,
-        0x28, 0x1e, 0x28, 0x89, 0x20,
+        0x28, 0x1e, 0x20, 0x89, 0x20,
         0x00, 0x00, 0x02, 0x03, 0x0f, 0x0c
 };
+
+/* "Known" PAS202BCB registers:
+  0x02 clock divider
+  0x04 Variable framerate bits 6-11 (*)
+  0x05 Var framerate  bits 0-5, one must leave the 2 msb's at 0 !!
+  0x07 Blue Gain
+  0x08 Green Gain
+  0x09 Red Gain
+  0x0b offset sign bit (bit0 1 > negative offset)
+  0x0c offset
+  0x0e Unknown image is slightly brighter when bit 0 is 0, if reg0f is 0 too,
+       leave at 1 otherwise we get a jump in our exposure control
+  0x0f Exposure 0-255, 0 = use full frame time, 255 = no exposure at all
+  0x10 Master gain 0 - 31
+  0x11 write 1 to apply changes
+  (*) The variable framerate control must never be set lower then 500
+      which sets the framerate at 30 / reg02, otherwise vsync is lost.
+*/
 static const __u8 pas202_sensor_init[][8] = {
-        {0xa0, 0x40, 0x02, 0x03, 0x00, 0x00, 0x00, 0x10},
+        /* Set the clock divider to 4 -> 30 / 4 = 7.5 fps, we would like
+           to set it lower, but for some reason the bridge starts missing
+           vsync's then */
+        {0xa0, 0x40, 0x02, 0x04, 0x00, 0x00, 0x00, 0x10},
         {0xd0, 0x40, 0x04, 0x07, 0x34, 0x00, 0x09, 0x10},
         {0xd0, 0x40, 0x08, 0x01, 0x00, 0x00, 0x01, 0x10},
-        {0xd0, 0x40, 0x0C, 0x00, 0x0C, 0x00, 0x32, 0x10},
+        {0xd0, 0x40, 0x0C, 0x00, 0x0C, 0x01, 0x32, 0x10},
         {0xd0, 0x40, 0x10, 0x00, 0x01, 0x00, 0x63, 0x10},
         {0xa0, 0x40, 0x15, 0x70, 0x01, 0x00, 0x63, 0x10},
         {0xa0, 0x40, 0x18, 0x00, 0x01, 0x00, 0x63, 0x10},
         {0xa0, 0x40, 0x11, 0x01, 0x01, 0x00, 0x63, 0x10},
         {0xa0, 0x40, 0x03, 0x56, 0x01, 0x00, 0x63, 0x10},
         {0xa0, 0x40, 0x11, 0x01, 0x01, 0x00, 0x63, 0x10},
-        {0xb0, 0x40, 0x04, 0x07, 0x2a, 0x00, 0x63, 0x10},
-        {0xb0, 0x40, 0x0e, 0x00, 0x3d, 0x00, 0x63, 0x10},
-
-        {0xa0, 0x40, 0x11, 0x01, 0x3d, 0x00, 0x63, 0x16},
-        {0xa0, 0x40, 0x10, 0x08, 0x3d, 0x00, 0x63, 0x15},
-        {0xa0, 0x40, 0x02, 0x04, 0x3d, 0x00, 0x63, 0x16},
-        {0xa0, 0x40, 0x11, 0x01, 0x3d, 0x00, 0x63, 0x16},
-        {0xb0, 0x40, 0x0e, 0x00, 0x31, 0x00, 0x63, 0x16},
-        {0xa0, 0x40, 0x11, 0x01, 0x31, 0x00, 0x63, 0x16},
-        {0xa0, 0x40, 0x10, 0x0e, 0x31, 0x00, 0x63, 0x15},
-        {0xa0, 0x40, 0x11, 0x01, 0x31, 0x00, 0x63, 0x16},
 };
 
-static const __u8 initTas5110[] = {
+static const __u8 initTas5110c[] = {
         0x44, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x11, 0x00, 0x00, 0x00,
         0x00, 0x00,
-        0x00, 0x01, 0x00, 0x45, 0x09, 0x0a,
+        0x00, 0x00, 0x00, 0x45, 0x09, 0x0a,
+        0x16, 0x12, 0x60, 0x86, 0x2b,
+        0x14, 0x0a, 0x02, 0x02, 0x09, 0x07
+};
+/* Same as above, except a different hstart */
+static const __u8 initTas5110d[] = {
+        0x44, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x11, 0x00, 0x00, 0x00,
+        0x00, 0x00,
+        0x00, 0x00, 0x00, 0x41, 0x09, 0x0a,
         0x16, 0x12, 0x60, 0x86, 0x2b,
         0x14, 0x0a, 0x02, 0x02, 0x09, 0x07
 };
@@ -476,7 +539,7 @@ static const __u8 tas5110_sensor_init[][8] = {
 static const __u8 initTas5130[] = {
         0x04, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x11, 0x00, 0x00, 0x00,
         0x00, 0x00,
-        0x00, 0x01, 0x00, 0x68, 0x0c, 0x0a,
+        0x00, 0x00, 0x00, 0x68, 0x0c, 0x0a,
         0x28, 0x1e, 0x60, COMP, MCK_INIT,
         0x18, 0x10, 0x04, 0x03, 0x11, 0x0c
 };
@@ -493,12 +556,14 @@ SENS(initHv7131, NULL, hv7131_sensor_init, NULL, NULL, 0, NO_EXPO|NO_FREQ, 0),
 SENS(initOv6650, NULL, ov6650_sensor_init, NULL, NULL, F_GAIN|F_SIF, 0, 0x60),
 SENS(initOv7630, initOv7630_3, ov7630_sensor_init, NULL, ov7630_sensor_init_3,
         F_GAIN, 0, 0x21),
-SENS(initPas106, NULL, pas106_sensor_init, NULL, NULL, F_SIF, NO_EXPO|NO_FREQ,
+SENS(initPas106, NULL, pas106_sensor_init, NULL, NULL, F_GAIN|F_SIF, NO_FREQ,
         0),
-SENS(initPas202, initPas202, pas202_sensor_init, NULL, NULL, 0,
-        NO_EXPO|NO_FREQ, 0),
-SENS(initTas5110, NULL, tas5110_sensor_init, NULL, NULL, F_GAIN|F_SIF,
-        NO_BRIGHTNESS|NO_FREQ, 0),
+SENS(initPas202, initPas202, pas202_sensor_init, NULL, NULL, F_GAIN,
+        NO_FREQ, 0),
+SENS(initTas5110c, NULL, tas5110_sensor_init, NULL, NULL,
+        F_GAIN|F_SIF|F_COARSE_EXPO, NO_BRIGHTNESS|NO_FREQ, 0),
+SENS(initTas5110d, NULL, tas5110_sensor_init, NULL, NULL,
+        F_GAIN|F_SIF|F_COARSE_EXPO, NO_BRIGHTNESS|NO_FREQ, 0),
 SENS(initTas5130, NULL, tas5130_sensor_init, NULL, NULL, 0, NO_EXPO|NO_FREQ,
         0),
 };
@@ -587,42 +652,28 @@ static void setbrightness(struct gspca_dev *gspca_dev)
                         goto err;
                 break;
             }
-        case SENSOR_PAS106: {
-                __u8 i2c1[] =
-                        {0xa1, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x14};
-
-                i2c1[3] = sd->brightness >> 3;
-                i2c1[2] = 0x0e;
-                if (i2c_w(gspca_dev, i2c1) < 0)
-                        goto err;
-                i2c1[3] = 0x01;
-                i2c1[2] = 0x13;
-                if (i2c_w(gspca_dev, i2c1) < 0)
-                        goto err;
-                break;
-            }
+        case SENSOR_PAS106:
         case SENSOR_PAS202: {
-                /* __u8 i2cpexpo1[] =
-                        {0xb0, 0x40, 0x04, 0x07, 0x2a, 0x00, 0x63, 0x16}; */
-                __u8 i2cpexpo[] =
-                        {0xb0, 0x40, 0x0e, 0x01, 0xab, 0x00, 0x63, 0x16};
-                __u8 i2cp202[] =
-                        {0xa0, 0x40, 0x10, 0x0e, 0x31, 0x00, 0x63, 0x15};
-                static __u8 i2cpdoit[] =
-                        {0xa0, 0x40, 0x11, 0x01, 0x31, 0x00, 0x63, 0x16};
-
-                /* change reg 0x10 */
-                i2cpexpo[4] = 0xff - sd->brightness;
-/*              if(i2c_w(gspca_dev,i2cpexpo1) < 0)
-                        goto err; */
-/*              if(i2c_w(gspca_dev,i2cpdoit) < 0)
-                        goto err; */
-                if (i2c_w(gspca_dev, i2cpexpo) < 0)
-                        goto err;
-                if (i2c_w(gspca_dev, i2cpdoit) < 0)
-                        goto err;
-                i2cp202[3] = sd->brightness >> 3;
-                if (i2c_w(gspca_dev, i2cp202) < 0)
+                __u8 i2cpbright[] =
+                        {0xb0, 0x40, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x16};
+                __u8 i2cpdoit[] =
+                        {0xa0, 0x40, 0x11, 0x01, 0x00, 0x00, 0x00, 0x16};
+
+                /* PAS106 uses reg 7 and 8 instead of b and c */
+                if (sd->sensor == SENSOR_PAS106) {
+                        i2cpbright[2] = 7;
+                        i2cpdoit[2] = 0x13;
+                }
+
+                if (sd->brightness < 127) {
+                        /* change reg 0x0b, signreg */
+                        i2cpbright[3] = 0x01;
+                        /* set reg 0x0c, offset */
+                        i2cpbright[4] = 127 - sd->brightness;
+                } else
+                        i2cpbright[4] = sd->brightness - 127;
+
+                if (i2c_w(gspca_dev, i2cpbright) < 0)
                         goto err;
                 if (i2c_w(gspca_dev, i2cpdoit) < 0)
                         goto err;
@@ -652,7 +703,8 @@ static void setsensorgain(struct gspca_dev *gspca_dev)
 
         switch (sd->sensor) {
 
-        case SENSOR_TAS5110: {
+        case SENSOR_TAS5110C:
+        case SENSOR_TAS5110D: {
                 __u8 i2c[] =
                         {0x30, 0x11, 0x02, 0x20, 0x70, 0x00, 0x00, 0x10};
 
@@ -674,6 +726,37 @@ static void setsensorgain(struct gspca_dev *gspca_dev)
                         goto err;
                 break;
             }
+        case SENSOR_PAS106:
+        case SENSOR_PAS202: {
+                __u8 i2cpgain[] =
+                        {0xa0, 0x40, 0x10, 0x00, 0x00, 0x00, 0x00, 0x15};
+                __u8 i2cpcolorgain[] =
+                        {0xc0, 0x40, 0x07, 0x00, 0x00, 0x00, 0x00, 0x15};
+                __u8 i2cpdoit[] =
+                        {0xa0, 0x40, 0x11, 0x01, 0x00, 0x00, 0x00, 0x16};
+
+                /* PAS106 uses different regs (and has split green gains) */
+                if (sd->sensor == SENSOR_PAS106) {
+                        i2cpgain[2] = 0x0e;
+                        i2cpcolorgain[0] = 0xd0;
+                        i2cpcolorgain[2] = 0x09;
+                        i2cpdoit[2] = 0x13;
+                }
+
+                i2cpgain[3] = sd->gain >> 3;
+                i2cpcolorgain[3] = sd->gain >> 4;
+                i2cpcolorgain[4] = sd->gain >> 4;
+                i2cpcolorgain[5] = sd->gain >> 4;
+                i2cpcolorgain[6] = sd->gain >> 4;
+
+                if (i2c_w(gspca_dev, i2cpgain) < 0)
+                        goto err;
+                if (i2c_w(gspca_dev, i2cpcolorgain) < 0)
+                        goto err;
+                if (i2c_w(gspca_dev, i2cpdoit) < 0)
+                        goto err;
+                break;
+            }
         }
         return;
 err:
@@ -684,19 +767,21 @@ static void setgain(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
         __u8 gain;
-        __u8 rgb_value;
+        __u8 buf[2] = { 0, 0 };
+
+        if (sensor_data[sd->sensor].flags & F_GAIN) {
+                /* Use the sensor gain to do the actual gain */
+                setsensorgain(gspca_dev);
+                return;
+        }
 
         gain = sd->gain >> 4;
 
         /* red and blue gain */
-        rgb_value = gain << 4 | gain;
-        reg_w(gspca_dev, 0x10, &rgb_value, 1);
+        buf[0] = gain << 4 | gain;
         /* green gain */
-        rgb_value = gain;
-        reg_w(gspca_dev, 0x11, &rgb_value, 1);
-
-        if (sensor_data[sd->sensor].flags & F_GAIN)
-                setsensorgain(gspca_dev);
+        buf[1] = gain;
+        reg_w(gspca_dev, 0x10, buf, 2);
 }
 
 static void setexposure(struct gspca_dev *gspca_dev)
@@ -704,17 +789,12 @@ static void setexposure(struct gspca_dev *gspca_dev)
         struct sd *sd = (struct sd *) gspca_dev;
 
         switch (sd->sensor) {
-        case SENSOR_TAS5110: {
-                __u8 reg;
-
+        case SENSOR_TAS5110C:
+        case SENSOR_TAS5110D: {
                 /* register 19's high nibble contains the sn9c10x clock divider
                    The high nibble configures the no fps according to the
                    formula: 60 / high_nibble. With a maximum of 30 fps */
-                reg = 120 * sd->exposure / 1000;
-                if (reg < 2)
-                        reg = 2;
-                else if (reg > 15)
-                        reg = 15;
+                __u8 reg = sd->exposure;
                 reg = (reg << 4) | 0x0b;
                 reg_w(gspca_dev, 0x19, &reg, 1);
                 break;
@@ -750,20 +830,21 @@ static void setexposure(struct gspca_dev *gspca_dev)
                 } else
                         reg10_max = 0x41;
 
-                reg11 = (60 * sd->exposure + 999) / 1000;
+                reg11 = (15 * sd->exposure + 999) / 1000;
                 if (reg11 < 1)
                         reg11 = 1;
                 else if (reg11 > 16)
                         reg11 = 16;
 
-                /* In 640x480, if the reg11 has less than 3, the image is
-                   unstable (not enough bandwidth). */
-                if (gspca_dev->width == 640 && reg11 < 3)
-                        reg11 = 3;
+                /* In 640x480, if the reg11 has less than 4, the image is
+                   unstable (the bridge goes into a higher compression mode
+                   which we have not reverse engineered yet). */
+                if (gspca_dev->width == 640 && reg11 < 4)
+                        reg11 = 4;
 
                 /* frame exposure time in ms = 1000 * reg11 / 30    ->
-                reg10 = sd->exposure * 2 * reg10_max / (1000 * reg11 / 30) */
-                reg10 = (sd->exposure * 60 * reg10_max) / (1000 * reg11);
+                reg10 = (sd->exposure / 2) * reg10_max / (1000 * reg11 / 30) */
+                reg10 = (sd->exposure * 15 * reg10_max) / (1000 * reg11);
 
                 /* Don't allow this to get below 10 when using autogain, the
                    steps become very large (relatively) when below 10 causing
@@ -786,10 +867,85 @@ static void setexposure(struct gspca_dev *gspca_dev)
                 if (i2c_w(gspca_dev, i2c) == 0)
                         sd->reg11 = reg11;
                 else
-                        PDEBUG(D_ERR, "i2c error exposure");
+                        goto err;
+                break;
+            }
+        case SENSOR_PAS202: {
+                __u8 i2cpframerate[] =
+                        {0xb0, 0x40, 0x04, 0x00, 0x00, 0x00, 0x00, 0x16};
+                __u8 i2cpexpo[] =
+                        {0xa0, 0x40, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x16};
+                const __u8 i2cpdoit[] =
+                        {0xa0, 0x40, 0x11, 0x01, 0x00, 0x00, 0x00, 0x16};
+                int framerate_ctrl;
+
+                /* The exposure knee for the autogain algorithm is 200
+                   (100 ms / 10 fps on other sensors), for values below this
+                   use the control for setting the partial frame expose time,
+                   above that use variable framerate. This way we run at max
+                   framerate (640x480@7.5 fps, 320x240@10fps) until the knee
+                   is reached. Using the variable framerate control above 200
+                   is better then playing around with both clockdiv + partial
+                   frame exposure times (like we are doing with the ov chips),
+                   as that sometimes leads to jumps in the exposure control,
+                   which are bad for auto exposure. */
+                if (sd->exposure < 200) {
+                        i2cpexpo[3] = 255 - (sd->exposure * 255) / 200;
+                        framerate_ctrl = 500;
+                } else {
+                        /* The PAS202's exposure control goes from 0 - 4095,
+                           but anything below 500 causes vsync issues, so scale
+                           our 200-1023 to 500-4095 */
+                        framerate_ctrl = (sd->exposure - 200) * 1000 / 229 +
+                                         500;
+                }
+
+                i2cpframerate[3] = framerate_ctrl >> 6;
+                i2cpframerate[4] = framerate_ctrl & 0x3f;
+                if (i2c_w(gspca_dev, i2cpframerate) < 0)
+                        goto err;
+                if (i2c_w(gspca_dev, i2cpexpo) < 0)
+                        goto err;
+                if (i2c_w(gspca_dev, i2cpdoit) < 0)
+                        goto err;
+                break;
+            }
+        case SENSOR_PAS106: {
+                __u8 i2cpframerate[] =
+                        {0xb1, 0x40, 0x03, 0x00, 0x00, 0x00, 0x00, 0x14};
+                __u8 i2cpexpo[] =
+                        {0xa1, 0x40, 0x05, 0x00, 0x00, 0x00, 0x00, 0x14};
+                const __u8 i2cpdoit[] =
+                        {0xa1, 0x40, 0x13, 0x01, 0x00, 0x00, 0x00, 0x14};
+                int framerate_ctrl;
+
+                /* For values below 150 use partial frame exposure, above
+                   that use framerate ctrl */
+                if (sd->exposure < 150) {
+                        i2cpexpo[3] = 150 - sd->exposure;
+                        framerate_ctrl = 300;
+                } else {
+                        /* The PAS106's exposure control goes from 0 - 4095,
+                           but anything below 300 causes vsync issues, so scale
+                           our 150-1023 to 300-4095 */
+                        framerate_ctrl = (sd->exposure - 150) * 1000 / 230 +
+                                         300;
+                }
+
+                i2cpframerate[3] = framerate_ctrl >> 4;
+                i2cpframerate[4] = framerate_ctrl & 0x0f;
+                if (i2c_w(gspca_dev, i2cpframerate) < 0)
+                        goto err;
+                if (i2c_w(gspca_dev, i2cpexpo) < 0)
+                        goto err;
+                if (i2c_w(gspca_dev, i2cpdoit) < 0)
+                        goto err;
                 break;
             }
         }
+        return;
+err:
+        PDEBUG(D_ERR, "i2c error exposure");
 }
 
 static void setfreq(struct gspca_dev *gspca_dev)
@@ -823,30 +979,43 @@ static void setfreq(struct gspca_dev *gspca_dev)
         }
 }
 
+#include "coarse_expo_autogain.h"
+
 static void do_autogain(struct gspca_dev *gspca_dev)
 {
-        int deadzone, desired_avg_lum;
+        int deadzone, desired_avg_lum, result;
         struct sd *sd = (struct sd *) gspca_dev;
         int avg_lum = atomic_read(&sd->avg_lum);
 
-        if (avg_lum == -1)
+        if (avg_lum == -1 || !sd->autogain)
                 return;
 
+        if (sd->autogain_ignore_frames > 0) {
+                sd->autogain_ignore_frames--;
+                return;
+        }
+
         /* SIF / VGA sensors have a different autoexposure area and thus
            different avg_lum values for the same picture brightness */
         if (sensor_data[sd->sensor].flags & F_SIF) {
-                deadzone = 1000;
-                desired_avg_lum = 7000;
+                deadzone = 500;
+                /* SIF sensors tend to overexpose, so keep this small */
+                desired_avg_lum = 5000;
         } else {
-                deadzone = 3000;
-                desired_avg_lum = 23000;
+                deadzone = 1500;
+                desired_avg_lum = 18000;
         }
 
-        if (sd->autogain_ignore_frames > 0)
-                sd->autogain_ignore_frames--;
-        else if (gspca_auto_gain_n_exposure(gspca_dev, avg_lum,
-                        sd->brightness * desired_avg_lum / 127,
-                        deadzone, GAIN_KNEE, EXPOSURE_KNEE)) {
+        if (sensor_data[sd->sensor].flags & F_COARSE_EXPO)
+                result = gspca_coarse_grained_expo_autogain(gspca_dev, avg_lum,
+                                sd->brightness * desired_avg_lum / 127,
+                                deadzone);
+        else
+                result = gspca_auto_gain_n_exposure(gspca_dev, avg_lum,
+                                sd->brightness * desired_avg_lum / 127,
+                                deadzone, GAIN_KNEE, EXPOSURE_KNEE);
+
+        if (result) {
                 PDEBUG(D_FRAM, "autogain: gain changed: gain: %d expo: %d",
                         (int)sd->gain, (int)sd->exposure);
                 sd->autogain_ignore_frames = AUTOGAIN_IGNORE_FRAMES;
@@ -881,7 +1050,13 @@ static int sd_config(struct gspca_dev *gspca_dev,
 
         sd->brightness = BRIGHTNESS_DEF;
         sd->gain = GAIN_DEF;
-        sd->exposure = EXPOSURE_DEF;
+        if (sensor_data[sd->sensor].flags & F_COARSE_EXPO) {
+                sd->exposure = COARSE_EXPOSURE_DEF;
+                gspca_dev->ctrl_dis |= (1 << EXPOSURE_IDX);
+        } else {
+                sd->exposure = EXPOSURE_DEF;
+                gspca_dev->ctrl_dis |= (1 << COARSE_EXPOSURE_IDX);
+        }
         if (gspca_dev->ctrl_dis & (1 << AUTOGAIN_IDX))
                 sd->autogain = 0; /* Disable do_autogain callback */
         else
@@ -917,9 +1092,6 @@ static int sd_start(struct gspca_dev *gspca_dev)
         reg12_19[6] = sn9c10x[0x18 - 1] | (mode << 4);
         /* Special cases where reg 17 and or 19 value depends on mode */
         switch (sd->sensor) {
-        case SENSOR_PAS202:
-                reg12_19[5] = mode ? 0x24 : 0x20;
-                break;
         case SENSOR_TAS5130CXX:
                 /* probably not mode specific at all most likely the upper
                    nibble of 0x19 is exposure (clock divider) just as with
@@ -955,6 +1127,16 @@ static int sd_start(struct gspca_dev *gspca_dev)
                         sensor_data[sd->sensor].sensor_bridge_init_size[
                                 sd->bridge]);
 
+        /* Mode specific sensor setup */
+        switch (sd->sensor) {
+        case SENSOR_PAS202: {
+                const __u8 i2cpclockdiv[] =
+                        {0xa0, 0x40, 0x02, 0x03, 0x00, 0x00, 0x00, 0x10};
+                /* clockdiv from 4 to 3 (7.5 -> 10 fps) when in low res mode */
+                if (mode)
+                        i2c_w(gspca_dev, i2cpclockdiv);
+            }
+        }
         /* H_size V_size 0x28, 0x1e -> 640x480. 0x16, 0x12 -> 352x288 */
         reg_w(gspca_dev, 0x15, &reg12_19[3], 2);
         /* compression register */
@@ -985,6 +1167,8 @@ static int sd_start(struct gspca_dev *gspca_dev)
 
         sd->frames_to_drop = 0;
         sd->autogain_ignore_frames = 0;
+        sd->exp_too_high_cnt = 0;
+        sd->exp_too_low_cnt = 0;
         atomic_set(&sd->avg_lum, -1);
         return 0;
 }
@@ -1143,11 +1327,14 @@ static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val)
         struct sd *sd = (struct sd *) gspca_dev;
 
         sd->autogain = val;
+        sd->exp_too_high_cnt = 0;
+        sd->exp_too_low_cnt = 0;
+
         /* when switching to autogain set defaults to make sure
            we are on a valid point of the autogain gain /
            exposure knee graph, and give this change time to
            take effect before doing autogain. */
-        if (sd->autogain) {
+        if (sd->autogain && !(sensor_data[sd->sensor].flags & F_COARSE_EXPO)) {
                 sd->exposure = EXPOSURE_DEF;
                 sd->gain = GAIN_DEF;
                 if (gspca_dev->streaming) {
@@ -1207,6 +1394,25 @@ static int sd_querymenu(struct gspca_dev *gspca_dev,
         return -EINVAL;
 }
 
+#ifdef CONFIG_INPUT
+static int sd_int_pkt_scan(struct gspca_dev *gspca_dev,
+                        u8 *data,               /* interrupt packet data */
+                        int len)                /* interrupt packet length */
+{
+        int ret = -EINVAL;
+
+        if (len == 1 && data[0] == 1) {
+                input_report_key(gspca_dev->input_dev, KEY_CAMERA, 1);
+                input_sync(gspca_dev->input_dev);
+                input_report_key(gspca_dev->input_dev, KEY_CAMERA, 0);
+                input_sync(gspca_dev->input_dev);
+                ret = 0;
+        }
+
+        return ret;
+}
+#endif
+
 /* sub-driver description */
 static const struct sd_desc sd_desc = {
         .name = MODULE_NAME,
@@ -1219,6 +1425,9 @@ static const struct sd_desc sd_desc = {
         .pkt_scan = sd_pkt_scan,
         .querymenu = sd_querymenu,
         .dq_callback = do_autogain,
+#ifdef CONFIG_INPUT
+        .int_pkt_scan = sd_int_pkt_scan,
+#endif
 };
 
 /* -- module initialisation -- */
@@ -1227,21 +1436,21 @@ static const struct sd_desc sd_desc = {
 
 
 static const struct usb_device_id device_table[] __devinitconst = {
-        {USB_DEVICE(0x0c45, 0x6001), SB(TAS5110, 102)}, /* TAS5110C1B */
-        {USB_DEVICE(0x0c45, 0x6005), SB(TAS5110, 101)}, /* TAS5110C1B */
+        {USB_DEVICE(0x0c45, 0x6001), SB(TAS5110C, 102)}, /* TAS5110C1B */
+        {USB_DEVICE(0x0c45, 0x6005), SB(TAS5110C, 101)}, /* TAS5110C1B */
 #if !defined CONFIG_USB_SN9C102 && !defined CONFIG_USB_SN9C102_MODULE
-        {USB_DEVICE(0x0c45, 0x6007), SB(TAS5110, 101)}, /* TAS5110D */
+        {USB_DEVICE(0x0c45, 0x6007), SB(TAS5110D, 101)}, /* TAS5110D */
+#endif
         {USB_DEVICE(0x0c45, 0x6009), SB(PAS106, 101)},
         {USB_DEVICE(0x0c45, 0x600d), SB(PAS106, 101)},
-#endif
         {USB_DEVICE(0x0c45, 0x6011), SB(OV6650, 101)},
 #if !defined CONFIG_USB_SN9C102 && !defined CONFIG_USB_SN9C102_MODULE
         {USB_DEVICE(0x0c45, 0x6019), SB(OV7630, 101)},
         {USB_DEVICE(0x0c45, 0x6024), SB(TAS5130CXX, 102)},
         {USB_DEVICE(0x0c45, 0x6025), SB(TAS5130CXX, 102)},
+#endif
         {USB_DEVICE(0x0c45, 0x6028), SB(PAS202, 102)},
         {USB_DEVICE(0x0c45, 0x6029), SB(PAS106, 102)},
-#endif
         {USB_DEVICE(0x0c45, 0x602c), SB(OV7630, 102)},
         {USB_DEVICE(0x0c45, 0x602d), SB(HV7131R, 102)},
 #if !defined CONFIG_USB_SN9C102 && !defined CONFIG_USB_SN9C102_MODULE
diff --git a/drivers/media/video/gspca/sonixj.c b/drivers/media/video/gspca/sonixj.c
index 0bd36a00dd2a..83d5773d4629 100644
--- a/drivers/media/video/gspca/sonixj.c
+++ b/drivers/media/video/gspca/sonixj.c
@@ -21,6 +21,7 @@
 
 #define MODULE_NAME "sonixj"
 
+#include <linux/input.h>
 #include "gspca.h"
 #include "jpeg.h"
 
@@ -45,6 +46,7 @@ struct sd {
         u8 red;
         u8 gamma;
         u8 vflip;                       /* ov7630/ov7648 only */
+        u8 sharpness;
         u8 infrared;                    /* mt9v111 only */
         u8 freq;                        /* ov76xx only */
         u8 quality;                     /* image quality */
@@ -64,16 +66,17 @@ struct sd {
 #define BRIDGE_SN9C110 2
 #define BRIDGE_SN9C120 3
         u8 sensor;                      /* Type of image sensor chip */
-#define SENSOR_HV7131R 0
-#define SENSOR_MI0360 1
-#define SENSOR_MO4000 2
-#define SENSOR_MT9V111 3
-#define SENSOR_OM6802 4
-#define SENSOR_OV7630 5
-#define SENSOR_OV7648 6
-#define SENSOR_OV7660 7
-#define SENSOR_PO1030 8
-#define SENSOR_SP80708 9
+#define SENSOR_ADCM1700 0
+#define SENSOR_HV7131R 1
+#define SENSOR_MI0360 2
+#define SENSOR_MO4000 3
+#define SENSOR_MT9V111 4
+#define SENSOR_OM6802 5
+#define SENSOR_OV7630 6
+#define SENSOR_OV7648 7
+#define SENSOR_OV7660 8
+#define SENSOR_PO1030 9
+#define SENSOR_SP80708 10
         u8 i2c_addr;
 
         u8 *jpeg_hdr;
@@ -96,12 +99,14 @@ static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val);
 static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val);
 static int sd_setvflip(struct gspca_dev *gspca_dev, __s32 val);
 static int sd_getvflip(struct gspca_dev *gspca_dev, __s32 *val);
+static int sd_setsharpness(struct gspca_dev *gspca_dev, __s32 val);
+static int sd_getsharpness(struct gspca_dev *gspca_dev, __s32 *val);
 static int sd_setinfrared(struct gspca_dev *gspca_dev, __s32 val);
 static int sd_getinfrared(struct gspca_dev *gspca_dev, __s32 *val);
 static int sd_setfreq(struct gspca_dev *gspca_dev, __s32 val);
 static int sd_getfreq(struct gspca_dev *gspca_dev, __s32 *val);
 
-static struct ctrl sd_ctrls[] = {
+static const struct ctrl sd_ctrls[] = {
 #define BRIGHTNESS_IDX 0
         {
             {
@@ -225,8 +230,23 @@ static struct ctrl sd_ctrls[] = {
             .set = sd_setvflip,
             .get = sd_getvflip,
         },
+#define SHARPNESS_IDX 8
+        {
+            {
+                .id      = V4L2_CID_SHARPNESS,
+                .type    = V4L2_CTRL_TYPE_INTEGER,
+                .name    = "Sharpness",
+                .minimum = 0,
+                .maximum = 255,
+                .step    = 1,
+#define SHARPNESS_DEF 90
+                .default_value = SHARPNESS_DEF,
+            },
+            .set = sd_setsharpness,
+            .get = sd_getsharpness,
+        },
 /* mt9v111 only */
-#define INFRARED_IDX 8
+#define INFRARED_IDX 9
         {
             {
                 .id      = V4L2_CID_INFRARED,
@@ -242,7 +262,7 @@ static struct ctrl sd_ctrls[] = {
             .get = sd_getinfrared,
         },
 /* ov7630/ov7648/ov7660 only */
-#define FREQ_IDX 9
+#define FREQ_IDX 10
         {
             {
                 .id      = V4L2_CID_POWER_LINE_FREQUENCY,
@@ -261,28 +281,37 @@ static struct ctrl sd_ctrls[] = {
 
 /* table of the disabled controls */
 static __u32 ctrl_dis[] = {
+        (1 << INFRARED_IDX) | (1 << VFLIP_IDX) | (1 << FREQ_IDX) |
+                        (1 << AUTOGAIN_IDX),    /* SENSOR_ADCM1700 0 */
+        (1 << INFRARED_IDX) | (1 << FREQ_IDX),
+                                                /* SENSOR_HV7131R 1 */
         (1 << INFRARED_IDX) | (1 << VFLIP_IDX) | (1 << FREQ_IDX),
-                                                /* SENSOR_HV7131R 0 */
+                                                /* SENSOR_MI0360 2 */
         (1 << INFRARED_IDX) | (1 << VFLIP_IDX) | (1 << FREQ_IDX),
-                                                /* SENSOR_MI0360 1 */
-        (1 << INFRARED_IDX) | (1 << VFLIP_IDX) | (1 << FREQ_IDX),
-                                                /* SENSOR_MO4000 2 */
+                                                /* SENSOR_MO4000 3 */
         (1 << VFLIP_IDX) | (1 << FREQ_IDX),
-                                                /* SENSOR_MT9V111 3 */
+                                                /* SENSOR_MT9V111 4 */
         (1 << INFRARED_IDX) | (1 << VFLIP_IDX) | (1 << FREQ_IDX),
-                                                /* SENSOR_OM6802 4 */
+                                                /* SENSOR_OM6802 5 */
         (1 << INFRARED_IDX),
-                                                /* SENSOR_OV7630 5 */
+                                                /* SENSOR_OV7630 6 */
         (1 << INFRARED_IDX),
-                                                /* SENSOR_OV7648 6 */
+                                                /* SENSOR_OV7648 7 */
         (1 << AUTOGAIN_IDX) | (1 << INFRARED_IDX) | (1 << VFLIP_IDX),
-                                                /* SENSOR_OV7660 7 */
+                                                /* SENSOR_OV7660 8 */
         (1 << AUTOGAIN_IDX) | (1 << INFRARED_IDX) | (1 << VFLIP_IDX) |
-                              (1 << FREQ_IDX),  /* SENSOR_PO1030 8 */
+                              (1 << FREQ_IDX),  /* SENSOR_PO1030 9 */
         (1 << AUTOGAIN_IDX) | (1 << INFRARED_IDX) | (1 << VFLIP_IDX) |
-                              (1 << FREQ_IDX),  /* SENSOR_SP80708 9 */
+                              (1 << FREQ_IDX),  /* SENSOR_SP80708 10 */
 };
 
+static const struct v4l2_pix_format cif_mode[] = {
+        {352, 288, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
+                .bytesperline = 352,
+                .sizeimage = 352 * 288 * 4 / 8 + 590,
+                .colorspace = V4L2_COLORSPACE_JPEG,
+                .priv = 0},
+};
 static const struct v4l2_pix_format vga_mode[] = {
         {160, 120, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
                 .bytesperline = 160,
@@ -302,6 +331,17 @@ static const struct v4l2_pix_format vga_mode[] = {
                 .priv = 0},
 };
 
+static const u8 sn_adcm1700[0x1c] = {
+/*      reg0    reg1    reg2    reg3    reg4    reg5    reg6    reg7 */
+        0x00,   0x43,   0x60,   0x00,   0x1a,   0x00,   0x00,   0x00,
+/*      reg8    reg9    rega    regb    regc    regd    rege    regf */
+        0x80,   0x51,   0x00,   0x00,   0x00,   0x00,   0x00,   0x00,
+/*      reg10   reg11   reg12   reg13   reg14   reg15   reg16   reg17 */
+        0x03,   0x00,   0x05,   0x01,   0x05,   0x16,   0x12,   0x42,
+/*      reg18   reg19   reg1a   reg1b */
+        0x06,   0x00,   0x00,   0x00
+};
+
 /*Data from sn9c102p+hv7131r */
 static const u8 sn_hv7131[0x1c] = {
 /*      reg0    reg1    reg2    reg3    reg4    reg5    reg6    reg7 */
@@ -415,6 +455,7 @@ static const u8 sn_sp80708[0x1c] = {
 
 /* sequence specific to the sensors - !! index = SENSOR_xxx */
 static const u8 *sn_tb[] = {
+        sn_adcm1700,
         sn_hv7131,
         sn_mi0360,
         sn_mo4000,
@@ -432,6 +473,11 @@ static const u8 gamma_def[17] = {
         0x00, 0x2d, 0x46, 0x5a, 0x6c, 0x7c, 0x8b, 0x99,
         0xa6, 0xb2, 0xbf, 0xca, 0xd5, 0xe0, 0xeb, 0xf5, 0xff
 };
+/* gamma for sensor ADCM1700 */
+static const u8 gamma_spec_0[17] = {
+        0x0f, 0x39, 0x5a, 0x74, 0x86, 0x95, 0xa6, 0xb4,
+        0xbd, 0xc4, 0xcc, 0xd4, 0xd5, 0xde, 0xe4, 0xed, 0xf5
+};
 /* gamma for sensors HV7131R and MT9V111 */
 static const u8 gamma_spec_1[17] = {
         0x08, 0x3a, 0x52, 0x65, 0x75, 0x83, 0x91, 0x9d,
@@ -450,6 +496,42 @@ static const u8 reg84[] = {
         0x3e, 0x00, 0xcd, 0x0f, 0xf7, 0x0f,     /* VR VG VB */
         0x00, 0x00, 0x00                        /* YUV offsets */
 };
+static const u8 adcm1700_sensor_init[][8] = {
+        {0xa0, 0x51, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x10},
+        {0xb0, 0x51, 0x04, 0x08, 0x00, 0x00, 0x00, 0x10},       /* reset */
+        {0xdd, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
+        {0xb0, 0x51, 0x04, 0x00, 0x00, 0x00, 0x00, 0x10},
+        {0xdd, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
+        {0xb0, 0x51, 0x0c, 0xe0, 0x2e, 0x00, 0x00, 0x10},
+        {0xb0, 0x51, 0x10, 0x02, 0x02, 0x00, 0x00, 0x10},
+        {0xb0, 0x51, 0x14, 0x0e, 0x0e, 0x00, 0x00, 0x10},
+        {0xb0, 0x51, 0x1c, 0x00, 0x80, 0x00, 0x00, 0x10},
+        {0xb0, 0x51, 0x20, 0x01, 0x00, 0x00, 0x00, 0x10},
+        {0xdd, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
+        {0xb0, 0x51, 0x04, 0x04, 0x00, 0x00, 0x00, 0x10},
+        {0xdd, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
+        {0xb0, 0x51, 0x04, 0x01, 0x00, 0x00, 0x00, 0x10},
+        {0xa0, 0x51, 0xfe, 0x10, 0x00, 0x00, 0x00, 0x10},
+        {0xb0, 0x51, 0x14, 0x01, 0x00, 0x00, 0x00, 0x10},
+        {0xb0, 0x51, 0x32, 0x00, 0x00, 0x00, 0x00, 0x10},
+        {}
+};
+static const u8 adcm1700_sensor_param1[][8] = {
+        {0xb0, 0x51, 0x26, 0xf9, 0x01, 0x00, 0x00, 0x10},       /* exposure? */
+        {0xd0, 0x51, 0x1e, 0x8e, 0x8e, 0x8e, 0x8e, 0x10},
+
+        {0xa0, 0x51, 0xfe, 0x01, 0x00, 0x00, 0x00, 0x10},
+        {0xb0, 0x51, 0x00, 0x02, 0x00, 0x00, 0x00, 0x10},
+        {0xa0, 0x51, 0xfe, 0x10, 0x00, 0x00, 0x00, 0x10},
+        {0xb0, 0x51, 0x32, 0x00, 0x72, 0x00, 0x00, 0x10},
+        {0xd0, 0x51, 0x1e, 0xbe, 0xd7, 0xe8, 0xbe, 0x10},       /* exposure? */
+
+        {0xa0, 0x51, 0xfe, 0x01, 0x00, 0x00, 0x00, 0x10},
+        {0xb0, 0x51, 0x00, 0x02, 0x00, 0x00, 0x00, 0x10},
+        {0xa0, 0x51, 0xfe, 0x10, 0x00, 0x00, 0x00, 0x10},
+        {0xb0, 0x51, 0x32, 0x00, 0xa2, 0x00, 0x00, 0x10},
+        {}
+};
 static const u8 hv7131r_sensor_init[][8] = {
         {0xc1, 0x11, 0x01, 0x08, 0x01, 0x00, 0x00, 0x10},
         {0xb1, 0x11, 0x34, 0x17, 0x7f, 0x00, 0x00, 0x10},
@@ -986,17 +1068,18 @@ static const u8 sp80708_sensor_param1[][8] = {
         {}
 };
 
-static const u8 (*sensor_init[10])[8] = {
-        hv7131r_sensor_init,    /* HV7131R 0 */
-        mi0360_sensor_init,     /* MI0360 1 */
-        mo4000_sensor_init,     /* MO4000 2 */
-        mt9v111_sensor_init,    /* MT9V111 3 */
-        om6802_sensor_init,     /* OM6802 4 */
-        ov7630_sensor_init,     /* OV7630 5 */
-        ov7648_sensor_init,     /* OV7648 6 */
-        ov7660_sensor_init,     /* OV7660 7 */
-        po1030_sensor_init,     /* PO1030 8 */
-        sp80708_sensor_init,    /* SP80708 9 */
+static const u8 (*sensor_init[11])[8] = {
+        adcm1700_sensor_init,   /* ADCM1700 0 */
+        hv7131r_sensor_init,    /* HV7131R 1 */
+        mi0360_sensor_init,     /* MI0360 2 */
+        mo4000_sensor_init,     /* MO4000 3 */
+        mt9v111_sensor_init,    /* MT9V111 4 */
+        om6802_sensor_init,     /* OM6802 5 */
+        ov7630_sensor_init,     /* OV7630 6 */
+        ov7648_sensor_init,     /* OV7648 7 */
+        ov7660_sensor_init,     /* OV7660 8 */
+        po1030_sensor_init,     /* PO1030 9 */
+        sp80708_sensor_init,    /* SP80708 10 */
 };
 
 /* read <len> bytes to gspca_dev->usb_buf */
@@ -1064,6 +1147,7 @@ static void i2c_w1(struct gspca_dev *gspca_dev, u8 reg, u8 val)
 
         PDEBUG(D_USBO, "i2c_w2 [%02x] = %02x", reg, val);
         switch (sd->sensor) {
+        case SENSOR_ADCM1700:
         case SENSOR_OM6802:             /* i2c command = a0 (100 kHz) */
                 gspca_dev->usb_buf[0] = 0x80 | (2 << 4);
                 break;
@@ -1110,6 +1194,7 @@ static void i2c_r(struct gspca_dev *gspca_dev, u8 reg, int len)
         u8 mode[8];
 
         switch (sd->sensor) {
+        case SENSOR_ADCM1700:
         case SENSOR_OM6802:             /* i2c command = 90 (100 kHz) */
                 mode[0] = 0x80 | 0x10;
                 break;
@@ -1260,7 +1345,8 @@ static void bridge_init(struct gspca_dev *gspca_dev,
                 {0x00, 0x40, 0x38, 0x30, 0x00, 0x20};
         static const u8 regd4[] = {0x60, 0x00, 0x00};
 
-        reg_w1(gspca_dev, 0xf1, 0x00);
+        /* sensor clock already enabled in sd_init */
+        /* reg_w1(gspca_dev, 0xf1, 0x00); */
         reg_w1(gspca_dev, 0x01, sn9c1xx[1]);
 
         /* configure gpio */
@@ -1284,6 +1370,12 @@ static void bridge_init(struct gspca_dev *gspca_dev,
         reg_w(gspca_dev, 0x03, &sn9c1xx[3], 0x0f);
 
         switch (sd->sensor) {
+        case SENSOR_ADCM1700:
+                reg_w1(gspca_dev, 0x01, 0x43);
+                reg_w1(gspca_dev, 0x17, 0x62);
+                reg_w1(gspca_dev, 0x01, 0x42);
+                reg_w1(gspca_dev, 0x01, 0x42);
+                break;
         case SENSOR_MT9V111:
                 reg_w1(gspca_dev, 0x01, 0x61);
                 reg_w1(gspca_dev, 0x17, 0x61);
@@ -1357,14 +1449,19 @@ static int sd_config(struct gspca_dev *gspca_dev,
         struct sd *sd = (struct sd *) gspca_dev;
         struct cam *cam;
 
-        cam = &gspca_dev->cam;
-        cam->cam_mode = vga_mode;
-        cam->nmodes = ARRAY_SIZE(vga_mode);
-        cam->npkt = 24;                 /* 24 packets per ISOC message */
-
         sd->bridge = id->driver_info >> 16;
         sd->sensor = id->driver_info;
 
+        cam = &gspca_dev->cam;
+        if (sd->sensor == SENSOR_ADCM1700) {
+                cam->cam_mode = cif_mode;
+                cam->nmodes = ARRAY_SIZE(cif_mode);
+        } else {
+                cam->cam_mode = vga_mode;
+                cam->nmodes = ARRAY_SIZE(vga_mode);
+        }
+        cam->npkt = 24;                 /* 24 packets per ISOC message */
+
         sd->brightness = BRIGHTNESS_DEF;
         sd->contrast = CONTRAST_DEF;
         sd->colors = COLOR_DEF;
@@ -1374,6 +1471,14 @@ static int sd_config(struct gspca_dev *gspca_dev,
         sd->autogain = AUTOGAIN_DEF;
         sd->ag_cnt = -1;
         sd->vflip = VFLIP_DEF;
+        switch (sd->sensor) {
+        case SENSOR_OM6802:
+                sd->sharpness = 0x10;
+                break;
+        default:
+                sd->sharpness = SHARPNESS_DEF;
+                break;
+        }
         sd->infrared = INFRARED_DEF;
         sd->freq = FREQ_DEF;
         sd->quality = QUALITY_DEF;
@@ -1433,7 +1538,9 @@ static int sd_init(struct gspca_dev *gspca_dev)
                 break;
         }
 
-        reg_w1(gspca_dev, 0xf1, 0x01);
+        /* Note we do not disable the sensor clock here (power saving mode),
+           as that also disables the button on the cam. */
+        reg_w1(gspca_dev, 0xf1, 0x00);
 
         /* set the i2c address */
         sn9c1xx = sn_tb[sd->sensor];
@@ -1543,6 +1650,10 @@ static void setbrightness(struct gspca_dev *gspca_dev)
 
         k2 = ((int) sd->brightness - 0x8000) >> 10;
         switch (sd->sensor) {
+        case SENSOR_ADCM1700:
+                if (k2 > 0x1f)
+                        k2 = 0;         /* only positive Y offset */
+                break;
         case SENSOR_HV7131R:
                 expo = sd->brightness << 4;
                 if (expo > 0x002dc6c0)
@@ -1625,6 +1736,9 @@ static void setgamma(struct gspca_dev *gspca_dev)
         };
 
         switch (sd->sensor) {
+        case SENSOR_ADCM1700:
+                gamma_base = gamma_spec_0;
+                break;
         case SENSOR_HV7131R:
         case SENSOR_MT9V111:
                 gamma_base = gamma_spec_1;
@@ -1670,23 +1784,39 @@ static void setautogain(struct gspca_dev *gspca_dev)
                 sd->ag_cnt = -1;
 }
 
-/* ov7630/ov7648 only */
+/* hv7131r/ov7630/ov7648 only */
 static void setvflip(struct sd *sd)
 {
         u8 comn;
 
         if (sd->gspca_dev.ctrl_dis & (1 << VFLIP_IDX))
                 return;
-        if (sd->sensor == SENSOR_OV7630) {
+        switch (sd->sensor) {
+        case SENSOR_HV7131R:
+                comn = 0x18;                    /* clkdiv = 1, ablcen = 1 */
+                if (sd->vflip)
+                        comn |= 0x01;
+                i2c_w1(&sd->gspca_dev, 0x01, comn);     /* sctra */
+                break;
+        case SENSOR_OV7630:
                 comn = 0x02;
                 if (!sd->vflip)
                         comn |= 0x80;
-        } else {
+                i2c_w1(&sd->gspca_dev, 0x75, comn);
+                break;
+        default:
+/*      case SENSOR_OV7648: */
                 comn = 0x06;
                 if (sd->vflip)
                         comn |= 0x80;
+                i2c_w1(&sd->gspca_dev, 0x75, comn);
+                break;
         }
-        i2c_w1(&sd->gspca_dev, 0x75, comn);
+}
+
+static void setsharpness(struct sd *sd)
+{
+        reg_w1(&sd->gspca_dev, 0x99, sd->sharpness);
 }
 
 static void setinfrared(struct sd *sd)
@@ -1804,6 +1934,8 @@ static int sd_start(struct gspca_dev *gspca_dev)
         int mode;
         static const u8 C0[] = { 0x2d, 0x2d, 0x3a, 0x05, 0x04, 0x3f };
         static const u8 CA[] = { 0x28, 0xd8, 0x14, 0xec };
+        static const u8 CA_adcm1700[] =
+                                { 0x14, 0xec, 0x0a, 0xf6 };
         static const u8 CE[] = { 0x32, 0xdd, 0x2d, 0xdd };      /* MI0360 */
         static const u8 CE_ov76xx[] =
                                 { 0x32, 0xdd, 0x32, 0xdd };
@@ -1824,6 +1956,9 @@ static int sd_start(struct gspca_dev *gspca_dev)
         i2c_w_seq(gspca_dev, sensor_init[sd->sensor]);
 
         switch (sd->sensor) {
+        case SENSOR_ADCM1700:
+                reg2 = 0x60;
+                break;
         case SENSOR_OM6802:
                 reg2 = 0x71;
                 break;
@@ -1842,17 +1977,28 @@ static int sd_start(struct gspca_dev *gspca_dev)
         reg_w1(gspca_dev, 0x12, sn9c1xx[0x12]);
         reg_w1(gspca_dev, 0x13, sn9c1xx[0x13]);
         reg_w1(gspca_dev, 0x18, sn9c1xx[0x18]);
-        reg_w1(gspca_dev, 0xd2, 0x6a);          /* DC29 */
-        reg_w1(gspca_dev, 0xd3, 0x50);
+        if (sd->sensor == SENSOR_ADCM1700) {
+                reg_w1(gspca_dev, 0xd2, 0x3a);  /* AE_H_SIZE = 116 */
+                reg_w1(gspca_dev, 0xd3, 0x30);  /* AE_V_SIZE = 96 */
+        } else {
+                reg_w1(gspca_dev, 0xd2, 0x6a);  /* AE_H_SIZE = 212 */
+                reg_w1(gspca_dev, 0xd3, 0x50);  /* AE_V_SIZE = 160 */
+        }
         reg_w1(gspca_dev, 0xc6, 0x00);
         reg_w1(gspca_dev, 0xc7, 0x00);
-        reg_w1(gspca_dev, 0xc8, 0x50);
-        reg_w1(gspca_dev, 0xc9, 0x3c);
+        if (sd->sensor == SENSOR_ADCM1700) {
+                reg_w1(gspca_dev, 0xc8, 0x2c);  /* AW_H_STOP = 352 */
+                reg_w1(gspca_dev, 0xc9, 0x24);  /* AW_V_STOP = 288 */
+        } else {
+                reg_w1(gspca_dev, 0xc8, 0x50);  /* AW_H_STOP = 640 */
+                reg_w1(gspca_dev, 0xc9, 0x3c);  /* AW_V_STOP = 480 */
+        }
         reg_w1(gspca_dev, 0x18, sn9c1xx[0x18]);
         switch (sd->sensor) {
         case SENSOR_MT9V111:
                 reg17 = 0xe0;
                 break;
+        case SENSOR_ADCM1700:
         case SENSOR_OV7630:
                 reg17 = 0xe2;
                 break;
@@ -1870,44 +2016,39 @@ static int sd_start(struct gspca_dev *gspca_dev)
                 break;
         }
         reg_w1(gspca_dev, 0x17, reg17);
-/* set reg1 was here */
-        reg_w1(gspca_dev, 0x05, sn9c1xx[5]);    /* red */
-        reg_w1(gspca_dev, 0x07, sn9c1xx[7]);    /* green */
-        reg_w1(gspca_dev, 0x06, sn9c1xx[6]);    /* blue */
+
+        reg_w1(gspca_dev, 0x05, 0x00);          /* red */
+        reg_w1(gspca_dev, 0x07, 0x00);          /* green */
+        reg_w1(gspca_dev, 0x06, 0x00);          /* blue */
         reg_w1(gspca_dev, 0x14, sn9c1xx[0x14]);
 
         setgamma(gspca_dev);
 
+/*fixme: 8 times with all zeroes and 1 or 2 times with normal values */
         for (i = 0; i < 8; i++)
                 reg_w(gspca_dev, 0x84, reg84, sizeof reg84);
         switch (sd->sensor) {
+        case SENSOR_ADCM1700:
+        case SENSOR_OV7660:
+        case SENSOR_SP80708:
+                reg_w1(gspca_dev, 0x9a, 0x05);
+                break;
         case SENSOR_MT9V111:
                 reg_w1(gspca_dev, 0x9a, 0x07);
-                reg_w1(gspca_dev, 0x99, 0x59);
-                break;
-        case SENSOR_OM6802:
-                reg_w1(gspca_dev, 0x9a, 0x08);
-                reg_w1(gspca_dev, 0x99, 0x10);
                 break;
         case SENSOR_OV7648:
                 reg_w1(gspca_dev, 0x9a, 0x0a);
-                reg_w1(gspca_dev, 0x99, 0x60);
-                break;
-        case SENSOR_OV7660:
-        case SENSOR_SP80708:
-                reg_w1(gspca_dev, 0x9a, 0x05);
-                reg_w1(gspca_dev, 0x99, 0x59);
                 break;
         default:
                 reg_w1(gspca_dev, 0x9a, 0x08);
-                reg_w1(gspca_dev, 0x99, 0x59);
                 break;
         }
+        setsharpness(sd);
 
         reg_w(gspca_dev, 0x84, reg84, sizeof reg84);
-        reg_w1(gspca_dev, 0x05, sn9c1xx[5]);    /* red */
-        reg_w1(gspca_dev, 0x07, sn9c1xx[7]);    /* green */
-        reg_w1(gspca_dev, 0x06, sn9c1xx[6]);    /* blue */
+        reg_w1(gspca_dev, 0x05, 0x20);          /* red */
+        reg_w1(gspca_dev, 0x07, 0x20);          /* green */
+        reg_w1(gspca_dev, 0x06, 0x20);          /* blue */
 
         init = NULL;
         mode = gspca_dev->cam.cam_mode[gspca_dev->curr_mode].priv;
@@ -1917,6 +2058,11 @@ static int sd_start(struct gspca_dev *gspca_dev)
                 reg1 = 0x06;    /* 640x480: clk 24Mhz, video trf enable */
         reg17 = 0x61;           /* 0x:20: enable sensor clock */
         switch (sd->sensor) {
+        case SENSOR_ADCM1700:
+                init = adcm1700_sensor_param1;
+                reg1 = 0x46;
+                reg17 = 0xe2;
+                break;
         case SENSOR_MO4000:
                 if (mode) {
 /*                      reg1 = 0x46;     * 320 clk 48Mhz 60fp/s */
@@ -1940,7 +2086,6 @@ static int sd_start(struct gspca_dev *gspca_dev)
                 reg17 = 0x64;           /* 640 MCKSIZE */
                 break;
         case SENSOR_OV7630:
-                setvflip(sd);
                 reg17 = 0xe2;
                 reg1 = 0x44;
                 break;
@@ -1986,8 +2131,12 @@ static int sd_start(struct gspca_dev *gspca_dev)
         }
 
         reg_w(gspca_dev, 0xc0, C0, 6);
-        reg_w(gspca_dev, 0xca, CA, 4);
+        if (sd->sensor == SENSOR_ADCM1700)
+                reg_w(gspca_dev, 0xca, CA_adcm1700, 4);
+        else
+                reg_w(gspca_dev, 0xca, CA, 4);
         switch (sd->sensor) {
+        case SENSOR_ADCM1700:
         case SENSOR_OV7630:
         case SENSOR_OV7648:
         case SENSOR_OV7660:
@@ -2008,11 +2157,7 @@ static int sd_start(struct gspca_dev *gspca_dev)
         reg_w1(gspca_dev, 0x17, reg17);
         reg_w1(gspca_dev, 0x01, reg1);
 
-        switch (sd->sensor) {
-        case SENSOR_OV7630:
-                setvflip(sd);
-                break;
-        }
+        setvflip(sd);
         setbrightness(gspca_dev);
         setcontrast(gspca_dev);
         setautogain(gspca_dev);
@@ -2056,7 +2201,8 @@ static void sd_stopN(struct gspca_dev *gspca_dev)
         reg_w1(gspca_dev, 0x17, sn9c1xx[0x17]);
         reg_w1(gspca_dev, 0x01, sn9c1xx[1]);
         reg_w1(gspca_dev, 0x01, data);
-        reg_w1(gspca_dev, 0xf1, 0x00);
+        /* Don't disable sensor clock as that disables the button on the cam */
+        /* reg_w1(gspca_dev, 0xf1, 0x01); */
 }
 
 static void sd_stop0(struct gspca_dev *gspca_dev)
@@ -2288,6 +2434,24 @@ static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val)
         return 0;
 }
 
+static int sd_setsharpness(struct gspca_dev *gspca_dev, __s32 val)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        sd->sharpness = val;
+        if (gspca_dev->streaming)
+                setsharpness(sd);
+        return 0;
+}
+
+static int sd_getsharpness(struct gspca_dev *gspca_dev, __s32 *val)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        *val = sd->sharpness;
+        return 0;
+}
+
 static int sd_setvflip(struct gspca_dev *gspca_dev, __s32 val)
 {
         struct sd *sd = (struct sd *) gspca_dev;
@@ -2391,6 +2555,25 @@ static int sd_querymenu(struct gspca_dev *gspca_dev,
         return -EINVAL;
 }
 
+#ifdef CONFIG_INPUT
+static int sd_int_pkt_scan(struct gspca_dev *gspca_dev,
+                        u8 *data,               /* interrupt packet data */
+                        int len)                /* interrupt packet length */
+{
+        int ret = -EINVAL;
+
+        if (len == 1 && data[0] == 1) {
+                input_report_key(gspca_dev->input_dev, KEY_CAMERA, 1);
+                input_sync(gspca_dev->input_dev);
+                input_report_key(gspca_dev->input_dev, KEY_CAMERA, 0);
+                input_sync(gspca_dev->input_dev);
+                ret = 0;
+        }
+
+        return ret;
+}
+#endif
+
 /* sub-driver description */
 static const struct sd_desc sd_desc = {
         .name = MODULE_NAME,
@@ -2406,6 +2589,9 @@ static const struct sd_desc sd_desc = {
         .get_jcomp = sd_get_jcomp,
         .set_jcomp = sd_set_jcomp,
         .querymenu = sd_querymenu,
+#ifdef CONFIG_INPUT
+        .int_pkt_scan = sd_int_pkt_scan,
+#endif
 };
 
 /* -- module initialisation -- */
@@ -2472,6 +2658,7 @@ static const __devinitdata struct usb_device_id device_table[] = {
 /*      {USB_DEVICE(0x0c45, 0x6142), BS(SN9C120, PO2030N)},      *sn9c120b*/
         {USB_DEVICE(0x0c45, 0x6143), BS(SN9C120, SP80708)},     /*sn9c120b*/
         {USB_DEVICE(0x0c45, 0x6148), BS(SN9C120, OM6802)},      /*sn9c120b*/
+        {USB_DEVICE(0x0c45, 0x614a), BS(SN9C120, ADCM1700)},    /*sn9c120b*/
         {}
 };
 MODULE_DEVICE_TABLE(usb, device_table);
diff --git a/drivers/media/video/gspca/spca500.c b/drivers/media/video/gspca/spca500.c
index fe46868a87f2..b866c73c97db 100644
--- a/drivers/media/video/gspca/spca500.c
+++ b/drivers/media/video/gspca/spca500.c
@@ -68,7 +68,7 @@ static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val);
 static int sd_setcolors(struct gspca_dev *gspca_dev, __s32 val);
 static int sd_getcolors(struct gspca_dev *gspca_dev, __s32 *val);
 
-static struct ctrl sd_ctrls[] = {
+static const struct ctrl sd_ctrls[] = {
         {
             {
                 .id      = V4L2_CID_BRIGHTNESS,
@@ -1047,7 +1047,7 @@ static int sd_get_jcomp(struct gspca_dev *gspca_dev,
 }
 
 /* sub-driver description */
-static struct sd_desc sd_desc = {
+static const struct sd_desc sd_desc = {
         .name = MODULE_NAME,
         .ctrls = sd_ctrls,
         .nctrls = ARRAY_SIZE(sd_ctrls),
diff --git a/drivers/media/video/gspca/spca501.c b/drivers/media/video/gspca/spca501.c
index 6761a3048a98..c99333933e32 100644
--- a/drivers/media/video/gspca/spca501.c
+++ b/drivers/media/video/gspca/spca501.c
@@ -59,7 +59,7 @@ static int sd_getblue_balance(struct gspca_dev *gspca_dev, __s32 *val);
 static int sd_setred_balance(struct gspca_dev *gspca_dev, __s32 val);
 static int sd_getred_balance(struct gspca_dev *gspca_dev, __s32 *val);
 
-static struct ctrl sd_ctrls[] = {
+static const struct ctrl sd_ctrls[] = {
 #define MY_BRIGHTNESS 0
         {
             {
diff --git a/drivers/media/video/gspca/spca505.c b/drivers/media/video/gspca/spca505.c
index 0f9232ff1281..c576eed73abe 100644
--- a/drivers/media/video/gspca/spca505.c
+++ b/drivers/media/video/gspca/spca505.c
@@ -42,7 +42,7 @@ struct sd {
 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val);
 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val);
 
-static struct ctrl sd_ctrls[] = {
+static const struct ctrl sd_ctrls[] = {
         {
             {
                 .id      = V4L2_CID_BRIGHTNESS,
diff --git a/drivers/media/video/gspca/spca506.c b/drivers/media/video/gspca/spca506.c
index 39257e4e074f..89fec4c500af 100644
--- a/drivers/media/video/gspca/spca506.c
+++ b/drivers/media/video/gspca/spca506.c
@@ -51,7 +51,7 @@ static int sd_getcolors(struct gspca_dev *gspca_dev, __s32 *val);
 static int sd_sethue(struct gspca_dev *gspca_dev, __s32 val);
 static int sd_gethue(struct gspca_dev *gspca_dev, __s32 *val);
 
-static struct ctrl sd_ctrls[] = {
+static const struct ctrl sd_ctrls[] = {
 #define SD_BRIGHTNESS 0
         {
             {
@@ -673,7 +673,7 @@ static int sd_gethue(struct gspca_dev *gspca_dev, __s32 *val)
 }
 
 /* sub-driver description */
-static struct sd_desc sd_desc = {
+static const struct sd_desc sd_desc = {
         .name = MODULE_NAME,
         .ctrls = sd_ctrls,
         .nctrls = ARRAY_SIZE(sd_ctrls),
diff --git a/drivers/media/video/gspca/spca508.c b/drivers/media/video/gspca/spca508.c
index 4d8e6cf75d55..15b2eef8a3f6 100644
--- a/drivers/media/video/gspca/spca508.c
+++ b/drivers/media/video/gspca/spca508.c
@@ -45,7 +45,7 @@ struct sd {
 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val);
 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val);
 
-static struct ctrl sd_ctrls[] = {
+static const struct ctrl sd_ctrls[] = {
         {
             {
                 .id      = V4L2_CID_BRIGHTNESS,
diff --git a/drivers/media/video/gspca/spca561.c b/drivers/media/video/gspca/spca561.c
index 58c2f0039af1..dc7f2b0fbc79 100644
--- a/drivers/media/video/gspca/spca561.c
+++ b/drivers/media/video/gspca/spca561.c
@@ -922,7 +922,7 @@ static int sd_getgain(struct gspca_dev *gspca_dev, __s32 *val)
 }
 
 /* control tables */
-static struct ctrl sd_ctrls_12a[] = {
+static const struct ctrl sd_ctrls_12a[] = {
         {
             {
                 .id = V4L2_CID_HUE,
@@ -964,7 +964,7 @@ static struct ctrl sd_ctrls_12a[] = {
         },
 };
 
-static struct ctrl sd_ctrls_72a[] = {
+static const struct ctrl sd_ctrls_72a[] = {
         {
             {
                 .id = V4L2_CID_HUE,
diff --git a/drivers/media/video/gspca/sq905c.c b/drivers/media/video/gspca/sq905c.c
index d70b156872d6..e64662052992 100644
--- a/drivers/media/video/gspca/sq905c.c
+++ b/drivers/media/video/gspca/sq905c.c
@@ -47,6 +47,7 @@ MODULE_LICENSE("GPL");
 
 /* Commands. These go in the "value" slot. */
 #define SQ905C_CLEAR   0xa0             /* clear everything */
+#define SQ905C_GET_ID  0x14f4           /* Read version number */
 #define SQ905C_CAPTURE_LOW 0xa040       /* Starts capture at 160x120 */
 #define SQ905C_CAPTURE_MED 0x1440       /* Starts capture at 320x240 */
 #define SQ905C_CAPTURE_HI 0x2840        /* Starts capture at 320x240 */
@@ -101,6 +102,26 @@ static int sq905c_command(struct gspca_dev *gspca_dev, u16 command, u16 index)
         return 0;
 }
 
+static int sq905c_read(struct gspca_dev *gspca_dev, u16 command, u16 index,
+                       int size)
+{
+        int ret;
+
+        ret = usb_control_msg(gspca_dev->dev,
+                              usb_rcvctrlpipe(gspca_dev->dev, 0),
+                              USB_REQ_SYNCH_FRAME,              /* request */
+                              USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+                              command, index, gspca_dev->usb_buf, size,
+                              SQ905C_CMD_TIMEOUT);
+        if (ret < 0) {
+                PDEBUG(D_ERR, "%s: usb_control_msg failed (%d)",
+                       __func__, ret);
+                return ret;
+        }
+
+        return 0;
+}
+
 /* This function is called as a workqueue function and runs whenever the camera
  * is streaming data. Because it is a workqueue function it is allowed to sleep
  * so we can use synchronous USB calls. To avoid possible collisions with other
@@ -183,13 +204,34 @@ static int sd_config(struct gspca_dev *gspca_dev,
 {
         struct cam *cam = &gspca_dev->cam;
         struct sd *dev = (struct sd *) gspca_dev;
+        int ret;
 
         PDEBUG(D_PROBE,
                 "SQ9050 camera detected"
                 " (vid/pid 0x%04X:0x%04X)", id->idVendor, id->idProduct);
+
+        ret = sq905c_command(gspca_dev, SQ905C_GET_ID, 0);
+        if (ret < 0) {
+                PDEBUG(D_ERR, "Get version command failed");
+                return ret;
+        }
+
+        ret = sq905c_read(gspca_dev, 0xf5, 0, 20);
+        if (ret < 0) {
+                PDEBUG(D_ERR, "Reading version command failed");
+                return ret;
+        }
+        /* Note we leave out the usb id and the manufacturing date */
+        PDEBUG(D_PROBE,
+               "SQ9050 ID string: %02x - %02x %02x %02x %02x %02x %02x",
+                gspca_dev->usb_buf[3],
+                gspca_dev->usb_buf[14], gspca_dev->usb_buf[15],
+                gspca_dev->usb_buf[16], gspca_dev->usb_buf[17],
+                gspca_dev->usb_buf[18], gspca_dev->usb_buf[19]);
+
         cam->cam_mode = sq905c_mode;
         cam->nmodes = 2;
-        if (id->idProduct == 0x9050)
+        if (gspca_dev->usb_buf[15] == 0)
                 cam->nmodes = 1;
         /* We don't use the buffer gspca allocates so make it small. */
         cam->bulk_size = 32;
@@ -258,6 +300,7 @@ static int sd_start(struct gspca_dev *gspca_dev)
 static const __devinitdata struct usb_device_id device_table[] = {
         {USB_DEVICE(0x2770, 0x905c)},
         {USB_DEVICE(0x2770, 0x9050)},
+        {USB_DEVICE(0x2770, 0x9052)},
         {USB_DEVICE(0x2770, 0x913d)},
         {}
 };
diff --git a/drivers/media/video/gspca/stk014.c b/drivers/media/video/gspca/stk014.c
index 2e2935532d99..0fb534210a2c 100644
--- a/drivers/media/video/gspca/stk014.c
+++ b/drivers/media/video/gspca/stk014.c
@@ -53,7 +53,7 @@ static int sd_getcolors(struct gspca_dev *gspca_dev, __s32 *val);
 static int sd_setfreq(struct gspca_dev *gspca_dev, __s32 val);
 static int sd_getfreq(struct gspca_dev *gspca_dev, __s32 *val);
 
-static struct ctrl sd_ctrls[] = {
+static const struct ctrl sd_ctrls[] = {
         {
             {
                 .id      = V4L2_CID_BRIGHTNESS,
diff --git a/drivers/media/video/gspca/stv0680.c b/drivers/media/video/gspca/stv0680.c
index 2a69d7ccb50d..e50dd7693f74 100644
--- a/drivers/media/video/gspca/stv0680.c
+++ b/drivers/media/video/gspca/stv0680.c
@@ -45,7 +45,7 @@ struct sd {
 };
 
 /* V4L2 controls supported by the driver */
-static struct ctrl sd_ctrls[] = {
+static const struct ctrl sd_ctrls[] = {
 };
 
 static int stv_sndctrl(struct gspca_dev *gspca_dev, int set, u8 req, u16 val,
@@ -53,24 +53,28 @@ static int stv_sndctrl(struct gspca_dev *gspca_dev, int set, u8 req, u16 val,
 {
         int ret = -1;
         u8 req_type = 0;
+        unsigned int pipe = 0;
 
         switch (set) {
         case 0: /*  0xc1  */
                 req_type = USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_ENDPOINT;
+                pipe = usb_rcvctrlpipe(gspca_dev->dev, 0);
                 break;
         case 1: /*  0x41  */
                 req_type = USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_ENDPOINT;
+                pipe = usb_sndctrlpipe(gspca_dev->dev, 0);
                 break;
         case 2: /*  0x80  */
                 req_type = USB_DIR_IN | USB_RECIP_DEVICE;
+                pipe = usb_rcvctrlpipe(gspca_dev->dev, 0);
                 break;
         case 3: /*  0x40  */
                 req_type = USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE;
+                pipe = usb_sndctrlpipe(gspca_dev->dev, 0);
                 break;
         }
 
-        ret = usb_control_msg(gspca_dev->dev,
-                              usb_rcvctrlpipe(gspca_dev->dev, 0),
+        ret = usb_control_msg(gspca_dev->dev, pipe,
                               req, req_type,
                               val, 0, gspca_dev->usb_buf, size, 500);
 
@@ -138,6 +142,10 @@ static int sd_config(struct gspca_dev *gspca_dev,
         struct sd *sd = (struct sd *) gspca_dev;
         struct cam *cam = &gspca_dev->cam;
 
+        /* Give the camera some time to settle, otherwise initalization will
+           fail on hotplug, and yes it really needs a full second. */
+        msleep(1000);
+
         /* ping camera to be sure STV0680 is present */
         if (stv_sndctrl(gspca_dev, 0, 0x88, 0x5678, 0x02) != 0x02 ||
             gspca_dev->usb_buf[0] != 0x56 || gspca_dev->usb_buf[1] != 0x78) {
@@ -169,6 +177,8 @@ static int sd_config(struct gspca_dev *gspca_dev,
                 PDEBUG(D_PROBE, "Camera supports CIF mode");
         if (gspca_dev->usb_buf[7] & 0x02)
                 PDEBUG(D_PROBE, "Camera supports VGA mode");
+        if (gspca_dev->usb_buf[7] & 0x04)
+                PDEBUG(D_PROBE, "Camera supports QCIF mode");
         if (gspca_dev->usb_buf[7] & 0x08)
                 PDEBUG(D_PROBE, "Camera supports QVGA mode");
 
diff --git a/drivers/media/video/gspca/stv06xx/stv06xx.c b/drivers/media/video/gspca/stv06xx/stv06xx.c
index 5d0241bb1611..af73da34c83f 100644
--- a/drivers/media/video/gspca/stv06xx/stv06xx.c
+++ b/drivers/media/video/gspca/stv06xx/stv06xx.c
@@ -27,6 +27,7 @@
  * P/N 861040-0000: Sensor ST VV6410       ASIC STV0610   - QuickCam Web
  */
 
+#include <linux/input.h>
 #include "stv06xx_sensor.h"
 
 MODULE_AUTHOR("Erik Andrén");
@@ -219,6 +220,7 @@ static void stv06xx_dump_bridge(struct sd *sd)
                 info("Read 0x%x from address 0x%x", data, i);
         }
 
+        info("Testing stv06xx bridge registers for writability");
         for (i = 0x1400; i < 0x160f; i++) {
                 stv06xx_read_bridge(sd, i, &data);
                 buf = data;
@@ -229,7 +231,7 @@ static void stv06xx_dump_bridge(struct sd *sd)
                         info("Register 0x%x is read/write", i);
                 else if (data != buf)
                         info("Register 0x%x is read/write,"
-                             "but only partially", i);
+                             " but only partially", i);
                 else
                         info("Register 0x%x is read-only", i);
 
@@ -426,6 +428,29 @@ frame_data:
         }
 }
 
+#ifdef CONFIG_INPUT
+static int sd_int_pkt_scan(struct gspca_dev *gspca_dev,
+                        u8 *data,               /* interrupt packet data */
+                        int len)                /* interrupt packet length */
+{
+        int ret = -EINVAL;
+
+        if (len == 1 && data[0] == 0x80) {
+                input_report_key(gspca_dev->input_dev, KEY_CAMERA, 1);
+                input_sync(gspca_dev->input_dev);
+                ret = 0;
+        }
+
+        if (len == 1 && data[0] == 0x88) {
+                input_report_key(gspca_dev->input_dev, KEY_CAMERA, 0);
+                input_sync(gspca_dev->input_dev);
+                ret = 0;
+        }
+
+        return ret;
+}
+#endif
+
 static int stv06xx_config(struct gspca_dev *gspca_dev,
                           const struct usb_device_id *id);
 
@@ -436,7 +461,10 @@ static const struct sd_desc sd_desc = {
         .init = stv06xx_init,
         .start = stv06xx_start,
         .stopN = stv06xx_stopN,
-        .pkt_scan = stv06xx_pkt_scan
+        .pkt_scan = stv06xx_pkt_scan,
+#ifdef CONFIG_INPUT
+        .int_pkt_scan = sd_int_pkt_scan,
+#endif
 };
 
 /* This function is called at probe time */
diff --git a/drivers/media/video/gspca/sunplus.c b/drivers/media/video/gspca/sunplus.c
index 306b7d75b4aa..0c786e00ebcf 100644
--- a/drivers/media/video/gspca/sunplus.c
+++ b/drivers/media/video/gspca/sunplus.c
@@ -67,7 +67,7 @@ static int sd_getcolors(struct gspca_dev *gspca_dev, __s32 *val);
 static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val);
 static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val);
 
-static struct ctrl sd_ctrls[] = {
+static const struct ctrl sd_ctrls[] = {
         {
             {
                 .id      = V4L2_CID_BRIGHTNESS,
@@ -267,142 +267,6 @@ static const struct cmd spca504A_clicksmart420_open_data[] = {
         {0x06, 0x0000, 0x0000},
         {0x00, 0x0004, 0x2880},
         {0x00, 0x0001, 0x2881},
-/* look like setting a qTable */
-        {0x00, 0x0006, 0x2800},
-        {0x00, 0x0004, 0x2801},
-        {0x00, 0x0004, 0x2802},
-        {0x00, 0x0006, 0x2803},
-        {0x00, 0x000a, 0x2804},
-        {0x00, 0x0010, 0x2805},
-        {0x00, 0x0014, 0x2806},
-        {0x00, 0x0018, 0x2807},
-        {0x00, 0x0005, 0x2808},
-        {0x00, 0x0005, 0x2809},
-        {0x00, 0x0006, 0x280a},
-        {0x00, 0x0008, 0x280b},
-        {0x00, 0x000a, 0x280c},
-        {0x00, 0x0017, 0x280d},
-        {0x00, 0x0018, 0x280e},
-        {0x00, 0x0016, 0x280f},
-
-        {0x00, 0x0006, 0x2810},
-        {0x00, 0x0005, 0x2811},
-        {0x00, 0x0006, 0x2812},
-        {0x00, 0x000a, 0x2813},
-        {0x00, 0x0010, 0x2814},
-        {0x00, 0x0017, 0x2815},
-        {0x00, 0x001c, 0x2816},
-        {0x00, 0x0016, 0x2817},
-        {0x00, 0x0006, 0x2818},
-        {0x00, 0x0007, 0x2819},
-        {0x00, 0x0009, 0x281a},
-        {0x00, 0x000c, 0x281b},
-        {0x00, 0x0014, 0x281c},
-        {0x00, 0x0023, 0x281d},
-        {0x00, 0x0020, 0x281e},
-        {0x00, 0x0019, 0x281f},
-
-        {0x00, 0x0007, 0x2820},
-        {0x00, 0x0009, 0x2821},
-        {0x00, 0x000f, 0x2822},
-        {0x00, 0x0016, 0x2823},
-        {0x00, 0x001b, 0x2824},
-        {0x00, 0x002c, 0x2825},
-        {0x00, 0x0029, 0x2826},
-        {0x00, 0x001f, 0x2827},
-        {0x00, 0x000a, 0x2828},
-        {0x00, 0x000e, 0x2829},
-        {0x00, 0x0016, 0x282a},
-        {0x00, 0x001a, 0x282b},
-        {0x00, 0x0020, 0x282c},
-        {0x00, 0x002a, 0x282d},
-        {0x00, 0x002d, 0x282e},
-        {0x00, 0x0025, 0x282f},
-
-        {0x00, 0x0014, 0x2830},
-        {0x00, 0x001a, 0x2831},
-        {0x00, 0x001f, 0x2832},
-        {0x00, 0x0023, 0x2833},
-        {0x00, 0x0029, 0x2834},
-        {0x00, 0x0030, 0x2835},
-        {0x00, 0x0030, 0x2836},
-        {0x00, 0x0028, 0x2837},
-        {0x00, 0x001d, 0x2838},
-        {0x00, 0x0025, 0x2839},
-        {0x00, 0x0026, 0x283a},
-        {0x00, 0x0027, 0x283b},
-        {0x00, 0x002d, 0x283c},
-        {0x00, 0x0028, 0x283d},
-        {0x00, 0x0029, 0x283e},
-        {0x00, 0x0028, 0x283f},
-
-        {0x00, 0x0007, 0x2840},
-        {0x00, 0x0007, 0x2841},
-        {0x00, 0x000a, 0x2842},
-        {0x00, 0x0013, 0x2843},
-        {0x00, 0x0028, 0x2844},
-        {0x00, 0x0028, 0x2845},
-        {0x00, 0x0028, 0x2846},
-        {0x00, 0x0028, 0x2847},
-        {0x00, 0x0007, 0x2848},
-        {0x00, 0x0008, 0x2849},
-        {0x00, 0x000a, 0x284a},
-        {0x00, 0x001a, 0x284b},
-        {0x00, 0x0028, 0x284c},
-        {0x00, 0x0028, 0x284d},
-        {0x00, 0x0028, 0x284e},
-        {0x00, 0x0028, 0x284f},
-
-        {0x00, 0x000a, 0x2850},
-        {0x00, 0x000a, 0x2851},
-        {0x00, 0x0016, 0x2852},
-        {0x00, 0x0028, 0x2853},
-        {0x00, 0x0028, 0x2854},
-        {0x00, 0x0028, 0x2855},
-        {0x00, 0x0028, 0x2856},
-        {0x00, 0x0028, 0x2857},
-        {0x00, 0x0013, 0x2858},
-        {0x00, 0x001a, 0x2859},
-        {0x00, 0x0028, 0x285a},
-        {0x00, 0x0028, 0x285b},
-        {0x00, 0x0028, 0x285c},
-        {0x00, 0x0028, 0x285d},
-        {0x00, 0x0028, 0x285e},
-        {0x00, 0x0028, 0x285f},
-
-        {0x00, 0x0028, 0x2860},
-        {0x00, 0x0028, 0x2861},
-        {0x00, 0x0028, 0x2862},
-        {0x00, 0x0028, 0x2863},
-        {0x00, 0x0028, 0x2864},
-        {0x00, 0x0028, 0x2865},
-        {0x00, 0x0028, 0x2866},
-        {0x00, 0x0028, 0x2867},
-        {0x00, 0x0028, 0x2868},
-        {0x00, 0x0028, 0x2869},
-        {0x00, 0x0028, 0x286a},
-        {0x00, 0x0028, 0x286b},
-        {0x00, 0x0028, 0x286c},
-        {0x00, 0x0028, 0x286d},
-        {0x00, 0x0028, 0x286e},
-        {0x00, 0x0028, 0x286f},
-
-        {0x00, 0x0028, 0x2870},
-        {0x00, 0x0028, 0x2871},
-        {0x00, 0x0028, 0x2872},
-        {0x00, 0x0028, 0x2873},
-        {0x00, 0x0028, 0x2874},
-        {0x00, 0x0028, 0x2875},
-        {0x00, 0x0028, 0x2876},
-        {0x00, 0x0028, 0x2877},
-        {0x00, 0x0028, 0x2878},
-        {0x00, 0x0028, 0x2879},
-        {0x00, 0x0028, 0x287a},
-        {0x00, 0x0028, 0x287b},
-        {0x00, 0x0028, 0x287c},
-        {0x00, 0x0028, 0x287d},
-        {0x00, 0x0028, 0x287e},
-        {0x00, 0x0028, 0x287f},
 
         {0xa0, 0x0000, 0x0503},
 };
@@ -622,6 +486,20 @@ static void spca504_acknowledged_command(struct gspca_dev *gspca_dev,
         PDEBUG(D_FRAM, "after wait 0x%04x", notdone);
 }
 
+static void spca504_read_info(struct gspca_dev *gspca_dev)
+{
+        int i;
+        u8 info[6];
+
+        for (i = 0; i < 6; i++)
+                info[i] = reg_r_1(gspca_dev, i);
+        PDEBUG(D_STREAM,
+                "Read info: %d %d %d %d %d %d."
+                " Should be 1,0,2,2,0,0",
+                info[0], info[1], info[2],
+                info[3], info[4], info[5]);
+}
+
 static void spca504A_acknowledged_command(struct gspca_dev *gspca_dev,
                         u8 req,
                         u16 idx, u16 val, u16 endcode, u8 count)
@@ -881,8 +759,6 @@ static int sd_config(struct gspca_dev *gspca_dev,
 static int sd_init(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
-        int i;
-        u8 info[6];
 
         switch (sd->bridge) {
         case BRIDGE_SPCA504B:
@@ -924,15 +800,8 @@ static int sd_init(struct gspca_dev *gspca_dev)
 /*      case BRIDGE_SPCA504: */
                 PDEBUG(D_STREAM, "Opening SPCA504");
                 if (sd->subtype == AiptekMiniPenCam13) {
-                        /*****************************/
-                        for (i = 0; i < 6; i++)
-                                info[i] = reg_r_1(gspca_dev, i);
-                        PDEBUG(D_STREAM,
-                                "Read info: %d %d %d %d %d %d."
-                                " Should be 1,0,2,2,0,0",
-                                info[0], info[1], info[2],
-                                info[3], info[4], info[5]);
-                        /* spca504a aiptek */
+                        spca504_read_info(gspca_dev);
+
                         /* Set AE AWB Banding Type 3-> 50Hz 2-> 60Hz */
                         spca504A_acknowledged_command(gspca_dev, 0x24,
                                                         8, 3, 0x9e, 1);
@@ -971,8 +840,6 @@ static int sd_start(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
         int enable;
-        int i;
-        u8 info[6];
 
         /* create the JPEG header */
         sd->jpeg_hdr = kmalloc(JPEG_HDR_SZ, GFP_KERNEL);
@@ -1008,14 +875,8 @@ static int sd_start(struct gspca_dev *gspca_dev)
                 break;
         case BRIDGE_SPCA504:
                 if (sd->subtype == AiptekMiniPenCam13) {
-                        for (i = 0; i < 6; i++)
-                                info[i] = reg_r_1(gspca_dev, i);
-                        PDEBUG(D_STREAM,
-                                "Read info: %d %d %d %d %d %d."
-                                " Should be 1,0,2,2,0,0",
-                                info[0], info[1], info[2],
-                                info[3], info[4], info[5]);
-                        /* spca504a aiptek */
+                        spca504_read_info(gspca_dev);
+
                         /* Set AE AWB Banding Type 3-> 50Hz 2-> 60Hz */
                         spca504A_acknowledged_command(gspca_dev, 0x24,
                                                         8, 3, 0x9e, 1);
@@ -1026,13 +887,7 @@ static int sd_start(struct gspca_dev *gspca_dev)
                                                         0, 0, 0x9d, 1);
                 } else {
                         spca504_acknowledged_command(gspca_dev, 0x24, 8, 3);
-                        for (i = 0; i < 6; i++)
-                                info[i] = reg_r_1(gspca_dev, i);
-                        PDEBUG(D_STREAM,
-                                "Read info: %d %d %d %d %d %d."
-                                " Should be 1,0,2,2,0,0",
-                                info[0], info[1], info[2],
-                                info[3], info[4], info[5]);
+                        spca504_read_info(gspca_dev);
                         spca504_acknowledged_command(gspca_dev, 0x24, 8, 3);
                         spca504_acknowledged_command(gspca_dev, 0x24, 0, 0);
                 }
@@ -1336,6 +1191,7 @@ static const __devinitdata struct usb_device_id device_table[] = {
         {USB_DEVICE(0x04fc, 0x5330), BS(SPCA533, 0)},
         {USB_DEVICE(0x04fc, 0x5360), BS(SPCA536, 0)},
         {USB_DEVICE(0x04fc, 0xffff), BS(SPCA504B, 0)},
+        {USB_DEVICE(0x052b, 0x1507), BS(SPCA533, MegapixV4)},
         {USB_DEVICE(0x052b, 0x1513), BS(SPCA533, MegapixV4)},
         {USB_DEVICE(0x052b, 0x1803), BS(SPCA533, MegaImageVI)},
         {USB_DEVICE(0x0546, 0x3155), BS(SPCA533, 0)},
diff --git a/drivers/media/video/gspca/t613.c b/drivers/media/video/gspca/t613.c
index 55ef6a744427..668a7536af90 100644
--- a/drivers/media/video/gspca/t613.c
+++ b/drivers/media/video/gspca/t613.c
@@ -52,6 +52,7 @@ struct sd {
 #define SENSOR_OM6802 0
 #define SENSOR_OTHER 1
 #define SENSOR_TAS5130A 2
+#define SENSOR_LT168G 3     /* must verify if this is the actual model */
 };
 
 /* V4L2 controls supported by the driver */
@@ -78,7 +79,7 @@ static int sd_geteffect(struct gspca_dev *gspca_dev, __s32 *val);
 static int sd_querymenu(struct gspca_dev *gspca_dev,
                         struct v4l2_querymenu *menu);
 
-static struct ctrl sd_ctrls[] = {
+static const struct ctrl sd_ctrls[] = {
         {
          {
           .id = V4L2_CID_BRIGHTNESS,
@@ -306,6 +307,17 @@ static const u8 n4_tas5130a[] = {
         0xbe, 0x36, 0xbf, 0xff, 0xc2, 0x88, 0xc5, 0xc8,
         0xc6, 0xda
 };
+static const u8 n4_lt168g[] = {
+        0x66, 0x01, 0x7f, 0x00, 0x80, 0x7c, 0x81, 0x28,
+        0x83, 0x44, 0x84, 0x20, 0x86, 0x20, 0x8a, 0x70,
+        0x8b, 0x58, 0x8c, 0x88, 0x8d, 0xa0, 0x8e, 0xb3,
+        0x8f, 0x24, 0xa1, 0xb0, 0xa2, 0x38, 0xa5, 0x20,
+        0xa6, 0x4a, 0xa8, 0xe8, 0xaf, 0x38, 0xb0, 0x68,
+        0xb1, 0x44, 0xb2, 0x88, 0xbb, 0x86, 0xbd, 0x40,
+        0xbe, 0x26, 0xc1, 0x05, 0xc2, 0x88, 0xc5, 0xc0,
+        0xda, 0x8e, 0xdb, 0xca, 0xdc, 0xa8, 0xdd, 0x8c,
+        0xde, 0x44, 0xdf, 0x0c, 0xe9, 0x80
+};
 
 static const struct additional_sensor_data sensor_data[] = {
     {                           /* 0: OM6802 */
@@ -380,6 +392,23 @@ static const struct additional_sensor_data sensor_data[] = {
         .stream =
                 {0x0b, 0x04, 0x0a, 0x40},
     },
+    {                           /* 3: LT168G */
+        .n3 = {0x61, 0xc2, 0x65, 0x68, 0x60, 0x00},
+        .n4 = n4_lt168g,
+        .n4sz = sizeof n4_lt168g,
+        .reg80 = 0x7c,
+        .reg8e = 0xb3,
+        .nset8 = {0xa8, 0xf0, 0xc6, 0xba, 0xc0, 0x00},
+        .data1 = {0xc0, 0x38, 0x08, 0x10, 0xc0, 0x30, 0x10, 0x40,
+                 0xb0, 0xf4},
+        .data2 = {0x40, 0x80, 0xc0, 0x50, 0xa0, 0xf0, 0x53, 0xa6,
+                 0xff},
+        .data3 = {0x40, 0x80, 0xc0, 0x50, 0xa0, 0xf0, 0x53, 0xa6,
+                 0xff},
+        .data4 = {0x66, 0x41, 0xa8, 0xf0},
+        .data5 = {0x0c, 0x03, 0xab, 0x4b, 0x81, 0x2b},
+        .stream = {0x0b, 0x04, 0x0a, 0x28},
+    },
 };
 
 #define MAX_EFFECTS 7
@@ -716,6 +745,10 @@ static int sd_init(struct gspca_dev *gspca_dev)
                 PDEBUG(D_PROBE, "sensor tas5130a");
                 sd->sensor = SENSOR_TAS5130A;
                 break;
+        case 0x0802:
+                PDEBUG(D_PROBE, "sensor lt168g");
+                sd->sensor = SENSOR_LT168G;
+                break;
         case 0x0803:
                 PDEBUG(D_PROBE, "sensor 'other'");
                 sd->sensor = SENSOR_OTHER;
@@ -758,6 +791,13 @@ static int sd_init(struct gspca_dev *gspca_dev)
         reg_w_buf(gspca_dev, sensor->n3, sizeof sensor->n3);
         reg_w_buf(gspca_dev, sensor->n4, sensor->n4sz);
 
+        if (sd->sensor == SENSOR_LT168G) {
+                test_byte = reg_r(gspca_dev, 0x80);
+                PDEBUG(D_STREAM, "Reg 0x%02x = 0x%02x", 0x80,
+                       test_byte);
+                reg_w(gspca_dev, 0x6c80);
+        }
+
         reg_w_ixbuf(gspca_dev, 0xd0, sensor->data1, sizeof sensor->data1);
         reg_w_ixbuf(gspca_dev, 0xc7, sensor->data2, sizeof sensor->data2);
         reg_w_ixbuf(gspca_dev, 0xe0, sensor->data3, sizeof sensor->data3);
@@ -782,6 +822,13 @@ static int sd_init(struct gspca_dev *gspca_dev)
         reg_w_buf(gspca_dev, sensor->nset8, sizeof sensor->nset8);
         reg_w_buf(gspca_dev, sensor->stream, sizeof sensor->stream);
 
+        if (sd->sensor == SENSOR_LT168G) {
+                test_byte = reg_r(gspca_dev, 0x80);
+                PDEBUG(D_STREAM, "Reg 0x%02x = 0x%02x", 0x80,
+                       test_byte);
+                reg_w(gspca_dev, 0x6c80);
+        }
+
         reg_w_ixbuf(gspca_dev, 0xd0, sensor->data1, sizeof sensor->data1);
         reg_w_ixbuf(gspca_dev, 0xc7, sensor->data2, sizeof sensor->data2);
         reg_w_ixbuf(gspca_dev, 0xe0, sensor->data3, sizeof sensor->data3);
@@ -888,6 +935,8 @@ static int sd_start(struct gspca_dev *gspca_dev)
         case SENSOR_OM6802:
                 om6802_sensor_init(gspca_dev);
                 break;
+        case SENSOR_LT168G:
+                break;
         case SENSOR_OTHER:
                 break;
         default:
diff --git a/drivers/media/video/gspca/tv8532.c b/drivers/media/video/gspca/tv8532.c
index b74a3b6489c7..c7b6eb1e04d5 100644
--- a/drivers/media/video/gspca/tv8532.c
+++ b/drivers/media/video/gspca/tv8532.c
@@ -39,7 +39,7 @@ struct sd {
 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val);
 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val);
 
-static struct ctrl sd_ctrls[] = {
+static const struct ctrl sd_ctrls[] = {
         {
          {
           .id = V4L2_CID_BRIGHTNESS,
diff --git a/drivers/media/video/gspca/vc032x.c b/drivers/media/video/gspca/vc032x.c
index 71921c878424..4989f9afb46e 100644
--- a/drivers/media/video/gspca/vc032x.c
+++ b/drivers/media/video/gspca/vc032x.c
@@ -32,10 +32,13 @@ MODULE_LICENSE("GPL");
 struct sd {
         struct gspca_dev gspca_dev;     /* !! must be the first item */
 
+        u8 brightness;
+        u8 contrast;
+        u8 colors;
         u8 hflip;
         u8 vflip;
         u8 lightfreq;
-        u8 sharpness;
+        s8 sharpness;
 
         u8 image_offset;
 
@@ -52,6 +55,7 @@ struct sd {
 #define SENSOR_OV7670 6
 #define SENSOR_PO1200 7
 #define SENSOR_PO3130NC 8
+#define SENSOR_POxxxx 9
         u8 flags;
 #define FL_SAMSUNG 0x01         /* SamsungQ1 (2 sensors) */
 #define FL_HFLIP 0x02           /* mirrored by default */
@@ -59,6 +63,12 @@ struct sd {
 };
 
 /* V4L2 controls supported by the driver */
+static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val);
+static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val);
+static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val);
+static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val);
+static int sd_setcolors(struct gspca_dev *gspca_dev, __s32 val);
+static int sd_getcolors(struct gspca_dev *gspca_dev, __s32 *val);
 static int sd_sethflip(struct gspca_dev *gspca_dev, __s32 val);
 static int sd_gethflip(struct gspca_dev *gspca_dev, __s32 *val);
 static int sd_setvflip(struct gspca_dev *gspca_dev, __s32 val);
@@ -68,9 +78,54 @@ static int sd_getfreq(struct gspca_dev *gspca_dev, __s32 *val);
 static int sd_setsharpness(struct gspca_dev *gspca_dev, __s32 val);
 static int sd_getsharpness(struct gspca_dev *gspca_dev, __s32 *val);
 
-static struct ctrl sd_ctrls[] = {
+static const struct ctrl sd_ctrls[] = {
+#define BRIGHTNESS_IDX 0
+        {
+            {
+                .id      = V4L2_CID_BRIGHTNESS,
+                .type    = V4L2_CTRL_TYPE_INTEGER,
+                .name    = "Brightness",
+                .minimum = 0,
+                .maximum = 255,
+                .step    = 1,
+#define BRIGHTNESS_DEF 128
+                .default_value = BRIGHTNESS_DEF,
+            },
+            .set = sd_setbrightness,
+            .get = sd_getbrightness,
+        },
+#define CONTRAST_IDX 1
+        {
+            {
+                .id      = V4L2_CID_CONTRAST,
+                .type    = V4L2_CTRL_TYPE_INTEGER,
+                .name    = "Contrast",
+                .minimum = 0,
+                .maximum = 255,
+                .step    = 1,
+#define CONTRAST_DEF 127
+                .default_value = CONTRAST_DEF,
+            },
+            .set = sd_setcontrast,
+            .get = sd_getcontrast,
+        },
+#define COLORS_IDX 2
+        {
+            {
+                .id      = V4L2_CID_SATURATION,
+                .type    = V4L2_CTRL_TYPE_INTEGER,
+                .name    = "Saturation",
+                .minimum = 1,
+                .maximum = 127,
+                .step    = 1,
+#define COLOR_DEF 63
+                .default_value = COLOR_DEF,
+            },
+            .set = sd_setcolors,
+            .get = sd_getcolors,
+        },
 /* next 2 controls work with some sensors only */
-#define HFLIP_IDX 0
+#define HFLIP_IDX 3
         {
             {
                 .id      = V4L2_CID_HFLIP,
@@ -85,7 +140,7 @@ static struct ctrl sd_ctrls[] = {
             .set = sd_sethflip,
             .get = sd_gethflip,
         },
-#define VFLIP_IDX 1
+#define VFLIP_IDX 4
         {
             {
                 .id      = V4L2_CID_VFLIP,
@@ -100,7 +155,7 @@ static struct ctrl sd_ctrls[] = {
             .set = sd_setvflip,
             .get = sd_getvflip,
         },
-#define LIGHTFREQ_IDX 2
+#define LIGHTFREQ_IDX 5
         {
             {
                 .id      = V4L2_CID_POWER_LINE_FREQUENCY,
@@ -115,17 +170,16 @@ static struct ctrl sd_ctrls[] = {
             .set = sd_setfreq,
             .get = sd_getfreq,
         },
-/* po1200 only */
-#define SHARPNESS_IDX 3
+#define SHARPNESS_IDX 6
         {
          {
           .id = V4L2_CID_SHARPNESS,
           .type = V4L2_CTRL_TYPE_INTEGER,
           .name = "Sharpness",
-          .minimum = 0,
+          .minimum = -1,
           .maximum = 2,
           .step = 1,
-#define SHARPNESS_DEF 1
+#define SHARPNESS_DEF -1
           .default_value = SHARPNESS_DEF,
           },
          .set = sd_setsharpness,
@@ -133,6 +187,42 @@ static struct ctrl sd_ctrls[] = {
          },
 };
 
+/* table of the disabled controls */
+static u32 ctrl_dis[] = {
+/* SENSOR_HV7131R 0 */
+        (1 << BRIGHTNESS_IDX) | (1 << CONTRAST_IDX) | (1 << COLORS_IDX)
+                | (1 << HFLIP_IDX) | (1 << VFLIP_IDX) | (1 << LIGHTFREQ_IDX)
+                | (1 << SHARPNESS_IDX),
+/* SENSOR_MI0360 1 */
+        (1 << BRIGHTNESS_IDX) | (1 << CONTRAST_IDX) | (1 << COLORS_IDX)
+                | (1 << HFLIP_IDX) | (1 << VFLIP_IDX) | (1 << LIGHTFREQ_IDX)
+                | (1 << SHARPNESS_IDX),
+/* SENSOR_MI1310_SOC 2 */
+        (1 << BRIGHTNESS_IDX) | (1 << CONTRAST_IDX) | (1 << COLORS_IDX)
+                | (1 << LIGHTFREQ_IDX) | (1 << SHARPNESS_IDX),
+/* SENSOR_MI1320 3 */
+        (1 << BRIGHTNESS_IDX) | (1 << CONTRAST_IDX) | (1 << COLORS_IDX)
+                | (1 << LIGHTFREQ_IDX) | (1 << SHARPNESS_IDX),
+/* SENSOR_MI1320_SOC 4 */
+        (1 << BRIGHTNESS_IDX) | (1 << CONTRAST_IDX) | (1 << COLORS_IDX)
+                | (1 << LIGHTFREQ_IDX) | (1 << SHARPNESS_IDX),
+/* SENSOR_OV7660 5 */
+        (1 << BRIGHTNESS_IDX) | (1 << CONTRAST_IDX) | (1 << COLORS_IDX)
+                | (1 << LIGHTFREQ_IDX) | (1 << SHARPNESS_IDX),
+/* SENSOR_OV7670 6 */
+        (1 << BRIGHTNESS_IDX) | (1 << CONTRAST_IDX) | (1 << COLORS_IDX)
+                | (1 << SHARPNESS_IDX),
+/* SENSOR_PO1200 7 */
+        (1 << BRIGHTNESS_IDX) | (1 << CONTRAST_IDX) | (1 << COLORS_IDX)
+                | (1 << LIGHTFREQ_IDX),
+/* SENSOR_PO3130NC 8 */
+        (1 << BRIGHTNESS_IDX) | (1 << CONTRAST_IDX) | (1 << COLORS_IDX)
+                | (1 << HFLIP_IDX) | (1 << VFLIP_IDX) | (1 << LIGHTFREQ_IDX)
+                | (1 << SHARPNESS_IDX),
+/* SENSOR_POxxxx 9 */
+        (1 << HFLIP_IDX) | (1 << VFLIP_IDX) | (1 << LIGHTFREQ_IDX),
+};
+
 static const struct v4l2_pix_format vc0321_mode[] = {
         {320, 240, V4L2_PIX_FMT_YVYU, V4L2_FIELD_NONE,
                 .bytesperline = 320,
@@ -215,7 +305,7 @@ static const u8 mi0360_initVGA_JPG[][4] = {
         {0xb3, 0x15, 0x00, 0xcc},
         {0xb3, 0x16, 0x02, 0xcc},
         {0xb3, 0x17, 0x7f, 0xcc},
-        {0xb3, 0x35, 0xdd, 0xcc},
+        {0xb3, 0x35, 0xdd, 0xcc},       /* i2c add: 5d */
         {0xb3, 0x34, 0x02, 0xcc},
         {0xb3, 0x00, 0x25, 0xcc},
         {0xbc, 0x00, 0x71, 0xcc},
@@ -435,7 +525,7 @@ static const u8 mi1310_socinitVGA_JPG[][4] = {
         {0xb3, 0x08, 0x01, 0xcc},
         {0xb3, 0x09, 0x0c, 0xcc},
         {0xb3, 0x34, 0x02, 0xcc},
-        {0xb3, 0x35, 0xdd, 0xcc},
+        {0xb3, 0x35, 0xdd, 0xcc},       /* i2c add: 5d */
         {0xb3, 0x02, 0x00, 0xcc},
         {0xb3, 0x03, 0x0a, 0xcc},
         {0xb3, 0x04, 0x05, 0xcc},
@@ -860,7 +950,8 @@ static const u8 mi1320_initVGA_data[][4] = {
         {0xb0, 0x16, 0x03, 0xcc},       {0xb3, 0x05, 0x00, 0xcc},
         {0xb3, 0x06, 0x00, 0xcc},       {0xb3, 0x08, 0x01, 0xcc},
         {0xb3, 0x09, 0x0c, 0xcc},       {0xb3, 0x34, 0x02, 0xcc},
-        {0xb3, 0x35, 0xc8, 0xcc},       {0xb3, 0x02, 0x00, 0xcc},
+        {0xb3, 0x35, 0xc8, 0xcc},       /* i2c add: 48 */
+        {0xb3, 0x02, 0x00, 0xcc},
         {0xb3, 0x03, 0x0a, 0xcc},       {0xb3, 0x04, 0x05, 0xcc},
         {0xb3, 0x20, 0x00, 0xcc},       {0xb3, 0x21, 0x00, 0xcc},
         {0xb3, 0x22, 0x03, 0xcc},       {0xb3, 0x23, 0xc0, 0xcc},
@@ -901,7 +992,8 @@ static const u8 mi1320_initVGA_data[][4] = {
         {0xc3, 0x01, 0x03, 0xbb},       {0xc4, 0x00, 0x04, 0xbb},
         {0xf0, 0x00, 0x00, 0xbb},       {0x05, 0x01, 0x13, 0xbb},
         {0x06, 0x00, 0x11, 0xbb},       {0x07, 0x00, 0x85, 0xbb},
-        {0x08, 0x00, 0x27, 0xbb},       {0x20, 0x01, 0x03, 0xbb},
+        {0x08, 0x00, 0x27, 0xbb},
+        {0x20, 0x01, 0x00, 0xbb},       /* h/v flips - was 03 */
         {0x21, 0x80, 0x00, 0xbb},       {0x22, 0x0d, 0x0f, 0xbb},
         {0x24, 0x80, 0x00, 0xbb},       {0x59, 0x00, 0xff, 0xbb},
         {0xf0, 0x00, 0x02, 0xbb},       {0x39, 0x03, 0x0d, 0xbb},
@@ -1012,7 +1104,7 @@ static const u8 mi1320_soc_InitVGA[][4] = {
         {0xb3, 0x08, 0x01, 0xcc},
         {0xb3, 0x09, 0x0c, 0xcc},
         {0xb3, 0x34, 0x02, 0xcc},
-        {0xb3, 0x35, 0xc8, 0xcc},
+        {0xb3, 0x35, 0xc8, 0xcc},       /* i2c add: 48 */
         {0xb3, 0x02, 0x00, 0xcc},
         {0xb3, 0x03, 0x0a, 0xcc},
         {0xb3, 0x04, 0x05, 0xcc},
@@ -1359,7 +1451,8 @@ static const u8 po3130_initVGA_data[][4] = {
         {0xb3, 0x23, 0xe8, 0xcc},       {0xb8, 0x08, 0xe8, 0xcc},
         {0xb3, 0x14, 0x00, 0xcc},       {0xb3, 0x15, 0x00, 0xcc},
         {0xb3, 0x16, 0x02, 0xcc},       {0xb3, 0x17, 0x7f, 0xcc},
-        {0xb3, 0x34, 0x01, 0xcc},       {0xb3, 0x35, 0xf6, 0xcc},
+        {0xb3, 0x34, 0x01, 0xcc},
+        {0xb3, 0x35, 0xf6, 0xcc},       /* i2c add: 76 */
         {0xb3, 0x00, 0x27, 0xcc},       {0xbc, 0x00, 0x71, 0xcc},
         {0xb8, 0x00, 0x21, 0xcc},       {0xb8, 0x27, 0x20, 0xcc},
         {0xb8, 0x01, 0x79, 0xcc},       {0xb8, 0x81, 0x09, 0xcc},
@@ -1561,7 +1654,7 @@ static const u8 hv7131r_initVGA_data[][4] = {
         {0xb3, 0x16, 0x02, 0xcc},
         {0xb3, 0x17, 0x7f, 0xcc},
         {0xb3, 0x34, 0x01, 0xcc},
-        {0xb3, 0x35, 0x91, 0xcc},
+        {0xb3, 0x35, 0x91, 0xcc},       /* i2c add: 11 */
         {0xb3, 0x00, 0x27, 0xcc},
         {0xbc, 0x00, 0x73, 0xcc},
         {0xb8, 0x00, 0x23, 0xcc},
@@ -1747,7 +1840,8 @@ static const u8 ov7660_initVGA_data[][4] = {
         {0xb3, 0x23, 0xe0, 0xcc},       {0xb3, 0x1d, 0x01, 0xcc},
         {0xb3, 0x1f, 0x02, 0xcc},
         {0xb3, 0x34, 0x01, 0xcc},
-        {0xb3, 0x35, 0xa1, 0xcc},       {0xb3, 0x00, 0x26, 0xcc},
+        {0xb3, 0x35, 0xa1, 0xcc},       /* i2c add: 21 */
+        {0xb3, 0x00, 0x26, 0xcc},
         {0xb8, 0x00, 0x33, 0xcc}, /* 13 */
         {0xb8, 0x01, 0x7d, 0xcc},
         {0xbc, 0x00, 0x73, 0xcc},       {0xb8, 0x81, 0x09, 0xcc},
@@ -1883,7 +1977,8 @@ static const u8 ov7670_initVGA_JPG[][4] = {
         {0x00, 0x00, 0x10, 0xdd},
         {0xb0, 0x04, 0x02, 0xcc},       {0x00, 0x00, 0x10, 0xdd},
         {0xb3, 0x00, 0x66, 0xcc},       {0xb3, 0x00, 0x67, 0xcc},
-        {0xb3, 0x35, 0xa1, 0xcc},       {0xb3, 0x34, 0x01, 0xcc},
+        {0xb3, 0x35, 0xa1, 0xcc},       /* i2c add: 21 */
+        {0xb3, 0x34, 0x01, 0xcc},
         {0xb3, 0x05, 0x01, 0xcc},       {0xb3, 0x06, 0x01, 0xcc},
         {0xb3, 0x08, 0x01, 0xcc},       {0xb3, 0x09, 0x0c, 0xcc},
         {0xb3, 0x02, 0x02, 0xcc},       {0xb3, 0x03, 0x1f, 0xcc},
@@ -2181,7 +2276,7 @@ static const u8 po1200_initVGA_data[][4] = {
         {0xb0, 0x54, 0x13, 0xcc},
         {0xb3, 0x00, 0x67, 0xcc},
         {0xb3, 0x34, 0x01, 0xcc},
-        {0xb3, 0x35, 0xdc, 0xcc},
+        {0xb3, 0x35, 0xdc, 0xcc},       /* i2c add: 5c */
         {0x00, 0x03, 0x00, 0xaa},
         {0x00, 0x12, 0x05, 0xaa},
         {0x00, 0x13, 0x02, 0xaa},
@@ -2408,6 +2503,251 @@ static const u8 po1200_initVGA_data[][4] = {
         {0x00, 0xb6, 0x39, 0xaa},
         {0x00, 0xb7, 0x24, 0xaa},
 /*write 89 0400 1415*/
+        {}
+};
+
+static const u8 poxxxx_init_common[][4] = {
+        {0xb3, 0x00, 0x04, 0xcc},
+        {0x00, 0x00, 0x10, 0xdd},
+        {0xb3, 0x00, 0x64, 0xcc},
+        {0x00, 0x00, 0x10, 0xdd},
+        {0xb3, 0x00, 0x65, 0xcc},
+        {0x00, 0x00, 0x10, 0xdd},
+        {0xb3, 0x00, 0x67, 0xcc},
+        {0xb0, 0x03, 0x09, 0xcc},
+        {0xb3, 0x05, 0x00, 0xcc},
+        {0xb3, 0x06, 0x00, 0xcc},
+        {0xb3, 0x5c, 0x01, 0xcc},
+        {0xb3, 0x08, 0x01, 0xcc},
+        {0xb3, 0x09, 0x0c, 0xcc},
+        {0xb3, 0x34, 0x01, 0xcc},
+        {0xb3, 0x35, 0xf6, 0xcc},       /* i2c add: 76 */
+        {0xb3, 0x02, 0xb0, 0xcc},
+        {0xb3, 0x03, 0x18, 0xcc},
+        {0xb3, 0x04, 0x15, 0xcc},
+        {0xb3, 0x20, 0x00, 0xcc},
+        {0xb3, 0x21, 0x00, 0xcc},
+        {0xb3, 0x22, 0x04, 0xcc},
+        {0xb3, 0x23, 0x00, 0xcc},
+        {0xb3, 0x14, 0x00, 0xcc},
+        {0xb3, 0x15, 0x00, 0xcc},
+        {0xb3, 0x16, 0x04, 0xcc},
+        {0xb3, 0x17, 0xff, 0xcc},
+        {0xb3, 0x2c, 0x03, 0xcc},
+        {0xb3, 0x2d, 0x56, 0xcc},
+        {0xb3, 0x2e, 0x02, 0xcc},
+        {0xb3, 0x2f, 0x0a, 0xcc},
+        {0xb3, 0x40, 0x00, 0xcc},
+        {0xb3, 0x41, 0x34, 0xcc},
+        {0xb3, 0x42, 0x01, 0xcc},
+        {0xb3, 0x43, 0xe0, 0xcc},
+        {0xbc, 0x00, 0x71, 0xcc},
+        {0xbc, 0x01, 0x01, 0xcc},
+        {0xb3, 0x01, 0x41, 0xcc},
+        {0xb3, 0x4d, 0x00, 0xcc},
+        {0x00, 0x0b, 0x2a, 0xaa},
+        {0x00, 0x0e, 0x03, 0xaa},
+        {0x00, 0x0f, 0xea, 0xaa},
+        {0x00, 0x12, 0x08, 0xaa},
+        {0x00, 0x1e, 0x06, 0xaa},
+        {0x00, 0x21, 0x00, 0xaa},
+        {0x00, 0x31, 0x1f, 0xaa},
+        {0x00, 0x33, 0x38, 0xaa},
+        {0x00, 0x36, 0xc0, 0xaa},
+        {0x00, 0x37, 0xc8, 0xaa},
+        {0x00, 0x3b, 0x36, 0xaa},
+        {0x00, 0x4b, 0xfe, 0xaa},
+        {0x00, 0x4d, 0x2e, 0xaa},
+        {0x00, 0x51, 0x1c, 0xaa},
+        {0x00, 0x52, 0x01, 0xaa},
+        {0x00, 0x55, 0x0a, 0xaa},
+        {0x00, 0x56, 0x0a, 0xaa},
+        {0x00, 0x57, 0x07, 0xaa},
+        {0x00, 0x58, 0x07, 0xaa},
+        {0x00, 0x59, 0x04, 0xaa},
+        {0x00, 0x70, 0x68, 0xaa},
+        {0x00, 0x71, 0x04, 0xaa},
+        {0x00, 0x72, 0x10, 0xaa},
+        {0x00, 0x80, 0x71, 0xaa},
+        {0x00, 0x81, 0x08, 0xaa},
+        {0x00, 0x82, 0x00, 0xaa},
+        {0x00, 0x83, 0x55, 0xaa},
+        {0x00, 0x84, 0x06, 0xaa},
+        {0x00, 0x85, 0x06, 0xaa},
+        {0x00, 0x8b, 0x25, 0xaa},
+        {0x00, 0x8c, 0x00, 0xaa},
+        {0x00, 0x8d, 0x86, 0xaa},
+        {0x00, 0x8e, 0x82, 0xaa},
+        {0x00, 0x8f, 0x2d, 0xaa},
+        {0x00, 0x90, 0x8b, 0xaa},
+        {0x00, 0x91, 0x81, 0xaa},
+        {0x00, 0x92, 0x81, 0xaa},
+        {0x00, 0x93, 0x23, 0xaa},
+        {0x00, 0xa3, 0x2a, 0xaa},
+        {0x00, 0xa4, 0x03, 0xaa},
+        {0x00, 0xa5, 0xea, 0xaa},
+        {0x00, 0xb0, 0x68, 0xaa},
+        {0x00, 0xbc, 0x04, 0xaa},
+        {0x00, 0xbe, 0x3b, 0xaa},
+        {0x00, 0x4e, 0x40, 0xaa},
+        {0x00, 0x06, 0x04, 0xaa},
+        {0x00, 0x07, 0x03, 0xaa},
+        {0x00, 0xcd, 0x18, 0xaa},
+        {0x00, 0x28, 0x03, 0xaa},
+        {0x00, 0x29, 0xef, 0xaa},
+/* reinit on alt 2 (qvga) or alt7 (vga) */
+        {0xb3, 0x05, 0x00, 0xcc},
+        {0xb3, 0x06, 0x00, 0xcc},
+        {0xb8, 0x00, 0x01, 0xcc},
+
+        {0x00, 0x1d, 0x85, 0xaa},
+        {0x00, 0x1e, 0xc6, 0xaa},
+        {0x00, 0x00, 0x40, 0xdd},
+        {0x00, 0x1d, 0x05, 0xaa},
+
+        {0x00, 0xd6, 0x22, 0xaa},       /* gamma 0 */
+        {0x00, 0x73, 0x00, 0xaa},
+        {0x00, 0x74, 0x0a, 0xaa},
+        {0x00, 0x75, 0x16, 0xaa},
+        {0x00, 0x76, 0x25, 0xaa},
+        {0x00, 0x77, 0x34, 0xaa},
+        {0x00, 0x78, 0x49, 0xaa},
+        {0x00, 0x79, 0x5a, 0xaa},
+        {0x00, 0x7a, 0x7f, 0xaa},
+        {0x00, 0x7b, 0x9b, 0xaa},
+        {0x00, 0x7c, 0xba, 0xaa},
+        {0x00, 0x7d, 0xd4, 0xaa},
+        {0x00, 0x7e, 0xea, 0xaa},
+
+        {0x00, 0xd6, 0x62, 0xaa},       /* gamma 1 */
+        {0x00, 0x73, 0x00, 0xaa},
+        {0x00, 0x74, 0x0a, 0xaa},
+        {0x00, 0x75, 0x16, 0xaa},
+        {0x00, 0x76, 0x25, 0xaa},
+        {0x00, 0x77, 0x34, 0xaa},
+        {0x00, 0x78, 0x49, 0xaa},
+        {0x00, 0x79, 0x5a, 0xaa},
+        {0x00, 0x7a, 0x7f, 0xaa},
+        {0x00, 0x7b, 0x9b, 0xaa},
+        {0x00, 0x7c, 0xba, 0xaa},
+        {0x00, 0x7d, 0xd4, 0xaa},
+        {0x00, 0x7e, 0xea, 0xaa},
+
+        {0x00, 0xd6, 0xa2, 0xaa},       /* gamma 2 */
+        {0x00, 0x73, 0x00, 0xaa},
+        {0x00, 0x74, 0x0a, 0xaa},
+        {0x00, 0x75, 0x16, 0xaa},
+        {0x00, 0x76, 0x25, 0xaa},
+        {0x00, 0x77, 0x34, 0xaa},
+        {0x00, 0x78, 0x49, 0xaa},
+        {0x00, 0x79, 0x5a, 0xaa},
+        {0x00, 0x7a, 0x7f, 0xaa},
+        {0x00, 0x7b, 0x9b, 0xaa},
+        {0x00, 0x7c, 0xba, 0xaa},
+        {0x00, 0x7d, 0xd4, 0xaa},
+        {0x00, 0x7e, 0xea, 0xaa},
+
+        {0x00, 0xaa, 0xff, 0xaa},       /* back light comp */
+        {0x00, 0xc4, 0x03, 0xaa},
+        {0x00, 0xc5, 0x19, 0xaa},
+        {0x00, 0xc6, 0x03, 0xaa},
+        {0x00, 0xc7, 0x91, 0xaa},
+        {0x00, 0xc8, 0x01, 0xaa},
+        {0x00, 0xc9, 0xdd, 0xaa},
+        {0x00, 0xca, 0x02, 0xaa},
+        {0x00, 0xcb, 0x37, 0xaa},
+
+/* read d1 */
+        {0x00, 0xd1, 0x3c, 0xaa},
+        {0x00, 0xb8, 0x28, 0xaa},
+        {0x00, 0xb9, 0x1e, 0xaa},
+        {0x00, 0xb6, 0x14, 0xaa},
+        {0x00, 0xb7, 0x0f, 0xaa},
+        {0x00, 0x5c, 0x10, 0xaa},
+        {0x00, 0x5d, 0x18, 0xaa},
+        {0x00, 0x5e, 0x24, 0xaa},
+        {0x00, 0x5f, 0x24, 0xaa},
+        {0x00, 0x86, 0x1a, 0xaa},
+        {0x00, 0x60, 0x00, 0xaa},
+        {0x00, 0x61, 0x1b, 0xaa},
+        {0x00, 0x62, 0x30, 0xaa},
+        {0x00, 0x63, 0x40, 0xaa},
+        {0x00, 0x87, 0x1a, 0xaa},
+        {0x00, 0x64, 0x00, 0xaa},
+        {0x00, 0x65, 0x08, 0xaa},
+        {0x00, 0x66, 0x10, 0xaa},
+        {0x00, 0x67, 0x20, 0xaa},
+        {0x00, 0x88, 0x10, 0xaa},
+        {0x00, 0x68, 0x00, 0xaa},
+        {0x00, 0x69, 0x08, 0xaa},
+        {0x00, 0x6a, 0x0f, 0xaa},
+        {0x00, 0x6b, 0x0f, 0xaa},
+        {0x00, 0x89, 0x07, 0xaa},
+        {0x00, 0xd5, 0x4c, 0xaa},
+        {0x00, 0x0a, 0x00, 0xaa},
+        {0x00, 0x0b, 0x2a, 0xaa},
+        {0x00, 0x0e, 0x03, 0xaa},
+        {0x00, 0x0f, 0xea, 0xaa},
+        {0x00, 0xa2, 0x00, 0xaa},
+        {0x00, 0xa3, 0x2a, 0xaa},
+        {0x00, 0xa4, 0x03, 0xaa},
+        {0x00, 0xa5, 0xea, 0xaa},
+        {}
+};
+static const u8 poxxxx_initVGA[][4] = {
+        {0x00, 0x20, 0x11, 0xaa},
+        {0x00, 0x33, 0x38, 0xaa},
+        {0x00, 0xbb, 0x0d, 0xaa},
+        {0xb3, 0x22, 0x01, 0xcc},
+        {0xb3, 0x23, 0xe0, 0xcc},
+        {0xb3, 0x16, 0x02, 0xcc},
+        {0xb3, 0x17, 0x7f, 0xcc},
+        {0xb3, 0x02, 0xb0, 0xcc},
+        {0xb3, 0x06, 0x00, 0xcc},
+        {0xb3, 0x5c, 0x01, 0xcc},
+        {0x00, 0x04, 0x06, 0xaa},
+        {0x00, 0x05, 0x3f, 0xaa},
+        {0x00, 0x04, 0x00, 0xdd},       /* delay 1s */
+        {}
+};
+static const u8 poxxxx_initQVGA[][4] = {
+        {0x00, 0x20, 0x33, 0xaa},
+        {0x00, 0x33, 0x38, 0xaa},
+        {0x00, 0xbb, 0x0d, 0xaa},
+        {0xb3, 0x22, 0x00, 0xcc},
+        {0xb3, 0x23, 0xf0, 0xcc},
+        {0xb3, 0x16, 0x01, 0xcc},
+        {0xb3, 0x17, 0x3f, 0xcc},
+        {0xb3, 0x02, 0xb0, 0xcc},
+        {0xb3, 0x06, 0x01, 0xcc},
+        {0xb3, 0x5c, 0x00, 0xcc},
+        {0x00, 0x04, 0x06, 0xaa},
+        {0x00, 0x05, 0x3f, 0xaa},
+        {0x00, 0x04, 0x00, 0xdd},       /* delay 1s */
+        {}
+};
+static const u8 poxxxx_init_end_1[][4] = {
+        {0x00, 0x47, 0x25, 0xaa},
+        {0x00, 0x48, 0x80, 0xaa},
+        {0x00, 0x49, 0x1f, 0xaa},
+        {0x00, 0x4a, 0x40, 0xaa},
+        {0x00, 0x44, 0x40, 0xaa},
+        {0x00, 0xab, 0x4a, 0xaa},
+        {0x00, 0xb1, 0x00, 0xaa},
+        {0x00, 0xb2, 0x04, 0xaa},
+        {0x00, 0xb3, 0x08, 0xaa},
+        {0x00, 0xb4, 0x0b, 0xaa},
+        {0x00, 0xb5, 0x0d, 0xaa},
+        {0x00, 0x59, 0x7e, 0xaa},       /* sharpness */
+        {0x00, 0x16, 0x00, 0xaa},       /* white balance */
+        {0x00, 0x18, 0x00, 0xaa},
+        {}
+};
+static const u8 poxxxx_init_end_2[][4] = {
+        {0x00, 0x1d, 0x85, 0xaa},
+        {0x00, 0x1e, 0x06, 0xaa},
+        {0x00, 0x1d, 0x05, 0xaa},
+        {}
 };
 
 struct sensor_info {
@@ -2420,33 +2760,89 @@ struct sensor_info {
         u8 op;
 };
 
-static const struct sensor_info sensor_info_data[] = {
-/*      sensorId,         I2cAdd,       IdAdd,  VpId,  m1,    m2,  op */
+/* probe values */
+static const struct sensor_info vc0321_probe_data[] = {
+/*      sensorId,          I2cAdd,      IdAdd,  VpId,  m1,    m2,  op */
+/* 0 OV9640 */
         {-1,                0x80 | 0x30, 0x0a, 0x0000, 0x25, 0x24, 0x05},
+/* 1 ICM108T (may respond on IdAdd == 0x83 - tested in vc032x_probe_sensor) */
         {-1,                0x80 | 0x20, 0x82, 0x0000, 0x24, 0x25, 0x01},
-/* (tested in vc032x_probe_sensor) */
-/*      {-1,                0x80 | 0x20, 0x83, 0x0000, 0x24, 0x25, 0x01}, */
-        {SENSOR_PO3130NC,   0x80 | 0x76, 0x00, 0x3130, 0x24, 0x25, 0x01},
+/* 2 PO2130 (may detect PO3130NC - tested in vc032x_probe_sensor)*/
+        {-1,                0x80 | 0x76, 0x00, 0x0000, 0x24, 0x25, 0x01},
+/* 3 MI1310 */
+        {-1,                0x80 | 0x5d, 0x00, 0x0000, 0x24, 0x25, 0x01},
+/* 4 MI360 - tested in vc032x_probe_sensor */
+/*      {SENSOR_MI0360,     0x80 | 0x5d, 0x00, 0x8243, 0x24, 0x25, 0x01}, */
+/* 5 7131R */
+        {SENSOR_HV7131R,    0x80 | 0x11, 0x00, 0x0209, 0x24, 0x25, 0x01},
+/* 6 OV7649 */
+        {-1,                0x80 | 0x21, 0x0a, 0x0000, 0x21, 0x20, 0x05},
+/* 7 PAS302BCW */
+        {-1,                0x80 | 0x40, 0x00, 0x0000, 0x20, 0x22, 0x05},
+/* 8 OV7660 */
+        {SENSOR_OV7660,     0x80 | 0x21, 0x0a, 0x7660, 0x26, 0x26, 0x05},
+/* 9 PO3130NC - (tested in vc032x_probe_sensor) */
+/*      {SENSOR_PO3130NC,   0x80 | 0x76, 0x00, 0x3130, 0x24, 0x25, 0x01}, */
+/* 10 PO1030KC */
+        {-1,                0x80 | 0x6e, 0x00, 0x0000, 0x24, 0x25, 0x01},
+/* 11 MI1310_SOC */
         {SENSOR_MI1310_SOC, 0x80 | 0x5d, 0x00, 0x143a, 0x24, 0x25, 0x01},
-/* (tested in vc032x_probe_sensor) */
+/* 12 OV9650 */
+        {-1,                0x80 | 0x30, 0x0a, 0x0000, 0x25, 0x24, 0x05},
+/* 13 S5K532 */
+        {-1,                0x80 | 0x11, 0x39, 0x0000, 0x24, 0x25, 0x01},
+/* 14 MI360_SOC - ??? */
+/* 15 PO1200N */
+        {SENSOR_PO1200,     0x80 | 0x5c, 0x00, 0x1200, 0x67, 0x67, 0x01},
+/* 16 PO3030K */
+        {-1,                0x80 | 0x18, 0x00, 0x0000, 0x24, 0x25, 0x01},
+/* 17 PO2030 */
+        {-1,                0x80 | 0x6e, 0x00, 0x0000, 0x24, 0x25, 0x01},
+/* ?? */
+        {-1,                0x80 | 0x56, 0x01, 0x0000, 0x64, 0x67, 0x01},
+        {SENSOR_MI1320,     0x80 | 0x48, 0x00, 0x148c, 0x64, 0x65, 0x01},
+};
+static const struct sensor_info vc0323_probe_data[] = {
+/*      sensorId,          I2cAdd,      IdAdd,  VpId,  m1,    m2,  op */
+/* 0 OV9640 */
+        {-1,                0x80 | 0x30, 0x0a, 0x0000, 0x25, 0x24, 0x05},
+/* 1 ICM108T (may respond on IdAdd == 0x83 - tested in vc032x_probe_sensor) */
+        {-1,                0x80 | 0x20, 0x82, 0x0000, 0x24, 0x25, 0x01},
+/* 2 PO2130 (may detect PO3130NC - tested in vc032x_probe_sensor)*/
+        {-1,                0x80 | 0x76, 0x00, 0x0000, 0x24, 0x25, 0x01},
+/* 3 MI1310 */
+        {-1,                0x80 | 0x5d, 0x00, 0x0000, 0x24, 0x25, 0x01},
+/* 4 MI360 - tested in vc032x_probe_sensor */
 /*      {SENSOR_MI0360,     0x80 | 0x5d, 0x00, 0x8243, 0x24, 0x25, 0x01}, */
+/* 5 7131R */
         {SENSOR_HV7131R,    0x80 | 0x11, 0x00, 0x0209, 0x24, 0x25, 0x01},
+/* 6 OV7649 */
         {-1,                0x80 | 0x21, 0x0a, 0x0000, 0x21, 0x20, 0x05},
+/* 7 PAS302BCW */
         {-1,                0x80 | 0x40, 0x00, 0x0000, 0x20, 0x22, 0x05},
+/* 8 OV7660 */
         {SENSOR_OV7660,     0x80 | 0x21, 0x0a, 0x7660, 0x26, 0x26, 0x05},
-/*      {SENSOR_PO3130NC,   0x80 | 0x76, 0x00, 0x0000, 0x24, 0x25, 0x01}, */
+/* 9 PO3130NC - (tested in vc032x_probe_sensor) */
+/*      {SENSOR_PO3130NC,   0x80 | 0x76, 0x00, 0x3130, 0x24, 0x25, 0x01}, */
+/* 10 PO1030KC */
         {-1,                0x80 | 0x6e, 0x00, 0x0000, 0x24, 0x25, 0x01},
-/*      {SENSOR_MI1310_SOC, 0x80 | 0x5d, 0x00, 0x0000, 0x24, 0x25, 0x01}, */
-/*      {-1,                0x80 | 0x30, 0x0a, 0x0000, 0x25, 0x24, 0x05}, */
+/* 11 MI1310_SOC */
+        {SENSOR_MI1310_SOC, 0x80 | 0x5d, 0x00, 0x143a, 0x24, 0x25, 0x01},
+/* 12 OV9650 */
+        {-1,                0x80 | 0x30, 0x0a, 0x0000, 0x25, 0x24, 0x05},
+/* 13 S5K532 */
         {-1,                0x80 | 0x11, 0x39, 0x0000, 0x24, 0x25, 0x01},
+/* 14 MI360_SOC - ??? */
+/* 15 PO1200N */
         {SENSOR_PO1200,     0x80 | 0x5c, 0x00, 0x1200, 0x67, 0x67, 0x01},
+/* 16 ?? */
         {-1,                0x80 | 0x2d, 0x00, 0x0000, 0x65, 0x67, 0x01},
+/* 17 PO2030 */
         {-1,                0x80 | 0x6e, 0x00, 0x0000, 0x24, 0x25, 0x01},
+/* ?? */
         {-1,                0x80 | 0x56, 0x01, 0x0000, 0x64, 0x67, 0x01},
         {SENSOR_MI1320_SOC, 0x80 | 0x48, 0x00, 0x148c, 0x64, 0x67, 0x01},
-/*fixme: previously detected?*/
-        {SENSOR_MI1320,     0x80 | 0x48, 0x00, 0x148c, 0x64, 0x65, 0x01},
-/*fixme: not in the ms-win probe - may be found before?*/
+/*fixme: not in the ms-win probe - may be found before? */
         {SENSOR_OV7670,     0x80 | 0x21, 0x0a, 0x7673, 0x66, 0x67, 0x05},
 };
 
@@ -2520,7 +2916,7 @@ static int vc032x_probe_sensor(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
         struct usb_device *dev = gspca_dev->dev;
-        int i;
+        int i, n;
         u16 value;
         const struct sensor_info *ptsensor_info;
 
@@ -2531,9 +2927,16 @@ static int vc032x_probe_sensor(struct gspca_dev *gspca_dev)
         }
 
         reg_r(gspca_dev, 0xa1, 0xbfcf, 1);
-        PDEBUG(D_PROBE, "check sensor header %02x", gspca_dev->usb_buf[0]);
-        for (i = 0; i < ARRAY_SIZE(sensor_info_data); i++) {
-                ptsensor_info = &sensor_info_data[i];
+        PDEBUG(D_PROBE, "vc032%d check sensor header %02x",
+                sd->bridge == BRIDGE_VC0321 ? 1 : 3, gspca_dev->usb_buf[0]);
+        if (sd->bridge == BRIDGE_VC0321) {
+                ptsensor_info = vc0321_probe_data;
+                n = ARRAY_SIZE(vc0321_probe_data);
+        } else {
+                ptsensor_info = vc0323_probe_data;
+                n = ARRAY_SIZE(vc0323_probe_data);
+        }
+        for (i = 0; i < n; i++) {
                 reg_w(dev, 0xa0, 0x02, 0xb334);
                 reg_w(dev, 0xa0, ptsensor_info->m1, 0xb300);
                 reg_w(dev, 0xa0, ptsensor_info->m2, 0xb300);
@@ -2551,13 +2954,15 @@ static int vc032x_probe_sensor(struct gspca_dev *gspca_dev)
                                 return ptsensor_info->sensorId;
 
                         switch (value) {
+                        case 0x3130:
+                                return SENSOR_PO3130NC;
                         case 0x7673:
                                 return SENSOR_OV7670;
                         case 0x8243:
                                 return SENSOR_MI0360;
                         }
-/*fixme: should return here*/
                 }
+                ptsensor_info++;
         }
         return -1;
 }
@@ -2619,7 +3024,7 @@ static void usb_exchange(struct gspca_dev *gspca_dev,
                         i2c_write(gspca_dev, data[i][0], &data[i][1], 2);
                         break;
                 case 0xdd:
-                        msleep(data[i][2] + 10);
+                        msleep(data[i][1] * 256 + data[i][2] + 10);
                         break;
                 }
                 i++;
@@ -2646,12 +3051,17 @@ static int sd_config(struct gspca_dev *gspca_dev,
                 64,             /* OV7670 6 */
                 128,            /* PO1200 7 */
                 128,            /* PO3130NC 8 */
+                128,            /* POxxxx 9 */
         };
 
         cam = &gspca_dev->cam;
         sd->bridge = id->driver_info >> 8;
         sd->flags = id->driver_info & 0xff;
-        sensor = vc032x_probe_sensor(gspca_dev);
+        if (id->idVendor == 0x046d &&
+            (id->idProduct == 0x0892 || id->idProduct == 0x0896))
+                sensor = SENSOR_POxxxx;
+        else
+                sensor = vc032x_probe_sensor(gspca_dev);
         switch (sensor) {
         case -1:
                 PDEBUG(D_PROBE, "Unknown sensor...");
@@ -2684,6 +3094,9 @@ static int sd_config(struct gspca_dev *gspca_dev,
         case SENSOR_PO3130NC:
                 PDEBUG(D_PROBE, "Find Sensor PO3130NC");
                 break;
+        case SENSOR_POxxxx:
+                PDEBUG(D_PROBE, "Sensor POxxxx");
+                break;
         }
         sd->sensor = sensor;
 
@@ -2712,28 +3125,19 @@ static int sd_config(struct gspca_dev *gspca_dev,
         }
         cam->npkt = npkt[sd->sensor];
 
+        sd->brightness = BRIGHTNESS_DEF;
+        sd->contrast = CONTRAST_DEF;
+        sd->colors = COLOR_DEF;
         sd->hflip = HFLIP_DEF;
         sd->vflip = VFLIP_DEF;
-        if (sd->sensor == SENSOR_OV7670)
-                sd->flags |= FL_HFLIP | FL_VFLIP;
         sd->lightfreq = FREQ_DEF;
-        if (sd->sensor != SENSOR_OV7670)
-                gspca_dev->ctrl_dis = (1 << LIGHTFREQ_IDX);
-        switch (sd->sensor) {
-        case SENSOR_MI1310_SOC:
-        case SENSOR_MI1320_SOC:
-        case SENSOR_OV7660:
-        case SENSOR_OV7670:
-        case SENSOR_PO1200:
-                break;
-        default:
-                gspca_dev->ctrl_dis = (1 << HFLIP_IDX)
-                                        | (1 << VFLIP_IDX);
-                break;
-        }
-
         sd->sharpness = SHARPNESS_DEF;
 
+        gspca_dev->ctrl_dis = ctrl_dis[sd->sensor];
+
+        if (sd->sensor == SENSOR_OV7670)
+                sd->flags |= FL_HFLIP | FL_VFLIP;
+
         if (sd->bridge == BRIDGE_VC0321) {
                 reg_r(gspca_dev, 0x8a, 0, 3);
                 reg_w(dev, 0x87, 0x00, 0x0f0f);
@@ -2747,10 +3151,55 @@ static int sd_config(struct gspca_dev *gspca_dev,
 /* this function is called at probe and resume time */
 static int sd_init(struct gspca_dev *gspca_dev)
 {
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        if (sd->sensor == SENSOR_POxxxx) {
+                reg_r(gspca_dev, 0xa1, 0xb300, 1);
+                if (gspca_dev->usb_buf[0] != 0) {
+                        reg_w(gspca_dev->dev, 0xa0, 0x26, 0xb300);
+                        reg_w(gspca_dev->dev, 0xa0, 0x04, 0xb300);
+                        reg_w(gspca_dev->dev, 0xa0, 0x00, 0xb300);
+                }
+        }
         return 0;
 }
 
-/* some sensors only */
+static void setbrightness(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        u8 data;
+
+        if (gspca_dev->ctrl_dis & (1 << BRIGHTNESS_IDX))
+                return;
+        data = sd->brightness;
+        if (data >= 0x80)
+                data &= 0x7f;
+        else
+                data = 0xff ^ data;
+        i2c_write(gspca_dev, 0x98, &data, 1);
+}
+
+static void setcontrast(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        if (gspca_dev->ctrl_dis & (1 << CONTRAST_IDX))
+                return;
+        i2c_write(gspca_dev, 0x99, &sd->contrast, 1);
+}
+
+static void setcolors(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        u8 data;
+
+        if (gspca_dev->ctrl_dis & (1 << COLORS_IDX))
+                return;
+        data = sd->colors - (sd->colors >> 3) - 1;
+        i2c_write(gspca_dev, 0x94, &data, 1);
+        i2c_write(gspca_dev, 0x95, &sd->colors, 1);
+}
+
 static void sethvflip(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
@@ -2764,6 +3213,7 @@ static void sethvflip(struct gspca_dev *gspca_dev)
                 vflip = !vflip;
         switch (sd->sensor) {
         case SENSOR_MI1310_SOC:
+        case SENSOR_MI1320:
         case SENSOR_MI1320_SOC:
                 data[0] = data[1] = 0;          /* select page 0 */
                 i2c_write(gspca_dev, 0xf0, data, 2);
@@ -2801,18 +3251,29 @@ static void setlightfreq(struct gspca_dev *gspca_dev)
         usb_exchange(gspca_dev, ov7660_freq_tb[sd->lightfreq]);
 }
 
-/* po1200 only */
 static void setsharpness(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
         u8 data;
 
-        if (sd->sensor != SENSOR_PO1200)
-                return;
-        data = 0;
-        i2c_write(gspca_dev, 0x03, &data, 1);
-        data = 0xb5 + sd->sharpness * 3;
-        i2c_write(gspca_dev, 0x61, &data, 1);
+        switch (sd->sensor) {
+        case SENSOR_PO1200:
+                data = 0;
+                i2c_write(gspca_dev, 0x03, &data, 1);
+                if (sd->sharpness < 0)
+                        data = 0x6a;
+                else
+                        data = 0xb5 + sd->sharpness * 3;
+                i2c_write(gspca_dev, 0x61, &data, 1);
+                break;
+        case SENSOR_POxxxx:
+                if (sd->sharpness < 0)
+                        data = 0x7e;    /* def = max */
+                else
+                        data = 0x60 + sd->sharpness * 0x0f;
+                i2c_write(gspca_dev, 0x59, &data, 1);
+                break;
+        }
 }
 
 static int sd_start(struct gspca_dev *gspca_dev)
@@ -2922,12 +3383,27 @@ static int sd_start(struct gspca_dev *gspca_dev)
                 usb_exchange(gspca_dev, init);
                 init = po3130_rundata;
                 break;
-        default:
-/*      case SENSOR_PO1200: */
+        case SENSOR_PO1200:
                 GammaT = po1200_gamma;
                 MatrixT = po1200_matrix;
                 init = po1200_initVGA_data;
                 break;
+        default:
+/*      case SENSOR_POxxxx: */
+                usb_exchange(gspca_dev, poxxxx_init_common);
+                if (mode)
+                        init = poxxxx_initQVGA;
+                else
+                        init = poxxxx_initVGA;
+                usb_exchange(gspca_dev, init);
+                reg_r(gspca_dev, 0x8c, 0x0000, 3);
+                reg_w(gspca_dev->dev, 0xa0,
+                                gspca_dev->usb_buf[2] & 1 ? 0 : 1,
+                                0xb35c);
+                msleep(300);
+/*fixme: i2c read 04 and 05*/
+                init = poxxxx_init_end_1;
+                break;
         }
         usb_exchange(gspca_dev, init);
         if (GammaT && MatrixT) {
@@ -2936,7 +3412,6 @@ static int sd_start(struct gspca_dev *gspca_dev)
                 put_tab_to_reg(gspca_dev, GammaT, 17, 0xb86c);
                 put_tab_to_reg(gspca_dev, MatrixT, 9, 0xb82c);
 
-                /* set the led on 0x0892 0x0896 */
                 switch (sd->sensor) {
                 case SENSOR_PO1200:
                 case SENSOR_HV7131R:
@@ -2945,16 +3420,22 @@ static int sd_start(struct gspca_dev *gspca_dev)
                 case SENSOR_MI1310_SOC:
                         reg_w(gspca_dev->dev, 0x89, 0x058c, 0x0000);
                         break;
-                default:
-                        if (!(sd->flags & FL_SAMSUNG))
-                                reg_w(gspca_dev->dev, 0x89, 0xffff, 0xfdff);
-                        break;
                 }
                 msleep(100);
                 setsharpness(gspca_dev);
                 sethvflip(gspca_dev);
                 setlightfreq(gspca_dev);
         }
+        if (sd->sensor == SENSOR_POxxxx) {
+                setcolors(gspca_dev);
+                setbrightness(gspca_dev);
+                setcontrast(gspca_dev);
+
+                /* led on */
+                msleep(80);
+                reg_w(gspca_dev->dev, 0x89, 0xffff, 0xfdff);
+                usb_exchange(gspca_dev, poxxxx_init_end_2);
+        }
         return 0;
 }
 
@@ -2963,10 +3444,17 @@ static void sd_stopN(struct gspca_dev *gspca_dev)
         struct usb_device *dev = gspca_dev->dev;
         struct sd *sd = (struct sd *) gspca_dev;
 
-        if (sd->sensor == SENSOR_MI1310_SOC)
+        switch (sd->sensor) {
+        case SENSOR_MI1310_SOC:
                 reg_w(dev, 0x89, 0x058c, 0x00ff);
-        else if (!(sd->flags & FL_SAMSUNG))
-                reg_w(dev, 0x89, 0xffff, 0xffff);
+                break;
+        case SENSOR_POxxxx:
+                return;
+        default:
+                if (!(sd->flags & FL_SAMSUNG))
+                        reg_w(dev, 0x89, 0xffff, 0xffff);
+                break;
+        }
         reg_w(dev, 0xa0, 0x01, 0xb301);
         reg_w(dev, 0xa0, 0x09, 0xb003);
 }
@@ -2984,6 +3472,12 @@ static void sd_stop0(struct gspca_dev *gspca_dev)
                 reg_w(dev, 0x89, 0x058c, 0x00ff);
         else if (!(sd->flags & FL_SAMSUNG))
                 reg_w(dev, 0x89, 0xffff, 0xffff);
+
+        if (sd->sensor == SENSOR_POxxxx) {
+                reg_w(dev, 0xa0, 0x26, 0xb300);
+                reg_w(dev, 0xa0, 0x04, 0xb300);
+                reg_w(dev, 0xa0, 0x00, 0xb300);
+        }
 }
 
 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
@@ -3020,6 +3514,60 @@ static void sd_pkt_scan(struct gspca_dev *gspca_dev,
         gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
 }
 
+static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        sd->brightness = val;
+        if (gspca_dev->streaming)
+                setbrightness(gspca_dev);
+        return 0;
+}
+
+static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        *val = sd->brightness;
+        return 0;
+}
+
+static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        sd->contrast = val;
+        if (gspca_dev->streaming)
+                setcontrast(gspca_dev);
+        return 0;
+}
+
+static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        *val = sd->contrast;
+        return 0;
+}
+
+static int sd_setcolors(struct gspca_dev *gspca_dev, __s32 val)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        sd->colors = val;
+        if (gspca_dev->streaming)
+                setcolors(gspca_dev);
+        return 0;
+}
+
+static int sd_getcolors(struct gspca_dev *gspca_dev, __s32 *val)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        *val = sd->colors;
+        return 0;
+}
+
 static int sd_sethflip(struct gspca_dev *gspca_dev, __s32 val)
 {
         struct sd *sd = (struct sd *) gspca_dev;
diff --git a/drivers/media/video/gspca/zc3xx.c b/drivers/media/video/gspca/zc3xx.c
index 1a800fc1c00e..50986da3d912 100644
--- a/drivers/media/video/gspca/zc3xx.c
+++ b/drivers/media/video/gspca/zc3xx.c
@@ -1,9 +1,8 @@
 /*
- *      Z-Star/Vimicro zc301/zc302p/vc30x library
- *      Copyright (C) 2004 2005 2006 Michel Xhaard
- *              mxhaard@magic.fr
+ * Z-Star/Vimicro zc301/zc302p/vc30x library
  *
- * V4L2 by Jean-Francois Moine <http://moinejf.free.fr>
+ * Copyright (C) 2009-2010 Jean-Francois Moine <http://moinejf.free.fr>
+ * Copyright (C) 2004 2005 2006 Michel Xhaard mxhaard@magic.fr
  *
  * 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
@@ -22,10 +21,11 @@
 
 #define MODULE_NAME "zc3xx"
 
+#include <linux/input.h>
 #include "gspca.h"
 #include "jpeg.h"
 
-MODULE_AUTHOR("Michel Xhaard <mxhaard@users.sourceforge.net>, "
+MODULE_AUTHOR("Jean-Francois Moine <http://moinejf.free.fr>, "
                 "Serge A. Suchkov <Serge.A.S@tochka.ru>");
 MODULE_DESCRIPTION("GSPCA ZC03xx/VC3xx USB Camera Driver");
 MODULE_LICENSE("GPL");
@@ -39,18 +39,18 @@ static int force_sensor = -1;
 struct sd {
         struct gspca_dev gspca_dev;     /* !! must be the first item */
 
-        __u8 brightness;
-        __u8 contrast;
-        __u8 gamma;
-        __u8 autogain;
-        __u8 lightfreq;
-        __u8 sharpness;
+        u8 brightness;
+        u8 contrast;
+        u8 gamma;
+        u8 autogain;
+        u8 lightfreq;
+        u8 sharpness;
         u8 quality;                     /* image quality */
 #define QUALITY_MIN 40
 #define QUALITY_MAX 60
 #define QUALITY_DEF 50
 
-        signed char sensor;             /* Type of image sensor chip */
+        u8 sensor;              /* Type of image sensor chip */
 /* !! values used in different tables */
 #define SENSOR_ADCM2700 0
 #define SENSOR_CS2102 1
@@ -92,9 +92,8 @@ static int sd_getfreq(struct gspca_dev *gspca_dev, __s32 *val);
 static int sd_setsharpness(struct gspca_dev *gspca_dev, __s32 val);
 static int sd_getsharpness(struct gspca_dev *gspca_dev, __s32 *val);
 
-static struct ctrl sd_ctrls[] = {
+static const struct ctrl sd_ctrls[] = {
 #define BRIGHTNESS_IDX 0
-#define SD_BRIGHTNESS 0
         {
             {
                 .id      = V4L2_CID_BRIGHTNESS,
@@ -103,26 +102,26 @@ static struct ctrl sd_ctrls[] = {
                 .minimum = 0,
                 .maximum = 255,
                 .step    = 1,
-                .default_value = 128,
+#define BRIGHTNESS_DEF 128
+                .default_value = BRIGHTNESS_DEF,
             },
             .set = sd_setbrightness,
             .get = sd_getbrightness,
         },
-#define SD_CONTRAST 1
         {
             {
                 .id      = V4L2_CID_CONTRAST,
                 .type    = V4L2_CTRL_TYPE_INTEGER,
                 .name    = "Contrast",
                 .minimum = 0,
-                .maximum = 256,
+                .maximum = 255,
                 .step    = 1,
-                .default_value = 128,
+#define CONTRAST_DEF 128
+                .default_value = CONTRAST_DEF,
             },
             .set = sd_setcontrast,
             .get = sd_getcontrast,
         },
-#define SD_GAMMA 2
         {
             {
                 .id      = V4L2_CID_GAMMA,
@@ -136,7 +135,6 @@ static struct ctrl sd_ctrls[] = {
             .set = sd_setgamma,
             .get = sd_getgamma,
         },
-#define SD_AUTOGAIN 3
         {
             {
                 .id      = V4L2_CID_AUTOGAIN,
@@ -145,13 +143,13 @@ static struct ctrl sd_ctrls[] = {
                 .minimum = 0,
                 .maximum = 1,
                 .step    = 1,
-                .default_value = 1,
+#define AUTOGAIN_DEF 1
+                .default_value = AUTOGAIN_DEF,
             },
             .set = sd_setautogain,
             .get = sd_getautogain,
         },
 #define LIGHTFREQ_IDX 4
-#define SD_FREQ 4
         {
             {
                 .id      = V4L2_CID_POWER_LINE_FREQUENCY,
@@ -160,12 +158,12 @@ static struct ctrl sd_ctrls[] = {
                 .minimum = 0,
                 .maximum = 2,   /* 0: 0, 1: 50Hz, 2:60Hz */
                 .step    = 1,
-                .default_value = 1,
+#define FREQ_DEF 0
+                .default_value = FREQ_DEF,
             },
             .set = sd_setfreq,
             .get = sd_getfreq,
         },
-#define SD_SHARPNESS 5
         {
             {
                 .id      = V4L2_CID_SHARPNESS,
@@ -174,7 +172,8 @@ static struct ctrl sd_ctrls[] = {
                 .minimum = 0,
                 .maximum = 3,
                 .step    = 1,
-                .default_value = 2,
+#define SHARPNESS_DEF 2
+                .default_value = SHARPNESS_DEF,
             },
             .set = sd_setsharpness,
             .get = sd_getsharpness,
@@ -194,6 +193,19 @@ static const struct v4l2_pix_format vga_mode[] = {
                 .priv = 0},
 };
 
+static const struct v4l2_pix_format broken_vga_mode[] = {
+        {320, 232, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
+                .bytesperline = 320,
+                .sizeimage = 320 * 232 * 4 / 8 + 590,
+                .colorspace = V4L2_COLORSPACE_JPEG,
+                .priv = 1},
+        {640, 472, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
+                .bytesperline = 640,
+                .sizeimage = 640 * 472 * 3 / 8 + 590,
+                .colorspace = V4L2_COLORSPACE_JPEG,
+                .priv = 0},
+};
+
 static const struct v4l2_pix_format sif_mode[] = {
         {176, 144, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
                 .bytesperline = 176,
@@ -209,9 +221,9 @@ static const struct v4l2_pix_format sif_mode[] = {
 
 /* usb exchanges */
 struct usb_action {
-        __u8    req;
-        __u8    val;
-        __u16   idx;
+        u8      req;
+        u8      val;
+        u16     idx;
 };
 
 static const struct usb_action adcm2700_Initial[] = {
@@ -421,7 +433,7 @@ static const struct usb_action adcm2700_NoFliker[] = {
         {0xaa, 0xfe, 0x0010},                           /* 00,fe,10,aa */
         {}
 };
-static const struct usb_action cs2102_Initial[] = {     /* 320x240 */
+static const struct usb_action cs2102_InitialScale[] = {        /* 320x240 */
         {0xa0, 0x01, ZC3XX_R000_SYSTEMCONTROL},
         {0xa0, 0x10, ZC3XX_R002_CLOCKSELECT},
         {0xa0, 0x00, ZC3XX_R010_CMOSSENSORSELECT},
@@ -473,7 +485,7 @@ static const struct usb_action cs2102_Initial[] = {	/* 320x240 */
         {}
 };
 
-static const struct usb_action cs2102_InitialScale[] = {        /* 640x480 */
+static const struct usb_action cs2102_Initial[] = {     /* 640x480 */
         {0xa0, 0x01, ZC3XX_R000_SYSTEMCONTROL},
         {0xa0, 0x00, ZC3XX_R002_CLOCKSELECT},
         {0xa0, 0x00, ZC3XX_R010_CMOSSENSORSELECT},
@@ -524,7 +536,7 @@ static const struct usb_action cs2102_InitialScale[] = {	/* 640x480 */
         {0xa0, 0x00, 0x01ad},
         {}
 };
-static const struct usb_action cs2102_50HZ[] = {
+static const struct usb_action cs2102_50HZScale[] = {
         {0xa0, 0x00, ZC3XX_R019_AUTOADJUSTFPS},
         {0xaa, 0x23, 0x0001},
         {0xaa, 0x24, 0x005f},
@@ -546,7 +558,7 @@ static const struct usb_action cs2102_50HZ[] = {
         {0xa0, 0xff, ZC3XX_R020_HSYNC_3},
         {}
 };
-static const struct usb_action cs2102_50HZScale[] = {
+static const struct usb_action cs2102_50HZ[] = {
         {0xa0, 0x00, ZC3XX_R019_AUTOADJUSTFPS},
         {0xaa, 0x23, 0x0000},
         {0xaa, 0x24, 0x00af},
@@ -568,7 +580,7 @@ static const struct usb_action cs2102_50HZScale[] = {
         {0xa0, 0xff, ZC3XX_R020_HSYNC_3},
         {}
 };
-static const struct usb_action cs2102_60HZ[] = {
+static const struct usb_action cs2102_60HZScale[] = {
         {0xa0, 0x00, ZC3XX_R019_AUTOADJUSTFPS},
         {0xaa, 0x23, 0x0001},
         {0xaa, 0x24, 0x0055},
@@ -590,7 +602,7 @@ static const struct usb_action cs2102_60HZ[] = {
         {0xa0, 0xff, ZC3XX_R020_HSYNC_3},
         {}
 };
-static const struct usb_action cs2102_60HZScale[] = {
+static const struct usb_action cs2102_60HZ[] = {
         {0xa0, 0x00, ZC3XX_R019_AUTOADJUSTFPS},
         {0xaa, 0x23, 0x0000},
         {0xaa, 0x24, 0x00aa},
@@ -612,7 +624,7 @@ static const struct usb_action cs2102_60HZScale[] = {
         {0xa0, 0xff, ZC3XX_R020_HSYNC_3},
         {}
 };
-static const struct usb_action cs2102_NoFliker[] = {
+static const struct usb_action cs2102_NoFlikerScale[] = {
         {0xa0, 0x00, ZC3XX_R019_AUTOADJUSTFPS},
         {0xaa, 0x23, 0x0001},
         {0xaa, 0x24, 0x005f},
@@ -634,7 +646,7 @@ static const struct usb_action cs2102_NoFliker[] = {
         {0xa0, 0xff, ZC3XX_R020_HSYNC_3},
         {}
 };
-static const struct usb_action cs2102_NoFlikerScale[] = {
+static const struct usb_action cs2102_NoFliker[] = {
         {0xa0, 0x00, ZC3XX_R019_AUTOADJUSTFPS},
         {0xaa, 0x23, 0x0000},
         {0xaa, 0x24, 0x00af},
@@ -658,7 +670,7 @@ static const struct usb_action cs2102_NoFlikerScale[] = {
 };
 
 /* CS2102_KOCOM */
-static const struct usb_action cs2102K_Initial[] = {
+static const struct usb_action cs2102K_InitialScale[] = {
         {0xa0, 0x11, ZC3XX_R002_CLOCKSELECT},
         {0xa0, 0x03, ZC3XX_R008_CLOCKSETTING},
         {0xa0, 0x08, ZC3XX_R010_CMOSSENSORSELECT},
@@ -917,7 +929,7 @@ static const struct usb_action cs2102K_Initial[] = {
         {}
 };
 
-static const struct usb_action cs2102K_InitialScale[] = {
+static const struct usb_action cs2102K_Initial[] = {
         {0xa0, 0x01, ZC3XX_R000_SYSTEMCONTROL},
         {0xa0, 0x00, ZC3XX_R002_CLOCKSELECT},
         {0xa0, 0x03, ZC3XX_R008_CLOCKSETTING},
@@ -1495,7 +1507,7 @@ static const struct usb_action gc0305_NoFliker[] = {
         {}
 };
 
-static const struct usb_action hdcs2020xb_Initial[] = {
+static const struct usb_action hdcs2020b_InitialScale[] = {
         {0xa0, 0x01, ZC3XX_R000_SYSTEMCONTROL},
         {0xa0, 0x11, ZC3XX_R002_CLOCKSELECT},
         {0xa0, 0x03, ZC3XX_R008_CLOCKSETTING},  /* qtable 0x05 */
@@ -1627,7 +1639,7 @@ static const struct usb_action hdcs2020xb_Initial[] = {
         {0xa0, 0x40, ZC3XX_R118_BGAIN},
         {}
 };
-static const struct usb_action hdcs2020xb_InitialScale[] = {
+static const struct usb_action hdcs2020b_Initial[] = {
         {0xa0, 0x01, ZC3XX_R000_SYSTEMCONTROL},
         {0xa0, 0x00, ZC3XX_R002_CLOCKSELECT},
         {0xa0, 0x03, ZC3XX_R008_CLOCKSETTING},
@@ -1819,7 +1831,7 @@ static const struct usb_action hdcs2020b_NoFliker[] = {
         {}
 };
 
-static const struct usb_action hv7131bxx_Initial[] = {          /* 320x240 */
+static const struct usb_action hv7131b_InitialScale[] = {       /* 320x240 */
         {0xa0, 0x01, ZC3XX_R000_SYSTEMCONTROL},
         {0xa0, 0x10, ZC3XX_R002_CLOCKSELECT},
         {0xa0, 0x00, ZC3XX_R010_CMOSSENSORSELECT},
@@ -1866,7 +1878,7 @@ static const struct usb_action hv7131bxx_Initial[] = {		/* 320x240 */
         {}
 };
 
-static const struct usb_action hv7131bxx_InitialScale[] = {     /* 640x480*/
+static const struct usb_action hv7131b_Initial[] = {    /* 640x480*/
         {0xa0, 0x01, ZC3XX_R000_SYSTEMCONTROL},
         {0xa0, 0x00, ZC3XX_R002_CLOCKSELECT},
         {0xa0, 0x00, ZC3XX_R010_CMOSSENSORSELECT},
@@ -2063,7 +2075,7 @@ static const struct usb_action hv7131b_NoFlikerScale[] = { /* 320x240 */
         {}
 };
 
-static const struct usb_action hv7131cxx_Initial[] = {
+static const struct usb_action hv7131r_InitialScale[] = {
         {0xa0, 0x01, ZC3XX_R000_SYSTEMCONTROL},
         {0xa0, 0x10, ZC3XX_R002_CLOCKSELECT},
         {0xa0, 0x01, ZC3XX_R010_CMOSSENSORSELECT},
@@ -2157,7 +2169,7 @@ static const struct usb_action hv7131cxx_Initial[] = {
         {}
 };
 
-static const struct usb_action hv7131cxx_InitialScale[] = {
+static const struct usb_action hv7131r_Initial[] = {
         {0xa0, 0x01, ZC3XX_R000_SYSTEMCONTROL},
 
         {0xa0, 0x00, ZC3XX_R002_CLOCKSELECT},   /* diff */
@@ -2259,7 +2271,7 @@ static const struct usb_action hv7131cxx_InitialScale[] = {
         {}
 };
 
-static const struct usb_action icm105axx_Initial[] = {
+static const struct usb_action icm105a_InitialScale[] = {
         {0xa0, 0x01, ZC3XX_R000_SYSTEMCONTROL},
         {0xa0, 0x10, ZC3XX_R002_CLOCKSELECT},
         {0xa0, 0x03, ZC3XX_R008_CLOCKSETTING},
@@ -2436,7 +2448,7 @@ static const struct usb_action icm105axx_Initial[] = {
         {}
 };
 
-static const struct usb_action icm105axx_InitialScale[] = {
+static const struct usb_action icm105a_Initial[] = {
         {0xa0, 0x01, ZC3XX_R000_SYSTEMCONTROL},
         {0xa0, 0x00, ZC3XX_R002_CLOCKSELECT},
         {0xa0, 0x03, ZC3XX_R008_CLOCKSETTING},
@@ -2615,7 +2627,7 @@ static const struct usb_action icm105axx_InitialScale[] = {
         {0xa0, 0x40, ZC3XX_R118_BGAIN},
         {}
 };
-static const struct usb_action icm105a_50HZ[] = {
+static const struct usb_action icm105a_50HZScale[] = {
         {0xa0, 0x00, ZC3XX_R019_AUTOADJUSTFPS}, /* 00,19,00,cc */
         {0xaa, 0x0d, 0x0003}, /* 00,0d,03,aa */
         {0xaa, 0x0c, 0x0020}, /* 00,0c,20,aa */
@@ -2646,7 +2658,7 @@ static const struct usb_action icm105a_50HZ[] = {
         {0xa0, 0xff, ZC3XX_R020_HSYNC_3}, /* 00,20,ff,cc */
         {}
 };
-static const struct usb_action icm105a_50HZScale[] = {
+static const struct usb_action icm105a_50HZ[] = {
         {0xa0, 0x00, ZC3XX_R019_AUTOADJUSTFPS}, /* 00,19,00,cc */
         {0xaa, 0x0d, 0x0003}, /* 00,0d,03,aa */
         {0xaa, 0x0c, 0x008c}, /* 00,0c,8c,aa */
@@ -2679,7 +2691,7 @@ static const struct usb_action icm105a_50HZScale[] = {
         {0xa0, 0xc0, ZC3XX_R1A8_DIGITALGAIN}, /* 01,a8,c0,cc */
         {}
 };
-static const struct usb_action icm105a_60HZ[] = {
+static const struct usb_action icm105a_60HZScale[] = {
         {0xa0, 0x00, ZC3XX_R019_AUTOADJUSTFPS}, /* 00,19,00,cc */
         {0xaa, 0x0d, 0x0003}, /* 00,0d,03,aa */
         {0xaa, 0x0c, 0x0004}, /* 00,0c,04,aa */
@@ -2710,7 +2722,7 @@ static const struct usb_action icm105a_60HZ[] = {
         {0xa0, 0xff, ZC3XX_R020_HSYNC_3}, /* 00,20,ff,cc */
         {}
 };
-static const struct usb_action icm105a_60HZScale[] = {
+static const struct usb_action icm105a_60HZ[] = {
         {0xa0, 0x00, ZC3XX_R019_AUTOADJUSTFPS}, /* 00,19,00,cc */
         {0xaa, 0x0d, 0x0003}, /* 00,0d,03,aa */
         {0xaa, 0x0c, 0x0008}, /* 00,0c,08,aa */
@@ -2743,7 +2755,7 @@ static const struct usb_action icm105a_60HZScale[] = {
         {0xa0, 0xc0, ZC3XX_R1A8_DIGITALGAIN}, /* 01,a8,c0,cc */
         {}
 };
-static const struct usb_action icm105a_NoFliker[] = {
+static const struct usb_action icm105a_NoFlikerScale[] = {
         {0xa0, 0x00, ZC3XX_R019_AUTOADJUSTFPS}, /* 00,19,00,cc */
         {0xaa, 0x0d, 0x0003}, /* 00,0d,03,aa */
         {0xaa, 0x0c, 0x0004}, /* 00,0c,04,aa */
@@ -2774,7 +2786,7 @@ static const struct usb_action icm105a_NoFliker[] = {
         {0xa0, 0xff, ZC3XX_R020_HSYNC_3}, /* 00,20,ff,cc */
         {}
 };
-static const struct usb_action icm105a_NoFlikerScale[] = {
+static const struct usb_action icm105a_NoFliker[] = {
         {0xa0, 0x00, ZC3XX_R019_AUTOADJUSTFPS}, /* 00,19,00,cc */
         {0xaa, 0x0d, 0x0003}, /* 00,0d,03,aa */
         {0xaa, 0x0c, 0x0004}, /* 00,0c,04,aa */
@@ -2808,7 +2820,7 @@ static const struct usb_action icm105a_NoFlikerScale[] = {
         {}
 };
 
-static const struct usb_action MC501CB_InitialScale[] = {
+static const struct usb_action mc501cb_Initial[] = {
         {0xa0, 0x01, ZC3XX_R000_SYSTEMCONTROL}, /* 00,00,01,cc */
         {0xa0, 0x00, ZC3XX_R002_CLOCKSELECT}, /* 00,02,00,cc */
         {0xa0, 0x01, ZC3XX_R010_CMOSSENSORSELECT}, /* 00,10,01,cc */
@@ -2928,7 +2940,7 @@ static const struct usb_action MC501CB_InitialScale[] = {
         {}
 };
 
-static const struct usb_action MC501CB_Initial[] = {     /* 320x240 */
+static const struct usb_action mc501cb_InitialScale[] = {        /* 320x240 */
         {0xa0, 0x01, ZC3XX_R000_SYSTEMCONTROL}, /* 00,00,01,cc */
         {0xa0, 0x10, ZC3XX_R002_CLOCKSELECT}, /* 00,02,10,cc */
         {0xa0, 0x01, ZC3XX_R010_CMOSSENSORSELECT}, /* 00,10,01,cc */
@@ -3047,7 +3059,7 @@ static const struct usb_action MC501CB_Initial[] = {	 /* 320x240 */
         {}
 };
 
-static const struct usb_action MC501CB_50HZ[] = {
+static const struct usb_action mc501cb_50HZScale[] = {
         {0xaa, 0x03, 0x0003}, /* 00,03,03,aa */
         {0xaa, 0x10, 0x00fc}, /* 00,10,fc,aa */
         {0xaa, 0x36, 0x001d}, /* 00,36,1D,aa */
@@ -3064,7 +3076,7 @@ static const struct usb_action MC501CB_50HZ[] = {
         {}
 };
 
-static const struct usb_action MC501CB_50HZScale[] = {
+static const struct usb_action mc501cb_50HZ[] = {
         {0xaa, 0x03, 0x0003}, /* 00,03,03,aa */
         {0xaa, 0x10, 0x00fc}, /* 00,10,fc,aa */
         {0xaa, 0x36, 0x003a}, /* 00,36,3A,aa */
@@ -3081,7 +3093,7 @@ static const struct usb_action MC501CB_50HZScale[] = {
         {}
 };
 
-static const struct usb_action MC501CB_60HZ[] = {
+static const struct usb_action mc501cb_60HZScale[] = {
         {0xaa, 0x03, 0x0003}, /* 00,03,03,aa */
         {0xaa, 0x10, 0x00fc}, /* 00,10,fc,aa */
         {0xaa, 0x36, 0x0018}, /* 00,36,18,aa */
@@ -3098,7 +3110,7 @@ static const struct usb_action MC501CB_60HZ[] = {
         {}
 };
 
-static const struct usb_action MC501CB_60HZScale[] = {
+static const struct usb_action mc501cb_60HZ[] = {
         {0xaa, 0x03, 0x0003}, /* 00,03,03,aa */
         {0xaa, 0x10, 0x00fc}, /* 00,10,fc,aa */
         {0xaa, 0x36, 0x0030}, /* 00,36,30,aa */
@@ -3115,7 +3127,7 @@ static const struct usb_action MC501CB_60HZScale[] = {
         {}
 };
 
-static const struct usb_action MC501CB_NoFliker[] = {
+static const struct usb_action mc501cb_NoFlikerScale[] = {
         {0xaa, 0x03, 0x0003}, /* 00,03,03,aa */
         {0xaa, 0x10, 0x00fc}, /* 00,10,fc,aa */
         {0xaa, 0x36, 0x0018}, /* 00,36,18,aa */
@@ -3132,7 +3144,7 @@ static const struct usb_action MC501CB_NoFliker[] = {
         {}
 };
 
-static const struct usb_action MC501CB_NoFlikerScale[] = {
+static const struct usb_action mc501cb_NoFliker[] = {
         {0xaa, 0x03, 0x0003}, /* 00,03,03,aa */
         {0xaa, 0x10, 0x00fc}, /* 00,10,fc,aa */
         {0xaa, 0x36, 0x0030}, /* 00,36,30,aa */
@@ -3144,8 +3156,8 @@ static const struct usb_action MC501CB_NoFlikerScale[] = {
         {}
 };
 
-/* from zs211.inf - HKR,%OV7620%,Initial - 640x480 */
-static const struct usb_action OV7620_mode0[] = {
+/* from zs211.inf */
+static const struct usb_action ov7620_Initial[] = {     /* 640x480 */
         {0xa0, 0x01, ZC3XX_R000_SYSTEMCONTROL}, /* 00,00,01,cc */
         {0xa0, 0x40, ZC3XX_R002_CLOCKSELECT}, /* 00,02,40,cc */
         {0xa0, 0x00, ZC3XX_R008_CLOCKSETTING}, /* 00,08,00,cc */
@@ -3214,9 +3226,7 @@ static const struct usb_action OV7620_mode0[] = {
         {0xa0, 0x50, ZC3XX_R1A8_DIGITALGAIN}, /* 01,a8,50,cc */
         {}
 };
-
-/* from zs211.inf - HKR,%OV7620%,InitialScale - 320x240 */
-static const struct usb_action OV7620_mode1[] = {
+static const struct usb_action ov7620_InitialScale[] = {        /* 320x240 */
         {0xa0, 0x01, ZC3XX_R000_SYSTEMCONTROL}, /* 00,00,01,cc */
         {0xa0, 0x50, ZC3XX_R002_CLOCKSELECT},   /* 00,02,50,cc */
         {0xa0, 0x03, ZC3XX_R008_CLOCKSETTING},  /* 00,08,00,cc */
@@ -3287,9 +3297,7 @@ static const struct usb_action OV7620_mode1[] = {
         {0xa0, 0x50, ZC3XX_R1A8_DIGITALGAIN},   /* 01,a8,50,cc */
         {}
 };
-
-/* from zs211.inf - HKR,%OV7620%\AE,50HZ */
-static const struct usb_action OV7620_50HZ[] = {
+static const struct usb_action ov7620_50HZ[] = {
         {0xaa, 0x13, 0x00a3},   /* 00,13,a3,aa */
         {0xdd, 0x00, 0x0100},   /* 00,01,00,dd */
         {0xaa, 0x2b, 0x0096},   /* 00,2b,96,aa */
@@ -3307,9 +3315,7 @@ static const struct usb_action OV7620_50HZ[] = {
                                                          if mode0 (640x480) */
         {}
 };
-
-/* from zs211.inf - HKR,%OV7620%\AE,60HZ */
-static const struct usb_action OV7620_60HZ[] = {
+static const struct usb_action ov7620_60HZ[] = {
         {0xaa, 0x13, 0x00a3},                   /* 00,13,a3,aa */
                                                 /* (bug in zs211.inf) */
         {0xdd, 0x00, 0x0100},                   /* 00,01,00,dd */
@@ -3331,9 +3337,7 @@ static const struct usb_action OV7620_60HZ[] = {
         {0xa1, 0x01, 0x0037},           */
         {}
 };
-
-/* from zs211.inf - HKR,%OV7620%\AE,NoFliker */
-static const struct usb_action OV7620_NoFliker[] = {
+static const struct usb_action ov7620_NoFliker[] = {
         {0xaa, 0x13, 0x00a3},                   /* 00,13,a3,aa */
                                                 /* (bug in zs211.inf) */
         {0xdd, 0x00, 0x0100},                   /* 00,01,00,dd */
@@ -3354,7 +3358,7 @@ static const struct usb_action OV7620_NoFliker[] = {
         {}
 };
 
-static const struct usb_action ov7630c_Initial[] = {
+static const struct usb_action ov7630c_InitialScale[] = {
         {0xa0, 0x01, ZC3XX_R000_SYSTEMCONTROL},
         {0xa0, 0x10, ZC3XX_R002_CLOCKSELECT},
         {0xa0, 0x01, ZC3XX_R000_SYSTEMCONTROL},
@@ -3511,7 +3515,7 @@ static const struct usb_action ov7630c_Initial[] = {
         {}
 };
 
-static const struct usb_action ov7630c_InitialScale[] = {
+static const struct usb_action ov7630c_Initial[] = {
         {0xa0, 0x01, ZC3XX_R000_SYSTEMCONTROL},
         {0xa0, 0x00, ZC3XX_R002_CLOCKSELECT},
         {0xa0, 0x03, ZC3XX_R008_CLOCKSETTING},
@@ -3682,7 +3686,7 @@ static const struct usb_action pas106b_Initial_com[] = {
         {}
 };
 
-static const struct usb_action pas106b_Initial[] = {    /* 176x144 */
+static const struct usb_action pas106b_InitialScale[] = {       /* 176x144 */
 /* JPEG control */
         {0xa0, 0x03, ZC3XX_R008_CLOCKSETTING},
 /* Sream and Sensor specific */
@@ -3800,7 +3804,7 @@ static const struct usb_action pas106b_Initial[] = {	/* 176x144 */
         {}
 };
 
-static const struct usb_action pas106b_InitialScale[] = {       /* 352x288 */
+static const struct usb_action pas106b_Initial[] = {    /* 352x288 */
 /* JPEG control */
         {0xa0, 0x03, ZC3XX_R008_CLOCKSETTING},
 /* Sream and Sensor specific */
@@ -3972,10 +3976,10 @@ static const struct usb_action pas106b_NoFliker[] = {
         {}
 };
 
-/* from usbvm31b.inf */
+/* from lvWIMv.inf 046d:08a2/:08aa 2007/06/03 */
 static const struct usb_action pas202b_Initial[] = {    /* 640x480 */
         {0xa0, 0x01, ZC3XX_R000_SYSTEMCONTROL},         /* 00,00,01,cc */
-        {0xa0, 0x00, ZC3XX_R008_CLOCKSETTING},          /* 00,08,00,cc */
+        {0xa0, 0x03, ZC3XX_R008_CLOCKSETTING},
         {0xa0, 0x0e, ZC3XX_R010_CMOSSENSORSELECT},      /* 00,10,0e,cc */
         {0xa0, 0x00, ZC3XX_R002_CLOCKSELECT},           /* 00,02,00,cc */
         {0xa0, 0x02, ZC3XX_R003_FRAMEWIDTHHIGH},        /* 00,03,02,cc */
@@ -4000,7 +4004,7 @@ static const struct usb_action pas202b_Initial[] = {	/* 640x480 */
         {0xaa, 0x09, 0x0006},                           /* 00,09,06,aa */
         {0xaa, 0x0a, 0x0001},                           /* 00,0a,01,aa */
         {0xaa, 0x0b, 0x0001},                           /* 00,0b,01,aa */
-        {0xaa, 0x0c, 0x0008},                           /* 00,0c,08,aa */
+        {0xaa, 0x0c, 0x0006},
         {0xaa, 0x0d, 0x0000},                           /* 00,0d,00,aa */
         {0xaa, 0x10, 0x0000},                           /* 00,10,00,aa */
         {0xaa, 0x12, 0x0005},                           /* 00,12,05,aa */
@@ -4019,13 +4023,13 @@ static const struct usb_action pas202b_Initial[] = {	/* 640x480 */
 };
 static const struct usb_action pas202b_InitialScale[] = {       /* 320x240 */
         {0xa0, 0x01, ZC3XX_R000_SYSTEMCONTROL},         /* 00,00,01,cc */
-        {0xa0, 0x00, ZC3XX_R008_CLOCKSETTING},          /* 00,08,00,cc */
+        {0xa0, 0x03, ZC3XX_R008_CLOCKSETTING},
         {0xa0, 0x0e, ZC3XX_R010_CMOSSENSORSELECT},      /* 00,10,0e,cc */
         {0xa0, 0x10, ZC3XX_R002_CLOCKSELECT},           /* 00,02,10,cc */
         {0xa0, 0x02, ZC3XX_R003_FRAMEWIDTHHIGH},        /* 00,03,02,cc */
         {0xa0, 0x80, ZC3XX_R004_FRAMEWIDTHLOW},         /* 00,04,80,cc */
         {0xa0, 0x01, ZC3XX_R005_FRAMEHEIGHTHIGH},       /* 00,05,01,cc */
-        {0xa0, 0xd0, ZC3XX_R006_FRAMEHEIGHTLOW},        /* 00,06,d0,cc */
+        {0xa0, 0xe0, ZC3XX_R006_FRAMEHEIGHTLOW},
         {0xa0, 0x01, ZC3XX_R001_SYSTEMOPERATING},       /* 00,01,01,cc */
         {0xa0, 0x03, ZC3XX_R012_VIDEOCONTROLFUNC},      /* 00,12,03,cc */
         {0xa0, 0x01, ZC3XX_R012_VIDEOCONTROLFUNC},      /* 00,12,01,cc */
@@ -4035,7 +4039,7 @@ static const struct usb_action pas202b_InitialScale[] = {	/* 320x240 */
         {0xa0, 0x08, ZC3XX_R11A_FIRSTYLOW},             /* 01,1a,08,cc */
         {0xa0, 0x02, ZC3XX_R11C_FIRSTXLOW},             /* 01,1c,02,cc */
         {0xa0, 0x01, ZC3XX_R09B_WINHEIGHTHIGH},         /* 00,9b,01,cc */
-        {0xa0, 0xd8, ZC3XX_R09C_WINHEIGHTLOW},          /* 00,9c,d8,cc */
+        {0xa0, 0xe8, ZC3XX_R09C_WINHEIGHTLOW},
         {0xa0, 0x02, ZC3XX_R09D_WINWIDTHHIGH},          /* 00,9d,02,cc */
         {0xa0, 0x88, ZC3XX_R09E_WINWIDTHLOW},           /* 00,9e,88,cc */
         {0xaa, 0x02, 0x0002},                           /* 00,02,02,aa */
@@ -4044,7 +4048,7 @@ static const struct usb_action pas202b_InitialScale[] = {	/* 320x240 */
         {0xaa, 0x09, 0x0006},                           /* 00,09,06,aa */
         {0xaa, 0x0a, 0x0001},                           /* 00,0a,01,aa */
         {0xaa, 0x0b, 0x0001},                           /* 00,0b,01,aa */
-        {0xaa, 0x0c, 0x0008},                           /* 00,0c,08,aa */
+        {0xaa, 0x0c, 0x0006},
         {0xaa, 0x0d, 0x0000},                           /* 00,0d,00,aa */
         {0xaa, 0x10, 0x0000},                           /* 00,10,00,aa */
         {0xaa, 0x12, 0x0005},                           /* 00,12,05,aa */
@@ -4059,6 +4063,8 @@ static const struct usb_action pas202b_InitialScale[] = {	/* 320x240 */
         {0xa0, 0x08, ZC3XX_R250_DEADPIXELSMODE},        /* 02,50,08,cc */
         {0xa0, 0x08, ZC3XX_R301_EEPROMACCESS},          /* 03,01,08,cc */
         {0xa0, 0x70, ZC3XX_R18D_YTARGET},               /* 01,8d,70,cc */
+        {0xa0, 0xff, ZC3XX_R097_WINYSTARTHIGH},
+        {0xa0, 0xfe, ZC3XX_R098_WINYSTARTLOW},
         {}
 };
 static const struct usb_action pas202b_50HZ[] = {
@@ -4066,22 +4072,22 @@ static const struct usb_action pas202b_50HZ[] = {
         {0xa0, 0x20, ZC3XX_R087_EXPTIMEMID},            /* 00,87,20,cc */
         {0xa0, 0x21, ZC3XX_R088_EXPTIMELOW},            /* 00,88,21,cc */
         {0xaa, 0x20, 0x0002},                           /* 00,20,02,aa */
-        {0xaa, 0x21, 0x0068},                           /* 00,21,68,aa */
+        {0xaa, 0x21, 0x001b},
         {0xaa, 0x03, 0x0044},                           /* 00,03,44,aa */
-        {0xaa, 0x04, 0x0009},                           /* 00,04,09,aa */
-        {0xaa, 0x05, 0x0028},                           /* 00,05,28,aa */
+        {0xaa, 0x04, 0x0008},
+        {0xaa, 0x05, 0x001b},
         {0xaa, 0x0e, 0x0001},                           /* 00,0e,01,aa */
         {0xaa, 0x0f, 0x0000},                           /* 00,0f,00,aa */
-        {0xa0, 0x14, ZC3XX_R1A9_DIGITALLIMITDIFF},      /* 01,a9,14,cc */
+        {0xa0, 0x1c, ZC3XX_R1A9_DIGITALLIMITDIFF},
         {0xa0, 0x24, ZC3XX_R1AA_DIGITALGAINSTEP},       /* 01,aa,24,cc */
         {0xa0, 0x00, ZC3XX_R190_EXPOSURELIMITHIGH},     /* 01,90,00,cc */
-        {0xa0, 0x07, ZC3XX_R191_EXPOSURELIMITMID},      /* 01,91,07,cc */
-        {0xa0, 0xd2, ZC3XX_R192_EXPOSURELIMITLOW},      /* 01,92,d2,cc */
+        {0xa0, 0x02, ZC3XX_R191_EXPOSURELIMITMID},
+        {0xa0, 0x1b, ZC3XX_R192_EXPOSURELIMITLOW},
         {0xa0, 0x00, ZC3XX_R195_ANTIFLICKERHIGH},       /* 01,95,00,cc */
         {0xa0, 0x00, ZC3XX_R196_ANTIFLICKERMID},        /* 01,96,00,cc */
         {0xa0, 0x4d, ZC3XX_R197_ANTIFLICKERLOW},        /* 01,97,4d,cc */
-        {0xa0, 0x10, ZC3XX_R18C_AEFREEZE},              /* 01,8c,10,cc */
-        {0xa0, 0x20, ZC3XX_R18F_AEUNFREEZE},            /* 01,8f,20,cc */
+        {0xa0, 0x0e, ZC3XX_R18C_AEFREEZE},
+        {0xa0, 0x1b, ZC3XX_R18F_AEUNFREEZE},
         {0xa0, 0x44, ZC3XX_R01D_HSYNC_0},               /* 00,1d,44,cc */
         {0xa0, 0x6f, ZC3XX_R01E_HSYNC_1},               /* 00,1e,6f,cc */
         {0xa0, 0xad, ZC3XX_R01F_HSYNC_2},               /* 00,1f,ad,cc */
@@ -4094,23 +4100,23 @@ static const struct usb_action pas202b_50HZScale[] = {
         {0xa0, 0x00, ZC3XX_R019_AUTOADJUSTFPS},         /* 00,19,00,cc */
         {0xa0, 0x20, ZC3XX_R087_EXPTIMEMID},            /* 00,87,20,cc */
         {0xa0, 0x21, ZC3XX_R088_EXPTIMELOW},            /* 00,88,21,cc */
-        {0xaa, 0x20, 0x0002},                           /* 00,20,02,aa */
-        {0xaa, 0x21, 0x006c},                           /* 00,21,6c,aa */
+        {0xaa, 0x20, 0x0004},
+        {0xaa, 0x21, 0x003d},
         {0xaa, 0x03, 0x0041},                           /* 00,03,41,aa */
-        {0xaa, 0x04, 0x0009},                           /* 00,04,09,aa */
-        {0xaa, 0x05, 0x002c},                           /* 00,05,2c,aa */
+        {0xaa, 0x04, 0x0010},
+        {0xaa, 0x05, 0x003d},
         {0xaa, 0x0e, 0x0001},                           /* 00,0e,01,aa */
         {0xaa, 0x0f, 0x0000},                           /* 00,0f,00,aa */
-        {0xa0, 0x14, ZC3XX_R1A9_DIGITALLIMITDIFF},      /* 01,a9,14,cc */
+        {0xa0, 0x1c, ZC3XX_R1A9_DIGITALLIMITDIFF},
         {0xa0, 0x24, ZC3XX_R1AA_DIGITALGAINSTEP},       /* 01,aa,24,cc */
         {0xa0, 0x00, ZC3XX_R190_EXPOSURELIMITHIGH},     /* 01,90,00,cc */
-        {0xa0, 0x0f, ZC3XX_R191_EXPOSURELIMITMID},      /* 01,91,0f,cc */
-        {0xa0, 0xbe, ZC3XX_R192_EXPOSURELIMITLOW},      /* 01,92,be,cc */
+        {0xa0, 0x04, ZC3XX_R191_EXPOSURELIMITMID},
+        {0xa0, 0x3d, ZC3XX_R192_EXPOSURELIMITLOW},
         {0xa0, 0x00, ZC3XX_R195_ANTIFLICKERHIGH},       /* 01,95,00,cc */
         {0xa0, 0x00, ZC3XX_R196_ANTIFLICKERMID},        /* 01,96,00,cc */
         {0xa0, 0x9b, ZC3XX_R197_ANTIFLICKERLOW},        /* 01,97,9b,cc */
-        {0xa0, 0x10, ZC3XX_R18C_AEFREEZE},              /* 01,8c,10,cc */
-        {0xa0, 0x20, ZC3XX_R18F_AEUNFREEZE},            /* 01,8f,20,cc */
+        {0xa0, 0x0e, ZC3XX_R18C_AEFREEZE},
+        {0xa0, 0x1b, ZC3XX_R18F_AEUNFREEZE},
         {0xa0, 0x41, ZC3XX_R01D_HSYNC_0},               /* 00,1d,41,cc */
         {0xa0, 0x6f, ZC3XX_R01E_HSYNC_1},               /* 00,1e,6f,cc */
         {0xa0, 0xad, ZC3XX_R01F_HSYNC_2},               /* 00,1f,ad,cc */
@@ -4130,16 +4136,16 @@ static const struct usb_action pas202b_60HZ[] = {
         {0xaa, 0x05, 0x0000},                           /* 00,05,00,aa */
         {0xaa, 0x0e, 0x0001},                           /* 00,0e,01,aa */
         {0xaa, 0x0f, 0x0000},                           /* 00,0f,00,aa */
-        {0xa0, 0x14, ZC3XX_R1A9_DIGITALLIMITDIFF},      /* 01,a9,14,cc */
+        {0xa0, 0x1c, ZC3XX_R1A9_DIGITALLIMITDIFF},
         {0xa0, 0x24, ZC3XX_R1AA_DIGITALGAINSTEP},       /* 01,aa,24,cc */
         {0xa0, 0x00, ZC3XX_R190_EXPOSURELIMITHIGH},     /* 01,90,00,cc */
-        {0xa0, 0x07, ZC3XX_R191_EXPOSURELIMITMID},      /* 01,91,07,cc */
-        {0xa0, 0xc0, ZC3XX_R192_EXPOSURELIMITLOW},      /* 01,92,c0,cc */
+        {0xa0, 0x02, ZC3XX_R191_EXPOSURELIMITMID},
+        {0xa0, 0x00, ZC3XX_R192_EXPOSURELIMITLOW},
         {0xa0, 0x00, ZC3XX_R195_ANTIFLICKERHIGH},       /* 01,95,00,cc */
         {0xa0, 0x00, ZC3XX_R196_ANTIFLICKERMID},        /* 01,96,00,cc */
         {0xa0, 0x40, ZC3XX_R197_ANTIFLICKERLOW},        /* 01,97,40,cc */
-        {0xa0, 0x10, ZC3XX_R18C_AEFREEZE},              /* 01,8c,10,cc */
-        {0xa0, 0x20, ZC3XX_R18F_AEUNFREEZE},            /* 01,8f,20,cc */
+        {0xa0, 0x0e, ZC3XX_R18C_AEFREEZE},
+        {0xa0, 0x1b, ZC3XX_R18F_AEUNFREEZE},
         {0xa0, 0x45, ZC3XX_R01D_HSYNC_0},               /* 00,1d,45,cc */
         {0xa0, 0x8e, ZC3XX_R01E_HSYNC_1},               /* 00,1e,8e,cc */
         {0xa0, 0xc1, ZC3XX_R01F_HSYNC_2},               /* 00,1f,c1,cc */
@@ -4152,23 +4158,23 @@ static const struct usb_action pas202b_60HZScale[] = {
         {0xa0, 0x00, ZC3XX_R019_AUTOADJUSTFPS},         /* 00,19,00,cc */
         {0xa0, 0x20, ZC3XX_R087_EXPTIMEMID},            /* 00,87,20,cc */
         {0xa0, 0x21, ZC3XX_R088_EXPTIMELOW},            /* 00,88,21,cc */
-        {0xaa, 0x20, 0x0002},                           /* 00,20,02,aa */
-        {0xaa, 0x21, 0x0004},                           /* 00,21,04,aa */
+        {0xaa, 0x20, 0x0004},
+        {0xaa, 0x21, 0x0008},
         {0xaa, 0x03, 0x0042},                           /* 00,03,42,aa */
-        {0xaa, 0x04, 0x0008},                           /* 00,04,08,aa */
-        {0xaa, 0x05, 0x0004},                           /* 00,05,04,aa */
+        {0xaa, 0x04, 0x0010},
+        {0xaa, 0x05, 0x0008},
         {0xaa, 0x0e, 0x0001},                           /* 00,0e,01,aa */
         {0xaa, 0x0f, 0x0000},                           /* 00,0f,00,aa */
-        {0xa0, 0x14, ZC3XX_R1A9_DIGITALLIMITDIFF},      /* 01,a9,14,cc */
+        {0xa0, 0x1c, ZC3XX_R1A9_DIGITALLIMITDIFF},
         {0xa0, 0x24, ZC3XX_R1AA_DIGITALGAINSTEP},       /* 01,aa,24,cc */
         {0xa0, 0x00, ZC3XX_R190_EXPOSURELIMITHIGH},     /* 01,90,00,cc */
-        {0xa0, 0x0f, ZC3XX_R191_EXPOSURELIMITMID},      /* 01,91,0f,cc */
-        {0xa0, 0x9f, ZC3XX_R192_EXPOSURELIMITLOW},      /* 01,92,9f,cc */
+        {0xa0, 0x04, ZC3XX_R191_EXPOSURELIMITMID},
+        {0xa0, 0x08, ZC3XX_R192_EXPOSURELIMITLOW},
         {0xa0, 0x00, ZC3XX_R195_ANTIFLICKERHIGH},       /* 01,95,00,cc */
         {0xa0, 0x00, ZC3XX_R196_ANTIFLICKERMID},        /* 01,96,00,cc */
         {0xa0, 0x81, ZC3XX_R197_ANTIFLICKERLOW},        /* 01,97,81,cc */
-        {0xa0, 0x10, ZC3XX_R18C_AEFREEZE},              /* 01,8c,10,cc */
-        {0xa0, 0x20, ZC3XX_R18F_AEUNFREEZE},            /* 01,8f,20,cc */
+        {0xa0, 0x0e, ZC3XX_R18C_AEFREEZE},
+        {0xa0, 0x1b, ZC3XX_R18F_AEUNFREEZE},
         {0xa0, 0x42, ZC3XX_R01D_HSYNC_0},               /* 00,1d,42,cc */
         {0xa0, 0x6f, ZC3XX_R01E_HSYNC_1},               /* 00,1e,6f,cc */
         {0xa0, 0xaf, ZC3XX_R01F_HSYNC_2},               /* 00,1f,af,cc */
@@ -4182,22 +4188,22 @@ static const struct usb_action pas202b_NoFliker[] = {
         {0xa0, 0x20, ZC3XX_R087_EXPTIMEMID},            /* 00,87,20,cc */
         {0xa0, 0x21, ZC3XX_R088_EXPTIMELOW},            /* 00,88,21,cc */
         {0xaa, 0x20, 0x0002},                           /* 00,20,02,aa */
-        {0xaa, 0x21, 0x0020},                           /* 00,21,20,aa */
+        {0xaa, 0x21, 0x0006},
         {0xaa, 0x03, 0x0040},                           /* 00,03,40,aa */
         {0xaa, 0x04, 0x0008},                           /* 00,04,08,aa */
-        {0xaa, 0x05, 0x0020},                           /* 00,05,20,aa */
+        {0xaa, 0x05, 0x0006},
         {0xaa, 0x0e, 0x0001},                           /* 00,0e,01,aa */
         {0xaa, 0x0f, 0x0000},                           /* 00,0f,00,aa */
         {0xa0, 0x00, ZC3XX_R190_EXPOSURELIMITHIGH},     /* 01,90,00,cc */
-        {0xa0, 0x07, ZC3XX_R191_EXPOSURELIMITMID},      /* 01,91,07,cc */
-        {0xa0, 0xf0, ZC3XX_R192_EXPOSURELIMITLOW},      /* 01,92,f0,cc */
+        {0xa0, 0x02, ZC3XX_R191_EXPOSURELIMITMID},
+        {0xa0, 0x06, ZC3XX_R192_EXPOSURELIMITLOW},
         {0xa0, 0x00, ZC3XX_R195_ANTIFLICKERHIGH},       /* 01,95,00,cc */
         {0xa0, 0x00, ZC3XX_R196_ANTIFLICKERMID},        /* 01,96,00,cc */
-        {0xa0, 0x02, ZC3XX_R197_ANTIFLICKERLOW},        /* 01,97,02,cc */
+        {0xa0, 0x01, ZC3XX_R197_ANTIFLICKERLOW},
         {0xa0, 0x10, ZC3XX_R18C_AEFREEZE},              /* 01,8c,10,cc */
         {0xa0, 0x20, ZC3XX_R18F_AEUNFREEZE},            /* 01,8f,20,cc */
         {0xa0, 0x00, ZC3XX_R1A9_DIGITALLIMITDIFF},      /* 01,a9,00,cc */
-        {0xa0, 0x00, ZC3XX_R1AA_DIGITALGAINSTEP},       /* 01,aa,00,cc */
+        {0xa0, 0x24, ZC3XX_R1AA_DIGITALGAINSTEP},
         {0xa0, 0x40, ZC3XX_R01D_HSYNC_0},               /* 00,1d,40,cc */
         {0xa0, 0x60, ZC3XX_R01E_HSYNC_1},               /* 00,1e,60,cc */
         {0xa0, 0x90, ZC3XX_R01F_HSYNC_2},               /* 00,1f,90,cc */
@@ -4210,23 +4216,23 @@ static const struct usb_action pas202b_NoFlikerScale[] = {
         {0xa0, 0x00, ZC3XX_R019_AUTOADJUSTFPS},         /* 00,19,00,cc */
         {0xa0, 0x20, ZC3XX_R087_EXPTIMEMID},            /* 00,87,20,cc */
         {0xa0, 0x21, ZC3XX_R088_EXPTIMELOW},            /* 00,88,21,cc */
-        {0xaa, 0x20, 0x0002},                           /* 00,20,02,aa */
-        {0xaa, 0x21, 0x0010},                           /* 00,21,10,aa */
+        {0xaa, 0x20, 0x0004},
+        {0xaa, 0x21, 0x000c},
         {0xaa, 0x03, 0x0040},                           /* 00,03,40,aa */
-        {0xaa, 0x04, 0x0008},                           /* 00,04,08,aa */
-        {0xaa, 0x05, 0x0010},                           /* 00,05,10,aa */
+        {0xaa, 0x04, 0x0010},
+        {0xaa, 0x05, 0x000c},
         {0xaa, 0x0e, 0x0001},                           /* 00,0e,01,aa */
         {0xaa, 0x0f, 0x0000},                           /* 00,0f,00,aa */
         {0xa0, 0x00, ZC3XX_R190_EXPOSURELIMITHIGH},     /* 01,90,00,cc */
-        {0xa0, 0x0f, ZC3XX_R191_EXPOSURELIMITMID},      /* 01,91,0f,cc */
-        {0xa0, 0xf0, ZC3XX_R192_EXPOSURELIMITLOW},      /* 01,92,f0,cc */
+        {0xa0, 0x04, ZC3XX_R191_EXPOSURELIMITMID},
+        {0xa0, 0x0c, ZC3XX_R192_EXPOSURELIMITLOW},
         {0xa0, 0x00, ZC3XX_R195_ANTIFLICKERHIGH},       /* 01,95,00,cc */
         {0xa0, 0x00, ZC3XX_R196_ANTIFLICKERMID},        /* 01,96,00,cc */
         {0xa0, 0x02, ZC3XX_R197_ANTIFLICKERLOW},        /* 01,97,02,cc */
         {0xa0, 0x10, ZC3XX_R18C_AEFREEZE},              /* 01,8c,10,cc */
         {0xa0, 0x20, ZC3XX_R18F_AEUNFREEZE},            /* 01,8f,20,cc */
         {0xa0, 0x00, ZC3XX_R1A9_DIGITALLIMITDIFF},      /* 01,a9,00,cc */
-        {0xa0, 0x00, ZC3XX_R1AA_DIGITALGAINSTEP},       /* 01,aa,00,cc */
+        {0xa0, 0x24, ZC3XX_R1AA_DIGITALGAINSTEP},
         {0xa0, 0x40, ZC3XX_R01D_HSYNC_0},               /* 00,1d,40,cc */
         {0xa0, 0x60, ZC3XX_R01E_HSYNC_1},               /* 00,1e,60,cc */
         {0xa0, 0x90, ZC3XX_R01F_HSYNC_2},               /* 00,1f,90,cc */
@@ -4713,8 +4719,8 @@ static const struct usb_action pb0330_NoFlikerScale[] = {
         {}
 };
 
-/* from oem9.inf - HKR,%PO2030%,Initial - 640x480 - (close to CS2102) */
-static const struct usb_action PO2030_mode0[] = {
+/* from oem9.inf */
+static const struct usb_action po2030_Initial[] = {     /* 640x480 */
         {0xa0, 0x01, ZC3XX_R000_SYSTEMCONTROL}, /* 00,00,01,cc */
         {0xa0, 0x04, ZC3XX_R002_CLOCKSELECT},   /* 00,02,04,cc */
         {0xa0, 0x01, ZC3XX_R010_CMOSSENSORSELECT}, /* 00,10,01,cc */
@@ -4790,8 +4796,8 @@ static const struct usb_action PO2030_mode0[] = {
         {}
 };
 
-/* from oem9.inf - HKR,%PO2030%,InitialScale - 320x240 */
-static const struct usb_action PO2030_mode1[] = {
+/* from oem9.inf */
+static const struct usb_action po2030_InitialScale[] = {        /* 320x240 */
         {0xa0, 0x01, ZC3XX_R000_SYSTEMCONTROL}, /* 00,00,01,cc */
         {0xa0, 0x10, ZC3XX_R002_CLOCKSELECT}, /* 00,02,10,cc */
         {0xa0, 0x01, ZC3XX_R010_CMOSSENSORSELECT}, /* 00,10,01,cc */
@@ -4867,7 +4873,7 @@ static const struct usb_action PO2030_mode1[] = {
         {}
 };
 
-static const struct usb_action PO2030_50HZ[] = {
+static const struct usb_action po2030_50HZ[] = {
         {0xaa, 0x8d, 0x0008}, /* 00,8d,08,aa */
         {0xaa, 0x1a, 0x0001}, /* 00,1a,01,aa */
         {0xaa, 0x1b, 0x000a}, /* 00,1b,0a,aa */
@@ -4889,7 +4895,7 @@ static const struct usb_action PO2030_50HZ[] = {
         {}
 };
 
-static const struct usb_action PO2030_60HZ[] = {
+static const struct usb_action po2030_60HZ[] = {
         {0xaa, 0x8d, 0x0008}, /* 00,8d,08,aa */
         {0xaa, 0x1a, 0x0000}, /* 00,1a,00,aa */
         {0xaa, 0x1b, 0x00de}, /* 00,1b,de,aa */
@@ -4912,7 +4918,7 @@ static const struct usb_action PO2030_60HZ[] = {
         {}
 };
 
-static const struct usb_action PO2030_NoFliker[] = {
+static const struct usb_action po2030_NoFliker[] = {
         {0xa0, 0x02, ZC3XX_R180_AUTOCORRECTENABLE}, /* 01,80,02,cc */
         {0xaa, 0x8d, 0x000d}, /* 00,8d,0d,aa */
         {0xaa, 0x1a, 0x0000}, /* 00,1a,00,aa */
@@ -4924,7 +4930,7 @@ static const struct usb_action PO2030_NoFliker[] = {
 };
 
 /* TEST */
-static const struct usb_action tas5130CK_Initial[] = {
+static const struct usb_action tas5130cK_InitialScale[] = {
         {0xa0, 0x01, ZC3XX_R000_SYSTEMCONTROL},
         {0xa0, 0x01, 0x003b},
         {0xa0, 0x0e, 0x003a},
@@ -5127,7 +5133,7 @@ static const struct usb_action tas5130CK_Initial[] = {
         {}
 };
 
-static const struct usb_action tas5130CK_InitialScale[] = {
+static const struct usb_action tas5130cK_Initial[] = {
         {0xa0, 0x01, ZC3XX_R000_SYSTEMCONTROL},
         {0xa0, 0x01, 0x003b},
         {0xa0, 0x0e, 0x003a},
@@ -5560,7 +5566,7 @@ static const struct usb_action tas5130cxx_NoFlikerScale[] = {
         {}
 };
 
-static const struct usb_action tas5130c_vf0250_Initial[] = {
+static const struct usb_action tas5130c_vf0250_InitialScale[] = {
         {0xa0, 0x01, ZC3XX_R000_SYSTEMCONTROL},         /* 00,00,01,cc, */
         {0xa0, 0x02, ZC3XX_R008_CLOCKSETTING},          /* 00,08,02,cc, */
         {0xa0, 0x01, ZC3XX_R010_CMOSSENSORSELECT},      /* 00,10,01,cc, */
@@ -5627,7 +5633,7 @@ static const struct usb_action tas5130c_vf0250_Initial[] = {
         {}
 };
 
-static const struct usb_action tas5130c_vf0250_InitialScale[] = {
+static const struct usb_action tas5130c_vf0250_Initial[] = {
         {0xa0, 0x01, ZC3XX_R000_SYSTEMCONTROL},         /* 00,00,01,cc, */
         {0xa0, 0x02, ZC3XX_R008_CLOCKSETTING},          /* 00,08,02,cc, */
         {0xa0, 0x01, ZC3XX_R010_CMOSSENSORSELECT},      /* 00,10,01,cc, */
@@ -5692,8 +5698,7 @@ static const struct usb_action tas5130c_vf0250_InitialScale[] = {
         {0xa0, 0x65, ZC3XX_R118_BGAIN},         /* 01,18,65,cc */
         {}
 };
-/* "50HZ" light frequency banding filter */
-static const struct usb_action tas5130c_vf0250_50HZ[] = {
+static const struct usb_action tas5130c_vf0250_50HZScale[] = {
         {0xaa, 0x82, 0x0000},           /* 00,82,00,aa */
         {0xaa, 0x83, 0x0001},           /* 00,83,01,aa */
         {0xaa, 0x84, 0x00aa},           /* 00,84,aa,aa */
@@ -5717,8 +5722,7 @@ static const struct usb_action tas5130c_vf0250_50HZ[] = {
         {}
 };
 
-/* "50HZScale" light frequency banding filter */
-static const struct usb_action tas5130c_vf0250_50HZScale[] = {
+static const struct usb_action tas5130c_vf0250_50HZ[] = {
         {0xaa, 0x82, 0x0000},           /* 00,82,00,aa */
         {0xaa, 0x83, 0x0003},           /* 00,83,03,aa */
         {0xaa, 0x84, 0x0054},           /* 00,84,54,aa */
@@ -5742,8 +5746,7 @@ static const struct usb_action tas5130c_vf0250_50HZScale[] = {
         {}
 };
 
-/* "60HZ" light frequency banding filter */
-static const struct usb_action tas5130c_vf0250_60HZ[] = {
+static const struct usb_action tas5130c_vf0250_60HZScale[] = {
         {0xaa, 0x82, 0x0000},           /* 00,82,00,aa */
         {0xaa, 0x83, 0x0001},           /* 00,83,01,aa */
         {0xaa, 0x84, 0x0062},           /* 00,84,62,aa */
@@ -5767,8 +5770,7 @@ static const struct usb_action tas5130c_vf0250_60HZ[] = {
         {}
 };
 
-/* "60HZScale" light frequency banding ilter */
-static const struct usb_action tas5130c_vf0250_60HZScale[] = {
+static const struct usb_action tas5130c_vf0250_60HZ[] = {
         {0xaa, 0x82, 0x0000},           /* 00,82,00,aa */
         {0xaa, 0x83, 0x0002},           /* 00,83,02,aa */
         {0xaa, 0x84, 0x00c4},           /* 00,84,c4,aa */
@@ -5792,8 +5794,7 @@ static const struct usb_action tas5130c_vf0250_60HZScale[] = {
         {}
 };
 
-/* "NoFliker" light frequency banding flter */
-static const struct usb_action tas5130c_vf0250_NoFliker[] = {
+static const struct usb_action tas5130c_vf0250_NoFlikerScale[] = {
         {0xa0, 0x0c, ZC3XX_R100_OPERATIONMODE},         /* 01,00,0c,cc, */
         {0xaa, 0x82, 0x0000},           /* 00,82,00,aa */
         {0xaa, 0x83, 0x0000},           /* 00,83,00,aa */
@@ -5815,8 +5816,7 @@ static const struct usb_action tas5130c_vf0250_NoFliker[] = {
         {}
 };
 
-/* "NoFlikerScale" light frequency banding filter */
-static const struct usb_action tas5130c_vf0250_NoFlikerScale[] = {
+static const struct usb_action tas5130c_vf0250_NoFliker[] = {
         {0xa0, 0x0c, ZC3XX_R100_OPERATIONMODE},         /* 01,00,0c,cc, */
         {0xaa, 0x82, 0x0000},           /* 00,82,00,aa */
         {0xaa, 0x83, 0x0000},           /* 00,83,00,aa */
@@ -5839,7 +5839,7 @@ static const struct usb_action tas5130c_vf0250_NoFlikerScale[] = {
 };
 
 static u8 reg_r_i(struct gspca_dev *gspca_dev,
-                __u16 index)
+                u16 index)
 {
         usb_control_msg(gspca_dev->dev,
                         usb_rcvctrlpipe(gspca_dev->dev, 0),
@@ -5852,7 +5852,7 @@ static u8 reg_r_i(struct gspca_dev *gspca_dev,
 }
 
 static u8 reg_r(struct gspca_dev *gspca_dev,
-                __u16 index)
+                u16 index)
 {
         u8 ret;
 
@@ -5862,8 +5862,8 @@ static u8 reg_r(struct gspca_dev *gspca_dev,
 }
 
 static void reg_w_i(struct usb_device *dev,
-                        __u8 value,
-                        __u16 index)
+                        u8 value,
+                        u16 index)
 {
         usb_control_msg(dev,
                         usb_sndctrlpipe(dev, 0),
@@ -5874,18 +5874,18 @@ static void reg_w_i(struct usb_device *dev,
 }
 
 static void reg_w(struct usb_device *dev,
-                        __u8 value,
-                        __u16 index)
+                        u8 value,
+                        u16 index)
 {
         PDEBUG(D_USBO, "reg w [%04x] = %02x", index, value);
         reg_w_i(dev, value, index);
 }
 
-static __u16 i2c_read(struct gspca_dev *gspca_dev,
-                        __u8 reg)
+static u16 i2c_read(struct gspca_dev *gspca_dev,
+                        u8 reg)
 {
-        __u8 retbyte;
-        __u16 retval;
+        u8 retbyte;
+        u16 retval;
 
         reg_w_i(gspca_dev->dev, reg, 0x0092);
         reg_w_i(gspca_dev->dev, 0x02, 0x0090);          /* <- read command */
@@ -5900,12 +5900,12 @@ static __u16 i2c_read(struct gspca_dev *gspca_dev,
         return retval;
 }
 
-static __u8 i2c_write(struct gspca_dev *gspca_dev,
-                        __u8 reg,
-                        __u8 valL,
-                        __u8 valH)
+static u8 i2c_write(struct gspca_dev *gspca_dev,
+                        u8 reg,
+                        u8 valL,
+                        u8 valH)
 {
-        __u8 retbyte;
+        u8 retbyte;
 
         reg_w_i(gspca_dev->dev, reg, 0x92);
         reg_w_i(gspca_dev->dev, valL, 0x93);
@@ -5957,24 +5957,24 @@ static void setmatrix(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
         int i;
-        const __u8 *matrix;
+        const u8 *matrix;
         static const u8 adcm2700_matrix[9] =
 /*              {0x66, 0xed, 0xed, 0xed, 0x66, 0xed, 0xed, 0xed, 0x66}; */
 /*ms-win*/
                 {0x74, 0xed, 0xed, 0xed, 0x74, 0xed, 0xed, 0xed, 0x74};
-        static const __u8 gc0305_matrix[9] =
+        static const u8 gc0305_matrix[9] =
                 {0x50, 0xf8, 0xf8, 0xf8, 0x50, 0xf8, 0xf8, 0xf8, 0x50};
-        static const __u8 ov7620_matrix[9] =
+        static const u8 ov7620_matrix[9] =
                 {0x58, 0xf4, 0xf4, 0xf4, 0x58, 0xf4, 0xf4, 0xf4, 0x58};
-        static const __u8 pas202b_matrix[9] =
+        static const u8 pas202b_matrix[9] =
                 {0x4c, 0xf5, 0xff, 0xf9, 0x51, 0xf5, 0xfb, 0xed, 0x5f};
-        static const __u8 po2030_matrix[9] =
+        static const u8 po2030_matrix[9] =
                 {0x60, 0xf0, 0xf0, 0xf0, 0x60, 0xf0, 0xf0, 0xf0, 0x60};
         static const u8 tas5130c_matrix[9] =
                 {0x68, 0xec, 0xec, 0xec, 0x68, 0xec, 0xec, 0xec, 0x68};
-        static const __u8 vf0250_matrix[9] =
+        static const u8 vf0250_matrix[9] =
                 {0x7b, 0xea, 0xea, 0xea, 0x7b, 0xea, 0xea, 0xea, 0x7b};
-        static const __u8 *matrix_tb[SENSOR_MAX] = {
+        static const u8 *matrix_tb[SENSOR_MAX] = {
                 adcm2700_matrix, /* SENSOR_ADCM2700 0 */
                 ov7620_matrix,  /* SENSOR_CS2102 1 */
                 NULL,           /* SENSOR_CS2102K 2 */
@@ -6006,11 +6006,12 @@ static void setmatrix(struct gspca_dev *gspca_dev)
 static void setbrightness(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
-        __u8 brightness;
+        u8 brightness;
 
         switch (sd->sensor) {
         case SENSOR_GC0305:
         case SENSOR_OV7620:
+        case SENSOR_PAS202B:
         case SENSOR_PO2030:
                 return;
         }
@@ -6034,7 +6035,7 @@ static void setsharpness(struct gspca_dev *gspca_dev)
         struct sd *sd = (struct sd *) gspca_dev;
         struct usb_device *dev = gspca_dev->dev;
         int sharpness;
-        static const __u8 sharpness_tb[][2] = {
+        static const u8 sharpness_tb[][2] = {
                 {0x02, 0x03},
                 {0x04, 0x07},
                 {0x08, 0x0f},
@@ -6053,118 +6054,69 @@ static void setcontrast(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
         struct usb_device *dev = gspca_dev->dev;
-        const __u8 *Tgamma, *Tgradient;
-        int g, i, k;
-        static const __u8 kgamma_tb[16] =       /* delta for contrast */
+        const u8 *Tgamma;
+        int g, i, k, adj, gp;
+        u8 gr[16];
+        static const u8 delta_tb[16] =          /* delta for contrast */
                 {0x15, 0x0d, 0x0a, 0x09, 0x08, 0x08, 0x08, 0x08,
                  0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08};
-        static const __u8 kgrad_tb[16] =
-                {0x1b, 0x06, 0x03, 0x02, 0x00, 0x00, 0x00, 0x00,
-                 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x06, 0x04};
-        static const __u8 Tgamma_1[16] =
+        static const u8 gamma_tb[6][16] = {
                 {0x00, 0x00, 0x03, 0x0d, 0x1b, 0x2e, 0x45, 0x5f,
-                 0x79, 0x93, 0xab, 0xc1, 0xd4, 0xe5, 0xf3, 0xff};
-        static const __u8 Tgradient_1[16] =
-                {0x00, 0x01, 0x05, 0x0b, 0x10, 0x15, 0x18, 0x1a,
-                 0x1a, 0x18, 0x16, 0x14, 0x12, 0x0f, 0x0d, 0x06};
-        static const __u8 Tgamma_2[16] =
+                 0x79, 0x93, 0xab, 0xc1, 0xd4, 0xe5, 0xf3, 0xff},
                 {0x01, 0x0c, 0x1f, 0x3a, 0x53, 0x6d, 0x85, 0x9c,
-                 0xb0, 0xc2, 0xd1, 0xde, 0xe9, 0xf2, 0xf9, 0xff};
-        static const __u8 Tgradient_2[16] =
-                {0x05, 0x0f, 0x16, 0x1a, 0x19, 0x19, 0x17, 0x15,
-                 0x12, 0x10, 0x0e, 0x0b, 0x09, 0x08, 0x06, 0x03};
-        static const __u8 Tgamma_3[16] =
+                 0xb0, 0xc2, 0xd1, 0xde, 0xe9, 0xf2, 0xf9, 0xff},
                 {0x04, 0x16, 0x30, 0x4e, 0x68, 0x81, 0x98, 0xac,
-                 0xbe, 0xcd, 0xda, 0xe4, 0xed, 0xf5, 0xfb, 0xff};
-        static const __u8 Tgradient_3[16] =
-                {0x0c, 0x16, 0x1b, 0x1c, 0x19, 0x18, 0x15, 0x12,
-                 0x10, 0x0d, 0x0b, 0x09, 0x08, 0x06, 0x05, 0x03};
-        static const __u8 Tgamma_4[16] =
+                 0xbe, 0xcd, 0xda, 0xe4, 0xed, 0xf5, 0xfb, 0xff},
                 {0x13, 0x38, 0x59, 0x79, 0x92, 0xa7, 0xb9, 0xc8,
-                 0xd4, 0xdf, 0xe7, 0xee, 0xf4, 0xf9, 0xfc, 0xff};
-        static const __u8 Tgradient_4[16] =
-                {0x26, 0x22, 0x20, 0x1c, 0x16, 0x13, 0x10, 0x0d,
-                 0x0b, 0x09, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02};
-        static const __u8 Tgamma_5[16] =
+                 0xd4, 0xdf, 0xe7, 0xee, 0xf4, 0xf9, 0xfc, 0xff},
                 {0x20, 0x4b, 0x6e, 0x8d, 0xa3, 0xb5, 0xc5, 0xd2,
-                 0xdc, 0xe5, 0xec, 0xf2, 0xf6, 0xfa, 0xfd, 0xff};
-        static const __u8 Tgradient_5[16] =
-                {0x37, 0x26, 0x20, 0x1a, 0x14, 0x10, 0x0e, 0x0b,
-                 0x09, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x02};
-        static const __u8 Tgamma_6[16] =                /* ?? was gamma 5 */
+                 0xdc, 0xe5, 0xec, 0xf2, 0xf6, 0xfa, 0xfd, 0xff},
                 {0x24, 0x44, 0x64, 0x84, 0x9d, 0xb2, 0xc4, 0xd3,
-                 0xe0, 0xeb, 0xf4, 0xff, 0xff, 0xff, 0xff, 0xff};
-        static const __u8 Tgradient_6[16] =
-                {0x18, 0x20, 0x20, 0x1c, 0x16, 0x13, 0x10, 0x0e,
-                 0x0b, 0x09, 0x07, 0x00, 0x00, 0x00, 0x00, 0x01};
-        static const __u8 *gamma_tb[] = {
-                NULL, Tgamma_1, Tgamma_2,
-                Tgamma_3, Tgamma_4, Tgamma_5, Tgamma_6
+                 0xe0, 0xeb, 0xf4, 0xff, 0xff, 0xff, 0xff, 0xff},
         };
-        static const __u8 *gradient_tb[] = {
-                NULL, Tgradient_1, Tgradient_2,
-                Tgradient_3, Tgradient_4, Tgradient_5, Tgradient_6
-        };
-#ifdef GSPCA_DEBUG
-        __u8 v[16];
-#endif
 
-        Tgamma = gamma_tb[sd->gamma];
-        Tgradient = gradient_tb[sd->gamma];
+        Tgamma = gamma_tb[sd->gamma - 1];
 
-        k = (sd->contrast - 128)                /* -128 / 128 */
-                        * Tgamma[0];
-        PDEBUG(D_CONF, "gamma:%d contrast:%d gamma coeff: %d/128",
-                sd->gamma, sd->contrast, k);
+        k = ((int) sd->contrast - 128);         /* -128 / 128 */
+        adj = 0;
+        gp = 0;
         for (i = 0; i < 16; i++) {
-                g = Tgamma[i] + kgamma_tb[i] * k / 128;
+                g = Tgamma[i] - delta_tb[i] * k / 128 - adj / 2;
                 if (g > 0xff)
                         g = 0xff;
                 else if (g <= 0)
                         g = 1;
                 reg_w(dev, g, 0x0120 + i);      /* gamma */
-#ifdef GSPCA_DEBUG
-                if (gspca_debug & D_CONF)
-                        v[i] = g;
-#endif
-        }
-        PDEBUG(D_CONF, "tb: %02x %02x %02x %02x %02x %02x %02x %02x",
-                v[0], v[1], v[2], v[3], v[4], v[5], v[6], v[7]);
-        PDEBUG(D_CONF, "    %02x %02x %02x %02x %02x %02x %02x %02x",
-                v[8], v[9], v[10], v[11], v[12], v[13], v[14], v[15]);
-        for (i = 0; i < 16; i++) {
-                g = Tgradient[i] - kgrad_tb[i] * k / 128;
-                if (g > 0xff)
-                        g = 0xff;
-                else if (g <= 0) {
-                        if (i != 15)
-                                g = 0;
+                if (k > 0)
+                        adj--;
+                else
+                        adj++;
+
+                if (i != 0) {
+                        if (gp == 0)
+                                gr[i - 1] = 0;
                         else
-                                g = 1;
+                                gr[i - 1] = g - gp;
                 }
-                reg_w(dev, g, 0x0130 + i);      /* gradient */
-#ifdef GSPCA_DEBUG
-                if (gspca_debug & D_CONF)
-                        v[i] = g;
-#endif
+                gp = g;
         }
-        PDEBUG(D_CONF, "    %02x %02x %02x %02x %02x %02x %02x %02x",
-                v[0], v[1], v[2], v[3], v[4], v[5], v[6], v[7]);
-        PDEBUG(D_CONF, "    %02x %02x %02x %02x %02x %02x %02x %02x",
-                v[8], v[9], v[10], v[11], v[12], v[13], v[14], v[15]);
+        gr[15] = gr[14] / 2;
+        for (i = 0; i < 16; i++)
+                reg_w(dev, gr[i], 0x0130 + i);  /* gradient */
 }
 
 static void setquality(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
         struct usb_device *dev = gspca_dev->dev;
-        __u8 frxt;
+        u8 frxt;
 
         switch (sd->sensor) {
         case SENSOR_ADCM2700:
         case SENSOR_GC0305:
         case SENSOR_HV7131B:
         case SENSOR_OV7620:
+        case SENSOR_PAS202B:
         case SENSOR_PO2030:
                 return;
         }
@@ -6218,9 +6170,9 @@ static int setlightfreq(struct gspca_dev *gspca_dev)
                  hdcs2020b_50HZ, hdcs2020b_50HZ,
                  hdcs2020b_60HZ, hdcs2020b_60HZ},
 /* SENSOR_HV7131B 5 */
-                {hv7131b_NoFlikerScale, hv7131b_NoFliker,
-                 hv7131b_50HZScale, hv7131b_50HZ,
-                 hv7131b_60HZScale, hv7131b_60HZ},
+                {hv7131b_NoFliker, hv7131b_NoFlikerScale,
+                 hv7131b_50HZ, hv7131b_50HZScale,
+                 hv7131b_60HZ, hv7131b_60HZScale},
 /* SENSOR_HV7131C 6 */
                 {NULL, NULL,
                  NULL, NULL,
@@ -6230,17 +6182,17 @@ static int setlightfreq(struct gspca_dev *gspca_dev)
                  icm105a_50HZ, icm105a_50HZScale,
                  icm105a_60HZ, icm105a_60HZScale},
 /* SENSOR_MC501CB 8 */
-                {MC501CB_NoFliker, MC501CB_NoFlikerScale,
-                 MC501CB_50HZ, MC501CB_50HZScale,
-                 MC501CB_60HZ, MC501CB_60HZScale},
+                {mc501cb_NoFliker, mc501cb_NoFlikerScale,
+                 mc501cb_50HZ, mc501cb_50HZScale,
+                 mc501cb_60HZ, mc501cb_60HZScale},
 /* SENSOR_MI0360SOC 9 */
-                {mi360soc_AENoFlikerScale, mi360soc_AENoFliker,
-                 mi360soc_AE50HZScale, mi360soc_AE50HZ,
-                 mi360soc_AE60HZScale, mi360soc_AE60HZ},
+                {mi360soc_AENoFliker, mi360soc_AENoFlikerScale,
+                 mi360soc_AE50HZ, mi360soc_AE50HZScale,
+                 mi360soc_AE60HZ, mi360soc_AE60HZScale},
 /* SENSOR_OV7620 10 */
-                {OV7620_NoFliker, OV7620_NoFliker,
-                 OV7620_50HZ, OV7620_50HZ,
-                 OV7620_60HZ, OV7620_60HZ},
+                {ov7620_NoFliker, ov7620_NoFliker,
+                 ov7620_50HZ, ov7620_50HZ,
+                 ov7620_60HZ, ov7620_60HZ},
 /* SENSOR_OV7630C 11 */
                 {NULL, NULL,
                  NULL, NULL,
@@ -6258,17 +6210,17 @@ static int setlightfreq(struct gspca_dev *gspca_dev)
                  pb0330_50HZScale, pb0330_50HZ,
                  pb0330_60HZScale, pb0330_60HZ},
 /* SENSOR_PO2030 15 */
-                {PO2030_NoFliker, PO2030_NoFliker,
-                 PO2030_50HZ, PO2030_50HZ,
-                 PO2030_60HZ, PO2030_60HZ},
+                {po2030_NoFliker, po2030_NoFliker,
+                 po2030_50HZ, po2030_50HZ,
+                 po2030_60HZ, po2030_60HZ},
 /* SENSOR_TAS5130CK 16 */
-                {tas5130cxx_NoFlikerScale, tas5130cxx_NoFliker,
-                 tas5130cxx_50HZScale, tas5130cxx_50HZ,
-                 tas5130cxx_60HZScale, tas5130cxx_60HZ},
+                {tas5130cxx_NoFliker, tas5130cxx_NoFlikerScale,
+                 tas5130cxx_50HZ, tas5130cxx_50HZScale,
+                 tas5130cxx_60HZ, tas5130cxx_60HZScale},
 /* SENSOR_TAS5130CXX 17 */
-                {tas5130cxx_NoFlikerScale, tas5130cxx_NoFliker,
-                 tas5130cxx_50HZScale, tas5130cxx_50HZ,
-                 tas5130cxx_60HZScale, tas5130cxx_60HZ},
+                {tas5130cxx_NoFliker, tas5130cxx_NoFlikerScale,
+                 tas5130cxx_50HZ, tas5130cxx_50HZScale,
+                 tas5130cxx_60HZ, tas5130cxx_60HZScale},
 /* SENSOR_TAS5130C_VF0250 18 */
                 {tas5130c_vf0250_NoFliker, tas5130c_vf0250_NoFlikerScale,
                  tas5130c_vf0250_50HZ, tas5130c_vf0250_50HZScale,
@@ -6277,9 +6229,9 @@ static int setlightfreq(struct gspca_dev *gspca_dev)
 
         i = sd->lightfreq * 2;
         mode = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv;
-        if (!mode)
-                i++;                    /* 640x480 */
-        zc3_freq = freq_tb[(int) sd->sensor][i];
+        if (mode)
+                i++;                    /* 320x240 */
+        zc3_freq = freq_tb[sd->sensor][i];
         if (zc3_freq != NULL) {
                 usb_exchange(gspca_dev, zc3_freq);
                 switch (sd->sensor) {
@@ -6297,6 +6249,9 @@ static int setlightfreq(struct gspca_dev *gspca_dev)
                                         reg_w(gspca_dev->dev, 0x44, 0x0002);
                         }
                         break;
+                case SENSOR_PAS202B:
+                        reg_w(gspca_dev->dev, 0x00, 0x01a7);
+                        break;
                 }
         }
         return 0;
@@ -6305,7 +6260,7 @@ static int setlightfreq(struct gspca_dev *gspca_dev)
 static void setautogain(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
-        __u8 autoval;
+        u8 autoval;
 
         if (sd->autogain)
                 autoval = 0x42;
@@ -6333,6 +6288,12 @@ static void send_unknown(struct usb_device *dev, int sensor)
                 reg_w(dev, 0x02, 0x003b);
                 reg_w(dev, 0x00, 0x0038);
                 break;
+        case SENSOR_PAS202B:
+                reg_w(dev, 0x03, 0x003b);
+                reg_w(dev, 0x0c, 0x003a);
+                reg_w(dev, 0x0b, 0x0039);
+                reg_w(dev, 0x0b, 0x0038);
+                break;
         }
 }
 
@@ -6349,7 +6310,7 @@ static void start_2wr_probe(struct usb_device *dev, int sensor)
 
 static int sif_probe(struct gspca_dev *gspca_dev)
 {
-        __u16 checkword;
+        u16 checkword;
 
         start_2wr_probe(gspca_dev->dev, 0x0f);          /* PAS106 */
         reg_w(gspca_dev->dev, 0x08, 0x008d);
@@ -6392,6 +6353,7 @@ static int vga_2wr_probe(struct gspca_dev *gspca_dev)
         }
 
         start_2wr_probe(dev, 0x08);             /* HDCS2020 */
+        i2c_write(gspca_dev, 0x1c, 0x00, 0x00);
         i2c_write(gspca_dev, 0x15, 0xaa, 0x00);
         retword = i2c_read(gspca_dev, 0x15);
         if (retword != 0)
@@ -6420,8 +6382,10 @@ static int vga_2wr_probe(struct gspca_dev *gspca_dev)
         i2c_write(gspca_dev, 0x03, 0xaa, 0x00);
         msleep(50);
         retword = i2c_read(gspca_dev, 0x03);
-        if (retword != 0)
+        if (retword != 0) {
+                send_unknown(dev, SENSOR_PAS202B);
                 return 0x0e;                    /* PAS202BCB */
+        }
 
         start_2wr_probe(dev, 0x02);             /* TAS5130C */
         i2c_write(gspca_dev, 0x01, 0xaa, 0x00);
@@ -6457,8 +6421,8 @@ ov_check:
 }
 
 struct sensor_by_chipset_revision {
-        __u16 revision;
-        __u8 internal_sensor_id;
+        u16 revision;
+        u8 internal_sensor_id;
 };
 static const struct sensor_by_chipset_revision chipset_revision_sensor[] = {
         {0xc000, 0x12},         /* TAS5130C */
@@ -6467,6 +6431,7 @@ static const struct sensor_by_chipset_revision chipset_revision_sensor[] = {
         {0x8001, 0x13},
         {0x8000, 0x14},         /* CS2102K */
         {0x8400, 0x15},         /* TAS5130K */
+        {0xe400, 0x15},
 };
 
 static int vga_3wr_probe(struct gspca_dev *gspca_dev)
@@ -6474,7 +6439,7 @@ static int vga_3wr_probe(struct gspca_dev *gspca_dev)
         struct sd *sd = (struct sd *) gspca_dev;
         struct usb_device *dev = gspca_dev->dev;
         int i;
-        __u8 retbyte;
+        u8 retbyte;
         u16 retword;
 
 /*fixme: lack of 8b=b3 (11,12)-> 10, 8b=e0 (14,15,16)-> 12 found in gspcav1*/
@@ -6622,8 +6587,7 @@ static int sd_config(struct gspca_dev *gspca_dev,
         struct sd *sd = (struct sd *) gspca_dev;
         struct cam *cam;
         int sensor;
-        int vga = 1;            /* 1: vga, 0: sif */
-        static const __u8 gamma[SENSOR_MAX] = {
+        static const u8 gamma[SENSOR_MAX] = {
                 4,      /* SENSOR_ADCM2700 0 */
                 4,      /* SENSOR_CS2102 1 */
                 5,      /* SENSOR_CS2102K 2 */
@@ -6644,9 +6608,30 @@ static int sd_config(struct gspca_dev *gspca_dev,
                 3,      /* SENSOR_TAS5130CXX 17 */
                 3,      /* SENSOR_TAS5130C_VF0250 18 */
         };
+        static const u8 mode_tb[SENSOR_MAX] = {
+                2,      /* SENSOR_ADCM2700 0 */
+                1,      /* SENSOR_CS2102 1 */
+                1,      /* SENSOR_CS2102K 2 */
+                1,      /* SENSOR_GC0305 3 */
+                1,      /* SENSOR_HDCS2020b 4 */
+                1,      /* SENSOR_HV7131B 5 */
+                1,      /* SENSOR_HV7131C 6 */
+                1,      /* SENSOR_ICM105A 7 */
+                2,      /* SENSOR_MC501CB 8 */
+                1,      /* SENSOR_MI0360SOC 9 */
+                2,      /* SENSOR_OV7620 10 */
+                1,      /* SENSOR_OV7630C 11 */
+                0,      /* SENSOR_PAS106 12 */
+                1,      /* SENSOR_PAS202B 13 */
+                1,      /* SENSOR_PB0330 14 */
+                1,      /* SENSOR_PO2030 15 */
+                1,      /* SENSOR_TAS5130CK 16 */
+                1,      /* SENSOR_TAS5130CXX 17 */
+                1,      /* SENSOR_TAS5130C_VF0250 18 */
+        };
 
         /* define some sensors from the vendor/product */
-        sd->sharpness = 2;
+        sd->sharpness = SHARPNESS_DEF;
         sd->sensor = id->driver_info;
         sensor = zcxx_probeSensor(gspca_dev);
         if (sensor >= 0)
@@ -6671,8 +6656,21 @@ static int sd_config(struct gspca_dev *gspca_dev,
                         }
                         break;
                 case 0:
-                        PDEBUG(D_PROBE, "Find Sensor HV7131B");
-                        sd->sensor = SENSOR_HV7131B;
+                        /* check the sensor type */
+                        sensor = i2c_read(gspca_dev, 0x00);
+                        PDEBUG(D_PROBE, "Sensor hv7131 type %d", sensor);
+                        switch (sensor) {
+                        case 0:                 /* hv7131b */
+                        case 1:                 /* hv7131e */
+                                PDEBUG(D_PROBE, "Find Sensor HV7131B");
+                                sd->sensor = SENSOR_HV7131B;
+                                break;
+                        default:
+/*                      case 2:                  * hv7131r */
+                                PDEBUG(D_PROBE, "Find Sensor HV7131R(c)");
+                                sd->sensor = SENSOR_HV7131C;
+                                break;
+                        }
                         break;
                 case 0x02:
                         PDEBUG(D_PROBE, "Sensor TAS5130C");
@@ -6699,12 +6697,11 @@ static int sd_config(struct gspca_dev *gspca_dev,
                 case 0x0e:
                         PDEBUG(D_PROBE, "Find Sensor PAS202B");
                         sd->sensor = SENSOR_PAS202B;
-                        sd->sharpness = 1;
+/*                      sd->sharpness = 1; */
                         break;
                 case 0x0f:
                         PDEBUG(D_PROBE, "Find Sensor PAS106");
                         sd->sensor = SENSOR_PAS106;
-                        vga = 0;                /* SIF */
                         break;
                 case 0x10:
                 case 0x12:
@@ -6770,31 +6767,38 @@ static int sd_config(struct gspca_dev *gspca_dev,
         if (sensor < 0x20) {
                 if (sensor == -1 || sensor == 0x10 || sensor == 0x12)
                         reg_w(gspca_dev->dev, 0x02, 0x0010);
-                else
-                        reg_w(gspca_dev->dev, sensor & 0x0f, 0x0010);
                 reg_r(gspca_dev, 0x0010);
         }
 
         cam = &gspca_dev->cam;
 /*fixme:test*/
         gspca_dev->nbalt--;
-        if (vga) {
-                cam->cam_mode = vga_mode;
-                cam->nmodes = ARRAY_SIZE(vga_mode);
-        } else {
+        switch (mode_tb[sd->sensor]) {
+        case 0:
                 cam->cam_mode = sif_mode;
                 cam->nmodes = ARRAY_SIZE(sif_mode);
+                break;
+        case 1:
+                cam->cam_mode = vga_mode;
+                cam->nmodes = ARRAY_SIZE(vga_mode);
+                break;
+        default:
+/*      case 2: */
+                cam->cam_mode = broken_vga_mode;
+                cam->nmodes = ARRAY_SIZE(broken_vga_mode);
+                break;
         }
-        sd->brightness = sd_ctrls[SD_BRIGHTNESS].qctrl.default_value;
-        sd->contrast = sd_ctrls[SD_CONTRAST].qctrl.default_value;
-        sd->gamma = gamma[(int) sd->sensor];
-        sd->autogain = sd_ctrls[SD_AUTOGAIN].qctrl.default_value;
-        sd->lightfreq = sd_ctrls[SD_FREQ].qctrl.default_value;
+        sd->brightness = BRIGHTNESS_DEF;
+        sd->contrast = CONTRAST_DEF;
+        sd->gamma = gamma[sd->sensor];
+        sd->autogain = AUTOGAIN_DEF;
+        sd->lightfreq = FREQ_DEF;
         sd->quality = QUALITY_DEF;
 
         switch (sd->sensor) {
         case SENSOR_GC0305:
         case SENSOR_OV7620:
+        case SENSOR_PAS202B:
         case SENSOR_PO2030:
                 gspca_dev->ctrl_dis = (1 << BRIGHTNESS_IDX);
                 break;
@@ -6805,14 +6809,13 @@ static int sd_config(struct gspca_dev *gspca_dev,
                 break;
         }
 
-        /* switch the led off */
-        reg_w(gspca_dev->dev, 0x01, 0x0000);
         return 0;
 }
 
 /* this function is called at probe and resume time */
 static int sd_init(struct gspca_dev *gspca_dev)
 {
+        /* switch off the led */
         reg_w(gspca_dev->dev, 0x01, 0x0000);
         return 0;
 }
@@ -6821,28 +6824,27 @@ static int sd_start(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
         struct usb_device *dev = gspca_dev->dev;
-        const struct usb_action *zc3_init;
         int mode;
         static const struct usb_action *init_tb[SENSOR_MAX][2] = {
                 {adcm2700_Initial, adcm2700_InitialScale},      /* 0 */
-                {cs2102_InitialScale, cs2102_Initial},          /* 1 */
-                {cs2102K_InitialScale, cs2102K_Initial},        /* 2 */
+                {cs2102_Initial, cs2102_InitialScale},          /* 1 */
+                {cs2102K_Initial, cs2102K_InitialScale},        /* 2 */
                 {gc0305_Initial, gc0305_InitialScale},          /* 3 */
-                {hdcs2020xb_InitialScale, hdcs2020xb_Initial},  /* 4 */
-                {hv7131bxx_InitialScale, hv7131bxx_Initial},    /* 5 */
-                {hv7131cxx_InitialScale, hv7131cxx_Initial},    /* 6 */
-                {icm105axx_InitialScale, icm105axx_Initial},    /* 7 */
-                {MC501CB_InitialScale, MC501CB_Initial},        /* 8 */
+                {hdcs2020b_Initial, hdcs2020b_InitialScale},    /* 4 */
+                {hv7131b_Initial, hv7131b_InitialScale},        /* 5 */
+                {hv7131r_Initial, hv7131r_InitialScale},        /* 6 */
+                {icm105a_Initial, icm105a_InitialScale},        /* 7 */
+                {mc501cb_Initial, mc501cb_InitialScale},        /* 8 */
                 {mi0360soc_Initial, mi0360soc_InitialScale},    /* 9 */
-                {OV7620_mode0, OV7620_mode1},                   /* 10 */
-                {ov7630c_InitialScale, ov7630c_Initial},        /* 11 */
-                {pas106b_InitialScale, pas106b_Initial},        /* 12 */
+                {ov7620_Initial, ov7620_InitialScale},          /* 10 */
+                {ov7630c_Initial, ov7630c_InitialScale},        /* 11 */
+                {pas106b_Initial, pas106b_InitialScale},        /* 12 */
                 {pas202b_Initial, pas202b_InitialScale},        /* 13 */
                 {pb0330_Initial, pb0330_InitialScale},          /* 14 */
-                {PO2030_mode0, PO2030_mode1},                   /* 15 */
-                {tas5130CK_InitialScale, tas5130CK_Initial},    /* 16 */
+                {po2030_Initial, po2030_InitialScale},          /* 15 */
+                {tas5130cK_Initial, tas5130cK_InitialScale},    /* 16 */
                 {tas5130cxx_Initial, tas5130cxx_InitialScale},  /* 17 */
-                {tas5130c_vf0250_InitialScale, tas5130c_vf0250_Initial},
+                {tas5130c_vf0250_Initial, tas5130c_vf0250_InitialScale},
                                                                 /* 18 */
         };
 
@@ -6854,8 +6856,7 @@ static int sd_start(struct gspca_dev *gspca_dev)
                         0x21);          /* JPEG 422 */
         jpeg_set_qual(sd->jpeg_hdr, sd->quality);
 
-        mode = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv;
-        zc3_init = init_tb[(int) sd->sensor][mode];
+        mode = gspca_dev->cam.cam_mode[gspca_dev->curr_mode].priv;
         switch (sd->sensor) {
         case SENSOR_HV7131C:
                 zcxx_probeSensor(gspca_dev);
@@ -6864,7 +6865,7 @@ static int sd_start(struct gspca_dev *gspca_dev)
                 usb_exchange(gspca_dev, pas106b_Initial_com);
                 break;
         }
-        usb_exchange(gspca_dev, zc3_init);
+        usb_exchange(gspca_dev, init_tb[sd->sensor][mode]);
 
         switch (sd->sensor) {
         case SENSOR_ADCM2700:
@@ -6883,6 +6884,11 @@ static int sd_start(struct gspca_dev *gspca_dev)
                 reg_w(dev, 0x02, 0x003b);
                 reg_w(dev, 0x00, 0x0038);
                 break;
+        case SENSOR_PAS202B:
+                reg_w(dev, 0x03, 0x003b);
+                reg_w(dev, 0x0c, 0x003a);
+                reg_w(dev, 0x0b, 0x0039);
+                break;
         }
 
         setmatrix(gspca_dev);
@@ -6961,13 +6967,13 @@ static int sd_start(struct gspca_dev *gspca_dev)
         switch (sd->sensor) {
         case SENSOR_PO2030:
                 msleep(50);
-                reg_r(gspca_dev, 0x0008);
-                reg_r(gspca_dev, 0x0007);
-                /*fall thru*/
-        case SENSOR_PAS202B:
                 reg_w(dev, 0x00, 0x0007);       /* (from win traces) */
                 reg_w(dev, 0x02, ZC3XX_R008_CLOCKSETTING);
                 break;
+        case SENSOR_PAS202B:
+                reg_w(dev, 0x32, 0x0007);       /* (from win traces) */
+                reg_w(dev, 0x02, ZC3XX_R008_CLOCKSETTING);
+                break;
         }
         return 0;
 }
@@ -7165,6 +7171,22 @@ static int sd_get_jcomp(struct gspca_dev *gspca_dev,
         return 0;
 }
 
+#ifdef CONFIG_INPUT
+static int sd_int_pkt_scan(struct gspca_dev *gspca_dev,
+                        u8 *data,               /* interrupt packet data */
+                        int len)                /* interrput packet length */
+{
+        if (len == 8 && data[4] == 1) {
+                input_report_key(gspca_dev->input_dev, KEY_CAMERA, 1);
+                input_sync(gspca_dev->input_dev);
+                input_report_key(gspca_dev->input_dev, KEY_CAMERA, 0);
+                input_sync(gspca_dev->input_dev);
+        }
+
+        return 0;
+}
+#endif
+
 static const struct sd_desc sd_desc = {
         .name = MODULE_NAME,
         .ctrls = sd_ctrls,
@@ -7177,6 +7199,9 @@ static const struct sd_desc sd_desc = {
         .querymenu = sd_querymenu,
         .get_jcomp = sd_get_jcomp,
         .set_jcomp = sd_set_jcomp,
+#ifdef CONFIG_INPUT
+        .int_pkt_scan = sd_int_pkt_scan,
+#endif
 };
 
 static const __devinitdata struct usb_device_id device_table[] = {
diff --git a/drivers/media/video/hdpvr/hdpvr-core.c b/drivers/media/video/hdpvr/hdpvr-core.c
index 51f393d03a46..2fc9865fd486 100644
--- a/drivers/media/video/hdpvr/hdpvr-core.c
+++ b/drivers/media/video/hdpvr/hdpvr-core.c
@@ -39,12 +39,12 @@ int hdpvr_debug;
 module_param(hdpvr_debug, int, S_IRUGO|S_IWUSR);
 MODULE_PARM_DESC(hdpvr_debug, "enable debugging output");
 
-uint default_video_input = HDPVR_VIDEO_INPUTS;
+static uint default_video_input = HDPVR_VIDEO_INPUTS;
 module_param(default_video_input, uint, S_IRUGO|S_IWUSR);
 MODULE_PARM_DESC(default_video_input, "default video input: 0=Component / "
                  "1=S-Video / 2=Composite");
 
-uint default_audio_input = HDPVR_AUDIO_INPUTS;
+static uint default_audio_input = HDPVR_AUDIO_INPUTS;
 module_param(default_audio_input, uint, S_IRUGO|S_IWUSR);
 MODULE_PARM_DESC(default_audio_input, "default audio input: 0=RCA back / "
                  "1=RCA front / 2=S/PDIF");
@@ -59,6 +59,7 @@ static struct usb_device_id hdpvr_table[] = {
         { USB_DEVICE(HD_PVR_VENDOR_ID, HD_PVR_PRODUCT_ID) },
         { USB_DEVICE(HD_PVR_VENDOR_ID, HD_PVR_PRODUCT_ID1) },
         { USB_DEVICE(HD_PVR_VENDOR_ID, HD_PVR_PRODUCT_ID2) },
+        { USB_DEVICE(HD_PVR_VENDOR_ID, HD_PVR_PRODUCT_ID3) },
         { }                                     /* Terminating entry */
 };
 MODULE_DEVICE_TABLE(usb, hdpvr_table);
diff --git a/drivers/media/video/hdpvr/hdpvr-video.c b/drivers/media/video/hdpvr/hdpvr-video.c
index fdd782039e9d..196f82de48f0 100644
--- a/drivers/media/video/hdpvr/hdpvr-video.c
+++ b/drivers/media/video/hdpvr/hdpvr-video.c
@@ -302,7 +302,8 @@ static int hdpvr_start_streaming(struct hdpvr_device *dev)
 /* function expects dev->io_mutex to be hold by caller */
 static int hdpvr_stop_streaming(struct hdpvr_device *dev)
 {
-        uint actual_length, c = 0;
+        int actual_length;
+        uint c = 0;
         u8 *buf;
 
         if (dev->status == STATUS_IDLE)
@@ -572,7 +573,7 @@ static int vidioc_querycap(struct file *file, void  *priv,
         struct hdpvr_device *dev = video_drvdata(file);
 
         strcpy(cap->driver, "hdpvr");
-        strcpy(cap->card, "Haupauge HD PVR");
+        strcpy(cap->card, "Hauppauge HD PVR");
         usb_make_path(dev->udev, cap->bus_info, sizeof(cap->bus_info));
         cap->version = HDPVR_VERSION;
         cap->capabilities =     V4L2_CAP_VIDEO_CAPTURE |
diff --git a/drivers/media/video/hdpvr/hdpvr.h b/drivers/media/video/hdpvr/hdpvr.h
index 1edd8759121e..49ae25d83d10 100644
--- a/drivers/media/video/hdpvr/hdpvr.h
+++ b/drivers/media/video/hdpvr/hdpvr.h
@@ -30,6 +30,7 @@
 #define HD_PVR_PRODUCT_ID       0x4900
 #define HD_PVR_PRODUCT_ID1      0x4901
 #define HD_PVR_PRODUCT_ID2      0x4902
+#define HD_PVR_PRODUCT_ID3      0x4982
 
 #define UNSET    (-1U)
 
diff --git a/drivers/media/video/hexium_gemini.c b/drivers/media/video/hexium_gemini.c
index 60d992ee2589..e620a3a92f25 100644
--- a/drivers/media/video/hexium_gemini.c
+++ b/drivers/media/video/hexium_gemini.c
@@ -352,9 +352,13 @@ static struct saa7146_ext_vv vv_data;
 static int hexium_attach(struct saa7146_dev *dev, struct saa7146_pci_extension_data *info)
 {
         struct hexium *hexium = (struct hexium *) dev->ext_priv;
+        int ret;
 
         DEB_EE((".\n"));
 
+        ret = saa7146_vv_devinit(dev);
+        if (ret)
+                return ret;
         hexium = kzalloc(sizeof(struct hexium), GFP_KERNEL);
         if (NULL == hexium) {
                 printk("hexium_gemini: not enough kernel memory in hexium_attach().\n");
@@ -400,9 +404,10 @@ static int hexium_attach(struct saa7146_dev *dev, struct saa7146_pci_extension_d
         vv_data.ops.vidioc_enum_input = vidioc_enum_input;
         vv_data.ops.vidioc_g_input = vidioc_g_input;
         vv_data.ops.vidioc_s_input = vidioc_s_input;
-        if (0 != saa7146_register_device(&hexium->video_dev, dev, "hexium gemini", VFL_TYPE_GRABBER)) {
+        ret = saa7146_register_device(&hexium->video_dev, dev, "hexium gemini", VFL_TYPE_GRABBER);
+        if (ret < 0) {
                 printk("hexium_gemini: cannot register capture v4l2 device. skipping.\n");
-                return -1;
+                return ret;
         }
 
         printk("hexium_gemini: found 'hexium gemini' frame grabber-%d.\n", hexium_num);
diff --git a/drivers/media/video/hexium_orion.c b/drivers/media/video/hexium_orion.c
index 938a1f8f880a..fe596a1c12a8 100644
--- a/drivers/media/video/hexium_orion.c
+++ b/drivers/media/video/hexium_orion.c
@@ -216,6 +216,10 @@ static int hexium_probe(struct saa7146_dev *dev)
                 return -EFAULT;
         }
 
+        err = saa7146_vv_devinit(dev);
+        if (err)
+                return err;
+
         hexium = kzalloc(sizeof(struct hexium), GFP_KERNEL);
         if (NULL == hexium) {
                 printk("hexium_orion: hexium_probe: not enough kernel memory.\n");
diff --git a/drivers/media/video/ir-kbd-i2c.c b/drivers/media/video/ir-kbd-i2c.c
index b86e35386cee..da18d698e7f2 100644
--- a/drivers/media/video/ir-kbd-i2c.c
+++ b/drivers/media/video/ir-kbd-i2c.c
@@ -299,7 +299,7 @@ static int ir_probe(struct i2c_client *client, const struct i2c_device_id *id)
 {
         struct ir_scancode_table *ir_codes = NULL;
         const char *name = NULL;
-        int ir_type = 0;
+        u64 ir_type = 0;
         struct IR_i2c *ir;
         struct input_dev *input_dev;
         struct i2c_adapter *adap = client->adapter;
@@ -331,6 +331,7 @@ static int ir_probe(struct i2c_client *client, const struct i2c_device_id *id)
                 ir_codes    = &ir_codes_pv951_table;
                 break;
         case 0x18:
+        case 0x1f:
         case 0x1a:
                 name        = "Hauppauge";
                 ir->get_key = get_key_haup;
@@ -446,7 +447,7 @@ static int ir_probe(struct i2c_client *client, const struct i2c_device_id *id)
         input_dev->name       = ir->name;
         input_dev->phys       = ir->phys;
 
-        err = ir_input_register(ir->input, ir->ir_codes);
+        err = ir_input_register(ir->input, ir->ir_codes, NULL);
         if (err)
                 goto err_out_free;
 
diff --git a/drivers/media/video/ivtv/ivtv-cards.c b/drivers/media/video/ivtv/ivtv-cards.c
index 79d0fe4990d6..ca1fd3227a93 100644
--- a/drivers/media/video/ivtv/ivtv-cards.c
+++ b/drivers/media/video/ivtv/ivtv-cards.c
@@ -1210,6 +1210,53 @@ static const struct ivtv_card ivtv_card_buffalo = {
         .i2c = &ivtv_i2c_std,
 };
 
+/* ------------------------------------------------------------------------- */
+/* Sony Kikyou */
+
+static const struct ivtv_card_pci_info ivtv_pci_kikyou[] = {
+        { PCI_DEVICE_ID_IVTV16, IVTV_PCI_ID_SONY, 0x813d },
+        { 0, 0, 0 }
+};
+
+static const struct ivtv_card ivtv_card_kikyou = {
+        .type = IVTV_CARD_KIKYOU,
+        .name = "Sony VAIO Giga Pocket (ENX Kikyou)",
+        .v4l2_capabilities = IVTV_CAP_ENCODER,
+        .hw_video = IVTV_HW_SAA7115,
+        .hw_audio = IVTV_HW_GPIO,
+        .hw_audio_ctrl = IVTV_HW_GPIO,
+        .hw_all = IVTV_HW_GPIO | IVTV_HW_SAA7115 | IVTV_HW_TUNER,
+        .video_inputs = {
+        { IVTV_CARD_INPUT_VID_TUNER,  0, IVTV_SAA71XX_COMPOSITE1 },
+        { IVTV_CARD_INPUT_COMPOSITE1, 1, IVTV_SAA71XX_COMPOSITE1 },
+        { IVTV_CARD_INPUT_SVIDEO1,    1, IVTV_SAA71XX_SVIDEO1 },
+        },
+        .audio_inputs = {
+             { IVTV_CARD_INPUT_AUD_TUNER,  IVTV_GPIO_TUNER },
+             { IVTV_CARD_INPUT_LINE_IN1,   IVTV_GPIO_LINE_IN },
+             { IVTV_CARD_INPUT_LINE_IN2,   IVTV_GPIO_LINE_IN },
+        },
+        .gpio_init = { .direction = 0x03e1, .initial_value = 0x0320 },
+        .gpio_audio_input = { .mask   = 0x0060,
+                              .tuner  = 0x0020,
+                              .linein = 0x0000,
+                              .radio  = 0x0060 },
+        .gpio_audio_mute  = { .mask = 0x0000,
+                              .mute = 0x0000 }, /* 0x200? Disable for now. */
+        .gpio_audio_mode  = { .mask   = 0x0080,
+                              .mono   = 0x0000,
+                              .stereo = 0x0000, /* SAP */
+                              .lang1  = 0x0080,
+                              .lang2  = 0x0000,
+                              .both   = 0x0080 },
+        .tuners = {
+             { .std = V4L2_STD_ALL, .tuner = TUNER_SONY_BTF_PXN01Z },
+        },
+        .pci_list = ivtv_pci_kikyou,
+        .i2c = &ivtv_i2c_std,
+};
+
+
 static const struct ivtv_card *ivtv_card_list[] = {
         &ivtv_card_pvr250,
         &ivtv_card_pvr350,
@@ -1238,6 +1285,7 @@ static const struct ivtv_card *ivtv_card_list[] = {
         &ivtv_card_aver_m104,
         &ivtv_card_buffalo,
         &ivtv_card_aver_ultra1500mce,
+        &ivtv_card_kikyou,
 
         /* Variations of standard cards but with the same PCI IDs.
            These cards must come last in this list. */
diff --git a/drivers/media/video/ivtv/ivtv-cards.h b/drivers/media/video/ivtv/ivtv-cards.h
index 6148827ec885..78eca992e1fd 100644
--- a/drivers/media/video/ivtv/ivtv-cards.h
+++ b/drivers/media/video/ivtv/ivtv-cards.h
@@ -51,7 +51,8 @@
 #define IVTV_CARD_AVER_M104          24 /* AverMedia M104 miniPCI card */
 #define IVTV_CARD_BUFFALO_MV5L       25 /* Buffalo PC-MV5L/PCI card */
 #define IVTV_CARD_AVER_ULTRA1500MCE  26 /* AVerMedia UltraTV 1500 MCE */
-#define IVTV_CARD_LAST               26
+#define IVTV_CARD_KIKYOU             27 /* Sony VAIO Giga Pocket (ENX Kikyou) */
+#define IVTV_CARD_LAST               27
 
 /* Variants of existing cards but with the same PCI IDs. The driver
    detects these based on other device information.
@@ -86,6 +87,7 @@
 #define IVTV_PCI_ID_MELCO               0x1154
 #define IVTV_PCI_ID_GOTVIEW1            0xffac
 #define IVTV_PCI_ID_GOTVIEW2            0xffad
+#define IVTV_PCI_ID_SONY                0x104d
 
 /* hardware flags, no gaps allowed */
 #define IVTV_HW_CX25840                 (1 << 0)
diff --git a/drivers/media/video/ivtv/ivtv-driver.c b/drivers/media/video/ivtv/ivtv-driver.c
index 347c3344f56d..9a250548be4d 100644
--- a/drivers/media/video/ivtv/ivtv-driver.c
+++ b/drivers/media/video/ivtv/ivtv-driver.c
@@ -193,6 +193,7 @@ MODULE_PARM_DESC(cardtype,
                  "\t\t\t25 = AverMedia M104 (not yet working)\n"
                  "\t\t\t26 = Buffalo PC-MV5L/PCI\n"
                  "\t\t\t27 = AVerMedia UltraTV 1500 MCE\n"
+                 "\t\t\t28 = Sony VAIO Giga Pocket (ENX Kikyou)\n"
                  "\t\t\t 0 = Autodetect (default)\n"
                  "\t\t\t-1 = Ignore this card\n\t\t");
 MODULE_PARM_DESC(pal, "Set PAL standard: BGH, DK, I, M, N, Nc, 60");
diff --git a/drivers/media/video/ivtv/ivtv-firmware.c b/drivers/media/video/ivtv/ivtv-firmware.c
index c1b7ec475c27..a71e8ba306b0 100644
--- a/drivers/media/video/ivtv/ivtv-firmware.c
+++ b/drivers/media/video/ivtv/ivtv-firmware.c
@@ -258,7 +258,7 @@ void ivtv_init_mpeg_decoder(struct ivtv *itv)
                 IVTV_ERR("ivtv_init_mpeg_decoder failed to start playback\n");
                 return;
         }
-        ivtv_api_get_data(&itv->dec_mbox, IVTV_MBOX_DMA, data);
+        ivtv_api_get_data(&itv->dec_mbox, IVTV_MBOX_DMA, 2, data);
         mem_offset = itv->dec_mem + data[1];
 
         if ((readbytes = load_fw_direct(IVTV_DECODE_INIT_MPEG_FILENAME,
diff --git a/drivers/media/video/ivtv/ivtv-irq.c b/drivers/media/video/ivtv/ivtv-irq.c
index cd9db0bf33bf..12d36ca91d53 100644
--- a/drivers/media/video/ivtv/ivtv-irq.c
+++ b/drivers/media/video/ivtv/ivtv-irq.c
@@ -562,7 +562,7 @@ static void ivtv_irq_enc_dma_complete(struct ivtv *itv)
         u32 data[CX2341X_MBOX_MAX_DATA];
         struct ivtv_stream *s;
 
-        ivtv_api_get_data(&itv->enc_mbox, IVTV_MBOX_DMA_END, data);
+        ivtv_api_get_data(&itv->enc_mbox, IVTV_MBOX_DMA_END, 2, data);
         IVTV_DEBUG_HI_IRQ("ENC DMA COMPLETE %x %d (%d)\n", data[0], data[1], itv->cur_dma_stream);
 
         del_timer(&itv->dma_timer);
@@ -638,7 +638,7 @@ static void ivtv_irq_dma_err(struct ivtv *itv)
         u32 data[CX2341X_MBOX_MAX_DATA];
 
         del_timer(&itv->dma_timer);
-        ivtv_api_get_data(&itv->enc_mbox, IVTV_MBOX_DMA_END, data);
+        ivtv_api_get_data(&itv->enc_mbox, IVTV_MBOX_DMA_END, 2, data);
         IVTV_DEBUG_WARN("DMA ERROR %08x %08x %08x %d\n", data[0], data[1],
                                 read_reg(IVTV_REG_DMASTATUS), itv->cur_dma_stream);
         write_reg(read_reg(IVTV_REG_DMASTATUS) & 3, IVTV_REG_DMASTATUS);
@@ -669,7 +669,7 @@ static void ivtv_irq_enc_start_cap(struct ivtv *itv)
         struct ivtv_stream *s;
 
         /* Get DMA destination and size arguments from card */
-        ivtv_api_get_data(&itv->enc_mbox, IVTV_MBOX_DMA, data);
+        ivtv_api_get_data(&itv->enc_mbox, IVTV_MBOX_DMA, 7, data);
         IVTV_DEBUG_HI_IRQ("ENC START CAP %d: %08x %08x\n", data[0], data[1], data[2]);
 
         if (data[0] > 2 || data[1] == 0 || data[2] == 0) {
@@ -713,9 +713,9 @@ static void ivtv_irq_dec_data_req(struct ivtv *itv)
         struct ivtv_stream *s;
 
         /* YUV or MPG */
-        ivtv_api_get_data(&itv->dec_mbox, IVTV_MBOX_DMA, data);
 
         if (test_bit(IVTV_F_I_DEC_YUV, &itv->i_flags)) {
+                ivtv_api_get_data(&itv->dec_mbox, IVTV_MBOX_DMA, 2, data);
                 itv->dma_data_req_size =
                                  1080 * ((itv->yuv_info.v4l2_src_h + 31) & ~31);
                 itv->dma_data_req_offset = data[1];
@@ -724,6 +724,7 @@ static void ivtv_irq_dec_data_req(struct ivtv *itv)
                 s = &itv->streams[IVTV_DEC_STREAM_TYPE_YUV];
         }
         else {
+                ivtv_api_get_data(&itv->dec_mbox, IVTV_MBOX_DMA, 3, data);
                 itv->dma_data_req_size = min_t(u32, data[2], 0x10000);
                 itv->dma_data_req_offset = data[1];
                 s = &itv->streams[IVTV_DEC_STREAM_TYPE_MPG];
@@ -940,9 +941,10 @@ irqreturn_t ivtv_irq_handler(int irq, void *dev_id)
                                 ivtv_dma_enc_start(s);
                         break;
                 }
-                if (i == IVTV_MAX_STREAMS && test_and_clear_bit(IVTV_F_I_UDMA_PENDING, &itv->i_flags)) {
+
+                if (i == IVTV_MAX_STREAMS &&
+                    test_bit(IVTV_F_I_UDMA_PENDING, &itv->i_flags))
                         ivtv_udma_start(itv);
-                }
         }
 
         if ((combo & IVTV_IRQ_DMA) && !test_bit(IVTV_F_I_PIO, &itv->i_flags)) {
diff --git a/drivers/media/video/ivtv/ivtv-mailbox.c b/drivers/media/video/ivtv/ivtv-mailbox.c
index 1b5c0ac09a85..84577f6f41a2 100644
--- a/drivers/media/video/ivtv/ivtv-mailbox.c
+++ b/drivers/media/video/ivtv/ivtv-mailbox.c
@@ -369,10 +369,11 @@ int ivtv_vapi(struct ivtv *itv, int cmd, int args, ...)
 }
 
 /* This one is for stuff that can't sleep.. irq handlers, etc.. */
-void ivtv_api_get_data(struct ivtv_mailbox_data *mbdata, int mb, u32 data[])
+void ivtv_api_get_data(struct ivtv_mailbox_data *mbdata, int mb,
+                       int argc, u32 data[])
 {
+        volatile u32 __iomem *p = mbdata->mbox[mb].data;
         int i;
-
-        for (i = 0; i < CX2341X_MBOX_MAX_DATA; i++)
-                data[i] = readl(&mbdata->mbox[mb].data[i]);
+        for (i = 0; i < argc; i++, p++)
+                data[i] = readl(p);
 }
diff --git a/drivers/media/video/ivtv/ivtv-mailbox.h b/drivers/media/video/ivtv/ivtv-mailbox.h
index 6ef12091e3f3..8247662c928e 100644
--- a/drivers/media/video/ivtv/ivtv-mailbox.h
+++ b/drivers/media/video/ivtv/ivtv-mailbox.h
@@ -24,7 +24,8 @@
 #define IVTV_MBOX_DMA_END         8
 #define IVTV_MBOX_DMA             9
 
-void ivtv_api_get_data(struct ivtv_mailbox_data *mbox, int mb, u32 data[]);
+void ivtv_api_get_data(struct ivtv_mailbox_data *mbdata, int mb,
+                       int argc, u32 data[]);
 int ivtv_api(struct ivtv *itv, int cmd, int args, u32 data[]);
 int ivtv_vapi_result(struct ivtv *itv, u32 data[CX2341X_MBOX_MAX_DATA], int cmd, int args, ...);
 int ivtv_vapi(struct ivtv *itv, int cmd, int args, ...);
diff --git a/drivers/media/video/ivtv/ivtv-streams.c b/drivers/media/video/ivtv/ivtv-streams.c
index e12c6022373e..1f9387f6ca24 100644
--- a/drivers/media/video/ivtv/ivtv-streams.c
+++ b/drivers/media/video/ivtv/ivtv-streams.c
@@ -577,10 +577,14 @@ int ivtv_start_v4l2_encode_stream(struct ivtv_stream *s)
                 clear_bit(IVTV_F_I_EOS, &itv->i_flags);
 
                 /* Initialize Digitizer for Capture */
+                /* Avoid tinny audio problem - ensure audio clocks are going */
+                v4l2_subdev_call(itv->sd_audio, audio, s_stream, 1);
+                /* Avoid unpredictable PCI bus hang - disable video clocks */
                 v4l2_subdev_call(itv->sd_video, video, s_stream, 0);
-                ivtv_msleep_timeout(300, 1);
+                ivtv_msleep_timeout(150, 1);
                 ivtv_vapi(itv, CX2341X_ENC_INITIALIZE_INPUT, 0);
                 v4l2_subdev_call(itv->sd_video, video, s_stream, 1);
+                ivtv_msleep_timeout(150, 1);
         }
 
         /* begin_capture */
diff --git a/drivers/media/video/ivtv/ivtv-udma.c b/drivers/media/video/ivtv/ivtv-udma.c
index d07ad6c39024..1daf1dd65bf7 100644
--- a/drivers/media/video/ivtv/ivtv-udma.c
+++ b/drivers/media/video/ivtv/ivtv-udma.c
@@ -213,6 +213,7 @@ void ivtv_udma_start(struct ivtv *itv)
         write_reg_sync(read_reg(IVTV_REG_DMAXFER) | 0x01, IVTV_REG_DMAXFER);
         set_bit(IVTV_F_I_DMA, &itv->i_flags);
         set_bit(IVTV_F_I_UDMA, &itv->i_flags);
+        clear_bit(IVTV_F_I_UDMA_PENDING, &itv->i_flags);
 }
 
 void ivtv_udma_prepare(struct ivtv *itv)
diff --git a/drivers/media/video/mt9t112.c b/drivers/media/video/mt9t112.c
index fc4dd6045720..7438f8d775ba 100644
--- a/drivers/media/video/mt9t112.c
+++ b/drivers/media/video/mt9t112.c
@@ -514,7 +514,7 @@ static int mt9t112_init_pll(const struct i2c_client *client)
         /* poll to verify out of standby. Must Poll this bit */
         for (i = 0; i < 100; i++) {
                 mt9t112_reg_read(data, client, 0x0018);
-                if (0x4000 & data)
+                if (!(0x4000 & data))
                         break;
 
                 mdelay(10);
diff --git a/drivers/media/video/mt9v022.c b/drivers/media/video/mt9v022.c
index 91df7ec91fb6..1a34d2993e94 100644
--- a/drivers/media/video/mt9v022.c
+++ b/drivers/media/video/mt9v022.c
@@ -257,19 +257,18 @@ static int mt9v022_set_bus_param(struct soc_camera_device *icd,
 static unsigned long mt9v022_query_bus_param(struct soc_camera_device *icd)
 {
         struct soc_camera_link *icl = to_soc_camera_link(icd);
-        unsigned int width_flag;
+        unsigned int flags = SOCAM_MASTER | SOCAM_SLAVE |
+                SOCAM_PCLK_SAMPLE_RISING | SOCAM_PCLK_SAMPLE_FALLING |
+                SOCAM_HSYNC_ACTIVE_HIGH | SOCAM_HSYNC_ACTIVE_LOW |
+                SOCAM_VSYNC_ACTIVE_HIGH | SOCAM_VSYNC_ACTIVE_LOW |
+                SOCAM_DATA_ACTIVE_HIGH;
 
         if (icl->query_bus_param)
-                width_flag = icl->query_bus_param(icl) &
-                        SOCAM_DATAWIDTH_MASK;
+                flags |= icl->query_bus_param(icl) & SOCAM_DATAWIDTH_MASK;
         else
-                width_flag = SOCAM_DATAWIDTH_10;
+                flags |= SOCAM_DATAWIDTH_10;
 
-        return SOCAM_PCLK_SAMPLE_RISING | SOCAM_PCLK_SAMPLE_FALLING |
-                SOCAM_HSYNC_ACTIVE_HIGH | SOCAM_HSYNC_ACTIVE_LOW |
-                SOCAM_VSYNC_ACTIVE_HIGH | SOCAM_VSYNC_ACTIVE_LOW |
-                SOCAM_DATA_ACTIVE_HIGH | SOCAM_MASTER | SOCAM_SLAVE |
-                width_flag;
+        return soc_camera_apply_sensor_flags(icl, flags);
 }
 
 static int mt9v022_s_crop(struct v4l2_subdev *sd, struct v4l2_crop *a)
diff --git a/drivers/media/video/mxb.c b/drivers/media/video/mxb.c
index c1fc6dc776f5..9f01f14e4aa2 100644
--- a/drivers/media/video/mxb.c
+++ b/drivers/media/video/mxb.c
@@ -169,7 +169,11 @@ static struct saa7146_extension extension;
 static int mxb_probe(struct saa7146_dev *dev)
 {
         struct mxb *mxb = NULL;
+        int err;
 
+        err = saa7146_vv_devinit(dev);
+        if (err)
+                return err;
         mxb = kzalloc(sizeof(struct mxb), GFP_KERNEL);
         if (mxb == NULL) {
                 DEB_D(("not enough kernel memory.\n"));
@@ -294,7 +298,7 @@ static int mxb_init_done(struct saa7146_dev* dev)
         /* select tuner-output on saa7111a */
         i = 0;
         saa7111a_call(mxb, video, s_routing, SAA7115_COMPOSITE0,
-                SAA7111_FMT_CCIR | SAA7111_VBI_BYPASS, 0);
+                SAA7111_FMT_CCIR, 0);
 
         /* select a tuner type */
         tun_setup.mode_mask = T_ANALOG_TV;
@@ -518,8 +522,8 @@ static int vidioc_s_input(struct file *file, void *fh, unsigned int input)
                 return err;
 
         /* switch video in saa7111a */
-        if (saa7111a_call(mxb, video, s_routing, i, 0, 0))
-                printk(KERN_ERR "VIDIOC_S_INPUT: could not address saa7111a #1.\n");
+        if (saa7111a_call(mxb, video, s_routing, i, SAA7111_FMT_CCIR, 0))
+                printk(KERN_ERR "VIDIOC_S_INPUT: could not address saa7111a.\n");
 
         /* switch the audio-source only if necessary */
         if (0 == mxb->cur_mute)
diff --git a/drivers/media/video/ov772x.c b/drivers/media/video/ov772x.c
index 3a45e945a528..7f8ece30c77b 100644
--- a/drivers/media/video/ov772x.c
+++ b/drivers/media/video/ov772x.c
@@ -547,7 +547,6 @@ static const struct v4l2_queryctrl ov772x_controls[] = {
         },
 };
 
-
 /*
  * general function
  */
@@ -634,7 +633,12 @@ static unsigned long ov772x_query_bus_param(struct soc_camera_device *icd)
         struct soc_camera_link *icl = to_soc_camera_link(icd);
         unsigned long flags = SOCAM_PCLK_SAMPLE_RISING | SOCAM_MASTER |
                 SOCAM_VSYNC_ACTIVE_HIGH | SOCAM_HSYNC_ACTIVE_HIGH |
-                SOCAM_DATA_ACTIVE_HIGH | priv->info->buswidth;
+                SOCAM_DATA_ACTIVE_HIGH;
+
+        if (priv->info->flags & OV772X_FLAG_8BIT)
+                flags |= SOCAM_DATAWIDTH_8;
+        else
+                flags |= SOCAM_DATAWIDTH_10;
 
         return soc_camera_apply_sensor_flags(icl, flags);
 }
@@ -1040,15 +1044,6 @@ static int ov772x_video_probe(struct soc_camera_device *icd,
                 return -ENODEV;
 
         /*
-         * ov772x only use 8 or 10 bit bus width
-         */
-        if (SOCAM_DATAWIDTH_10 != priv->info->buswidth &&
-            SOCAM_DATAWIDTH_8  != priv->info->buswidth) {
-                dev_err(&client->dev, "bus width error\n");
-                return -ENODEV;
-        }
-
-        /*
          * check and show product ID and manufacturer ID
          */
         pid = i2c_smbus_read_byte_data(client, PID);
@@ -1130,7 +1125,6 @@ static int ov772x_probe(struct i2c_client *client,
                         const struct i2c_device_id *did)
 {
         struct ov772x_priv        *priv;
-        struct ov772x_camera_info *info;
         struct soc_camera_device  *icd = client->dev.platform_data;
         struct i2c_adapter        *adapter = to_i2c_adapter(client->dev.parent);
         struct soc_camera_link    *icl;
@@ -1145,8 +1139,6 @@ static int ov772x_probe(struct i2c_client *client,
         if (!icl || !icl->priv)
                 return -EINVAL;
 
-        info = icl->priv;
-
         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
                 dev_err(&adapter->dev,
                         "I2C-Adapter doesn't support "
@@ -1158,7 +1150,7 @@ static int ov772x_probe(struct i2c_client *client,
         if (!priv)
                 return -ENOMEM;
 
-        priv->info = info;
+        priv->info = icl->priv;
 
         v4l2_i2c_subdev_init(&priv->subdev, client, &ov772x_subdev_ops);
 
diff --git a/drivers/media/video/pvrusb2/pvrusb2-hdw-internal.h b/drivers/media/video/pvrusb2/pvrusb2-hdw-internal.h
index de5485f506b1..cb4057bb07a0 100644
--- a/drivers/media/video/pvrusb2/pvrusb2-hdw-internal.h
+++ b/drivers/media/video/pvrusb2/pvrusb2-hdw-internal.h
@@ -233,8 +233,9 @@ struct pvr2_hdw {
         int state_encoder_waitok;     /* Encoder pre-wait done */
         int state_encoder_runok;      /* Encoder has run for >= .25 sec */
         int state_decoder_run;        /* Decoder is running */
+        int state_decoder_ready;      /* Decoder is stabilized & streamable */
         int state_usbstream_run;      /* FX2 is streaming */
-        int state_decoder_quiescent;  /* Decoder idle for > 50msec */
+        int state_decoder_quiescent;  /* Decoder idle for minimal interval */
         int state_pipeline_config;    /* Pipeline is configured */
         int state_pipeline_req;       /* Somebody wants to stream */
         int state_pipeline_pause;     /* Pipeline must be paused */
@@ -255,9 +256,16 @@ struct pvr2_hdw {
         void (*state_func)(void *);
         void *state_data;
 
-        /* Timer for measuring decoder settling time */
+        /* Timer for measuring required decoder settling time before we're
+           allowed to fire it up again. */
         struct timer_list quiescent_timer;
 
+        /* Timer for measuring decoder stabilization time, which is the
+           amount of time we need to let the decoder run before we can
+           trust its output (otherwise the encoder might see garbage and
+           then fail to start correctly). */
+        struct timer_list decoder_stabilization_timer;
+
         /* Timer for measuring encoder pre-wait time */
         struct timer_list encoder_wait_timer;
 
diff --git a/drivers/media/video/pvrusb2/pvrusb2-hdw.c b/drivers/media/video/pvrusb2/pvrusb2-hdw.c
index 1bbdab08fe0e..712b300f723f 100644
--- a/drivers/media/video/pvrusb2/pvrusb2-hdw.c
+++ b/drivers/media/video/pvrusb2/pvrusb2-hdw.c
@@ -48,11 +48,13 @@
    before we are allowed to start it running. */
 #define TIME_MSEC_DECODER_WAIT 50
 
+/* This defines a minimum interval that the decoder must be allowed to run
+   before we can safely begin using its streaming output. */
+#define TIME_MSEC_DECODER_STABILIZATION_WAIT 300
+
 /* This defines a minimum interval that the encoder must remain quiet
-   before we are allowed to configure it.  I had this originally set to
-   50msec, but Martin Dauskardt <martin.dauskardt@gmx.de> reports that
-   things work better when it's set to 100msec. */
-#define TIME_MSEC_ENCODER_WAIT 100
+   before we are allowed to configure it. */
+#define TIME_MSEC_ENCODER_WAIT 50
 
 /* This defines the minimum interval that the encoder must successfully run
    before we consider that the encoder has run at least once since its
@@ -334,6 +336,7 @@ static int pvr2_hdw_get_eeprom_addr(struct pvr2_hdw *hdw);
 static void pvr2_hdw_internal_find_stdenum(struct pvr2_hdw *hdw);
 static void pvr2_hdw_internal_set_std_avail(struct pvr2_hdw *hdw);
 static void pvr2_hdw_quiescent_timeout(unsigned long);
+static void pvr2_hdw_decoder_stabilization_timeout(unsigned long);
 static void pvr2_hdw_encoder_wait_timeout(unsigned long);
 static void pvr2_hdw_encoder_run_timeout(unsigned long);
 static int pvr2_issue_simple_cmd(struct pvr2_hdw *,u32);
@@ -1705,6 +1708,7 @@ static int pvr2_decoder_enable(struct pvr2_hdw *hdw,int enablefl)
         pvr2_trace(PVR2_TRACE_CHIPS, "subdev v4l2 stream=%s",
                    (enablefl ? "on" : "off"));
         v4l2_device_call_all(&hdw->v4l2_dev, 0, video, s_stream, enablefl);
+        v4l2_device_call_all(&hdw->v4l2_dev, 0, audio, s_stream, enablefl);
         if (hdw->decoder_client_id) {
                 /* We get here if the encoder has been noticed.  Otherwise
                    we'll issue a warning to the user (which should
@@ -2461,6 +2465,11 @@ struct pvr2_hdw *pvr2_hdw_create(struct usb_interface *intf,
         hdw->quiescent_timer.data = (unsigned long)hdw;
         hdw->quiescent_timer.function = pvr2_hdw_quiescent_timeout;
 
+        init_timer(&hdw->decoder_stabilization_timer);
+        hdw->decoder_stabilization_timer.data = (unsigned long)hdw;
+        hdw->decoder_stabilization_timer.function =
+                pvr2_hdw_decoder_stabilization_timeout;
+
         init_timer(&hdw->encoder_wait_timer);
         hdw->encoder_wait_timer.data = (unsigned long)hdw;
         hdw->encoder_wait_timer.function = pvr2_hdw_encoder_wait_timeout;
@@ -2674,6 +2683,7 @@ struct pvr2_hdw *pvr2_hdw_create(struct usb_interface *intf,
  fail:
         if (hdw) {
                 del_timer_sync(&hdw->quiescent_timer);
+                del_timer_sync(&hdw->decoder_stabilization_timer);
                 del_timer_sync(&hdw->encoder_run_timer);
                 del_timer_sync(&hdw->encoder_wait_timer);
                 if (hdw->workqueue) {
@@ -2741,6 +2751,7 @@ void pvr2_hdw_destroy(struct pvr2_hdw *hdw)
                 hdw->workqueue = NULL;
         }
         del_timer_sync(&hdw->quiescent_timer);
+        del_timer_sync(&hdw->decoder_stabilization_timer);
         del_timer_sync(&hdw->encoder_run_timer);
         del_timer_sync(&hdw->encoder_wait_timer);
         if (hdw->fw_buffer) {
@@ -4452,7 +4463,7 @@ static int state_check_enable_encoder_run(struct pvr2_hdw *hdw)
 
         switch (hdw->pathway_state) {
         case PVR2_PATHWAY_ANALOG:
-                if (hdw->state_decoder_run) {
+                if (hdw->state_decoder_run && hdw->state_decoder_ready) {
                         /* In analog mode, if the decoder is running, then
                            run the encoder. */
                         return !0;
@@ -4519,6 +4530,17 @@ static void pvr2_hdw_quiescent_timeout(unsigned long data)
 }
 
 
+/* Timeout function for decoder stabilization timer. */
+static void pvr2_hdw_decoder_stabilization_timeout(unsigned long data)
+{
+        struct pvr2_hdw *hdw = (struct pvr2_hdw *)data;
+        hdw->state_decoder_ready = !0;
+        trace_stbit("state_decoder_ready", hdw->state_decoder_ready);
+        hdw->state_stale = !0;
+        queue_work(hdw->workqueue, &hdw->workpoll);
+}
+
+
 /* Timeout function for encoder wait timer. */
 static void pvr2_hdw_encoder_wait_timeout(unsigned long data)
 {
@@ -4557,8 +4579,13 @@ static int state_eval_decoder_run(struct pvr2_hdw *hdw)
                 }
                 hdw->state_decoder_quiescent = 0;
                 hdw->state_decoder_run = 0;
-                /* paranoia - solve race if timer just completed */
+                /* paranoia - solve race if timer(s) just completed */
                 del_timer_sync(&hdw->quiescent_timer);
+                /* Kill the stabilization timer, in case we're killing the
+                   encoder before the previous stabilization interval has
+                   been properly timed. */
+                del_timer_sync(&hdw->decoder_stabilization_timer);
+                hdw->state_decoder_ready = 0;
         } else {
                 if (!hdw->state_decoder_quiescent) {
                         if (!timer_pending(&hdw->quiescent_timer)) {
@@ -4596,10 +4623,21 @@ static int state_eval_decoder_run(struct pvr2_hdw *hdw)
                 if (hdw->flag_decoder_missed) return 0;
                 if (pvr2_decoder_enable(hdw,!0) < 0) return 0;
                 hdw->state_decoder_quiescent = 0;
+                hdw->state_decoder_ready = 0;
                 hdw->state_decoder_run = !0;
+                if (hdw->decoder_client_id == PVR2_CLIENT_ID_SAA7115) {
+                        hdw->decoder_stabilization_timer.expires =
+                                jiffies +
+                                (HZ * TIME_MSEC_DECODER_STABILIZATION_WAIT /
+                                 1000);
+                        add_timer(&hdw->decoder_stabilization_timer);
+                } else {
+                        hdw->state_decoder_ready = !0;
+                }
         }
         trace_stbit("state_decoder_quiescent",hdw->state_decoder_quiescent);
         trace_stbit("state_decoder_run",hdw->state_decoder_run);
+        trace_stbit("state_decoder_ready", hdw->state_decoder_ready);
         return !0;
 }
 
@@ -4797,7 +4835,8 @@ static unsigned int pvr2_hdw_report_unlocked(struct pvr2_hdw *hdw,int which,
                         buf,acnt,
                         "worker:%s%s%s%s%s%s%s",
                         (hdw->state_decoder_run ?
-                         " <decode:run>" :
+                         (hdw->state_decoder_ready ?
+                          "<decode:run>" : " <decode:start>") :
                          (hdw->state_decoder_quiescent ?
                           "" : " <decode:stop>")),
                         (hdw->state_decoder_quiescent ?
diff --git a/drivers/media/video/pvrusb2/pvrusb2-hdw.h b/drivers/media/video/pvrusb2/pvrusb2-hdw.h
index 56e70eae20c1..51d3009ab57f 100644
--- a/drivers/media/video/pvrusb2/pvrusb2-hdw.h
+++ b/drivers/media/video/pvrusb2/pvrusb2-hdw.h
@@ -306,6 +306,7 @@ struct pvr2_hdw_debug_info {
         int state_encoder_ok;
         int state_encoder_run;
         int state_decoder_run;
+        int state_decoder_ready;
         int state_usbstream_run;
         int state_decoder_quiescent;
         int state_pipeline_config;
diff --git a/drivers/media/video/pwc/pwc-ctrl.c b/drivers/media/video/pwc/pwc-ctrl.c
index 50b415e07eda..f7f7e04cf485 100644
--- a/drivers/media/video/pwc/pwc-ctrl.c
+++ b/drivers/media/video/pwc/pwc-ctrl.c
@@ -753,7 +753,7 @@ int pwc_set_shutter_speed(struct pwc_device *pdev, int mode, int value)
                 buf[0] = 0xff; /* fixed */
 
         ret = send_control_msg(pdev,
-                SET_LUM_CTL, SHUTTER_MODE_FORMATTER, &buf, sizeof(buf));
+                SET_LUM_CTL, SHUTTER_MODE_FORMATTER, &buf, 1);
 
         if (!mode && ret >= 0) {
                 if (value < 0)
diff --git a/drivers/media/video/pxa_camera.c b/drivers/media/video/pxa_camera.c
index 294f860ce2b0..322ac4eecf0a 100644
--- a/drivers/media/video/pxa_camera.c
+++ b/drivers/media/video/pxa_camera.c
@@ -898,18 +898,8 @@ static void recalculate_fifo_timeout(struct pxa_camera_dev *pcdev,
 
 static void pxa_camera_activate(struct pxa_camera_dev *pcdev)
 {
-        struct pxacamera_platform_data *pdata = pcdev->pdata;
-        struct device *dev = pcdev->soc_host.v4l2_dev.dev;
         u32 cicr4 = 0;
 
-        dev_dbg(dev, "Registered platform device at %p data %p\n",
-                pcdev, pdata);
-
-        if (pdata && pdata->init) {
-                dev_dbg(dev, "%s: Init gpios\n", __func__);
-                pdata->init(dev);
-        }
-
         /* disable all interrupts */
         __raw_writel(0x3ff, pcdev->base + CICR0);
 
diff --git a/drivers/media/video/rj54n1cb0c.c b/drivers/media/video/rj54n1cb0c.c
index 805226e0d9c1..9277194cd821 100644
--- a/drivers/media/video/rj54n1cb0c.c
+++ b/drivers/media/video/rj54n1cb0c.c
@@ -165,7 +165,7 @@ struct rj54n1_reg_val {
         u8 val;
 };
 
-const static struct rj54n1_reg_val bank_4[] = {
+static const struct rj54n1_reg_val bank_4[] = {
         {0x417, 0},
         {0x42c, 0},
         {0x42d, 0xf0},
@@ -186,7 +186,7 @@ const static struct rj54n1_reg_val bank_4[] = {
         {0x4fe, 2},
 };
 
-const static struct rj54n1_reg_val bank_5[] = {
+static const struct rj54n1_reg_val bank_5[] = {
         {0x514, 0},
         {0x516, 0},
         {0x518, 0},
@@ -207,7 +207,7 @@ const static struct rj54n1_reg_val bank_5[] = {
         {0x5fe, 2},
 };
 
-const static struct rj54n1_reg_val bank_7[] = {
+static const struct rj54n1_reg_val bank_7[] = {
         {0x70a, 0},
         {0x714, 0xff},
         {0x715, 0xff},
@@ -215,7 +215,7 @@ const static struct rj54n1_reg_val bank_7[] = {
         {0x7FE, 2},
 };
 
-const static struct rj54n1_reg_val bank_8[] = {
+static const struct rj54n1_reg_val bank_8[] = {
         {0x800, 0x00},
         {0x801, 0x01},
         {0x802, 0x61},
@@ -403,12 +403,12 @@ const static struct rj54n1_reg_val bank_8[] = {
         {0x8FE, 2},
 };
 
-const static struct rj54n1_reg_val bank_10[] = {
+static const struct rj54n1_reg_val bank_10[] = {
         {0x10bf, 0x69}
 };
 
 /* Clock dividers - these are default register values, divider = register + 1 */
-const static struct rj54n1_clock_div clk_div = {
+static const struct rj54n1_clock_div clk_div = {
         .ratio_tg       = 3 /* default: 5 */,
         .ratio_t        = 4 /* default: 1 */,
         .ratio_r        = 4 /* default: 0 */,
diff --git a/drivers/media/video/saa7115.c b/drivers/media/video/saa7115.c
index 44873a016c2c..c0a7f8a369f4 100644
--- a/drivers/media/video/saa7115.c
+++ b/drivers/media/video/saa7115.c
@@ -104,6 +104,10 @@ static int saa711x_has_reg(const int id, const u8 reg)
         if (id == V4L2_IDENT_SAA7111)
                 return reg < 0x20 && reg != 0x01 && reg != 0x0f &&
                        (reg < 0x13 || reg > 0x19) && reg != 0x1d && reg != 0x1e;
+        if (id == V4L2_IDENT_SAA7111A)
+                return reg < 0x20 && reg != 0x01 && reg != 0x0f &&
+                       reg != 0x14 && reg != 0x18 && reg != 0x19 &&
+                       reg != 0x1d && reg != 0x1e;
 
         /* common for saa7113/4/5/8 */
         if (unlikely((reg >= 0x3b && reg <= 0x3f) || reg == 0x5c || reg == 0x5f ||
@@ -954,8 +958,7 @@ static void saa711x_set_v4lstd(struct v4l2_subdev *sd, v4l2_std_id std)
         011 NTSC N (3.58MHz)            PAL M (3.58MHz)
         100 reserved                    NTSC-Japan (3.58MHz)
         */
-        if (state->ident == V4L2_IDENT_SAA7111 ||
-            state->ident == V4L2_IDENT_SAA7113) {
+        if (state->ident <= V4L2_IDENT_SAA7113) {
                 u8 reg = saa711x_read(sd, R_0E_CHROMA_CNTL_1) & 0x8f;
 
                 if (std == V4L2_STD_PAL_M) {
@@ -1232,22 +1235,19 @@ static int saa711x_s_routing(struct v4l2_subdev *sd,
                              u32 input, u32 output, u32 config)
 {
         struct saa711x_state *state = to_state(sd);
-        u8 mask = (state->ident == V4L2_IDENT_SAA7111) ? 0xf8 : 0xf0;
+        u8 mask = (state->ident <= V4L2_IDENT_SAA7111A) ? 0xf8 : 0xf0;
 
         v4l2_dbg(1, debug, sd, "decoder set input %d output %d\n",
                 input, output);
 
         /* saa7111/3 does not have these inputs */
-        if ((state->ident == V4L2_IDENT_SAA7113 ||
-             state->ident == V4L2_IDENT_SAA7111) &&
+        if (state->ident <= V4L2_IDENT_SAA7113 &&
             (input == SAA7115_COMPOSITE4 ||
              input == SAA7115_COMPOSITE5)) {
                 return -EINVAL;
         }
         if (input > SAA7115_SVIDEO3)
                 return -EINVAL;
-        if (output > SAA7115_IPORT_ON)
-                return -EINVAL;
         if (state->input == input && state->output == output)
                 return 0;
         v4l2_dbg(1, debug, sd, "now setting %s input %s output\n",
@@ -1256,7 +1256,7 @@ static int saa711x_s_routing(struct v4l2_subdev *sd,
         state->input = input;
 
         /* saa7111 has slightly different input numbering */
-        if (state->ident == V4L2_IDENT_SAA7111) {
+        if (state->ident <= V4L2_IDENT_SAA7111A) {
                 if (input >= SAA7115_COMPOSITE4)
                         input -= 2;
                 /* saa7111 specific */
@@ -1292,7 +1292,7 @@ static int saa711x_s_gpio(struct v4l2_subdev *sd, u32 val)
 {
         struct saa711x_state *state = to_state(sd);
 
-        if (state->ident != V4L2_IDENT_SAA7111)
+        if (state->ident > V4L2_IDENT_SAA7111A)
                 return -EINVAL;
         saa711x_write(sd, 0x11, (saa711x_read(sd, 0x11) & 0x7f) |
                 (val ? 0x80 : 0));
@@ -1596,6 +1596,10 @@ static int saa711x_probe(struct i2c_client *client,
         switch (chip_id) {
         case '1':
                 state->ident = V4L2_IDENT_SAA7111;
+                if (saa711x_read(sd, R_00_CHIP_VERSION) & 0xf0) {
+                        v4l_info(client, "saa7111a variant found\n");
+                        state->ident = V4L2_IDENT_SAA7111A;
+                }
                 break;
         case '3':
                 state->ident = V4L2_IDENT_SAA7113;
@@ -1612,7 +1616,7 @@ static int saa711x_probe(struct i2c_client *client,
         default:
                 state->ident = V4L2_IDENT_SAA7111;
                 v4l2_info(sd, "WARNING: Chip is not known - Falling back to saa7111\n");
-
+                break;
         }
 
         state->audclk_freq = 48000;
@@ -1623,6 +1627,7 @@ static int saa711x_probe(struct i2c_client *client,
         state->crystal_freq = SAA7115_FREQ_24_576_MHZ;
         switch (state->ident) {
         case V4L2_IDENT_SAA7111:
+        case V4L2_IDENT_SAA7111A:
                 saa711x_writeregs(sd, saa7111_init);
                 break;
         case V4L2_IDENT_SAA7113:
@@ -1632,7 +1637,7 @@ static int saa711x_probe(struct i2c_client *client,
                 state->crystal_freq = SAA7115_FREQ_32_11_MHZ;
                 saa711x_writeregs(sd, saa7115_init_auto_input);
         }
-        if (state->ident != V4L2_IDENT_SAA7111)
+        if (state->ident > V4L2_IDENT_SAA7111A)
                 saa711x_writeregs(sd, saa7115_init_misc);
         saa711x_set_v4lstd(sd, V4L2_STD_NTSC);
 
diff --git a/drivers/media/video/saa7127.c b/drivers/media/video/saa7127.c
index 2fe7a701b954..250ef84cf5ca 100644
--- a/drivers/media/video/saa7127.c
+++ b/drivers/media/video/saa7127.c
@@ -181,7 +181,7 @@ static const struct i2c_reg_value saa7127_init_config_common[] = {
 #define SAA7127_60HZ_DAC_CONTROL 0x15
 static const struct i2c_reg_value saa7127_init_config_60hz[] = {
         { SAA7127_REG_BURST_START,                      0x19 },
-        /* BURST_END is also used as a chip ID in saa7127_detect_client */
+        /* BURST_END is also used as a chip ID in saa7127_probe */
         { SAA7127_REG_BURST_END,                        0x1d },
         { SAA7127_REG_CHROMA_PHASE,                     0xa3 },
         { SAA7127_REG_GAINU,                            0x98 },
@@ -200,10 +200,10 @@ static const struct i2c_reg_value saa7127_init_config_60hz[] = {
         { 0, 0 }
 };
 
-#define SAA7127_50HZ_DAC_CONTROL 0x02
-static struct i2c_reg_value saa7127_init_config_50hz[] = {
+#define SAA7127_50HZ_PAL_DAC_CONTROL 0x02
+static struct i2c_reg_value saa7127_init_config_50hz_pal[] = {
         { SAA7127_REG_BURST_START,                      0x21 },
-        /* BURST_END is also used as a chip ID in saa7127_detect_client */
+        /* BURST_END is also used as a chip ID in saa7127_probe */
         { SAA7127_REG_BURST_END,                        0x1d },
         { SAA7127_REG_CHROMA_PHASE,                     0x3f },
         { SAA7127_REG_GAINU,                            0x7d },
@@ -222,6 +222,28 @@ static struct i2c_reg_value saa7127_init_config_50hz[] = {
         { 0, 0 }
 };
 
+#define SAA7127_50HZ_SECAM_DAC_CONTROL 0x08
+static struct i2c_reg_value saa7127_init_config_50hz_secam[] = {
+        { SAA7127_REG_BURST_START,                      0x21 },
+        /* BURST_END is also used as a chip ID in saa7127_probe */
+        { SAA7127_REG_BURST_END,                        0x1d },
+        { SAA7127_REG_CHROMA_PHASE,                     0x3f },
+        { SAA7127_REG_GAINU,                            0x6a },
+        { SAA7127_REG_GAINV,                            0x81 },
+        { SAA7127_REG_BLACK_LEVEL,                      0x33 },
+        { SAA7127_REG_BLANKING_LEVEL,                   0x35 },
+        { SAA7127_REG_VBI_BLANKING,                     0x35 },
+        { SAA7127_REG_DAC_CONTROL,                      0x08 },
+        { SAA7127_REG_BURST_AMP,                        0x2f },
+        { SAA7127_REG_SUBC3,                            0xb2 },
+        { SAA7127_REG_SUBC2,                            0x3b },
+        { SAA7127_REG_SUBC1,                            0xa3 },
+        { SAA7127_REG_SUBC0,                            0x28 },
+        { SAA7127_REG_MULTI,                            0x90 },
+        { SAA7127_REG_CLOSED_CAPTION,                   0x00 },
+        { 0, 0 }
+};
+
 /*
  **********************************************************************
  *
@@ -463,10 +485,21 @@ static int saa7127_set_std(struct v4l2_subdev *sd, v4l2_std_id std)
                 v4l2_dbg(1, debug, sd, "Selecting 60 Hz video Standard\n");
                 inittab = saa7127_init_config_60hz;
                 state->reg_61 = SAA7127_60HZ_DAC_CONTROL;
+
+        } else if (state->ident == V4L2_IDENT_SAA7129 &&
+                   (std & V4L2_STD_SECAM) &&
+                   !(std & (V4L2_STD_625_50 & ~V4L2_STD_SECAM))) {
+
+                /* If and only if SECAM, with a SAA712[89] */
+                v4l2_dbg(1, debug, sd,
+                         "Selecting 50 Hz SECAM video Standard\n");
+                inittab = saa7127_init_config_50hz_secam;
+                state->reg_61 = SAA7127_50HZ_SECAM_DAC_CONTROL;
+
         } else {
-                v4l2_dbg(1, debug, sd, "Selecting 50 Hz video Standard\n");
-                inittab = saa7127_init_config_50hz;
-                state->reg_61 = SAA7127_50HZ_DAC_CONTROL;
+                v4l2_dbg(1, debug, sd, "Selecting 50 Hz PAL video Standard\n");
+                inittab = saa7127_init_config_50hz_pal;
+                state->reg_61 = SAA7127_50HZ_PAL_DAC_CONTROL;
         }
 
         /* Write Table */
diff --git a/drivers/media/video/saa7134/saa7134-cards.c b/drivers/media/video/saa7134/saa7134-cards.c
index 03f572708b85..297833fb3b4a 100644
--- a/drivers/media/video/saa7134/saa7134-cards.c
+++ b/drivers/media/video/saa7134/saa7134-cards.c
@@ -4160,7 +4160,7 @@ struct saa7134_board saa7134_boards[] = {
                         .amux = LINE2,
                 },
         },
-        [SAA7134_BOARD_BEHOLD_505RDS] = {
+        [SAA7134_BOARD_BEHOLD_505RDS_MK5] = {
                 /*       Beholder Intl. Ltd. 2008      */
                 /*Dmitry Belimov <d.belimov@gmail.com> */
                 .name           = "Beholder BeholdTV 505 RDS",
@@ -5320,6 +5320,41 @@ struct saa7134_board saa7134_boards[] = {
                         .vmux = 8,
                 } },
         },
+        [SAA7134_BOARD_BEHOLD_505RDS_MK3] = {
+                /*       Beholder Intl. Ltd. 2008      */
+                /*Dmitry Belimov <d.belimov@gmail.com> */
+                .name           = "Beholder BeholdTV 505 RDS",
+                .audio_clock    = 0x00200000,
+                .tuner_type     = TUNER_PHILIPS_FM1216ME_MK3,
+                .radio_type     = UNSET,
+                .tuner_addr     = ADDR_UNSET,
+                .radio_addr     = ADDR_UNSET,
+                .rds_addr       = 0x10,
+                .tda9887_conf   = TDA9887_PRESENT,
+                .gpiomask       = 0x00008000,
+                .inputs         = {{
+                        .name = name_tv,
+                        .vmux = 3,
+                        .amux = LINE2,
+                        .tv   = 1,
+                }, {
+                        .name = name_comp1,
+                        .vmux = 1,
+                        .amux = LINE1,
+                }, {
+                        .name = name_svideo,
+                        .vmux = 8,
+                        .amux = LINE1,
+                } },
+                .mute = {
+                        .name = name_mute,
+                        .amux = LINE1,
+                },
+                .radio = {
+                        .name = name_radio,
+                        .amux = LINE2,
+                },
+        },
 
 };
 
@@ -6235,7 +6270,13 @@ struct pci_device_id saa7134_pci_tbl[] = {
                 .device       = PCI_DEVICE_ID_PHILIPS_SAA7130,
                 .subvendor    = 0x0000,
                 .subdevice    = 0x505B,
-                .driver_data  = SAA7134_BOARD_BEHOLD_505RDS,
+                .driver_data  = SAA7134_BOARD_BEHOLD_505RDS_MK5,
+        }, {
+                .vendor       = PCI_VENDOR_ID_PHILIPS,
+                .device       = PCI_DEVICE_ID_PHILIPS_SAA7130,
+                .subvendor    = 0x0000,
+                .subdevice    = 0x5051,
+                .driver_data  = SAA7134_BOARD_BEHOLD_505RDS_MK3,
         },{
                 .vendor       = PCI_VENDOR_ID_PHILIPS,
                 .device       = PCI_DEVICE_ID_PHILIPS_SAA7130,
@@ -6792,7 +6833,8 @@ int saa7134_board_init1(struct saa7134_dev *dev)
         case SAA7134_BOARD_BEHOLD_407FM:
         case SAA7134_BOARD_BEHOLD_409:
         case SAA7134_BOARD_BEHOLD_505FM:
-        case SAA7134_BOARD_BEHOLD_505RDS:
+        case SAA7134_BOARD_BEHOLD_505RDS_MK5:
+        case SAA7134_BOARD_BEHOLD_505RDS_MK3:
         case SAA7134_BOARD_BEHOLD_507_9FM:
         case SAA7134_BOARD_BEHOLD_507RDS_MK3:
         case SAA7134_BOARD_BEHOLD_507RDS_MK5:
@@ -6953,8 +6995,8 @@ int saa7134_board_init1(struct saa7134_dev *dev)
                 break;
         case SAA7134_BOARD_VIDEOMATE_S350:
                 dev->has_remote = SAA7134_REMOTE_GPIO;
-                saa_andorl(SAA7134_GPIO_GPMODE0 >> 2,   0x00008000, 0x00008000);
-                saa_andorl(SAA7134_GPIO_GPSTATUS0 >> 2, 0x00008000, 0x00008000);
+                saa_andorl(SAA7134_GPIO_GPMODE0 >> 2,   0x0000C000, 0x0000C000);
+                saa_andorl(SAA7134_GPIO_GPSTATUS0 >> 2, 0x0000C000, 0x0000C000);
                 break;
         }
         return 0;
diff --git a/drivers/media/video/saa7134/saa7134-input.c b/drivers/media/video/saa7134/saa7134-input.c
index f8e985989ca0..9499000f66b6 100644
--- a/drivers/media/video/saa7134/saa7134-input.c
+++ b/drivers/media/video/saa7134/saa7134-input.c
@@ -460,7 +460,7 @@ int saa7134_input_init1(struct saa7134_dev *dev)
         int polling      = 0;
         int rc5_gpio     = 0;
         int nec_gpio     = 0;
-        int ir_type      = IR_TYPE_OTHER;
+        u64 ir_type = IR_TYPE_OTHER;
         int err;
 
         if (dev->has_remote != SAA7134_REMOTE_GPIO)
@@ -568,7 +568,8 @@ int saa7134_input_init1(struct saa7134_dev *dev)
         case SAA7134_BOARD_BEHOLD_407FM:
         case SAA7134_BOARD_BEHOLD_409:
         case SAA7134_BOARD_BEHOLD_505FM:
-        case SAA7134_BOARD_BEHOLD_505RDS:
+        case SAA7134_BOARD_BEHOLD_505RDS_MK5:
+        case SAA7134_BOARD_BEHOLD_505RDS_MK3:
         case SAA7134_BOARD_BEHOLD_507_9FM:
         case SAA7134_BOARD_BEHOLD_507RDS_MK3:
         case SAA7134_BOARD_BEHOLD_507RDS_MK5:
@@ -728,7 +729,7 @@ int saa7134_input_init1(struct saa7134_dev *dev)
         dev->remote = ir;
         saa7134_ir_start(dev, ir);
 
-        err = ir_input_register(ir->dev, ir_codes);
+        err = ir_input_register(ir->dev, ir_codes, NULL);
         if (err)
                 goto err_out_stop;
 
diff --git a/drivers/media/video/saa7134/saa7134-video.c b/drivers/media/video/saa7134/saa7134-video.c
index cb732640ac4a..31138d3e51bb 100644
--- a/drivers/media/video/saa7134/saa7134-video.c
+++ b/drivers/media/video/saa7134/saa7134-video.c
@@ -205,7 +205,7 @@ static struct saa7134_format formats[] = {
 
 #define NORM_525_60                     \
                 .h_start       = 0,     \
-                .h_stop        = 703,   \
+                .h_stop        = 719,   \
                 .video_v_start = 23,    \
                 .video_v_stop  = 262,   \
                 .vbi_v_start_0 = 10,    \
diff --git a/drivers/media/video/saa7134/saa7134.h b/drivers/media/video/saa7134/saa7134.h
index 53b7e0b8a2fb..bf130967ed17 100644
--- a/drivers/media/video/saa7134/saa7134.h
+++ b/drivers/media/video/saa7134/saa7134.h
@@ -282,7 +282,7 @@ struct saa7134_format {
 #define SAA7134_BOARD_HAUPPAUGE_HVR1120   156
 #define SAA7134_BOARD_AVERMEDIA_STUDIO_507UA 157
 #define SAA7134_BOARD_AVERMEDIA_CARDBUS_501 158
-#define SAA7134_BOARD_BEHOLD_505RDS         159
+#define SAA7134_BOARD_BEHOLD_505RDS_MK5     159
 #define SAA7134_BOARD_BEHOLD_507RDS_MK3     160
 #define SAA7134_BOARD_BEHOLD_507RDS_MK5     161
 #define SAA7134_BOARD_BEHOLD_607FM_MK5      162
@@ -299,6 +299,7 @@ struct saa7134_format {
 #define SAA7134_BOARD_ZOLID_HYBRID_PCI          173
 #define SAA7134_BOARD_ASUS_EUROPA_HYBRID        174
 #define SAA7134_BOARD_LEADTEK_WINFAST_DTV1000S 175
+#define SAA7134_BOARD_BEHOLD_505RDS_MK3     176
 
 #define SAA7134_MAXBOARDS 32
 #define SAA7134_INPUT_MAX 8
diff --git a/drivers/media/video/saa7164/saa7164-api.c b/drivers/media/video/saa7164/saa7164-api.c
index 6f094a96ac81..1d487c150340 100644
--- a/drivers/media/video/saa7164/saa7164-api.c
+++ b/drivers/media/video/saa7164/saa7164-api.c
@@ -523,7 +523,7 @@ int saa7164_api_i2c_write(struct saa7164_i2c *bus, u8 addr, u32 datalen,
         }
 
         reglen = saa7164_i2caddr_to_reglen(bus, addr);
-        if (unitid < 0) {
+        if (reglen < 0) {
                 printk(KERN_ERR
                         "%s() error, cannot translate regaddr to reglen\n",
                         __func__);
diff --git a/drivers/media/video/sh_mobile_ceu_camera.c b/drivers/media/video/sh_mobile_ceu_camera.c
index f09c7140d6b2..fb88c63188f3 100644
--- a/drivers/media/video/sh_mobile_ceu_camera.c
+++ b/drivers/media/video/sh_mobile_ceu_camera.c
@@ -1748,6 +1748,22 @@ static void sh_mobile_ceu_init_videobuf(struct videobuf_queue *q,
                                        icd);
 }
 
+static int sh_mobile_ceu_get_parm(struct soc_camera_device *icd,
+                                  struct v4l2_streamparm *parm)
+{
+        struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
+
+        return v4l2_subdev_call(sd, video, g_parm, parm);
+}
+
+static int sh_mobile_ceu_set_parm(struct soc_camera_device *icd,
+                                  struct v4l2_streamparm *parm)
+{
+        struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
+
+        return v4l2_subdev_call(sd, video, s_parm, parm);
+}
+
 static int sh_mobile_ceu_get_ctrl(struct soc_camera_device *icd,
                                   struct v4l2_control *ctrl)
 {
@@ -1808,6 +1824,8 @@ static struct soc_camera_host_ops sh_mobile_ceu_host_ops = {
         .try_fmt        = sh_mobile_ceu_try_fmt,
         .set_ctrl       = sh_mobile_ceu_set_ctrl,
         .get_ctrl       = sh_mobile_ceu_get_ctrl,
+        .set_parm       = sh_mobile_ceu_set_parm,
+        .get_parm       = sh_mobile_ceu_get_parm,
         .reqbufs        = sh_mobile_ceu_reqbufs,
         .poll           = sh_mobile_ceu_poll,
         .querycap       = sh_mobile_ceu_querycap,
diff --git a/drivers/media/video/sn9c102/Kconfig b/drivers/media/video/sn9c102/Kconfig
index f71f272776de..6ebaf2940d06 100644
--- a/drivers/media/video/sn9c102/Kconfig
+++ b/drivers/media/video/sn9c102/Kconfig
@@ -1,7 +1,10 @@
 config USB_SN9C102
-        tristate "USB SN9C1xx PC Camera Controller support"
+        tristate "USB SN9C1xx PC Camera Controller support (DEPRECATED)"
         depends on VIDEO_V4L2
         ---help---
+          This driver is DEPRECATED please use the gspca sonixb and
+          sonixj modules instead.
+
           Say Y here if you want support for cameras based on SONiX SN9C101,
           SN9C102, SN9C103, SN9C105 and SN9C120 PC Camera Controllers.
 
diff --git a/drivers/media/video/sn9c102/sn9c102_devtable.h b/drivers/media/video/sn9c102/sn9c102_devtable.h
index 36ee43a9ee95..cc40d6ba9f22 100644
--- a/drivers/media/video/sn9c102/sn9c102_devtable.h
+++ b/drivers/media/video/sn9c102/sn9c102_devtable.h
@@ -45,20 +45,24 @@ static const struct usb_device_id sn9c102_id_table[] = {
         { SN9C102_USB_DEVICE(0x0c45, 0x6005, BRIDGE_SN9C102), },
 #endif
         { SN9C102_USB_DEVICE(0x0c45, 0x6007, BRIDGE_SN9C102), },
+#if !defined CONFIG_USB_GSPCA && !defined CONFIG_USB_GSPCA_MODULE
         { SN9C102_USB_DEVICE(0x0c45, 0x6009, BRIDGE_SN9C102), },
         { SN9C102_USB_DEVICE(0x0c45, 0x600d, BRIDGE_SN9C102), },
 /*      { SN9C102_USB_DEVICE(0x0c45, 0x6011, BRIDGE_SN9C102), }, OV6650 */
+#endif
         { SN9C102_USB_DEVICE(0x0c45, 0x6019, BRIDGE_SN9C102), },
         { SN9C102_USB_DEVICE(0x0c45, 0x6024, BRIDGE_SN9C102), },
         { SN9C102_USB_DEVICE(0x0c45, 0x6025, BRIDGE_SN9C102), },
+#if !defined CONFIG_USB_GSPCA && !defined CONFIG_USB_GSPCA_MODULE
         { SN9C102_USB_DEVICE(0x0c45, 0x6028, BRIDGE_SN9C102), },
         { SN9C102_USB_DEVICE(0x0c45, 0x6029, BRIDGE_SN9C102), },
+#endif
         { SN9C102_USB_DEVICE(0x0c45, 0x602a, BRIDGE_SN9C102), },
         { SN9C102_USB_DEVICE(0x0c45, 0x602b, BRIDGE_SN9C102), },
 #if !defined CONFIG_USB_GSPCA && !defined CONFIG_USB_GSPCA_MODULE
         { SN9C102_USB_DEVICE(0x0c45, 0x602c, BRIDGE_SN9C102), },
-#endif
 /*      { SN9C102_USB_DEVICE(0x0c45, 0x602d, BRIDGE_SN9C102), }, HV7131R */
+#endif
         { SN9C102_USB_DEVICE(0x0c45, 0x602e, BRIDGE_SN9C102), },
         { SN9C102_USB_DEVICE(0x0c45, 0x6030, BRIDGE_SN9C102), },
         /* SN9C103 */
diff --git a/drivers/media/video/soc_camera.c b/drivers/media/video/soc_camera.c
index 6b3fbcca7747..80f6bfa2632b 100644
--- a/drivers/media/video/soc_camera.c
+++ b/drivers/media/video/soc_camera.c
@@ -781,6 +781,32 @@ static int soc_camera_s_crop(struct file *file, void *fh,
         return ret;
 }
 
+static int soc_camera_g_parm(struct file *file, void *fh,
+                             struct v4l2_streamparm *a)
+{
+        struct soc_camera_file *icf = file->private_data;
+        struct soc_camera_device *icd = icf->icd;
+        struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
+
+        if (ici->ops->get_parm)
+                return ici->ops->get_parm(icd, a);
+
+        return -ENOIOCTLCMD;
+}
+
+static int soc_camera_s_parm(struct file *file, void *fh,
+                             struct v4l2_streamparm *a)
+{
+        struct soc_camera_file *icf = file->private_data;
+        struct soc_camera_device *icd = icf->icd;
+        struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
+
+        if (ici->ops->set_parm)
+                return ici->ops->set_parm(icd, a);
+
+        return -ENOIOCTLCMD;
+}
+
 static int soc_camera_g_chip_ident(struct file *file, void *fh,
                                    struct v4l2_dbg_chip_ident *id)
 {
@@ -846,10 +872,8 @@ static int soc_camera_init_i2c(struct soc_camera_device *icd,
         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
         struct i2c_adapter *adap = i2c_get_adapter(icl->i2c_adapter_id);
         struct v4l2_subdev *subdev;
-        int ret;
 
         if (!adap) {
-                ret = -ENODEV;
                 dev_err(&icd->dev, "Cannot get I2C adapter #%d. No driver?\n",
                         icl->i2c_adapter_id);
                 goto ei2cga;
@@ -859,10 +883,8 @@ static int soc_camera_init_i2c(struct soc_camera_device *icd,
 
         subdev = v4l2_i2c_new_subdev_board(&ici->v4l2_dev, adap,
                                 icl->module_name, icl->board_info, NULL);
-        if (!subdev) {
-                ret = -ENOMEM;
+        if (!subdev)
                 goto ei2cnd;
-        }
 
         client = subdev->priv;
 
@@ -873,7 +895,7 @@ static int soc_camera_init_i2c(struct soc_camera_device *icd,
 ei2cnd:
         i2c_put_adapter(adap);
 ei2cga:
-        return ret;
+        return -ENODEV;
 }
 
 static void soc_camera_free_i2c(struct soc_camera_device *icd)
@@ -1260,6 +1282,8 @@ static const struct v4l2_ioctl_ops soc_camera_ioctl_ops = {
         .vidioc_cropcap          = soc_camera_cropcap,
         .vidioc_g_crop           = soc_camera_g_crop,
         .vidioc_s_crop           = soc_camera_s_crop,
+        .vidioc_g_parm           = soc_camera_g_parm,
+        .vidioc_s_parm           = soc_camera_s_parm,
         .vidioc_g_chip_ident     = soc_camera_g_chip_ident,
 #ifdef CONFIG_VIDEO_ADV_DEBUG
         .vidioc_g_register       = soc_camera_g_register,
diff --git a/drivers/media/video/soc_mediabus.c b/drivers/media/video/soc_mediabus.c
index f8d5c87dc2aa..8b63b6545e76 100644
--- a/drivers/media/video/soc_mediabus.c
+++ b/drivers/media/video/soc_mediabus.c
@@ -24,91 +24,106 @@ static const struct soc_mbus_pixelfmt mbus_fmt[] = {
                 .bits_per_sample        = 8,
                 .packing                = SOC_MBUS_PACKING_2X8_PADHI,
                 .order                  = SOC_MBUS_ORDER_LE,
-        }, [MBUS_IDX(YVYU8_2X8_LE)] = {
+        },
+        [MBUS_IDX(YVYU8_2X8_LE)] = {
                 .fourcc                 = V4L2_PIX_FMT_YVYU,
                 .name                   = "YVYU",
                 .bits_per_sample        = 8,
                 .packing                = SOC_MBUS_PACKING_2X8_PADHI,
                 .order                  = SOC_MBUS_ORDER_LE,
-        }, [MBUS_IDX(YUYV8_2X8_BE)] = {
+        },
+        [MBUS_IDX(YUYV8_2X8_BE)] = {
                 .fourcc                 = V4L2_PIX_FMT_UYVY,
                 .name                   = "UYVY",
                 .bits_per_sample        = 8,
                 .packing                = SOC_MBUS_PACKING_2X8_PADHI,
                 .order                  = SOC_MBUS_ORDER_LE,
-        }, [MBUS_IDX(YVYU8_2X8_BE)] = {
+        },
+        [MBUS_IDX(YVYU8_2X8_BE)] = {
                 .fourcc                 = V4L2_PIX_FMT_VYUY,
                 .name                   = "VYUY",
                 .bits_per_sample        = 8,
                 .packing                = SOC_MBUS_PACKING_2X8_PADHI,
                 .order                  = SOC_MBUS_ORDER_LE,
-        }, [MBUS_IDX(RGB555_2X8_PADHI_LE)] = {
+        },
+        [MBUS_IDX(RGB555_2X8_PADHI_LE)] = {
                 .fourcc                 = V4L2_PIX_FMT_RGB555,
                 .name                   = "RGB555",
                 .bits_per_sample        = 8,
                 .packing                = SOC_MBUS_PACKING_2X8_PADHI,
                 .order                  = SOC_MBUS_ORDER_LE,
-        }, [MBUS_IDX(RGB555_2X8_PADHI_BE)] = {
+        },
+        [MBUS_IDX(RGB555_2X8_PADHI_BE)] = {
                 .fourcc                 = V4L2_PIX_FMT_RGB555X,
                 .name                   = "RGB555X",
                 .bits_per_sample        = 8,
                 .packing                = SOC_MBUS_PACKING_2X8_PADHI,
                 .order                  = SOC_MBUS_ORDER_LE,
-        }, [MBUS_IDX(RGB565_2X8_LE)] = {
+        },
+        [MBUS_IDX(RGB565_2X8_LE)] = {
                 .fourcc                 = V4L2_PIX_FMT_RGB565,
                 .name                   = "RGB565",
                 .bits_per_sample        = 8,
                 .packing                = SOC_MBUS_PACKING_2X8_PADHI,
                 .order                  = SOC_MBUS_ORDER_LE,
-        }, [MBUS_IDX(RGB565_2X8_BE)] = {
+        },
+        [MBUS_IDX(RGB565_2X8_BE)] = {
                 .fourcc                 = V4L2_PIX_FMT_RGB565X,
                 .name                   = "RGB565X",
                 .bits_per_sample        = 8,
                 .packing                = SOC_MBUS_PACKING_2X8_PADHI,
                 .order                  = SOC_MBUS_ORDER_LE,
-        }, [MBUS_IDX(SBGGR8_1X8)] = {
+        },
+        [MBUS_IDX(SBGGR8_1X8)] = {
                 .fourcc                 = V4L2_PIX_FMT_SBGGR8,
                 .name                   = "Bayer 8 BGGR",
                 .bits_per_sample        = 8,
                 .packing                = SOC_MBUS_PACKING_NONE,
                 .order                  = SOC_MBUS_ORDER_LE,
-        }, [MBUS_IDX(SBGGR10_1X10)] = {
+        },
+        [MBUS_IDX(SBGGR10_1X10)] = {
                 .fourcc                 = V4L2_PIX_FMT_SBGGR10,
                 .name                   = "Bayer 10 BGGR",
                 .bits_per_sample        = 10,
                 .packing                = SOC_MBUS_PACKING_EXTEND16,
                 .order                  = SOC_MBUS_ORDER_LE,
-        }, [MBUS_IDX(GREY8_1X8)] = {
+        },
+        [MBUS_IDX(GREY8_1X8)] = {
                 .fourcc                 = V4L2_PIX_FMT_GREY,
                 .name                   = "Grey",
                 .bits_per_sample        = 8,
                 .packing                = SOC_MBUS_PACKING_NONE,
                 .order                  = SOC_MBUS_ORDER_LE,
-        }, [MBUS_IDX(Y10_1X10)] = {
+        },
+        [MBUS_IDX(Y10_1X10)] = {
                 .fourcc                 = V4L2_PIX_FMT_Y10,
                 .name                   = "Grey 10bit",
                 .bits_per_sample        = 10,
                 .packing                = SOC_MBUS_PACKING_EXTEND16,
                 .order                  = SOC_MBUS_ORDER_LE,
-        }, [MBUS_IDX(SBGGR10_2X8_PADHI_LE)] = {
+        },
+        [MBUS_IDX(SBGGR10_2X8_PADHI_LE)] = {
                 .fourcc                 = V4L2_PIX_FMT_SBGGR10,
                 .name                   = "Bayer 10 BGGR",
                 .bits_per_sample        = 8,
                 .packing                = SOC_MBUS_PACKING_2X8_PADHI,
                 .order                  = SOC_MBUS_ORDER_LE,
-        }, [MBUS_IDX(SBGGR10_2X8_PADLO_LE)] = {
+        },
+        [MBUS_IDX(SBGGR10_2X8_PADLO_LE)] = {
                 .fourcc                 = V4L2_PIX_FMT_SBGGR10,
                 .name                   = "Bayer 10 BGGR",
                 .bits_per_sample        = 8,
                 .packing                = SOC_MBUS_PACKING_2X8_PADLO,
                 .order                  = SOC_MBUS_ORDER_LE,
-        }, [MBUS_IDX(SBGGR10_2X8_PADHI_BE)] = {
+        },
+        [MBUS_IDX(SBGGR10_2X8_PADHI_BE)] = {
                 .fourcc                 = V4L2_PIX_FMT_SBGGR10,
                 .name                   = "Bayer 10 BGGR",
                 .bits_per_sample        = 8,
                 .packing                = SOC_MBUS_PACKING_2X8_PADHI,
                 .order                  = SOC_MBUS_ORDER_BE,
-        }, [MBUS_IDX(SBGGR10_2X8_PADLO_BE)] = {
+        },
+        [MBUS_IDX(SBGGR10_2X8_PADLO_BE)] = {
                 .fourcc                 = V4L2_PIX_FMT_SBGGR10,
                 .name                   = "Bayer 10 BGGR",
                 .bits_per_sample        = 8,
@@ -134,7 +149,8 @@ EXPORT_SYMBOL(soc_mbus_bytes_per_line);
 const struct soc_mbus_pixelfmt *soc_mbus_get_fmtdesc(
         enum v4l2_mbus_pixelcode code)
 {
-        if ((unsigned int)(code - V4L2_MBUS_FMT_FIXED) > ARRAY_SIZE(mbus_fmt))
+        if (code - V4L2_MBUS_FMT_FIXED > ARRAY_SIZE(mbus_fmt) ||
+            code <= V4L2_MBUS_FMT_FIXED)
                 return NULL;
         return mbus_fmt + code - V4L2_MBUS_FMT_FIXED - 1;
 }
diff --git a/drivers/media/video/tlg2300/Kconfig b/drivers/media/video/tlg2300/Kconfig
new file mode 100644
index 000000000000..2c29ec659b4e
--- /dev/null
+++ b/drivers/media/video/tlg2300/Kconfig
@@ -0,0 +1,16 @@
+config VIDEO_TLG2300
+        tristate "Telegent TLG2300 USB video capture support"
+        depends on VIDEO_DEV && I2C && INPUT && SND && DVB_CORE
+        select VIDEO_TUNER
+        select VIDEO_TVEEPROM
+        select VIDEO_IR
+        select VIDEOBUF_VMALLOC
+        select SND_PCM
+        select VIDEOBUF_DVB
+
+        ---help---
+          This is a video4linux driver for Telegent tlg2300 based TV cards.
+          The driver supports V4L2, DVB-T and radio.
+
+          To compile this driver as a module, choose M here: the
+          module will be called poseidon
diff --git a/drivers/media/video/tlg2300/Makefile b/drivers/media/video/tlg2300/Makefile
new file mode 100644
index 000000000000..81bb7fdd1e3d
--- /dev/null
+++ b/drivers/media/video/tlg2300/Makefile
@@ -0,0 +1,9 @@
+poseidon-objs := pd-video.o pd-alsa.o pd-dvb.o pd-radio.o pd-main.o
+
+obj-$(CONFIG_VIDEO_TLG2300) += poseidon.o
+
+EXTRA_CFLAGS += -Idrivers/media/video
+EXTRA_CFLAGS += -Idrivers/media/common/tuners
+EXTRA_CFLAGS += -Idrivers/media/dvb/dvb-core
+EXTRA_CFLAGS += -Idrivers/media/dvb/frontends
+
diff --git a/drivers/media/video/tlg2300/pd-alsa.c b/drivers/media/video/tlg2300/pd-alsa.c
new file mode 100644
index 000000000000..6f42621ad478
--- /dev/null
+++ b/drivers/media/video/tlg2300/pd-alsa.c
@@ -0,0 +1,332 @@
+#include <linux/kernel.h>
+#include <linux/usb.h>
+#include <linux/init.h>
+#include <linux/sound.h>
+#include <linux/spinlock.h>
+#include <linux/soundcard.h>
+#include <linux/slab.h>
+#include <linux/vmalloc.h>
+#include <linux/proc_fs.h>
+#include <linux/module.h>
+#include <sound/core.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include <sound/info.h>
+#include <sound/initval.h>
+#include <sound/control.h>
+#include <media/v4l2-common.h>
+#include "pd-common.h"
+#include "vendorcmds.h"
+
+static void complete_handler_audio(struct urb *urb);
+#define AUDIO_EP        (0x83)
+#define AUDIO_BUF_SIZE  (512)
+#define PERIOD_SIZE     (1024 * 8)
+#define PERIOD_MIN      (4)
+#define PERIOD_MAX      PERIOD_MIN
+
+static struct snd_pcm_hardware snd_pd_hw_capture = {
+        .info = SNDRV_PCM_INFO_BLOCK_TRANSFER |
+                SNDRV_PCM_INFO_MMAP           |
+                SNDRV_PCM_INFO_INTERLEAVED |
+                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 = PERIOD_SIZE * PERIOD_MIN,
+        .period_bytes_min = PERIOD_SIZE,
+        .period_bytes_max = PERIOD_SIZE,
+        .periods_min = PERIOD_MIN,
+        .periods_max = PERIOD_MAX,
+        /*
+        .buffer_bytes_max = 62720 * 8,
+        .period_bytes_min = 64,
+        .period_bytes_max = 12544,
+        .periods_min = 2,
+        .periods_max = 98
+        */
+};
+
+static int snd_pd_capture_open(struct snd_pcm_substream *substream)
+{
+        struct poseidon *p = snd_pcm_substream_chip(substream);
+        struct poseidon_audio *pa = &p->audio;
+        struct snd_pcm_runtime *runtime = substream->runtime;
+
+        if (!p)
+                return -ENODEV;
+        pa->users++;
+        pa->card_close          = 0;
+        pa->capture_pcm_substream       = substream;
+        runtime->private_data           = p;
+
+        runtime->hw = snd_pd_hw_capture;
+        snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
+        usb_autopm_get_interface(p->interface);
+        kref_get(&p->kref);
+        return 0;
+}
+
+static int snd_pd_pcm_close(struct snd_pcm_substream *substream)
+{
+        struct poseidon *p = snd_pcm_substream_chip(substream);
+        struct poseidon_audio *pa = &p->audio;
+
+        pa->users--;
+        pa->card_close          = 1;
+        usb_autopm_put_interface(p->interface);
+        kref_put(&p->kref, poseidon_delete);
+        return 0;
+}
+
+static int snd_pd_hw_capture_params(struct snd_pcm_substream *substream,
+                                        struct snd_pcm_hw_params *hw_params)
+{
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        unsigned int size;
+
+        size = params_buffer_bytes(hw_params);
+        if (runtime->dma_area) {
+                if (runtime->dma_bytes > size)
+                        return 0;
+                vfree(runtime->dma_area);
+        }
+        runtime->dma_area = vmalloc(size);
+        if (!runtime->dma_area)
+                return -ENOMEM;
+        else
+                runtime->dma_bytes = size;
+        return 0;
+}
+
+static int audio_buf_free(struct poseidon *p)
+{
+        struct poseidon_audio *pa = &p->audio;
+        int i;
+
+        for (i = 0; i < AUDIO_BUFS; i++)
+                if (pa->urb_array[i])
+                        usb_kill_urb(pa->urb_array[i]);
+        free_all_urb_generic(pa->urb_array, AUDIO_BUFS);
+        logpm();
+        return 0;
+}
+
+static int snd_pd_hw_capture_free(struct snd_pcm_substream *substream)
+{
+        struct poseidon *p = snd_pcm_substream_chip(substream);
+
+        logpm();
+        audio_buf_free(p);
+        return 0;
+}
+
+static int snd_pd_prepare(struct snd_pcm_substream *substream)
+{
+        return 0;
+}
+
+#define AUDIO_TRAILER_SIZE      (16)
+static inline void handle_audio_data(struct urb *urb, int *period_elapsed)
+{
+        struct poseidon_audio *pa = urb->context;
+        struct snd_pcm_runtime *runtime = pa->capture_pcm_substream->runtime;
+
+        int stride      = runtime->frame_bits >> 3;
+        int len         = urb->actual_length / stride;
+        unsigned char *cp       = urb->transfer_buffer;
+        unsigned int oldptr     = pa->rcv_position;
+
+        if (urb->actual_length == AUDIO_BUF_SIZE - 4)
+                len -= (AUDIO_TRAILER_SIZE / stride);
+
+        /* do the copy */
+        if (oldptr + len >= runtime->buffer_size) {
+                unsigned int cnt = runtime->buffer_size - oldptr;
+
+                memcpy(runtime->dma_area + oldptr * stride, cp, cnt * stride);
+                memcpy(runtime->dma_area, (cp + cnt * stride),
+                                        (len * stride - cnt * stride));
+        } else
+                memcpy(runtime->dma_area + oldptr * stride, cp, len * stride);
+
+        /* update the statas */
+        snd_pcm_stream_lock(pa->capture_pcm_substream);
+        pa->rcv_position        += len;
+        if (pa->rcv_position >= runtime->buffer_size)
+                pa->rcv_position -= runtime->buffer_size;
+
+        pa->copied_position += (len);
+        if (pa->copied_position >= runtime->period_size) {
+                pa->copied_position -= runtime->period_size;
+                *period_elapsed = 1;
+        }
+        snd_pcm_stream_unlock(pa->capture_pcm_substream);
+}
+
+static void complete_handler_audio(struct urb *urb)
+{
+        struct poseidon_audio *pa = urb->context;
+        struct snd_pcm_substream *substream = pa->capture_pcm_substream;
+        int    period_elapsed = 0;
+        int    ret;
+
+        if (1 == pa->card_close || pa->capture_stream != STREAM_ON)
+                return;
+
+        if (urb->status != 0) {
+                /*if (urb->status == -ESHUTDOWN)*/
+                        return;
+        }
+
+        if (substream) {
+                if (urb->actual_length) {
+                        handle_audio_data(urb, &period_elapsed);
+                        if (period_elapsed)
+                                snd_pcm_period_elapsed(substream);
+                }
+        }
+
+        ret = usb_submit_urb(urb, GFP_ATOMIC);
+        if (ret < 0)
+                log("audio urb failed (errcod = %i)", ret);
+        return;
+}
+
+static int fire_audio_urb(struct poseidon *p)
+{
+        int i, ret = 0;
+        struct poseidon_audio *pa = &p->audio;
+
+        alloc_bulk_urbs_generic(pa->urb_array, AUDIO_BUFS,
+                        p->udev, AUDIO_EP,
+                        AUDIO_BUF_SIZE, GFP_ATOMIC,
+                        complete_handler_audio, pa);
+
+        for (i = 0; i < AUDIO_BUFS; i++) {
+                ret = usb_submit_urb(pa->urb_array[i], GFP_KERNEL);
+                if (ret)
+                        log("urb err : %d", ret);
+        }
+        log();
+        return ret;
+}
+
+static int snd_pd_capture_trigger(struct snd_pcm_substream *substream, int cmd)
+{
+        struct poseidon *p = snd_pcm_substream_chip(substream);
+        struct poseidon_audio *pa = &p->audio;
+
+        if (debug_mode)
+                log("cmd %d, audio stat : %d\n", cmd, pa->capture_stream);
+
+        switch (cmd) {
+        case SNDRV_PCM_TRIGGER_RESUME:
+        case SNDRV_PCM_TRIGGER_START:
+                if (pa->capture_stream == STREAM_ON)
+                        return 0;
+
+                pa->rcv_position = pa->copied_position = 0;
+                pa->capture_stream = STREAM_ON;
+
+                if (in_hibernation(p))
+                        return 0;
+                fire_audio_urb(p);
+                return 0;
+
+        case SNDRV_PCM_TRIGGER_SUSPEND:
+                pa->capture_stream = STREAM_SUSPEND;
+                return 0;
+        case SNDRV_PCM_TRIGGER_STOP:
+                pa->capture_stream = STREAM_OFF;
+                return 0;
+        default:
+                return -EINVAL;
+        }
+}
+
+static snd_pcm_uframes_t
+snd_pd_capture_pointer(struct snd_pcm_substream *substream)
+{
+        struct poseidon *p = snd_pcm_substream_chip(substream);
+        struct poseidon_audio *pa = &p->audio;
+        return pa->rcv_position;
+}
+
+static struct page *snd_pcm_pd_get_page(struct snd_pcm_substream *subs,
+                                             unsigned long offset)
+{
+        void *pageptr = subs->runtime->dma_area + offset;
+        return vmalloc_to_page(pageptr);
+}
+
+static struct snd_pcm_ops pcm_capture_ops = {
+        .open      = snd_pd_capture_open,
+        .close     = snd_pd_pcm_close,
+        .ioctl     = snd_pcm_lib_ioctl,
+        .hw_params = snd_pd_hw_capture_params,
+        .hw_free   = snd_pd_hw_capture_free,
+        .prepare   = snd_pd_prepare,
+        .trigger   = snd_pd_capture_trigger,
+        .pointer   = snd_pd_capture_pointer,
+        .page      = snd_pcm_pd_get_page,
+};
+
+#ifdef CONFIG_PM
+int pm_alsa_suspend(struct poseidon *p)
+{
+        logpm(p);
+        audio_buf_free(p);
+        return 0;
+}
+
+int pm_alsa_resume(struct poseidon *p)
+{
+        logpm(p);
+        fire_audio_urb(p);
+        return 0;
+}
+#endif
+
+int poseidon_audio_init(struct poseidon *p)
+{
+        struct poseidon_audio *pa = &p->audio;
+        struct snd_card *card;
+        struct snd_pcm *pcm;
+        int ret;
+
+        ret = snd_card_create(-1, "Telegent", THIS_MODULE, 0, &card);
+        if (ret != 0)
+                return ret;
+
+        ret = snd_pcm_new(card, "poseidon audio", 0, 0, 1, &pcm);
+        snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &pcm_capture_ops);
+        pcm->info_flags   = 0;
+        pcm->private_data = p;
+        strcpy(pcm->name, "poseidon audio capture");
+
+        strcpy(card->driver, "ALSA driver");
+        strcpy(card->shortname, "poseidon Audio");
+        strcpy(card->longname, "poseidon ALSA Audio");
+
+        if (snd_card_register(card)) {
+                snd_card_free(card);
+                return -ENOMEM;
+        }
+        pa->card = card;
+        return 0;
+}
+
+int poseidon_audio_free(struct poseidon *p)
+{
+        struct poseidon_audio *pa = &p->audio;
+
+        if (pa->card)
+                snd_card_free(pa->card);
+        return 0;
+}
diff --git a/drivers/media/video/tlg2300/pd-common.h b/drivers/media/video/tlg2300/pd-common.h
new file mode 100644
index 000000000000..46066bdc73f9
--- /dev/null
+++ b/drivers/media/video/tlg2300/pd-common.h
@@ -0,0 +1,282 @@
+#ifndef PD_COMMON_H
+#define PD_COMMON_H
+
+#include <linux/version.h>
+#include <linux/fs.h>
+#include <linux/wait.h>
+#include <linux/list.h>
+#include <linux/videodev2.h>
+#include <linux/semaphore.h>
+#include <linux/usb.h>
+#include <linux/poll.h>
+#include <media/videobuf-vmalloc.h>
+#include <media/v4l2-device.h>
+
+#include "dvb_frontend.h"
+#include "dvbdev.h"
+#include "dvb_demux.h"
+#include "dmxdev.h"
+
+#define SBUF_NUM        8
+#define MAX_BUFFER_NUM  6
+#define PK_PER_URB      32
+#define ISO_PKT_SIZE    3072
+
+#define POSEIDON_STATE_NONE             (0x0000)
+#define POSEIDON_STATE_ANALOG           (0x0001)
+#define POSEIDON_STATE_FM               (0x0002)
+#define POSEIDON_STATE_DVBT             (0x0004)
+#define POSEIDON_STATE_VBI              (0x0008)
+#define POSEIDON_STATE_DISCONNECT       (0x0080)
+
+#define PM_SUSPEND_DELAY        3
+
+#define V4L_PAL_VBI_LINES       18
+#define V4L_NTSC_VBI_LINES      12
+#define V4L_PAL_VBI_FRAMESIZE   (V4L_PAL_VBI_LINES * 1440 * 2)
+#define V4L_NTSC_VBI_FRAMESIZE  (V4L_NTSC_VBI_LINES * 1440 * 2)
+
+#define TUNER_FREQ_MIN          (45000000)
+#define TUNER_FREQ_MAX          (862000000)
+
+struct vbi_data {
+        struct video_device     *v_dev;
+        struct video_data       *video;
+        struct front_face       *front;
+
+        unsigned int            copied;
+        unsigned int            vbi_size; /* the whole size of two fields */
+        int                     users;
+};
+
+/*
+ * This is the running context of the video, it is useful for
+ * resume()
+ */
+struct running_context {
+        u32             freq;           /* VIDIOC_S_FREQUENCY */
+        int             audio_idx;      /* VIDIOC_S_TUNER    */
+        v4l2_std_id     tvnormid;       /* VIDIOC_S_STD     */
+        int             sig_index;      /* VIDIOC_S_INPUT  */
+        struct v4l2_pix_format pix;     /* VIDIOC_S_FMT   */
+};
+
+struct video_data {
+        /* v4l2 video device */
+        struct video_device     *v_dev;
+
+        /* the working context */
+        struct running_context  context;
+
+        /* for data copy */
+        int             field_count;
+
+        char            *dst;
+        int             lines_copied;
+        int             prev_left;
+
+        int             lines_per_field;
+        int             lines_size;
+
+        /* for communication */
+        u8                      endpoint_addr;
+        struct urb              *urb_array[SBUF_NUM];
+        struct vbi_data         *vbi;
+        struct poseidon         *pd;
+        struct front_face       *front;
+
+        int                     is_streaming;
+        int                     users;
+
+        /* for bubble handler */
+        struct work_struct      bubble_work;
+};
+
+enum pcm_stream_state {
+        STREAM_OFF,
+        STREAM_ON,
+        STREAM_SUSPEND,
+};
+
+#define AUDIO_BUFS (3)
+#define CAPTURE_STREAM_EN 1
+struct poseidon_audio {
+        struct urb              *urb_array[AUDIO_BUFS];
+        unsigned int            copied_position;
+        struct snd_pcm_substream   *capture_pcm_substream;
+
+        unsigned int            rcv_position;
+        struct  snd_card        *card;
+        int                     card_close;
+
+        int                     users;
+        int                     pm_state;
+        enum pcm_stream_state   capture_stream;
+};
+
+struct radio_data {
+        __u32           fm_freq;
+        int             users;
+        unsigned int    is_radio_streaming;
+        int             pre_emphasis;
+        struct video_device *fm_dev;
+};
+
+#define DVB_SBUF_NUM            4
+#define DVB_URB_BUF_SIZE        0x2000
+struct pd_dvb_adapter {
+        struct dvb_adapter      dvb_adap;
+        struct dvb_frontend     dvb_fe;
+        struct dmxdev           dmxdev;
+        struct dvb_demux        demux;
+
+        atomic_t                users;
+        atomic_t                active_feed;
+
+        /* data transfer */
+        s32                     is_streaming;
+        struct urb              *urb_array[DVB_SBUF_NUM];
+        struct poseidon         *pd_device;
+        u8                      ep_addr;
+        u8                      reserved[3];
+
+        /* data for power resume*/
+        struct dvb_frontend_parameters fe_param;
+
+        /* for channel scanning */
+        int             prev_freq;
+        int             bandwidth;
+        unsigned long   last_jiffies;
+};
+
+struct front_face {
+        /* use this field to distinguish VIDEO and VBI */
+        enum v4l2_buf_type      type;
+
+        /* for host */
+        struct videobuf_queue   q;
+
+        /* the bridge for host and device */
+        struct videobuf_buffer  *curr_frame;
+
+        /* for device */
+        spinlock_t              queue_lock;
+        struct list_head        active;
+        struct poseidon         *pd;
+};
+
+struct poseidon {
+        struct list_head        device_list;
+
+        struct mutex            lock;
+        struct kref             kref;
+
+        /* for V4L2 */
+        struct v4l2_device      v4l2_dev;
+
+        /* hardware info */
+        struct usb_device       *udev;
+        struct usb_interface    *interface;
+        int                     cur_transfer_mode;
+
+        struct video_data       video_data;     /* video */
+        struct vbi_data         vbi_data;       /* vbi   */
+        struct poseidon_audio   audio;          /* audio (alsa) */
+        struct radio_data       radio_data;     /* FM    */
+        struct pd_dvb_adapter   dvb_data;       /* DVB   */
+
+        u32                     state;
+        struct file             *file_for_stream; /* the active stream*/
+
+#ifdef CONFIG_PM
+        int (*pm_suspend)(struct poseidon *);
+        int (*pm_resume)(struct poseidon *);
+        pm_message_t            msg;
+
+        struct work_struct      pm_work;
+        u8                      portnum;
+#endif
+};
+
+struct poseidon_format {
+        char    *name;
+        int     fourcc;          /* video4linux 2         */
+        int     depth;           /* bit/pixel             */
+        int     flags;
+};
+
+struct poseidon_tvnorm {
+        v4l2_std_id     v4l2_id;
+        char            name[12];
+        u32             tlg_tvnorm;
+};
+
+/* video */
+int pd_video_init(struct poseidon *);
+void pd_video_exit(struct poseidon *);
+int stop_all_video_stream(struct poseidon *);
+
+/* alsa audio */
+int poseidon_audio_init(struct poseidon *);
+int poseidon_audio_free(struct poseidon *);
+#ifdef CONFIG_PM
+int pm_alsa_suspend(struct poseidon *);
+int pm_alsa_resume(struct poseidon *);
+#endif
+
+/* dvb */
+int pd_dvb_usb_device_init(struct poseidon *);
+void pd_dvb_usb_device_exit(struct poseidon *);
+void pd_dvb_usb_device_cleanup(struct poseidon *);
+int pd_dvb_get_adapter_num(struct pd_dvb_adapter *);
+void dvb_stop_streaming(struct pd_dvb_adapter *);
+
+/* FM */
+int poseidon_fm_init(struct poseidon *);
+int poseidon_fm_exit(struct poseidon *);
+struct video_device *vdev_init(struct poseidon *, struct video_device *);
+
+/* vendor command ops */
+int send_set_req(struct poseidon*, u8, s32, s32*);
+int send_get_req(struct poseidon*, u8, s32, void*, s32*, s32);
+s32 set_tuner_mode(struct poseidon*, unsigned char);
+
+/* bulk urb alloc/free */
+int alloc_bulk_urbs_generic(struct urb **urb_array, int num,
+                        struct usb_device *udev, u8 ep_addr,
+                        int buf_size, gfp_t gfp_flags,
+                        usb_complete_t complete_fn, void *context);
+void free_all_urb_generic(struct urb **urb_array, int num);
+
+/* misc */
+void poseidon_delete(struct kref *kref);
+void destroy_video_device(struct video_device **v_dev);
+extern int debug_mode;
+void set_debug_mode(struct video_device *vfd, int debug_mode);
+
+#ifdef CONFIG_PM
+#define in_hibernation(pd) (pd->msg.event == PM_EVENT_FREEZE)
+#else
+#define in_hibernation(pd) (0)
+#endif
+#define get_pm_count(p) (atomic_read(&(p)->interface->pm_usage_cnt))
+
+#define log(a, ...) printk(KERN_DEBUG "\t[ %s : %.3d ] "a"\n", \
+                                __func__, __LINE__,  ## __VA_ARGS__)
+
+/* for power management */
+#define logpm(pd) do {\
+                        if (debug_mode & 0x10)\
+                                log();\
+                } while (0)
+
+#define logs(f) do { \
+                        if ((debug_mode & 0x4) && \
+                                (f)->type == V4L2_BUF_TYPE_VBI_CAPTURE) \
+                                        log("type : VBI");\
+                                                                \
+                        if ((debug_mode & 0x8) && \
+                                (f)->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) \
+                                        log("type : VIDEO");\
+                } while (0)
+#endif
diff --git a/drivers/media/video/tlg2300/pd-dvb.c b/drivers/media/video/tlg2300/pd-dvb.c
new file mode 100644
index 000000000000..4133aee568bf
--- /dev/null
+++ b/drivers/media/video/tlg2300/pd-dvb.c
@@ -0,0 +1,593 @@
+#include "pd-common.h"
+#include <linux/kernel.h>
+#include <linux/usb.h>
+#include <linux/dvb/dmx.h>
+#include <linux/delay.h>
+
+#include "vendorcmds.h"
+#include <linux/sched.h>
+#include <asm/atomic.h>
+
+static void dvb_urb_cleanup(struct pd_dvb_adapter *pd_dvb);
+
+static int dvb_bandwidth[][2] = {
+        { TLG_BW_8, BANDWIDTH_8_MHZ },
+        { TLG_BW_7, BANDWIDTH_7_MHZ },
+        { TLG_BW_6, BANDWIDTH_6_MHZ }
+};
+static int dvb_bandwidth_length = ARRAY_SIZE(dvb_bandwidth);
+
+static s32 dvb_start_streaming(struct pd_dvb_adapter *pd_dvb);
+static int poseidon_check_mode_dvbt(struct poseidon *pd)
+{
+        s32 ret = 0, cmd_status = 0;
+
+        set_current_state(TASK_INTERRUPTIBLE);
+        schedule_timeout(HZ/4);
+
+        ret = usb_set_interface(pd->udev, 0, BULK_ALTERNATE_IFACE);
+        if (ret != 0)
+                return ret;
+
+        ret = set_tuner_mode(pd, TLG_MODE_CAPS_DVB_T);
+        if (ret)
+                return ret;
+
+        /* signal source */
+        ret = send_set_req(pd, SGNL_SRC_SEL, TLG_SIG_SRC_ANTENNA, &cmd_status);
+        if (ret|cmd_status)
+                return ret;
+
+        return 0;
+}
+
+/* acquire :
+ *      1 == open
+ *      0 == release
+ */
+static int poseidon_ts_bus_ctrl(struct dvb_frontend *fe, int acquire)
+{
+        struct poseidon *pd = fe->demodulator_priv;
+        struct pd_dvb_adapter *pd_dvb;
+        int ret = 0;
+
+        if (!pd)
+                return -ENODEV;
+
+        pd_dvb = container_of(fe, struct pd_dvb_adapter, dvb_fe);
+        if (acquire) {
+                mutex_lock(&pd->lock);
+                if (pd->state & POSEIDON_STATE_DISCONNECT) {
+                        ret = -ENODEV;
+                        goto open_out;
+                }
+
+                if (pd->state && !(pd->state & POSEIDON_STATE_DVBT)) {
+                        ret = -EBUSY;
+                        goto open_out;
+                }
+
+                usb_autopm_get_interface(pd->interface);
+                if (0 == pd->state) {
+                        ret = poseidon_check_mode_dvbt(pd);
+                        if (ret < 0) {
+                                usb_autopm_put_interface(pd->interface);
+                                goto open_out;
+                        }
+                        pd->state |= POSEIDON_STATE_DVBT;
+                        pd_dvb->bandwidth = 0;
+                        pd_dvb->prev_freq = 0;
+                }
+                atomic_inc(&pd_dvb->users);
+                kref_get(&pd->kref);
+open_out:
+                mutex_unlock(&pd->lock);
+        } else {
+                dvb_stop_streaming(pd_dvb);
+
+                if (atomic_dec_and_test(&pd_dvb->users)) {
+                        mutex_lock(&pd->lock);
+                        pd->state &= ~POSEIDON_STATE_DVBT;
+                        mutex_unlock(&pd->lock);
+                }
+                kref_put(&pd->kref, poseidon_delete);
+                usb_autopm_put_interface(pd->interface);
+        }
+        return ret;
+}
+
+static void poseidon_fe_release(struct dvb_frontend *fe)
+{
+        struct poseidon *pd = fe->demodulator_priv;
+
+#ifdef CONFIG_PM
+        pd->pm_suspend = NULL;
+        pd->pm_resume  = NULL;
+#endif
+}
+
+static s32 poseidon_fe_sleep(struct dvb_frontend *fe)
+{
+        return 0;
+}
+
+/*
+ * return true if we can satisfy the conditions, else return false.
+ */
+static bool check_scan_ok(__u32 freq, int bandwidth,
+                        struct pd_dvb_adapter *adapter)
+{
+        if (bandwidth < 0)
+                return false;
+
+        if (adapter->prev_freq == freq
+                && adapter->bandwidth == bandwidth) {
+                long nl = jiffies - adapter->last_jiffies;
+                unsigned int msec ;
+
+                msec = jiffies_to_msecs(abs(nl));
+                return msec > 15000 ? true : false;
+        }
+        return true;
+}
+
+/*
+ * Check if the firmware delays too long for an invalid frequency.
+ */
+static int fw_delay_overflow(struct pd_dvb_adapter *adapter)
+{
+        long nl = jiffies - adapter->last_jiffies;
+        unsigned int msec ;
+
+        msec = jiffies_to_msecs(abs(nl));
+        return msec > 800 ? true : false;
+}
+
+static int poseidon_set_fe(struct dvb_frontend *fe,
+                        struct dvb_frontend_parameters *fep)
+{
+        s32 ret = 0, cmd_status = 0;
+        s32 i, bandwidth = -1;
+        struct poseidon *pd = fe->demodulator_priv;
+        struct pd_dvb_adapter *pd_dvb = &pd->dvb_data;
+
+        if (in_hibernation(pd))
+                return -EBUSY;
+
+        mutex_lock(&pd->lock);
+        for (i = 0; i < dvb_bandwidth_length; i++)
+                if (fep->u.ofdm.bandwidth == dvb_bandwidth[i][1])
+                        bandwidth = dvb_bandwidth[i][0];
+
+        if (check_scan_ok(fep->frequency, bandwidth, pd_dvb)) {
+                ret = send_set_req(pd, TUNE_FREQ_SELECT,
+                                        fep->frequency / 1000, &cmd_status);
+                if (ret | cmd_status) {
+                        log("error line");
+                        goto front_out;
+                }
+
+                ret = send_set_req(pd, DVBT_BANDW_SEL,
+                                                bandwidth, &cmd_status);
+                if (ret | cmd_status) {
+                        log("error line");
+                        goto front_out;
+                }
+
+                ret = send_set_req(pd, TAKE_REQUEST, 0, &cmd_status);
+                if (ret | cmd_status) {
+                        log("error line");
+                        goto front_out;
+                }
+
+                /* save the context for future */
+                memcpy(&pd_dvb->fe_param, fep, sizeof(*fep));
+                pd_dvb->bandwidth = bandwidth;
+                pd_dvb->prev_freq = fep->frequency;
+                pd_dvb->last_jiffies = jiffies;
+        }
+front_out:
+        mutex_unlock(&pd->lock);
+        return ret;
+}
+
+#ifdef CONFIG_PM
+static int pm_dvb_suspend(struct poseidon *pd)
+{
+        struct pd_dvb_adapter *pd_dvb = &pd->dvb_data;
+        dvb_stop_streaming(pd_dvb);
+        dvb_urb_cleanup(pd_dvb);
+        msleep(500);
+        return 0;
+}
+
+static int pm_dvb_resume(struct poseidon *pd)
+{
+        struct pd_dvb_adapter *pd_dvb = &pd->dvb_data;
+
+        poseidon_check_mode_dvbt(pd);
+        msleep(300);
+        poseidon_set_fe(&pd_dvb->dvb_fe, &pd_dvb->fe_param);
+
+        dvb_start_streaming(pd_dvb);
+        return 0;
+}
+#endif
+
+static s32 poseidon_fe_init(struct dvb_frontend *fe)
+{
+        struct poseidon *pd = fe->demodulator_priv;
+        struct pd_dvb_adapter *pd_dvb = &pd->dvb_data;
+
+#ifdef CONFIG_PM
+        pd->pm_suspend = pm_dvb_suspend;
+        pd->pm_resume  = pm_dvb_resume;
+#endif
+        memset(&pd_dvb->fe_param, 0,
+                        sizeof(struct dvb_frontend_parameters));
+        return 0;
+}
+
+static int poseidon_get_fe(struct dvb_frontend *fe,
+                        struct dvb_frontend_parameters *fep)
+{
+        struct poseidon *pd = fe->demodulator_priv;
+        struct pd_dvb_adapter *pd_dvb = &pd->dvb_data;
+
+        memcpy(fep, &pd_dvb->fe_param, sizeof(*fep));
+        return 0;
+}
+
+static int poseidon_fe_get_tune_settings(struct dvb_frontend *fe,
+                                struct dvb_frontend_tune_settings *tune)
+{
+        tune->min_delay_ms = 1000;
+        return 0;
+}
+
+static int poseidon_read_status(struct dvb_frontend *fe, fe_status_t *stat)
+{
+        struct poseidon *pd = fe->demodulator_priv;
+        s32 ret = -1, cmd_status;
+        struct tuner_dtv_sig_stat_s status = {};
+
+        if (in_hibernation(pd))
+                return -EBUSY;
+        mutex_lock(&pd->lock);
+
+        ret = send_get_req(pd, TUNER_STATUS, TLG_MODE_DVB_T,
+                                &status, &cmd_status, sizeof(status));
+        if (ret | cmd_status) {
+                log("get tuner status error");
+                goto out;
+        }
+
+        if (debug_mode)
+                log("P : %d, L %d, LB :%d", status.sig_present,
+                        status.sig_locked, status.sig_lock_busy);
+
+        if (status.sig_lock_busy) {
+                goto out;
+        } else if (status.sig_present || status.sig_locked) {
+                *stat |= FE_HAS_LOCK | FE_HAS_SIGNAL | FE_HAS_CARRIER
+                                | FE_HAS_SYNC | FE_HAS_VITERBI;
+        } else {
+                if (fw_delay_overflow(&pd->dvb_data))
+                        *stat |= FE_TIMEDOUT;
+        }
+out:
+        mutex_unlock(&pd->lock);
+        return ret;
+}
+
+static int poseidon_read_ber(struct dvb_frontend *fe, u32 *ber)
+{
+        struct poseidon *pd = fe->demodulator_priv;
+        struct tuner_ber_rate_s tlg_ber = {};
+        s32 ret = -1, cmd_status;
+
+        mutex_lock(&pd->lock);
+        ret = send_get_req(pd, TUNER_BER_RATE, 0,
+                                &tlg_ber, &cmd_status, sizeof(tlg_ber));
+        if (ret | cmd_status)
+                goto out;
+        *ber = tlg_ber.ber_rate;
+out:
+        mutex_unlock(&pd->lock);
+        return ret;
+}
+
+static s32 poseidon_read_signal_strength(struct dvb_frontend *fe, u16 *strength)
+{
+        struct poseidon *pd = fe->demodulator_priv;
+        struct tuner_dtv_sig_stat_s status = {};
+        s32 ret = 0, cmd_status;
+
+        mutex_lock(&pd->lock);
+        ret = send_get_req(pd, TUNER_STATUS, TLG_MODE_DVB_T,
+                                &status, &cmd_status, sizeof(status));
+        if (ret | cmd_status)
+                goto out;
+        if ((status.sig_present || status.sig_locked) && !status.sig_strength)
+                *strength = 0xFFFF;
+        else
+                *strength = status.sig_strength;
+out:
+        mutex_unlock(&pd->lock);
+        return ret;
+}
+
+static int poseidon_read_snr(struct dvb_frontend *fe, u16 *snr)
+{
+        return 0;
+}
+
+static int poseidon_read_unc_blocks(struct dvb_frontend *fe, u32 *unc)
+{
+        *unc = 0;
+        return 0;
+}
+
+static struct dvb_frontend_ops poseidon_frontend_ops = {
+        .info = {
+                .name           = "Poseidon DVB-T",
+                .type           = FE_OFDM,
+                .frequency_min  = 174000000,
+                .frequency_max  = 862000000,
+                .frequency_stepsize       = 62500,/* FIXME */
+                .caps = FE_CAN_INVERSION_AUTO |
+                        FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
+                        FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 | FE_CAN_FEC_AUTO |
+                        FE_CAN_QPSK | FE_CAN_QAM_16 | FE_CAN_QAM_64 |
+                        FE_CAN_QAM_AUTO | FE_CAN_TRANSMISSION_MODE_AUTO |
+                        FE_CAN_GUARD_INTERVAL_AUTO |
+                        FE_CAN_RECOVER |
+                        FE_CAN_HIERARCHY_AUTO,
+        },
+
+        .release = poseidon_fe_release,
+
+        .init = poseidon_fe_init,
+        .sleep = poseidon_fe_sleep,
+
+        .set_frontend = poseidon_set_fe,
+        .get_frontend = poseidon_get_fe,
+        .get_tune_settings = poseidon_fe_get_tune_settings,
+
+        .read_status    = poseidon_read_status,
+        .read_ber       = poseidon_read_ber,
+        .read_signal_strength = poseidon_read_signal_strength,
+        .read_snr       = poseidon_read_snr,
+        .read_ucblocks  = poseidon_read_unc_blocks,
+
+        .ts_bus_ctrl = poseidon_ts_bus_ctrl,
+};
+
+static void dvb_urb_irq(struct urb *urb)
+{
+        struct pd_dvb_adapter *pd_dvb = urb->context;
+        int len = urb->transfer_buffer_length;
+        struct dvb_demux *demux = &pd_dvb->demux;
+        s32 ret;
+
+        if (!pd_dvb->is_streaming || urb->status) {
+                if (urb->status == -EPROTO)
+                        goto resend;
+                return;
+        }
+
+        if (urb->actual_length == len)
+                dvb_dmx_swfilter(demux, urb->transfer_buffer, len);
+        else if (urb->actual_length == len - 4) {
+                int offset;
+                u8 *buf = urb->transfer_buffer;
+
+                /*
+                 * The packet size is 512,
+                 * last packet contains 456 bytes tsp data
+                 */
+                for (offset = 456; offset < len; offset += 512) {
+                        if (!strncmp(buf + offset, "DVHS", 4)) {
+                                dvb_dmx_swfilter(demux, buf, offset);
+                                if (len > offset + 52 + 4) {
+                                        /*16 bytes trailer + 36 bytes padding */
+                                        buf += offset + 52;
+                                        len -= offset + 52 + 4;
+                                        dvb_dmx_swfilter(demux, buf, len);
+                                }
+                                break;
+                        }
+                }
+        }
+
+resend:
+        ret = usb_submit_urb(urb, GFP_ATOMIC);
+        if (ret)
+                log(" usb_submit_urb failed: error %d", ret);
+}
+
+static int dvb_urb_init(struct pd_dvb_adapter *pd_dvb)
+{
+        if (pd_dvb->urb_array[0])
+                return 0;
+
+        alloc_bulk_urbs_generic(pd_dvb->urb_array, DVB_SBUF_NUM,
+                        pd_dvb->pd_device->udev, pd_dvb->ep_addr,
+                        DVB_URB_BUF_SIZE, GFP_KERNEL,
+                        dvb_urb_irq, pd_dvb);
+        return 0;
+}
+
+static void dvb_urb_cleanup(struct pd_dvb_adapter *pd_dvb)
+{
+        free_all_urb_generic(pd_dvb->urb_array, DVB_SBUF_NUM);
+}
+
+static s32 dvb_start_streaming(struct pd_dvb_adapter *pd_dvb)
+{
+        struct poseidon *pd = pd_dvb->pd_device;
+        int ret = 0;
+
+        if (pd->state & POSEIDON_STATE_DISCONNECT)
+                return -ENODEV;
+
+        mutex_lock(&pd->lock);
+        if (!pd_dvb->is_streaming) {
+                s32 i, cmd_status = 0;
+                /*
+                 * Once upon a time, there was a difficult bug lying here.
+                 * ret = send_set_req(pd, TAKE_REQUEST, 0, &cmd_status);
+                 */
+
+                ret = send_set_req(pd, PLAY_SERVICE, 1, &cmd_status);
+                if (ret | cmd_status)
+                        goto out;
+
+                ret = dvb_urb_init(pd_dvb);
+                if (ret < 0)
+                        goto out;
+
+                pd_dvb->is_streaming = 1;
+                for (i = 0; i < DVB_SBUF_NUM; i++) {
+                        ret = usb_submit_urb(pd_dvb->urb_array[i],
+                                                       GFP_KERNEL);
+                        if (ret) {
+                                log(" submit urb error %d", ret);
+                                goto out;
+                        }
+                }
+        }
+out:
+        mutex_unlock(&pd->lock);
+        return ret;
+}
+
+void dvb_stop_streaming(struct pd_dvb_adapter *pd_dvb)
+{
+        struct poseidon *pd = pd_dvb->pd_device;
+
+        mutex_lock(&pd->lock);
+        if (pd_dvb->is_streaming) {
+                s32 i, ret, cmd_status = 0;
+
+                pd_dvb->is_streaming = 0;
+
+                for (i = 0; i < DVB_SBUF_NUM; i++)
+                        if (pd_dvb->urb_array[i])
+                                usb_kill_urb(pd_dvb->urb_array[i]);
+
+                ret = send_set_req(pd, PLAY_SERVICE, TLG_TUNE_PLAY_SVC_STOP,
+                                        &cmd_status);
+                if (ret | cmd_status)
+                        log("error");
+        }
+        mutex_unlock(&pd->lock);
+}
+
+static int pd_start_feed(struct dvb_demux_feed *feed)
+{
+        struct pd_dvb_adapter *pd_dvb = feed->demux->priv;
+        int ret = 0;
+
+        if (!pd_dvb)
+                return -1;
+        if (atomic_inc_return(&pd_dvb->active_feed) == 1)
+                ret = dvb_start_streaming(pd_dvb);
+        return ret;
+}
+
+static int pd_stop_feed(struct dvb_demux_feed *feed)
+{
+        struct pd_dvb_adapter *pd_dvb = feed->demux->priv;
+
+        if (!pd_dvb)
+                return -1;
+        if (atomic_dec_and_test(&pd_dvb->active_feed))
+                dvb_stop_streaming(pd_dvb);
+        return 0;
+}
+
+DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
+int pd_dvb_usb_device_init(struct poseidon *pd)
+{
+        struct pd_dvb_adapter *pd_dvb = &pd->dvb_data;
+        struct dvb_demux *dvbdemux;
+        int ret = 0;
+
+        pd_dvb->ep_addr = 0x82;
+        atomic_set(&pd_dvb->users, 0);
+        atomic_set(&pd_dvb->active_feed, 0);
+        pd_dvb->pd_device = pd;
+
+        ret = dvb_register_adapter(&pd_dvb->dvb_adap,
+                                "Poseidon dvbt adapter",
+                                THIS_MODULE,
+                                NULL /* for hibernation correctly*/,
+                                adapter_nr);
+        if (ret < 0)
+                goto error1;
+
+        /* register frontend */
+        pd_dvb->dvb_fe.demodulator_priv = pd;
+        memcpy(&pd_dvb->dvb_fe.ops, &poseidon_frontend_ops,
+                        sizeof(struct dvb_frontend_ops));
+        ret = dvb_register_frontend(&pd_dvb->dvb_adap, &pd_dvb->dvb_fe);
+        if (ret < 0)
+                goto error2;
+
+        /* register demux device */
+        dvbdemux = &pd_dvb->demux;
+        dvbdemux->dmx.capabilities = DMX_TS_FILTERING | DMX_SECTION_FILTERING;
+        dvbdemux->priv = pd_dvb;
+        dvbdemux->feednum = dvbdemux->filternum = 64;
+        dvbdemux->start_feed = pd_start_feed;
+        dvbdemux->stop_feed = pd_stop_feed;
+        dvbdemux->write_to_decoder = NULL;
+
+        ret = dvb_dmx_init(dvbdemux);
+        if (ret < 0)
+                goto error3;
+
+        pd_dvb->dmxdev.filternum = pd_dvb->demux.filternum;
+        pd_dvb->dmxdev.demux = &pd_dvb->demux.dmx;
+        pd_dvb->dmxdev.capabilities = 0;
+
+        ret = dvb_dmxdev_init(&pd_dvb->dmxdev, &pd_dvb->dvb_adap);
+        if (ret < 0)
+                goto error3;
+        return 0;
+
+error3:
+        dvb_unregister_frontend(&pd_dvb->dvb_fe);
+error2:
+        dvb_unregister_adapter(&pd_dvb->dvb_adap);
+error1:
+        return ret;
+}
+
+void pd_dvb_usb_device_exit(struct poseidon *pd)
+{
+        struct pd_dvb_adapter *pd_dvb = &pd->dvb_data;
+
+        while (atomic_read(&pd_dvb->users) != 0
+                || atomic_read(&pd_dvb->active_feed) != 0) {
+                set_current_state(TASK_INTERRUPTIBLE);
+                schedule_timeout(HZ);
+        }
+        dvb_dmxdev_release(&pd_dvb->dmxdev);
+        dvb_unregister_frontend(&pd_dvb->dvb_fe);
+        dvb_unregister_adapter(&pd_dvb->dvb_adap);
+        pd_dvb_usb_device_cleanup(pd);
+}
+
+void pd_dvb_usb_device_cleanup(struct poseidon *pd)
+{
+        struct pd_dvb_adapter *pd_dvb = &pd->dvb_data;
+
+        dvb_urb_cleanup(pd_dvb);
+}
+
+int pd_dvb_get_adapter_num(struct pd_dvb_adapter *pd_dvb)
+{
+        return pd_dvb->dvb_adap.num;
+}
diff --git a/drivers/media/video/tlg2300/pd-main.c b/drivers/media/video/tlg2300/pd-main.c
new file mode 100644
index 000000000000..2cf0ebf9f28b
--- /dev/null
+++ b/drivers/media/video/tlg2300/pd-main.c
@@ -0,0 +1,539 @@
+/*
+ * device driver for Telegent tlg2300 based TV cards
+ *
+ * Author :
+ *      Kang Yong       <kangyong@telegent.com>
+ *      Zhang Xiaobing  <xbzhang@telegent.com>
+ *      Huang Shijie    <zyziii@telegent.com> or <shijie8@gmail.com>
+ *
+ *      (c) 2009 Telegent Systems
+ *      (c) 2010 Telegent Systems
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/version.h>
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/module.h>
+#include <linux/kref.h>
+#include <linux/suspend.h>
+#include <linux/usb/quirks.h>
+#include <linux/ctype.h>
+#include <linux/string.h>
+#include <linux/types.h>
+#include <linux/firmware.h>
+#include <linux/smp_lock.h>
+
+#include "vendorcmds.h"
+#include "pd-common.h"
+
+#define VENDOR_ID       0x1B24
+#define PRODUCT_ID      0x4001
+static struct usb_device_id id_table[] = {
+        { USB_DEVICE_AND_INTERFACE_INFO(VENDOR_ID, PRODUCT_ID, 255, 1, 0) },
+        { USB_DEVICE_AND_INTERFACE_INFO(VENDOR_ID, PRODUCT_ID, 255, 1, 1) },
+        { },
+};
+MODULE_DEVICE_TABLE(usb, id_table);
+
+int debug_mode;
+module_param(debug_mode, int, 0644);
+MODULE_PARM_DESC(debug_mode, "0 = disable, 1 = enable, 2 = verbose");
+
+const char *firmware_name = "tlg2300_firmware.bin";
+struct usb_driver poseidon_driver;
+static LIST_HEAD(pd_device_list);
+
+/*
+ * send set request to USB firmware.
+ */
+s32 send_set_req(struct poseidon *pd, u8 cmdid, s32 param, s32 *cmd_status)
+{
+        s32 ret;
+        s8  data[32] = {};
+        u16 lower_16, upper_16;
+
+        if (pd->state & POSEIDON_STATE_DISCONNECT)
+                return -ENODEV;
+
+        mdelay(30);
+
+        if (param == 0) {
+                upper_16 = lower_16 = 0;
+        } else {
+                /* send 32 bit param as  two 16 bit param,little endian */
+                lower_16 = (unsigned short)(param & 0xffff);
+                upper_16 = (unsigned short)((param >> 16) & 0xffff);
+        }
+        ret = usb_control_msg(pd->udev,
+                         usb_rcvctrlpipe(pd->udev, 0),
+                         REQ_SET_CMD | cmdid,
+                         USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+                         lower_16,
+                         upper_16,
+                         &data,
+                         sizeof(*cmd_status),
+                         USB_CTRL_GET_TIMEOUT);
+
+        if (!ret) {
+                return -ENXIO;
+        } else {
+                /*  1st 4 bytes into cmd_status   */
+                memcpy((char *)cmd_status, &(data[0]), sizeof(*cmd_status));
+        }
+        return 0;
+}
+
+/*
+ * send get request to Poseidon firmware.
+ */
+s32 send_get_req(struct poseidon *pd, u8 cmdid, s32 param,
+                        void *buf, s32 *cmd_status, s32 datalen)
+{
+        s32 ret;
+        s8 data[128] = {};
+        u16 lower_16, upper_16;
+
+        if (pd->state & POSEIDON_STATE_DISCONNECT)
+                return -ENODEV;
+
+        mdelay(30);
+        if (param == 0) {
+                upper_16 = lower_16 = 0;
+        } else {
+                /*send 32 bit param as two 16 bit param, little endian */
+                lower_16 = (unsigned short)(param & 0xffff);
+                upper_16 = (unsigned short)((param >> 16) & 0xffff);
+        }
+        ret = usb_control_msg(pd->udev,
+                         usb_rcvctrlpipe(pd->udev, 0),
+                         REQ_GET_CMD | cmdid,
+                         USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+                         lower_16,
+                         upper_16,
+                         &data,
+                         (datalen + sizeof(*cmd_status)),
+                         USB_CTRL_GET_TIMEOUT);
+
+        if (ret < 0) {
+                return -ENXIO;
+        } else {
+                /* 1st 4 bytes into cmd_status, remaining data into cmd_data */
+                memcpy((char *)cmd_status, &data[0], sizeof(*cmd_status));
+                memcpy((char *)buf, &data[sizeof(*cmd_status)], datalen);
+        }
+        return 0;
+}
+
+static int pm_notifier_block(struct notifier_block *nb,
+                                unsigned long event, void *dummy)
+{
+        struct poseidon *pd = NULL;
+        struct list_head *node, *next;
+
+        switch (event) {
+        case PM_POST_HIBERNATION:
+                list_for_each_safe(node, next, &pd_device_list) {
+                        struct usb_device *udev;
+                        struct usb_interface *iface;
+                        int rc = 0;
+
+                        pd = container_of(node, struct poseidon, device_list);
+                        udev = pd->udev;
+                        iface = pd->interface;
+
+                        /* It will cause the system to reload the firmware */
+                        rc = usb_lock_device_for_reset(udev, iface);
+                        if (rc >= 0) {
+                                usb_reset_device(udev);
+                                usb_unlock_device(udev);
+                        }
+                }
+                break;
+        default:
+                break;
+        }
+        log("event :%ld\n", event);
+        return 0;
+}
+
+static struct notifier_block pm_notifer = {
+        .notifier_call = pm_notifier_block,
+};
+
+int set_tuner_mode(struct poseidon *pd, unsigned char mode)
+{
+        s32 ret, cmd_status;
+
+        if (pd->state & POSEIDON_STATE_DISCONNECT)
+                return -ENODEV;
+
+        ret = send_set_req(pd, TUNE_MODE_SELECT, mode, &cmd_status);
+        if (ret || cmd_status)
+                return -ENXIO;
+        return 0;
+}
+
+void poseidon_delete(struct kref *kref)
+{
+        struct poseidon *pd = container_of(kref, struct poseidon, kref);
+
+        if (!pd)
+                return;
+        list_del_init(&pd->device_list);
+
+        pd_dvb_usb_device_cleanup(pd);
+        /* clean_audio_data(&pd->audio_data);*/
+
+        if (pd->udev) {
+                usb_put_dev(pd->udev);
+                pd->udev = NULL;
+        }
+        if (pd->interface) {
+                usb_put_intf(pd->interface);
+                pd->interface = NULL;
+        }
+        kfree(pd);
+        log();
+}
+
+static int firmware_download(struct usb_device *udev)
+{
+        int ret = 0, actual_length;
+        const struct firmware *fw = NULL;
+        void *fwbuf = NULL;
+        size_t fwlength = 0, offset;
+        size_t max_packet_size;
+
+        ret = request_firmware(&fw, firmware_name, &udev->dev);
+        if (ret) {
+                log("download err : %d", ret);
+                return ret;
+        }
+
+        fwlength = fw->size;
+
+        fwbuf = kzalloc(fwlength, GFP_KERNEL);
+        if (!fwbuf) {
+                ret = -ENOMEM;
+                goto out;
+        }
+        memcpy(fwbuf, fw->data, fwlength);
+
+        max_packet_size = udev->ep_out[0x1]->desc.wMaxPacketSize;
+        log("\t\t download size : %d", (int)max_packet_size);
+
+        for (offset = 0; offset < fwlength; offset += max_packet_size) {
+                actual_length = 0;
+                ret = usb_bulk_msg(udev,
+                                usb_sndbulkpipe(udev, 0x01), /* ep 1 */
+                                fwbuf + offset,
+                                min(max_packet_size, fwlength - offset),
+                                &actual_length,
+                                HZ * 10);
+                if (ret)
+                        break;
+        }
+        kfree(fwbuf);
+out:
+        release_firmware(fw);
+        return ret;
+}
+
+static inline struct poseidon *get_pd(struct usb_interface *intf)
+{
+        return usb_get_intfdata(intf);
+}
+
+#ifdef CONFIG_PM
+/* one-to-one map : poseidon{} <----> usb_device{}'s port */
+static inline void set_map_flags(struct poseidon *pd, struct usb_device *udev)
+{
+        pd->portnum = udev->portnum;
+}
+
+static inline int get_autopm_ref(struct poseidon *pd)
+{
+        return  pd->video_data.users + pd->vbi_data.users + pd->audio.users
+                + atomic_read(&pd->dvb_data.users) + pd->radio_data.users;
+}
+
+/* fixup something for poseidon */
+static inline struct poseidon *fixup(struct poseidon *pd)
+{
+        int count;
+
+        /* old udev and interface have gone, so put back reference . */
+        count = get_autopm_ref(pd);
+        log("count : %d, ref count : %d", count, get_pm_count(pd));
+        while (count--)
+                usb_autopm_put_interface(pd->interface);
+        /*usb_autopm_set_interface(pd->interface); */
+
+        usb_put_dev(pd->udev);
+        usb_put_intf(pd->interface);
+        log("event : %d\n", pd->msg.event);
+        return pd;
+}
+
+static struct poseidon *find_old_poseidon(struct usb_device *udev)
+{
+        struct poseidon *pd;
+
+        list_for_each_entry(pd, &pd_device_list, device_list) {
+                if (pd->portnum == udev->portnum && in_hibernation(pd))
+                        return fixup(pd);
+        }
+        return NULL;
+}
+
+/* Is the card working now ? */
+static inline int is_working(struct poseidon *pd)
+{
+        return get_pm_count(pd) > 0;
+}
+
+static int poseidon_suspend(struct usb_interface *intf, pm_message_t msg)
+{
+        struct poseidon *pd = get_pd(intf);
+
+        if (!pd)
+                return 0;
+        if (!is_working(pd)) {
+                if (get_pm_count(pd) <= 0 && !in_hibernation(pd)) {
+                        pd->msg.event = PM_EVENT_AUTO_SUSPEND;
+                        pd->pm_resume = NULL; /*  a good guard */
+                        printk(KERN_DEBUG "\n\t+ TLG2300 auto suspend +\n\n");
+                }
+                return 0;
+        }
+        pd->msg = msg; /* save it here */
+        logpm(pd);
+        return pd->pm_suspend ? pd->pm_suspend(pd) : 0;
+}
+
+static int poseidon_resume(struct usb_interface *intf)
+{
+        struct poseidon *pd = get_pd(intf);
+
+        if (!pd)
+                return 0;
+        printk(KERN_DEBUG "\n\t ++ TLG2300 resume ++\n\n");
+
+        if (!is_working(pd)) {
+                if (PM_EVENT_AUTO_SUSPEND == pd->msg.event)
+                        pd->msg = PMSG_ON;
+                return 0;
+        }
+        if (in_hibernation(pd)) {
+                logpm(pd);
+                return 0;
+        }
+        logpm(pd);
+        return pd->pm_resume ? pd->pm_resume(pd) : 0;
+}
+
+static void hibernation_resume(struct work_struct *w)
+{
+        struct poseidon *pd = container_of(w, struct poseidon, pm_work);
+        int count;
+
+        pd->msg.event = 0; /* clear it here */
+        pd->state &= ~POSEIDON_STATE_DISCONNECT;
+
+        /* set the new interface's reference */
+        count = get_autopm_ref(pd);
+        while (count--)
+                usb_autopm_get_interface(pd->interface);
+
+        /* resume the context */
+        logpm(pd);
+        if (pd->pm_resume)
+                pd->pm_resume(pd);
+}
+#else /* CONFIG_PM is not enabled: */
+static inline struct poseidon *find_old_poseidon(struct usb_device *udev)
+{
+        return NULL;
+}
+
+static inline void set_map_flags(struct poseidon *pd, struct usb_device *udev)
+{
+}
+#endif
+
+static bool check_firmware(struct usb_device *udev, int *down_firmware)
+{
+        void *buf;
+        int ret;
+        struct cmd_firmware_vers_s *cmd_firm;
+
+        buf = kzalloc(sizeof(*cmd_firm) + sizeof(u32), GFP_KERNEL);
+        if (!buf)
+                return -ENOMEM;
+        ret = usb_control_msg(udev,
+                         usb_rcvctrlpipe(udev, 0),
+                         REQ_GET_CMD | GET_FW_ID,
+                         USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+                         0,
+                         0,
+                         buf,
+                         sizeof(*cmd_firm) + sizeof(u32),
+                         USB_CTRL_GET_TIMEOUT);
+        kfree(buf);
+
+        if (ret < 0) {
+                *down_firmware = 1;
+                return firmware_download(udev);
+        }
+        return ret;
+}
+
+static int poseidon_probe(struct usb_interface *interface,
+                                const struct usb_device_id *id)
+{
+        struct usb_device *udev = interface_to_usbdev(interface);
+        struct poseidon *pd = NULL;
+        int ret = 0;
+        int new_one = 0;
+
+        /* download firmware */
+        check_firmware(udev, &ret);
+        if (ret)
+                return 0;
+
+        /* Do I recovery from the hibernate ? */
+        pd = find_old_poseidon(udev);
+        if (!pd) {
+                pd = kzalloc(sizeof(*pd), GFP_KERNEL);
+                if (!pd)
+                        return -ENOMEM;
+                kref_init(&pd->kref);
+                set_map_flags(pd, udev);
+                new_one = 1;
+        }
+
+        pd->udev        = usb_get_dev(udev);
+        pd->interface   = usb_get_intf(interface);
+        usb_set_intfdata(interface, pd);
+
+        if (new_one) {
+                struct device *dev = &interface->dev;
+
+                logpm(pd);
+                mutex_init(&pd->lock);
+
+                /* register v4l2 device */
+                snprintf(pd->v4l2_dev.name, sizeof(pd->v4l2_dev.name), "%s %s",
+                        dev->driver->name, dev_name(dev));
+                ret = v4l2_device_register(NULL, &pd->v4l2_dev);
+
+                /* register devices in directory /dev */
+                ret = pd_video_init(pd);
+                poseidon_audio_init(pd);
+                poseidon_fm_init(pd);
+                pd_dvb_usb_device_init(pd);
+
+                INIT_LIST_HEAD(&pd->device_list);
+                list_add_tail(&pd->device_list, &pd_device_list);
+        }
+
+        device_init_wakeup(&udev->dev, 1);
+#ifdef CONFIG_PM
+        pd->udev->autosuspend_disabled = 0;
+        pd->udev->autosuspend_delay = HZ * PM_SUSPEND_DELAY;
+
+        if (in_hibernation(pd)) {
+                INIT_WORK(&pd->pm_work, hibernation_resume);
+                schedule_work(&pd->pm_work);
+        }
+#endif
+        return 0;
+}
+
+static void poseidon_disconnect(struct usb_interface *interface)
+{
+        struct poseidon *pd = get_pd(interface);
+
+        if (!pd)
+                return;
+        logpm(pd);
+        if (in_hibernation(pd))
+                return;
+
+        mutex_lock(&pd->lock);
+        pd->state |= POSEIDON_STATE_DISCONNECT;
+        mutex_unlock(&pd->lock);
+
+        /* stop urb transferring */
+        stop_all_video_stream(pd);
+        dvb_stop_streaming(&pd->dvb_data);
+
+        /*unregister v4l2 device */
+        v4l2_device_unregister(&pd->v4l2_dev);
+
+        lock_kernel();
+        {
+                pd_dvb_usb_device_exit(pd);
+                poseidon_fm_exit(pd);
+
+                poseidon_audio_free(pd);
+                pd_video_exit(pd);
+        }
+        unlock_kernel();
+
+        usb_set_intfdata(interface, NULL);
+        kref_put(&pd->kref, poseidon_delete);
+}
+
+struct usb_driver poseidon_driver = {
+        .name           = "poseidon",
+        .probe          = poseidon_probe,
+        .disconnect     = poseidon_disconnect,
+        .id_table       = id_table,
+#ifdef CONFIG_PM
+        .suspend        = poseidon_suspend,
+        .resume         = poseidon_resume,
+#endif
+        .supports_autosuspend = 1,
+};
+
+static int __init poseidon_init(void)
+{
+        int ret;
+
+        ret = usb_register(&poseidon_driver);
+        if (ret)
+                return ret;
+        register_pm_notifier(&pm_notifer);
+        return ret;
+}
+
+static void __exit poseidon_exit(void)
+{
+        log();
+        unregister_pm_notifier(&pm_notifer);
+        usb_deregister(&poseidon_driver);
+}
+
+module_init(poseidon_init);
+module_exit(poseidon_exit);
+
+MODULE_AUTHOR("Telegent Systems");
+MODULE_DESCRIPTION("For tlg2300-based USB device ");
+MODULE_LICENSE("GPL");
diff --git a/drivers/media/video/tlg2300/pd-radio.c b/drivers/media/video/tlg2300/pd-radio.c
new file mode 100644
index 000000000000..755766b15157
--- /dev/null
+++ b/drivers/media/video/tlg2300/pd-radio.c
@@ -0,0 +1,420 @@
+#include <linux/init.h>
+#include <linux/list.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/bitmap.h>
+#include <linux/usb.h>
+#include <linux/i2c.h>
+#include <media/v4l2-dev.h>
+#include <linux/version.h>
+#include <linux/mm.h>
+#include <linux/mutex.h>
+#include <media/v4l2-ioctl.h>
+#include <linux/sched.h>
+
+#include "pd-common.h"
+#include "vendorcmds.h"
+
+static int set_frequency(struct poseidon *p, __u32 frequency);
+static int poseidon_fm_close(struct file *filp);
+static int poseidon_fm_open(struct file *filp);
+
+#define TUNER_FREQ_MIN_FM 76000000
+#define TUNER_FREQ_MAX_FM 108000000
+
+#define MAX_PREEMPHASIS (V4L2_PREEMPHASIS_75_uS + 1)
+static int preemphasis[MAX_PREEMPHASIS] = {
+        TLG_TUNE_ASTD_NONE,   /* V4L2_PREEMPHASIS_DISABLED */
+        TLG_TUNE_ASTD_FM_EUR, /* V4L2_PREEMPHASIS_50_uS    */
+        TLG_TUNE_ASTD_FM_US,  /* V4L2_PREEMPHASIS_75_uS    */
+};
+
+static int poseidon_check_mode_radio(struct poseidon *p)
+{
+        int ret;
+        u32 status;
+
+        set_current_state(TASK_INTERRUPTIBLE);
+        schedule_timeout(HZ/2);
+        ret = usb_set_interface(p->udev, 0, BULK_ALTERNATE_IFACE);
+        if (ret < 0)
+                goto out;
+
+        ret = set_tuner_mode(p, TLG_MODE_FM_RADIO);
+        if (ret != 0)
+                goto out;
+
+        ret = send_set_req(p, SGNL_SRC_SEL, TLG_SIG_SRC_ANTENNA, &status);
+        ret = send_set_req(p, TUNER_AUD_ANA_STD,
+                                p->radio_data.pre_emphasis, &status);
+        ret |= send_set_req(p, TUNER_AUD_MODE,
+                                TLG_TUNE_TVAUDIO_MODE_STEREO, &status);
+        ret |= send_set_req(p, AUDIO_SAMPLE_RATE_SEL,
+                                ATV_AUDIO_RATE_48K, &status);
+        ret |= send_set_req(p, TUNE_FREQ_SELECT, TUNER_FREQ_MIN_FM, &status);
+out:
+        return ret;
+}
+
+#ifdef CONFIG_PM
+static int pm_fm_suspend(struct poseidon *p)
+{
+        logpm(p);
+        pm_alsa_suspend(p);
+        usb_set_interface(p->udev, 0, 0);
+        msleep(300);
+        return 0;
+}
+
+static int pm_fm_resume(struct poseidon *p)
+{
+        logpm(p);
+        poseidon_check_mode_radio(p);
+        set_frequency(p, p->radio_data.fm_freq);
+        pm_alsa_resume(p);
+        return 0;
+}
+#endif
+
+static int poseidon_fm_open(struct file *filp)
+{
+        struct video_device *vfd = video_devdata(filp);
+        struct poseidon *p = video_get_drvdata(vfd);
+        int ret = 0;
+
+        if (!p)
+                return -1;
+
+        mutex_lock(&p->lock);
+        if (p->state & POSEIDON_STATE_DISCONNECT) {
+                ret = -ENODEV;
+                goto out;
+        }
+
+        if (p->state && !(p->state & POSEIDON_STATE_FM)) {
+                ret = -EBUSY;
+                goto out;
+        }
+
+        usb_autopm_get_interface(p->interface);
+        if (0 == p->state) {
+                /* default pre-emphasis */
+                if (p->radio_data.pre_emphasis == 0)
+                        p->radio_data.pre_emphasis = TLG_TUNE_ASTD_FM_EUR;
+                set_debug_mode(vfd, debug_mode);
+
+                ret = poseidon_check_mode_radio(p);
+                if (ret < 0) {
+                        usb_autopm_put_interface(p->interface);
+                        goto out;
+                }
+                p->state |= POSEIDON_STATE_FM;
+        }
+        p->radio_data.users++;
+        kref_get(&p->kref);
+        filp->private_data = p;
+out:
+        mutex_unlock(&p->lock);
+        return ret;
+}
+
+static int poseidon_fm_close(struct file *filp)
+{
+        struct poseidon *p = filp->private_data;
+        struct radio_data *fm = &p->radio_data;
+        uint32_t status;
+
+        mutex_lock(&p->lock);
+        fm->users--;
+        if (0 == fm->users)
+                p->state &= ~POSEIDON_STATE_FM;
+
+        if (fm->is_radio_streaming && filp == p->file_for_stream) {
+                fm->is_radio_streaming = 0;
+                send_set_req(p, PLAY_SERVICE, TLG_TUNE_PLAY_SVC_STOP, &status);
+        }
+        usb_autopm_put_interface(p->interface);
+        mutex_unlock(&p->lock);
+
+        kref_put(&p->kref, poseidon_delete);
+        filp->private_data = NULL;
+        return 0;
+}
+
+static int vidioc_querycap(struct file *file, void *priv,
+                        struct v4l2_capability *v)
+{
+        struct poseidon *p = file->private_data;
+
+        strlcpy(v->driver, "tele-radio", sizeof(v->driver));
+        strlcpy(v->card, "Telegent Poseidon", sizeof(v->card));
+        usb_make_path(p->udev, v->bus_info, sizeof(v->bus_info));
+        v->version = KERNEL_VERSION(0, 0, 1);
+        v->capabilities = V4L2_CAP_TUNER | V4L2_CAP_RADIO;
+        return 0;
+}
+
+static const struct v4l2_file_operations poseidon_fm_fops = {
+        .owner         = THIS_MODULE,
+        .open          = poseidon_fm_open,
+        .release       = poseidon_fm_close,
+        .ioctl         = video_ioctl2,
+};
+
+int tlg_fm_vidioc_g_tuner(struct file *file, void *priv, struct v4l2_tuner *vt)
+{
+        struct tuner_fm_sig_stat_s fm_stat = {};
+        int ret, status, count = 5;
+        struct poseidon *p = file->private_data;
+
+        if (vt->index != 0)
+                return -EINVAL;
+
+        vt->type        = V4L2_TUNER_RADIO;
+        vt->capability  = V4L2_TUNER_CAP_STEREO;
+        vt->rangelow    = TUNER_FREQ_MIN_FM / 62500;
+        vt->rangehigh   = TUNER_FREQ_MAX_FM / 62500;
+        vt->rxsubchans  = V4L2_TUNER_SUB_STEREO;
+        vt->audmode     = V4L2_TUNER_MODE_STEREO;
+        vt->signal      = 0;
+        vt->afc         = 0;
+
+        mutex_lock(&p->lock);
+        ret = send_get_req(p, TUNER_STATUS, TLG_MODE_FM_RADIO,
+                              &fm_stat, &status, sizeof(fm_stat));
+
+        while (fm_stat.sig_lock_busy && count-- && !ret) {
+                set_current_state(TASK_INTERRUPTIBLE);
+                schedule_timeout(HZ);
+
+                ret = send_get_req(p, TUNER_STATUS, TLG_MODE_FM_RADIO,
+                                  &fm_stat, &status, sizeof(fm_stat));
+        }
+        mutex_unlock(&p->lock);
+
+        if (ret || status) {
+                vt->signal = 0;
+        } else if ((fm_stat.sig_present || fm_stat.sig_locked)
+                        && fm_stat.sig_strength == 0) {
+                vt->signal = 0xffff;
+        } else
+                vt->signal = (fm_stat.sig_strength * 255 / 10) << 8;
+
+        return 0;
+}
+
+int fm_get_freq(struct file *file, void *priv, struct v4l2_frequency *argp)
+{
+        struct poseidon *p = file->private_data;
+
+        argp->frequency = p->radio_data.fm_freq;
+        return 0;
+}
+
+static int set_frequency(struct poseidon *p, __u32 frequency)
+{
+        __u32 freq ;
+        int ret, status;
+
+        mutex_lock(&p->lock);
+
+        ret = send_set_req(p, TUNER_AUD_ANA_STD,
+                                p->radio_data.pre_emphasis, &status);
+
+        freq =  (frequency * 125) * 500 / 1000;/* kHZ */
+        if (freq < TUNER_FREQ_MIN_FM/1000 || freq > TUNER_FREQ_MAX_FM/1000) {
+                ret = -EINVAL;
+                goto error;
+        }
+
+        ret = send_set_req(p, TUNE_FREQ_SELECT, freq, &status);
+        if (ret < 0)
+                goto error ;
+        ret = send_set_req(p, TAKE_REQUEST, 0, &status);
+
+        set_current_state(TASK_INTERRUPTIBLE);
+        schedule_timeout(HZ/4);
+        if (!p->radio_data.is_radio_streaming) {
+                ret = send_set_req(p, TAKE_REQUEST, 0, &status);
+                ret = send_set_req(p, PLAY_SERVICE,
+                                TLG_TUNE_PLAY_SVC_START, &status);
+                p->radio_data.is_radio_streaming = 1;
+        }
+        p->radio_data.fm_freq = frequency;
+error:
+        mutex_unlock(&p->lock);
+        return ret;
+}
+
+int fm_set_freq(struct file *file, void *priv, struct v4l2_frequency *argp)
+{
+        struct poseidon *p = file->private_data;
+
+        p->file_for_stream  = file;
+#ifdef CONFIG_PM
+        p->pm_suspend = pm_fm_suspend;
+        p->pm_resume  = pm_fm_resume;
+#endif
+        return set_frequency(p, argp->frequency);
+}
+
+int tlg_fm_vidioc_g_ctrl(struct file *file, void *priv,
+                struct v4l2_control *arg)
+{
+        return 0;
+}
+
+int tlg_fm_vidioc_g_exts_ctrl(struct file *file, void *fh,
+                                struct v4l2_ext_controls *ctrls)
+{
+        struct poseidon *p = file->private_data;
+        int i;
+
+        if (ctrls->ctrl_class != V4L2_CTRL_CLASS_FM_TX)
+                return -EINVAL;
+
+        for (i = 0; i < ctrls->count; i++) {
+                struct v4l2_ext_control *ctrl = ctrls->controls + i;
+
+                if (ctrl->id != V4L2_CID_TUNE_PREEMPHASIS)
+                        continue;
+
+                if (i < MAX_PREEMPHASIS)
+                        ctrl->value = p->radio_data.pre_emphasis;
+        }
+        return 0;
+}
+
+int tlg_fm_vidioc_s_exts_ctrl(struct file *file, void *fh,
+                        struct v4l2_ext_controls *ctrls)
+{
+        int i;
+
+        if (ctrls->ctrl_class != V4L2_CTRL_CLASS_FM_TX)
+                return -EINVAL;
+
+        for (i = 0; i < ctrls->count; i++) {
+                struct v4l2_ext_control *ctrl = ctrls->controls + i;
+
+                if (ctrl->id != V4L2_CID_TUNE_PREEMPHASIS)
+                        continue;
+
+                if (ctrl->value >= 0 && ctrl->value < MAX_PREEMPHASIS) {
+                        struct poseidon *p = file->private_data;
+                        int pre_emphasis = preemphasis[ctrl->value];
+                        u32 status;
+
+                        send_set_req(p, TUNER_AUD_ANA_STD,
+                                                pre_emphasis, &status);
+                        p->radio_data.pre_emphasis = pre_emphasis;
+                }
+        }
+        return 0;
+}
+
+int tlg_fm_vidioc_s_ctrl(struct file *file, void *priv,
+                struct v4l2_control *ctrl)
+{
+        return 0;
+}
+
+int tlg_fm_vidioc_queryctrl(struct file *file, void *priv,
+                struct v4l2_queryctrl *ctrl)
+{
+        if (!(ctrl->id & V4L2_CTRL_FLAG_NEXT_CTRL))
+                return -EINVAL;
+
+        ctrl->id &= ~V4L2_CTRL_FLAG_NEXT_CTRL;
+        if (ctrl->id != V4L2_CID_TUNE_PREEMPHASIS) {
+                /* return the next supported control */
+                ctrl->id = V4L2_CID_TUNE_PREEMPHASIS;
+                v4l2_ctrl_query_fill(ctrl, V4L2_PREEMPHASIS_DISABLED,
+                                        V4L2_PREEMPHASIS_75_uS, 1,
+                                        V4L2_PREEMPHASIS_50_uS);
+                ctrl->flags = V4L2_CTRL_FLAG_UPDATE;
+                return 0;
+        }
+        return -EINVAL;
+}
+
+int tlg_fm_vidioc_querymenu(struct file *file, void *fh,
+                                struct v4l2_querymenu *qmenu)
+{
+        return v4l2_ctrl_query_menu(qmenu, NULL, NULL);
+}
+
+static int vidioc_s_tuner(struct file *file, void *priv, struct v4l2_tuner *vt)
+{
+        return vt->index > 0 ? -EINVAL : 0;
+}
+static int vidioc_s_audio(struct file *file, void *priv, struct v4l2_audio *va)
+{
+        return (va->index != 0) ? -EINVAL : 0;
+}
+
+static int vidioc_g_audio(struct file *file, void *priv, struct v4l2_audio *a)
+{
+        a->index    = 0;
+        a->mode    = 0;
+        a->capability = V4L2_AUDCAP_STEREO;
+        strcpy(a->name, "Radio");
+        return 0;
+}
+
+static int vidioc_s_input(struct file *filp, void *priv, u32 i)
+{
+        return (i != 0) ? -EINVAL : 0;
+}
+
+static int vidioc_g_input(struct file *filp, void *priv, u32 *i)
+{
+        return (*i != 0) ? -EINVAL : 0;
+}
+
+static const struct v4l2_ioctl_ops poseidon_fm_ioctl_ops = {
+        .vidioc_querycap    = vidioc_querycap,
+        .vidioc_g_audio     = vidioc_g_audio,
+        .vidioc_s_audio     = vidioc_s_audio,
+        .vidioc_g_input     = vidioc_g_input,
+        .vidioc_s_input     = vidioc_s_input,
+        .vidioc_queryctrl   = tlg_fm_vidioc_queryctrl,
+        .vidioc_querymenu   = tlg_fm_vidioc_querymenu,
+        .vidioc_g_ctrl      = tlg_fm_vidioc_g_ctrl,
+        .vidioc_s_ctrl      = tlg_fm_vidioc_s_ctrl,
+        .vidioc_s_ext_ctrls = tlg_fm_vidioc_s_exts_ctrl,
+        .vidioc_g_ext_ctrls = tlg_fm_vidioc_g_exts_ctrl,
+        .vidioc_s_tuner     = vidioc_s_tuner,
+        .vidioc_g_tuner     = tlg_fm_vidioc_g_tuner,
+        .vidioc_g_frequency = fm_get_freq,
+        .vidioc_s_frequency = fm_set_freq,
+};
+
+static struct video_device poseidon_fm_template = {
+        .name       = "Telegent-Radio",
+        .fops       = &poseidon_fm_fops,
+        .minor      = -1,
+        .release    = video_device_release,
+        .ioctl_ops  = &poseidon_fm_ioctl_ops,
+};
+
+int poseidon_fm_init(struct poseidon *p)
+{
+        struct video_device *fm_dev;
+
+        fm_dev = vdev_init(p, &poseidon_fm_template);
+        if (fm_dev == NULL)
+                return -1;
+
+        if (video_register_device(fm_dev, VFL_TYPE_RADIO, -1) < 0) {
+                video_device_release(fm_dev);
+                return -1;
+        }
+        p->radio_data.fm_dev = fm_dev;
+        return 0;
+}
+
+int poseidon_fm_exit(struct poseidon *p)
+{
+        destroy_video_device(&p->radio_data.fm_dev);
+        return 0;
+}
diff --git a/drivers/media/video/tlg2300/pd-video.c b/drivers/media/video/tlg2300/pd-video.c
new file mode 100644
index 000000000000..becfba6a3041
--- /dev/null
+++ b/drivers/media/video/tlg2300/pd-video.c
@@ -0,0 +1,1667 @@
+#include <linux/fs.h>
+#include <linux/vmalloc.h>
+#include <linux/videodev2.h>
+#include <linux/usb.h>
+#include <linux/mm.h>
+#include <linux/sched.h>
+
+#include <media/v4l2-ioctl.h>
+#include <media/v4l2-dev.h>
+
+#include "pd-common.h"
+#include "vendorcmds.h"
+
+static int pm_video_suspend(struct poseidon *pd);
+static int pm_video_resume(struct poseidon *pd);
+static void iso_bubble_handler(struct work_struct *w);
+
+int usb_transfer_mode;
+module_param(usb_transfer_mode, int, 0644);
+MODULE_PARM_DESC(usb_transfer_mode, "0 = Bulk, 1 = Isochronous");
+
+static const struct poseidon_format poseidon_formats[] = {
+        { "YUV 422", V4L2_PIX_FMT_YUYV, 16, 0},
+        { "RGB565", V4L2_PIX_FMT_RGB565, 16, 0},
+};
+
+static const struct poseidon_tvnorm poseidon_tvnorms[] = {
+        { V4L2_STD_PAL_D, "PAL-D",  TLG_TUNE_VSTD_PAL_D },
+        { V4L2_STD_PAL_B, "PAL-B",  TLG_TUNE_VSTD_PAL_B },
+        { V4L2_STD_PAL_G, "PAL-G",  TLG_TUNE_VSTD_PAL_G },
+        { V4L2_STD_PAL_H, "PAL-H",  TLG_TUNE_VSTD_PAL_H },
+        { V4L2_STD_PAL_I, "PAL-I",  TLG_TUNE_VSTD_PAL_I },
+        { V4L2_STD_PAL_M, "PAL-M",  TLG_TUNE_VSTD_PAL_M },
+        { V4L2_STD_PAL_N, "PAL-N",  TLG_TUNE_VSTD_PAL_N_COMBO },
+        { V4L2_STD_PAL_Nc, "PAL-Nc", TLG_TUNE_VSTD_PAL_N_COMBO },
+        { V4L2_STD_NTSC_M, "NTSC-M", TLG_TUNE_VSTD_NTSC_M },
+        { V4L2_STD_NTSC_M_JP, "NTSC-JP", TLG_TUNE_VSTD_NTSC_M_J },
+        { V4L2_STD_SECAM_B, "SECAM-B", TLG_TUNE_VSTD_SECAM_B },
+        { V4L2_STD_SECAM_D, "SECAM-D", TLG_TUNE_VSTD_SECAM_D },
+        { V4L2_STD_SECAM_G, "SECAM-G", TLG_TUNE_VSTD_SECAM_G },
+        { V4L2_STD_SECAM_H, "SECAM-H", TLG_TUNE_VSTD_SECAM_H },
+        { V4L2_STD_SECAM_K, "SECAM-K", TLG_TUNE_VSTD_SECAM_K },
+        { V4L2_STD_SECAM_K1, "SECAM-K1", TLG_TUNE_VSTD_SECAM_K1 },
+        { V4L2_STD_SECAM_L, "SECAM-L", TLG_TUNE_VSTD_SECAM_L },
+        { V4L2_STD_SECAM_LC, "SECAM-LC", TLG_TUNE_VSTD_SECAM_L1 },
+};
+static const unsigned int POSEIDON_TVNORMS = ARRAY_SIZE(poseidon_tvnorms);
+
+struct pd_audio_mode {
+        u32 tlg_audio_mode;
+        u32 v4l2_audio_sub;
+        u32 v4l2_audio_mode;
+};
+
+static const struct pd_audio_mode pd_audio_modes[] = {
+        { TLG_TUNE_TVAUDIO_MODE_MONO, V4L2_TUNER_SUB_MONO,
+                V4L2_TUNER_MODE_MONO },
+        { TLG_TUNE_TVAUDIO_MODE_STEREO, V4L2_TUNER_SUB_STEREO,
+                V4L2_TUNER_MODE_STEREO },
+        { TLG_TUNE_TVAUDIO_MODE_LANG_A, V4L2_TUNER_SUB_LANG1,
+                V4L2_TUNER_MODE_LANG1 },
+        { TLG_TUNE_TVAUDIO_MODE_LANG_B, V4L2_TUNER_SUB_LANG2,
+                V4L2_TUNER_MODE_LANG2 },
+        { TLG_TUNE_TVAUDIO_MODE_LANG_C, V4L2_TUNER_SUB_LANG1,
+                V4L2_TUNER_MODE_LANG1_LANG2 }
+};
+static const unsigned int POSEIDON_AUDIOMODS = ARRAY_SIZE(pd_audio_modes);
+
+struct pd_input {
+        char *name;
+        uint32_t tlg_src;
+};
+
+static const struct pd_input pd_inputs[] = {
+        { "TV Antenna", TLG_SIG_SRC_ANTENNA },
+        { "TV Cable", TLG_SIG_SRC_CABLE },
+        { "TV SVideo", TLG_SIG_SRC_SVIDEO },
+        { "TV Composite", TLG_SIG_SRC_COMPOSITE }
+};
+static const unsigned int POSEIDON_INPUTS = ARRAY_SIZE(pd_inputs);
+
+struct poseidon_control {
+        struct v4l2_queryctrl v4l2_ctrl;
+        enum cmd_custom_param_id vc_id;
+};
+
+static struct poseidon_control controls[] = {
+        {
+                { V4L2_CID_BRIGHTNESS, V4L2_CTRL_TYPE_INTEGER,
+                        "brightness", 0, 10000, 1, 100, 0, },
+                CUST_PARM_ID_BRIGHTNESS_CTRL
+        }, {
+                { V4L2_CID_CONTRAST, V4L2_CTRL_TYPE_INTEGER,
+                        "contrast", 0, 10000, 1, 100, 0, },
+                CUST_PARM_ID_CONTRAST_CTRL,
+        }, {
+                { V4L2_CID_HUE, V4L2_CTRL_TYPE_INTEGER,
+                        "hue", 0, 10000, 1, 100, 0, },
+                CUST_PARM_ID_HUE_CTRL,
+        }, {
+                { V4L2_CID_SATURATION, V4L2_CTRL_TYPE_INTEGER,
+                        "saturation", 0, 10000, 1, 100, 0, },
+                CUST_PARM_ID_SATURATION_CTRL,
+        },
+};
+
+struct video_std_to_audio_std {
+        v4l2_std_id     video_std;
+        int             audio_std;
+};
+
+static const struct video_std_to_audio_std video_to_audio_map[] = {
+        /* country : { 27, 32, 33, 34, 36, 44, 45, 46, 47, 48, 64,
+                        65, 86, 351, 352, 353, 354, 358, 372, 852, 972 } */
+        { (V4L2_STD_PAL_I | V4L2_STD_PAL_B | V4L2_STD_PAL_D |
+                V4L2_STD_SECAM_L | V4L2_STD_SECAM_D), TLG_TUNE_ASTD_NICAM },
+
+        /* country : { 1, 52, 54, 55, 886 } */
+        {V4L2_STD_NTSC_M | V4L2_STD_PAL_N | V4L2_STD_PAL_M, TLG_TUNE_ASTD_BTSC},
+
+        /* country : { 81 } */
+        { V4L2_STD_NTSC_M_JP, TLG_TUNE_ASTD_EIAJ },
+
+        /* other country : TLG_TUNE_ASTD_A2 */
+};
+static const unsigned int map_size = ARRAY_SIZE(video_to_audio_map);
+
+static int get_audio_std(v4l2_std_id v4l2_std)
+{
+        int i = 0;
+
+        for (; i < map_size; i++) {
+                if (v4l2_std & video_to_audio_map[i].video_std)
+                        return video_to_audio_map[i].audio_std;
+        }
+        return TLG_TUNE_ASTD_A2;
+}
+
+static int vidioc_querycap(struct file *file, void *fh,
+                        struct v4l2_capability *cap)
+{
+        struct front_face *front = fh;
+        struct poseidon *p = front->pd;
+
+        logs(front);
+
+        strcpy(cap->driver, "tele-video");
+        strcpy(cap->card, "Telegent Poseidon");
+        usb_make_path(p->udev, cap->bus_info, sizeof(cap->bus_info));
+        cap->version = KERNEL_VERSION(0, 0, 1);
+        cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_TUNER |
+                                V4L2_CAP_AUDIO | V4L2_CAP_STREAMING |
+                                V4L2_CAP_READWRITE | V4L2_CAP_VBI_CAPTURE;
+        return 0;
+}
+
+/*====================================================================*/
+static void init_copy(struct video_data *video, bool index)
+{
+        struct front_face *front = video->front;
+
+        video->field_count      = index;
+        video->lines_copied     = 0;
+        video->prev_left        = 0 ;
+        video->dst              = (char *)videobuf_to_vmalloc(front->curr_frame)
+                                        + index * video->lines_size;
+        video->vbi->copied      = 0; /* set it here */
+}
+
+static bool get_frame(struct front_face *front, int *need_init)
+{
+        struct videobuf_buffer *vb = front->curr_frame;
+
+        if (vb)
+                return true;
+
+        spin_lock(&front->queue_lock);
+        if (!list_empty(&front->active)) {
+                vb = list_entry(front->active.next,
+                               struct videobuf_buffer, queue);
+                if (need_init)
+                        *need_init = 1;
+                front->curr_frame = vb;
+                list_del_init(&vb->queue);
+        }
+        spin_unlock(&front->queue_lock);
+
+        return !!vb;
+}
+
+/* check if the video's buffer is ready */
+static bool get_video_frame(struct front_face *front, struct video_data *video)
+{
+        int need_init = 0;
+        bool ret = true;
+
+        ret = get_frame(front, &need_init);
+        if (ret && need_init)
+                init_copy(video, 0);
+        return ret;
+}
+
+static void submit_frame(struct front_face *front)
+{
+        struct videobuf_buffer *vb = front->curr_frame;
+
+        if (vb == NULL)
+                return;
+
+        front->curr_frame       = NULL;
+        vb->state               = VIDEOBUF_DONE;
+        vb->field_count++;
+        do_gettimeofday(&vb->ts);
+
+        wake_up(&vb->done);
+}
+
+/*
+ * A frame is composed of two fields. If we receive all the two fields,
+ * call the  submit_frame() to submit the whole frame to applications.
+ */
+static void end_field(struct video_data *video)
+{
+        /* logs(video->front); */
+        if (1 == video->field_count)
+                submit_frame(video->front);
+        else
+                init_copy(video, 1);
+}
+
+static void copy_video_data(struct video_data *video, char *src,
+                                unsigned int count)
+{
+#define copy_data(len)  \
+        do { \
+                if (++video->lines_copied > video->lines_per_field) \
+                        goto overflow; \
+                memcpy(video->dst, src, len);\
+                video->dst += len + video->lines_size; \
+                src += len; \
+                count -= len; \
+         } while (0)
+
+        while (count && count >= video->lines_size) {
+                if (video->prev_left) {
+                        copy_data(video->prev_left);
+                        video->prev_left = 0;
+                        continue;
+                }
+                copy_data(video->lines_size);
+        }
+        if (count && count < video->lines_size) {
+                memcpy(video->dst, src, count);
+
+                video->prev_left = video->lines_size - count;
+                video->dst += count;
+        }
+        return;
+
+overflow:
+        end_field(video);
+}
+
+static void check_trailer(struct video_data *video, char *src, int count)
+{
+        struct vbi_data *vbi = video->vbi;
+        int offset; /* trailer's offset */
+        char *buf;
+
+        offset = (video->context.pix.sizeimage / 2 + vbi->vbi_size / 2)
+                - (vbi->copied + video->lines_size * video->lines_copied);
+        if (video->prev_left)
+                offset -= (video->lines_size - video->prev_left);
+
+        if (offset > count || offset <= 0)
+                goto short_package;
+
+        buf = src + offset;
+
+        /* trailer : (VFHS) + U32 + U32 + field_num */
+        if (!strncmp(buf, "VFHS", 4)) {
+                int field_num = *((u32 *)(buf + 12));
+
+                if ((field_num & 1) ^ video->field_count) {
+                        init_copy(video, video->field_count);
+                        return;
+                }
+                copy_video_data(video, src, offset);
+        }
+short_package:
+        end_field(video);
+}
+
+/* ==========  Check this more carefully! =========== */
+static inline void copy_vbi_data(struct vbi_data *vbi,
+                                char *src, unsigned int count)
+{
+        struct front_face *front = vbi->front;
+
+        if (front && get_frame(front, NULL)) {
+                char *buf = videobuf_to_vmalloc(front->curr_frame);
+
+                if (vbi->video->field_count)
+                        buf += (vbi->vbi_size / 2);
+                memcpy(buf + vbi->copied, src, count);
+        }
+        vbi->copied += count;
+}
+
+/*
+ * Copy the normal data (VBI or VIDEO) without the trailer.
+ * VBI is not interlaced, while VIDEO is interlaced.
+ */
+static inline void copy_vbi_video_data(struct video_data *video,
+                                char *src, unsigned int count)
+{
+        struct vbi_data *vbi = video->vbi;
+        unsigned int vbi_delta = (vbi->vbi_size / 2) - vbi->copied;
+
+        if (vbi_delta >= count) {
+                copy_vbi_data(vbi, src, count);
+        } else {
+                if (vbi_delta) {
+                        copy_vbi_data(vbi, src, vbi_delta);
+
+                        /* we receive the two fields of the VBI*/
+                        if (vbi->front && video->field_count)
+                                submit_frame(vbi->front);
+                }
+                copy_video_data(video, src + vbi_delta, count - vbi_delta);
+        }
+}
+
+static void urb_complete_bulk(struct urb *urb)
+{
+        struct front_face *front = urb->context;
+        struct video_data *video = &front->pd->video_data;
+        char *src = (char *)urb->transfer_buffer;
+        int count = urb->actual_length;
+        int ret = 0;
+
+        if (!video->is_streaming || urb->status) {
+                if (urb->status == -EPROTO)
+                        goto resend_it;
+                return;
+        }
+        if (!get_video_frame(front, video))
+                goto resend_it;
+
+        if (count == urb->transfer_buffer_length)
+                copy_vbi_video_data(video, src, count);
+        else
+                check_trailer(video, src, count);
+
+resend_it:
+        ret = usb_submit_urb(urb, GFP_ATOMIC);
+        if (ret)
+                log(" submit failed: error %d", ret);
+}
+
+/************************* for ISO *********************/
+#define GET_SUCCESS             (0)
+#define GET_TRAILER             (1)
+#define GET_TOO_MUCH_BUBBLE     (2)
+#define GET_NONE                (3)
+static int get_chunk(int start, struct urb *urb,
+                        int *head, int *tail, int *bubble_err)
+{
+        struct usb_iso_packet_descriptor *pkt = NULL;
+        int ret = GET_SUCCESS;
+
+        for (*head = *tail = -1; start < urb->number_of_packets; start++) {
+                pkt = &urb->iso_frame_desc[start];
+
+                /* handle the bubble of the Hub */
+                if (-EOVERFLOW == pkt->status) {
+                        if (++*bubble_err > urb->number_of_packets / 3)
+                                return GET_TOO_MUCH_BUBBLE;
+                        continue;
+                }
+
+                /* This is the gap */
+                if (pkt->status || pkt->actual_length <= 0
+                                || pkt->actual_length > ISO_PKT_SIZE) {
+                        if (*head != -1)
+                                break;
+                        continue;
+                }
+
+                /* a good isochronous packet */
+                if (pkt->actual_length == ISO_PKT_SIZE) {
+                        if (*head == -1)
+                                *head = start;
+                        *tail = start;
+                        continue;
+                }
+
+                /* trailer is here */
+                if (pkt->actual_length < ISO_PKT_SIZE) {
+                        if (*head == -1) {
+                                *head = start;
+                                *tail = start;
+                                return GET_TRAILER;
+                        }
+                        break;
+                }
+        }
+
+        if (*head == -1 && *tail == -1)
+                ret = GET_NONE;
+        return ret;
+}
+
+/*
+ * |__|------|___|-----|_______|
+ *       ^          ^
+ *       |          |
+ *      gap        gap
+ */
+static void urb_complete_iso(struct urb *urb)
+{
+        struct front_face *front = urb->context;
+        struct video_data *video = &front->pd->video_data;
+        int bubble_err = 0, head = 0, tail = 0;
+        char *src = (char *)urb->transfer_buffer;
+        int ret = 0;
+
+        if (!video->is_streaming)
+                return;
+
+        do {
+                if (!get_video_frame(front, video))
+                        goto out;
+
+                switch (get_chunk(head, urb, &head, &tail, &bubble_err)) {
+                case GET_SUCCESS:
+                        copy_vbi_video_data(video, src + (head * ISO_PKT_SIZE),
+                                        (tail - head + 1) * ISO_PKT_SIZE);
+                        break;
+                case GET_TRAILER:
+                        check_trailer(video, src + (head * ISO_PKT_SIZE),
+                                        ISO_PKT_SIZE);
+                        break;
+                case GET_NONE:
+                        goto out;
+                case GET_TOO_MUCH_BUBBLE:
+                        log("\t We got too much bubble");
+                        schedule_work(&video->bubble_work);
+                        return;
+                }
+        } while (head = tail + 1, head < urb->number_of_packets);
+
+out:
+        ret = usb_submit_urb(urb, GFP_ATOMIC);
+        if (ret)
+                log("usb_submit_urb err : %d", ret);
+}
+/*============================= [  end  ] =====================*/
+
+static int prepare_iso_urb(struct video_data *video)
+{
+        struct usb_device *udev = video->pd->udev;
+        int i;
+
+        if (video->urb_array[0])
+                return 0;
+
+        for (i = 0; i < SBUF_NUM; i++) {
+                struct urb *urb;
+                void *mem;
+                int j;
+
+                urb = usb_alloc_urb(PK_PER_URB, GFP_KERNEL);
+                if (urb == NULL)
+                        goto out;
+
+                video->urb_array[i] = urb;
+                mem = usb_buffer_alloc(udev,
+                                        ISO_PKT_SIZE * PK_PER_URB,
+                                        GFP_KERNEL,
+                                        &urb->transfer_dma);
+
+                urb->complete   = urb_complete_iso;     /* handler */
+                urb->dev        = udev;
+                urb->context    = video->front;
+                urb->pipe       = usb_rcvisocpipe(udev,
+                                                video->endpoint_addr);
+                urb->interval   = 1;
+                urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
+                urb->number_of_packets  = PK_PER_URB;
+                urb->transfer_buffer    = mem;
+                urb->transfer_buffer_length = PK_PER_URB * ISO_PKT_SIZE;
+
+                for (j = 0; j < PK_PER_URB; j++) {
+                        urb->iso_frame_desc[j].offset = ISO_PKT_SIZE * j;
+                        urb->iso_frame_desc[j].length = ISO_PKT_SIZE;
+                }
+        }
+        return 0;
+out:
+        for (; i > 0; i--)
+                ;
+        return -ENOMEM;
+}
+
+/* return the succeeded number of the allocation */
+int alloc_bulk_urbs_generic(struct urb **urb_array, int num,
+                        struct usb_device *udev, u8 ep_addr,
+                        int buf_size, gfp_t gfp_flags,
+                        usb_complete_t complete_fn, void *context)
+{
+        struct urb *urb;
+        void *mem;
+        int i;
+
+        for (i = 0; i < num; i++) {
+                urb = usb_alloc_urb(0, gfp_flags);
+                if (urb == NULL)
+                        return i;
+
+                mem = usb_buffer_alloc(udev, buf_size, gfp_flags,
+                                        &urb->transfer_dma);
+                if (mem == NULL)
+                        return i;
+
+                usb_fill_bulk_urb(urb, udev, usb_rcvbulkpipe(udev, ep_addr),
+                                mem, buf_size, complete_fn, context);
+                urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
+                urb_array[i] = urb;
+        }
+        return i;
+}
+
+void free_all_urb_generic(struct urb **urb_array, int num)
+{
+        int i;
+        struct urb *urb;
+
+        for (i = 0; i < num; i++) {
+                urb = urb_array[i];
+                if (urb) {
+                        usb_buffer_free(urb->dev,
+                                        urb->transfer_buffer_length,
+                                        urb->transfer_buffer,
+                                        urb->transfer_dma);
+                        usb_free_urb(urb);
+                        urb_array[i] = NULL;
+                }
+        }
+}
+
+static int prepare_bulk_urb(struct video_data *video)
+{
+        if (video->urb_array[0])
+                return 0;
+
+        alloc_bulk_urbs_generic(video->urb_array, SBUF_NUM,
+                        video->pd->udev, video->endpoint_addr,
+                        0x2000, GFP_KERNEL,
+                        urb_complete_bulk, video->front);
+        return 0;
+}
+
+/* free the URBs */
+static void free_all_urb(struct video_data *video)
+{
+        free_all_urb_generic(video->urb_array, SBUF_NUM);
+}
+
+static void pd_buf_release(struct videobuf_queue *q, struct videobuf_buffer *vb)
+{
+        videobuf_vmalloc_free(vb);
+        vb->state = VIDEOBUF_NEEDS_INIT;
+}
+
+static void pd_buf_queue(struct videobuf_queue *q, struct videobuf_buffer *vb)
+{
+        struct front_face *front = q->priv_data;
+        vb->state = VIDEOBUF_QUEUED;
+        list_add_tail(&vb->queue, &front->active);
+}
+
+static int pd_buf_prepare(struct videobuf_queue *q, struct videobuf_buffer *vb,
+                           enum v4l2_field field)
+{
+        struct front_face *front = q->priv_data;
+        int rc;
+
+        switch (front->type) {
+        case V4L2_BUF_TYPE_VIDEO_CAPTURE:
+                if (VIDEOBUF_NEEDS_INIT == vb->state) {
+                        struct v4l2_pix_format *pix;
+
+                        pix = &front->pd->video_data.context.pix;
+                        vb->size        = pix->sizeimage; /* real frame size */
+                        vb->width       = pix->width;
+                        vb->height      = pix->height;
+                        rc = videobuf_iolock(q, vb, NULL);
+                        if (rc < 0)
+                                return rc;
+                }
+                break;
+        case V4L2_BUF_TYPE_VBI_CAPTURE:
+                if (VIDEOBUF_NEEDS_INIT == vb->state) {
+                        vb->size        = front->pd->vbi_data.vbi_size;
+                        rc = videobuf_iolock(q, vb, NULL);
+                        if (rc < 0)
+                                return rc;
+                }
+                break;
+        default:
+                return -EINVAL;
+        }
+        vb->field = field;
+        vb->state = VIDEOBUF_PREPARED;
+        return 0;
+}
+
+int fire_all_urb(struct video_data *video)
+{
+        int i, ret;
+
+        video->is_streaming = 1;
+
+        for (i = 0; i < SBUF_NUM; i++) {
+                ret = usb_submit_urb(video->urb_array[i], GFP_KERNEL);
+                if (ret)
+                        log("(%d) failed: error %d", i, ret);
+        }
+        return ret;
+}
+
+static int start_video_stream(struct poseidon *pd)
+{
+        struct video_data *video = &pd->video_data;
+        s32 cmd_status;
+
+        send_set_req(pd, TAKE_REQUEST, 0, &cmd_status);
+        send_set_req(pd, PLAY_SERVICE, TLG_TUNE_PLAY_SVC_START, &cmd_status);
+
+        if (pd->cur_transfer_mode) {
+                prepare_iso_urb(video);
+                INIT_WORK(&video->bubble_work, iso_bubble_handler);
+        } else {
+                /* The bulk mode does not need a bubble handler */
+                prepare_bulk_urb(video);
+        }
+        fire_all_urb(video);
+        return 0;
+}
+
+static int pd_buf_setup(struct videobuf_queue *q, unsigned int *count,
+                       unsigned int *size)
+{
+        struct front_face *front = q->priv_data;
+        struct poseidon *pd     = front->pd;
+
+        switch (front->type) {
+        default:
+                return -EINVAL;
+        case V4L2_BUF_TYPE_VIDEO_CAPTURE: {
+                struct video_data *video = &pd->video_data;
+                struct v4l2_pix_format *pix = &video->context.pix;
+
+                *size = PAGE_ALIGN(pix->sizeimage);/* page aligned frame size */
+                if (*count < 4)
+                        *count = 4;
+                if (1) {
+                        /* same in different altersetting */
+                        video->endpoint_addr    = 0x82;
+                        video->vbi              = &pd->vbi_data;
+                        video->vbi->video       = video;
+                        video->pd               = pd;
+                        video->lines_per_field  = pix->height / 2;
+                        video->lines_size       = pix->width * 2;
+                        video->front            = front;
+                }
+                return start_video_stream(pd);
+        }
+
+        case V4L2_BUF_TYPE_VBI_CAPTURE: {
+                struct vbi_data *vbi = &pd->vbi_data;
+
+                *size = PAGE_ALIGN(vbi->vbi_size);
+                log("size : %d", *size);
+                if (*count == 0)
+                        *count = 4;
+        }
+                break;
+        }
+        return 0;
+}
+
+static struct videobuf_queue_ops pd_video_qops = {
+        .buf_setup      = pd_buf_setup,
+        .buf_prepare    = pd_buf_prepare,
+        .buf_queue      = pd_buf_queue,
+        .buf_release    = pd_buf_release,
+};
+
+static int vidioc_enum_fmt(struct file *file, void *fh,
+                                struct v4l2_fmtdesc *f)
+{
+        if (ARRAY_SIZE(poseidon_formats) <= f->index)
+                return -EINVAL;
+        f->type         = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+        f->flags        = 0;
+        f->pixelformat  = poseidon_formats[f->index].fourcc;
+        strcpy(f->description, poseidon_formats[f->index].name);
+        return 0;
+}
+
+static int vidioc_g_fmt(struct file *file, void *fh, struct v4l2_format *f)
+{
+        struct front_face *front = fh;
+        struct poseidon *pd = front->pd;
+
+        logs(front);
+        f->fmt.pix = pd->video_data.context.pix;
+        return 0;
+}
+
+static int vidioc_try_fmt(struct file *file, void *fh,
+                struct v4l2_format *f)
+{
+        return 0;
+}
+
+/*
+ * VLC calls VIDIOC_S_STD before VIDIOC_S_FMT, while
+ * Mplayer calls them in the reverse order.
+ */
+static int pd_vidioc_s_fmt(struct poseidon *pd, struct v4l2_pix_format *pix)
+{
+        struct video_data *video        = &pd->video_data;
+        struct running_context *context = &video->context;
+        struct v4l2_pix_format *pix_def = &context->pix;
+        s32 ret = 0, cmd_status = 0, vid_resol;
+
+        /* set the pixel format to firmware */
+        if (pix->pixelformat == V4L2_PIX_FMT_RGB565) {
+                vid_resol = TLG_TUNER_VID_FORMAT_RGB_565;
+        } else {
+                pix->pixelformat = V4L2_PIX_FMT_YUYV;
+                vid_resol = TLG_TUNER_VID_FORMAT_YUV;
+        }
+        ret = send_set_req(pd, VIDEO_STREAM_FMT_SEL,
+                                vid_resol, &cmd_status);
+
+        /* set the resolution to firmware */
+        vid_resol = TLG_TUNE_VID_RES_720;
+        switch (pix->width) {
+        case 704:
+                vid_resol = TLG_TUNE_VID_RES_704;
+                break;
+        default:
+                pix->width = 720;
+        case 720:
+                break;
+        }
+        ret |= send_set_req(pd, VIDEO_ROSOLU_SEL,
+                                vid_resol, &cmd_status);
+        if (ret || cmd_status) {
+                mutex_unlock(&pd->lock);
+                return -EBUSY;
+        }
+
+        pix_def->pixelformat = pix->pixelformat; /* save it */
+        pix->height = (context->tvnormid & V4L2_STD_525_60) ?  480 : 576;
+
+        /* Compare with the default setting */
+        if ((pix_def->width != pix->width)
+                || (pix_def->height != pix->height)) {
+                pix_def->width          = pix->width;
+                pix_def->height         = pix->height;
+                pix_def->bytesperline   = pix->width * 2;
+                pix_def->sizeimage      = pix->width * pix->height * 2;
+        }
+        *pix = *pix_def;
+
+        return 0;
+}
+
+static int vidioc_s_fmt(struct file *file, void *fh, struct v4l2_format *f)
+{
+        struct front_face *front        = fh;
+        struct poseidon *pd             = front->pd;
+
+        logs(front);
+        /* stop VBI here */
+        if (V4L2_BUF_TYPE_VIDEO_CAPTURE != f->type)
+                return -EINVAL;
+
+        mutex_lock(&pd->lock);
+        if (pd->file_for_stream == NULL)
+                pd->file_for_stream = file;
+        else if (file != pd->file_for_stream) {
+                mutex_unlock(&pd->lock);
+                return -EINVAL;
+        }
+
+        pd_vidioc_s_fmt(pd, &f->fmt.pix);
+        mutex_unlock(&pd->lock);
+        return 0;
+}
+
+static int vidioc_g_fmt_vbi(struct file *file, void *fh,
+                               struct v4l2_format *v4l2_f)
+{
+        struct front_face *front        = fh;
+        struct poseidon *pd             = front->pd;
+        struct v4l2_vbi_format *vbi_fmt = &v4l2_f->fmt.vbi;
+
+        vbi_fmt->samples_per_line       = 720 * 2;
+        vbi_fmt->sampling_rate          = 6750000 * 4;
+        vbi_fmt->sample_format          = V4L2_PIX_FMT_GREY;
+        vbi_fmt->offset                 = 64 * 4;  /*FIXME: why offset */
+        if (pd->video_data.context.tvnormid & V4L2_STD_525_60) {
+                vbi_fmt->start[0] = 10;
+                vbi_fmt->start[1] = 264;
+                vbi_fmt->count[0] = V4L_NTSC_VBI_LINES;
+                vbi_fmt->count[1] = V4L_NTSC_VBI_LINES;
+        } else {
+                vbi_fmt->start[0] = 6;
+                vbi_fmt->start[1] = 314;
+                vbi_fmt->count[0] = V4L_PAL_VBI_LINES;
+                vbi_fmt->count[1] = V4L_PAL_VBI_LINES;
+        }
+        vbi_fmt->flags = V4L2_VBI_UNSYNC;
+        logs(front);
+        return 0;
+}
+
+static int set_std(struct poseidon *pd, v4l2_std_id *norm)
+{
+        struct video_data *video = &pd->video_data;
+        struct vbi_data *vbi    = &pd->vbi_data;
+        struct running_context *context;
+        struct v4l2_pix_format *pix;
+        s32 i, ret = 0, cmd_status, param;
+        int height;
+
+        for (i = 0; i < POSEIDON_TVNORMS; i++) {
+                if (*norm & poseidon_tvnorms[i].v4l2_id) {
+                        param = poseidon_tvnorms[i].tlg_tvnorm;
+                        log("name : %s", poseidon_tvnorms[i].name);
+                        goto found;
+                }
+        }
+        return -EINVAL;
+found:
+        mutex_lock(&pd->lock);
+        ret = send_set_req(pd, VIDEO_STD_SEL, param, &cmd_status);
+        if (ret || cmd_status)
+                goto out;
+
+        /* Set vbi size and check the height of the frame */
+        context = &video->context;
+        context->tvnormid = poseidon_tvnorms[i].v4l2_id;
+        if (context->tvnormid & V4L2_STD_525_60) {
+                vbi->vbi_size = V4L_NTSC_VBI_FRAMESIZE;
+                height = 480;
+        } else {
+                vbi->vbi_size = V4L_PAL_VBI_FRAMESIZE;
+                height = 576;
+        }
+
+        pix = &context->pix;
+        if (pix->height != height) {
+                pix->height     = height;
+                pix->sizeimage  = pix->width * pix->height * 2;
+        }
+
+out:
+        mutex_unlock(&pd->lock);
+        return ret;
+}
+
+int vidioc_s_std(struct file *file, void *fh, v4l2_std_id *norm)
+{
+        struct front_face *front = fh;
+        logs(front);
+        return set_std(front->pd, norm);
+}
+
+static int vidioc_enum_input(struct file *file, void *fh, struct v4l2_input *in)
+{
+        struct front_face *front = fh;
+
+        if (in->index < 0 || in->index >= POSEIDON_INPUTS)
+                return -EINVAL;
+        strcpy(in->name, pd_inputs[in->index].name);
+        in->type  = V4L2_INPUT_TYPE_TUNER;
+
+        /*
+         * the audio input index mixed with this video input,
+         * Poseidon only have one audio/video, set to "0"
+         */
+        in->audioset    = 0;
+        in->tuner       = 0;
+        in->std         = V4L2_STD_ALL;
+        in->status      = 0;
+        logs(front);
+        return 0;
+}
+
+static int vidioc_g_input(struct file *file, void *fh, unsigned int *i)
+{
+        struct front_face *front = fh;
+        struct poseidon *pd = front->pd;
+        struct running_context *context = &pd->video_data.context;
+
+        logs(front);
+        *i = context->sig_index;
+        return 0;
+}
+
+/* We can support several inputs */
+static int vidioc_s_input(struct file *file, void *fh, unsigned int i)
+{
+        struct front_face *front = fh;
+        struct poseidon *pd = front->pd;
+        s32 ret, cmd_status;
+
+        if (i < 0 || i >= POSEIDON_INPUTS)
+                return -EINVAL;
+        ret = send_set_req(pd, SGNL_SRC_SEL,
+                        pd_inputs[i].tlg_src, &cmd_status);
+        if (ret)
+                return ret;
+
+        pd->video_data.context.sig_index = i;
+        return 0;
+}
+
+static struct poseidon_control *check_control_id(__u32 id)
+{
+        struct poseidon_control *control = &controls[0];
+        int array_size = ARRAY_SIZE(controls);
+
+        for (; control < &controls[array_size]; control++)
+                if (control->v4l2_ctrl.id  == id)
+                        return control;
+        return NULL;
+}
+
+static int vidioc_queryctrl(struct file *file, void *fh,
+                        struct v4l2_queryctrl *a)
+{
+        struct poseidon_control *control = NULL;
+
+        control = check_control_id(a->id);
+        if (!control)
+                return -EINVAL;
+
+        *a = control->v4l2_ctrl;
+        return 0;
+}
+
+static int vidioc_g_ctrl(struct file *file, void *fh, struct v4l2_control *ctrl)
+{
+        struct front_face *front = fh;
+        struct poseidon *pd = front->pd;
+        struct poseidon_control *control = NULL;
+        struct tuner_custom_parameter_s tuner_param;
+        s32 ret = 0, cmd_status;
+
+        control = check_control_id(ctrl->id);
+        if (!control)
+                return -EINVAL;
+
+        mutex_lock(&pd->lock);
+        ret = send_get_req(pd, TUNER_CUSTOM_PARAMETER, control->vc_id,
+                        &tuner_param, &cmd_status, sizeof(tuner_param));
+        mutex_unlock(&pd->lock);
+
+        if (ret || cmd_status)
+                return -1;
+
+        ctrl->value = tuner_param.param_value;
+        return 0;
+}
+
+static int vidioc_s_ctrl(struct file *file, void *fh, struct v4l2_control *a)
+{
+        struct tuner_custom_parameter_s param = {0};
+        struct poseidon_control *control = NULL;
+        struct front_face *front        = fh;
+        struct poseidon *pd             = front->pd;
+        s32 ret = 0, cmd_status, params;
+
+        control = check_control_id(a->id);
+        if (!control)
+                return -EINVAL;
+
+        param.param_value = a->value;
+        param.param_id  = control->vc_id;
+        params = *(s32 *)&param; /* temp code */
+
+        mutex_lock(&pd->lock);
+        ret = send_set_req(pd, TUNER_CUSTOM_PARAMETER, params, &cmd_status);
+        ret = send_set_req(pd, TAKE_REQUEST, 0, &cmd_status);
+        mutex_unlock(&pd->lock);
+
+        set_current_state(TASK_INTERRUPTIBLE);
+        schedule_timeout(HZ/4);
+        return ret;
+}
+
+/* Audio ioctls */
+static int vidioc_enumaudio(struct file *file, void *fh, struct v4l2_audio *a)
+{
+        if (0 != a->index)
+                return -EINVAL;
+        a->capability = V4L2_AUDCAP_STEREO;
+        strcpy(a->name, "USB audio in");
+        /*Poseidon have no AVL function.*/
+        a->mode = 0;
+        return 0;
+}
+
+int vidioc_g_audio(struct file *file, void *fh, struct v4l2_audio *a)
+{
+        a->index = 0;
+        a->capability = V4L2_AUDCAP_STEREO;
+        strcpy(a->name, "USB audio in");
+        a->mode = 0;
+        return 0;
+}
+
+int vidioc_s_audio(struct file *file, void *fh, struct v4l2_audio *a)
+{
+        return (0 == a->index) ? 0 : -EINVAL;
+}
+
+/* Tuner ioctls */
+static int vidioc_g_tuner(struct file *file, void *fh, struct v4l2_tuner *tuner)
+{
+        struct front_face *front        = fh;
+        struct poseidon *pd             = front->pd;
+        struct tuner_atv_sig_stat_s atv_stat;
+        s32 count = 5, ret, cmd_status;
+        int index;
+
+        if (0 != tuner->index)
+                return -EINVAL;
+
+        mutex_lock(&pd->lock);
+        ret = send_get_req(pd, TUNER_STATUS, TLG_MODE_ANALOG_TV,
+                                &atv_stat, &cmd_status, sizeof(atv_stat));
+
+        while (atv_stat.sig_lock_busy && count-- && !ret) {
+                set_current_state(TASK_INTERRUPTIBLE);
+                schedule_timeout(HZ);
+
+                ret = send_get_req(pd, TUNER_STATUS, TLG_MODE_ANALOG_TV,
+                                &atv_stat, &cmd_status, sizeof(atv_stat));
+        }
+        mutex_unlock(&pd->lock);
+
+        if (debug_mode)
+                log("P:%d,S:%d", atv_stat.sig_present, atv_stat.sig_strength);
+
+        if (ret || cmd_status)
+                tuner->signal = 0;
+        else if (atv_stat.sig_present && !atv_stat.sig_strength)
+                tuner->signal = 0xFFFF;
+        else
+                tuner->signal = (atv_stat.sig_strength * 255 / 10) << 8;
+
+        strcpy(tuner->name, "Telegent Systems");
+        tuner->type = V4L2_TUNER_ANALOG_TV;
+        tuner->rangelow = TUNER_FREQ_MIN / 62500;
+        tuner->rangehigh = TUNER_FREQ_MAX / 62500;
+        tuner->capability = V4L2_TUNER_CAP_NORM | V4L2_TUNER_CAP_STEREO |
+                                V4L2_TUNER_CAP_LANG1 | V4L2_TUNER_CAP_LANG2;
+        index = pd->video_data.context.audio_idx;
+        tuner->rxsubchans = pd_audio_modes[index].v4l2_audio_sub;
+        tuner->audmode = pd_audio_modes[index].v4l2_audio_mode;
+        tuner->afc = 0;
+        logs(front);
+        return 0;
+}
+
+static int pd_vidioc_s_tuner(struct poseidon *pd, int index)
+{
+        s32 ret = 0, cmd_status, param, audiomode;
+
+        mutex_lock(&pd->lock);
+        param = pd_audio_modes[index].tlg_audio_mode;
+        ret = send_set_req(pd, TUNER_AUD_MODE, param, &cmd_status);
+        audiomode = get_audio_std(pd->video_data.context.tvnormid);
+        ret |= send_set_req(pd, TUNER_AUD_ANA_STD, audiomode,
+                                &cmd_status);
+        if (!ret)
+                pd->video_data.context.audio_idx = index;
+        mutex_unlock(&pd->lock);
+        return ret;
+}
+
+static int vidioc_s_tuner(struct file *file, void *fh, struct v4l2_tuner *a)
+{
+        struct front_face *front        = fh;
+        struct poseidon *pd             = front->pd;
+        int index;
+
+        if (0 != a->index)
+                return -EINVAL;
+        logs(front);
+        for (index = 0; index < POSEIDON_AUDIOMODS; index++)
+                if (a->audmode == pd_audio_modes[index].v4l2_audio_mode)
+                        return pd_vidioc_s_tuner(pd, index);
+        return -EINVAL;
+}
+
+static int vidioc_g_frequency(struct file *file, void *fh,
+                        struct v4l2_frequency *freq)
+{
+        struct front_face *front = fh;
+        struct poseidon *pd = front->pd;
+        struct running_context *context = &pd->video_data.context;
+
+        if (0 != freq->tuner)
+                return -EINVAL;
+        freq->frequency = context->freq;
+        freq->type = V4L2_TUNER_ANALOG_TV;
+        return 0;
+}
+
+static int set_frequency(struct poseidon *pd, __u32 frequency)
+{
+        s32 ret = 0, param, cmd_status;
+        struct running_context *context = &pd->video_data.context;
+
+        param = frequency * 62500 / 1000;
+        if (param < TUNER_FREQ_MIN/1000 || param > TUNER_FREQ_MAX / 1000)
+                return -EINVAL;
+
+        mutex_lock(&pd->lock);
+        ret = send_set_req(pd, TUNE_FREQ_SELECT, param, &cmd_status);
+        ret = send_set_req(pd, TAKE_REQUEST, 0, &cmd_status);
+
+        msleep(250); /* wait for a while until the hardware is ready. */
+        context->freq = frequency;
+        mutex_unlock(&pd->lock);
+        return ret;
+}
+
+static int vidioc_s_frequency(struct file *file, void *fh,
+                                struct v4l2_frequency *freq)
+{
+        struct front_face *front = fh;
+        struct poseidon *pd = front->pd;
+
+        logs(front);
+#ifdef CONFIG_PM
+        pd->pm_suspend = pm_video_suspend;
+        pd->pm_resume = pm_video_resume;
+#endif
+        return set_frequency(pd, freq->frequency);
+}
+
+static int vidioc_reqbufs(struct file *file, void *fh,
+                                struct v4l2_requestbuffers *b)
+{
+        struct front_face *front = file->private_data;
+        logs(front);
+        return videobuf_reqbufs(&front->q, b);
+}
+
+static int vidioc_querybuf(struct file *file, void *fh, struct v4l2_buffer *b)
+{
+        struct front_face *front = file->private_data;
+        logs(front);
+        return videobuf_querybuf(&front->q, b);
+}
+
+static int vidioc_qbuf(struct file *file, void *fh, struct v4l2_buffer *b)
+{
+        struct front_face *front = file->private_data;
+        return videobuf_qbuf(&front->q, b);
+}
+
+static int vidioc_dqbuf(struct file *file, void *fh, struct v4l2_buffer *b)
+{
+        struct front_face *front = file->private_data;
+        return videobuf_dqbuf(&front->q, b, file->f_flags & O_NONBLOCK);
+}
+
+/* Just stop the URBs, do not free the URBs */
+int usb_transfer_stop(struct video_data *video)
+{
+        if (video->is_streaming) {
+                int i;
+                s32 cmd_status;
+                struct poseidon *pd = video->pd;
+
+                video->is_streaming = 0;
+                for (i = 0; i < SBUF_NUM; ++i) {
+                        if (video->urb_array[i])
+                                usb_kill_urb(video->urb_array[i]);
+                }
+
+                send_set_req(pd, PLAY_SERVICE, TLG_TUNE_PLAY_SVC_STOP,
+                               &cmd_status);
+        }
+        return 0;
+}
+
+int stop_all_video_stream(struct poseidon *pd)
+{
+        struct video_data *video = &pd->video_data;
+        struct vbi_data *vbi    = &pd->vbi_data;
+
+        mutex_lock(&pd->lock);
+        if (video->is_streaming) {
+                struct front_face *front = video->front;
+
+                /* stop the URBs */
+                usb_transfer_stop(video);
+                free_all_urb(video);
+
+                /* stop the host side of VIDEO */
+                videobuf_stop(&front->q);
+                videobuf_mmap_free(&front->q);
+
+                /* stop the host side of VBI */
+                front = vbi->front;
+                if (front) {
+                        videobuf_stop(&front->q);
+                        videobuf_mmap_free(&front->q);
+                }
+        }
+        mutex_unlock(&pd->lock);
+        return 0;
+}
+
+/*
+ * The bubbles can seriously damage the video's quality,
+ * though it occurs in very rare situation.
+ */
+static void iso_bubble_handler(struct work_struct *w)
+{
+        struct video_data *video;
+        struct poseidon *pd;
+
+        video = container_of(w, struct video_data, bubble_work);
+        pd = video->pd;
+
+        mutex_lock(&pd->lock);
+        usb_transfer_stop(video);
+        msleep(500);
+        start_video_stream(pd);
+        mutex_unlock(&pd->lock);
+}
+
+
+static int vidioc_streamon(struct file *file, void *fh,
+                                enum v4l2_buf_type type)
+{
+        struct front_face *front = fh;
+
+        logs(front);
+        if (unlikely(type != front->type))
+                return -EINVAL;
+        return videobuf_streamon(&front->q);
+}
+
+static int vidioc_streamoff(struct file *file, void *fh,
+                                enum v4l2_buf_type type)
+{
+        struct front_face *front = file->private_data;
+
+        logs(front);
+        if (unlikely(type != front->type))
+                return -EINVAL;
+        return videobuf_streamoff(&front->q);
+}
+
+/* Set the firmware's default values : need altersetting */
+static int pd_video_checkmode(struct poseidon *pd)
+{
+        s32 ret = 0, cmd_status, audiomode;
+
+        set_current_state(TASK_INTERRUPTIBLE);
+        schedule_timeout(HZ/2);
+
+        /* choose the altersetting */
+        ret = usb_set_interface(pd->udev, 0,
+                                        (pd->cur_transfer_mode ?
+                                         ISO_3K_BULK_ALTERNATE_IFACE :
+                                         BULK_ALTERNATE_IFACE));
+        if (ret < 0)
+                goto error;
+
+        /* set default parameters for PAL-D , with the VBI enabled*/
+        ret = set_tuner_mode(pd, TLG_MODE_ANALOG_TV);
+        ret |= send_set_req(pd, SGNL_SRC_SEL,
+                                TLG_SIG_SRC_ANTENNA, &cmd_status);
+        ret |= send_set_req(pd, VIDEO_STD_SEL,
+                                TLG_TUNE_VSTD_PAL_D, &cmd_status);
+        ret |= send_set_req(pd, VIDEO_STREAM_FMT_SEL,
+                                TLG_TUNER_VID_FORMAT_YUV, &cmd_status);
+        ret |= send_set_req(pd, VIDEO_ROSOLU_SEL,
+                                TLG_TUNE_VID_RES_720, &cmd_status);
+        ret |= send_set_req(pd, TUNE_FREQ_SELECT, TUNER_FREQ_MIN, &cmd_status);
+        ret |= send_set_req(pd, VBI_DATA_SEL, 1, &cmd_status);/* enable vbi */
+
+        /* set the audio */
+        audiomode = get_audio_std(pd->video_data.context.tvnormid);
+        ret |= send_set_req(pd, TUNER_AUD_ANA_STD, audiomode, &cmd_status);
+        ret |= send_set_req(pd, TUNER_AUD_MODE,
+                                TLG_TUNE_TVAUDIO_MODE_STEREO, &cmd_status);
+        ret |= send_set_req(pd, AUDIO_SAMPLE_RATE_SEL,
+                                ATV_AUDIO_RATE_48K, &cmd_status);
+error:
+        return ret;
+}
+
+#ifdef CONFIG_PM
+static int pm_video_suspend(struct poseidon *pd)
+{
+        /* stop audio */
+        pm_alsa_suspend(pd);
+
+        /* stop and free all the URBs */
+        usb_transfer_stop(&pd->video_data);
+        free_all_urb(&pd->video_data);
+
+        /* reset the interface */
+        usb_set_interface(pd->udev, 0, 0);
+        msleep(300);
+        return 0;
+}
+
+static int restore_v4l2_context(struct poseidon *pd,
+                                struct running_context *context)
+{
+        struct front_face *front = pd->video_data.front;
+
+        pd_video_checkmode(pd);
+
+        set_std(pd, &context->tvnormid);
+        vidioc_s_input(NULL, front, context->sig_index);
+        pd_vidioc_s_tuner(pd, context->audio_idx);
+        pd_vidioc_s_fmt(pd, &context->pix);
+        set_frequency(pd, context->freq);
+        return 0;
+}
+
+static int pm_video_resume(struct poseidon *pd)
+{
+        struct video_data *video = &pd->video_data;
+
+        /* resume the video */
+        /* [1] restore the origin V4L2 parameters */
+        restore_v4l2_context(pd, &video->context);
+
+        /* [2] initiate video copy variables */
+        if (video->front->curr_frame)
+                init_copy(video, 0);
+
+        /* [3] fire urbs        */
+        start_video_stream(pd);
+
+        /* resume the audio */
+        pm_alsa_resume(pd);
+        return 0;
+}
+#endif
+
+void set_debug_mode(struct video_device *vfd, int debug_mode)
+{
+        vfd->debug = 0;
+        if (debug_mode & 0x1)
+                vfd->debug = V4L2_DEBUG_IOCTL;
+        if (debug_mode & 0x2)
+                vfd->debug = V4L2_DEBUG_IOCTL | V4L2_DEBUG_IOCTL_ARG;
+}
+
+static void init_video_context(struct running_context *context)
+{
+        context->sig_index      = 0;
+        context->audio_idx      = 1; /* stereo */
+        context->tvnormid       = V4L2_STD_PAL_D;
+        context->pix = (struct v4l2_pix_format) {
+                                .width          = 720,
+                                .height         = 576,
+                                .pixelformat    = V4L2_PIX_FMT_YUYV,
+                                .field          = V4L2_FIELD_INTERLACED,
+                                .bytesperline   = 720 * 2,
+                                .sizeimage      = 720 * 576 * 2,
+                                .colorspace     = V4L2_COLORSPACE_SMPTE170M,
+                                .priv           = 0
+                        };
+}
+
+static int pd_video_open(struct file *file)
+{
+        struct video_device *vfd = video_devdata(file);
+        struct poseidon *pd = video_get_drvdata(vfd);
+        struct front_face *front = NULL;
+        int ret = -ENOMEM;
+
+        mutex_lock(&pd->lock);
+        usb_autopm_get_interface(pd->interface);
+
+        if (vfd->vfl_type == VFL_TYPE_GRABBER
+                && !(pd->state & POSEIDON_STATE_ANALOG)) {
+                front = kzalloc(sizeof(struct front_face), GFP_KERNEL);
+                if (!front)
+                        goto out;
+
+                pd->cur_transfer_mode   = usb_transfer_mode;/* bulk or iso */
+                init_video_context(&pd->video_data.context);
+
+                ret = pd_video_checkmode(pd);
+                if (ret < 0) {
+                        kfree(front);
+                        ret = -1;
+                        goto out;
+                }
+
+                pd->state               |= POSEIDON_STATE_ANALOG;
+                front->type             = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+                pd->video_data.users++;
+                set_debug_mode(vfd, debug_mode);
+
+                videobuf_queue_vmalloc_init(&front->q, &pd_video_qops,
+                                NULL, &front->queue_lock,
+                                V4L2_BUF_TYPE_VIDEO_CAPTURE,
+                                V4L2_FIELD_INTERLACED,/* video is interlacd */
+                                sizeof(struct videobuf_buffer),/*it's enough*/
+                                front);
+        } else if (vfd->vfl_type == VFL_TYPE_VBI
+                && !(pd->state & POSEIDON_STATE_VBI)) {
+                front = kzalloc(sizeof(struct front_face), GFP_KERNEL);
+                if (!front)
+                        goto out;
+
+                pd->state       |= POSEIDON_STATE_VBI;
+                front->type     = V4L2_BUF_TYPE_VBI_CAPTURE;
+                pd->vbi_data.front = front;
+                pd->vbi_data.users++;
+
+                videobuf_queue_vmalloc_init(&front->q, &pd_video_qops,
+                                NULL, &front->queue_lock,
+                                V4L2_BUF_TYPE_VBI_CAPTURE,
+                                V4L2_FIELD_NONE, /* vbi is NONE mode */
+                                sizeof(struct videobuf_buffer),
+                                front);
+        } else {
+                /* maybe add FM support here */
+                log("other ");
+                ret = -EINVAL;
+                goto out;
+        }
+
+        front->pd               = pd;
+        front->curr_frame       = NULL;
+        INIT_LIST_HEAD(&front->active);
+        spin_lock_init(&front->queue_lock);
+
+        file->private_data      = front;
+        kref_get(&pd->kref);
+
+        mutex_unlock(&pd->lock);
+        return 0;
+out:
+        usb_autopm_put_interface(pd->interface);
+        mutex_unlock(&pd->lock);
+        return ret;
+}
+
+static int pd_video_release(struct file *file)
+{
+        struct front_face *front = file->private_data;
+        struct poseidon *pd = front->pd;
+        s32 cmd_status = 0;
+
+        logs(front);
+        mutex_lock(&pd->lock);
+
+        if (front->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
+                pd->state &= ~POSEIDON_STATE_ANALOG;
+
+                /* stop the device, and free the URBs */
+                usb_transfer_stop(&pd->video_data);
+                free_all_urb(&pd->video_data);
+
+                /* stop the firmware */
+                send_set_req(pd, PLAY_SERVICE, TLG_TUNE_PLAY_SVC_STOP,
+                               &cmd_status);
+
+                pd->file_for_stream = NULL;
+                pd->video_data.users--;
+        } else if (front->type  == V4L2_BUF_TYPE_VBI_CAPTURE) {
+                pd->state &= ~POSEIDON_STATE_VBI;
+                pd->vbi_data.front = NULL;
+                pd->vbi_data.users--;
+        }
+        videobuf_stop(&front->q);
+        videobuf_mmap_free(&front->q);
+
+        usb_autopm_put_interface(pd->interface);
+        mutex_unlock(&pd->lock);
+
+        kfree(front);
+        file->private_data = NULL;
+        kref_put(&pd->kref, poseidon_delete);
+        return 0;
+}
+
+static int pd_video_mmap(struct file *file, struct vm_area_struct *vma)
+{
+        struct front_face *front = file->private_data;
+        return  videobuf_mmap_mapper(&front->q, vma);
+}
+
+unsigned int pd_video_poll(struct file *file, poll_table *table)
+{
+        struct front_face *front = file->private_data;
+        return videobuf_poll_stream(file, &front->q, table);
+}
+
+ssize_t pd_video_read(struct file *file, char __user *buffer,
+                        size_t count, loff_t *ppos)
+{
+        struct front_face *front = file->private_data;
+        return videobuf_read_stream(&front->q, buffer, count, ppos,
+                                0, file->f_flags & O_NONBLOCK);
+}
+
+/* This struct works for both VIDEO and VBI */
+static const struct v4l2_file_operations pd_video_fops = {
+        .owner          = THIS_MODULE,
+        .open           = pd_video_open,
+        .release        = pd_video_release,
+        .read           = pd_video_read,
+        .poll           = pd_video_poll,
+        .mmap           = pd_video_mmap,
+        .ioctl          = video_ioctl2, /* maybe changed in future */
+};
+
+static const struct v4l2_ioctl_ops pd_video_ioctl_ops = {
+        .vidioc_querycap        = vidioc_querycap,
+
+        /* Video format */
+        .vidioc_g_fmt_vid_cap   = vidioc_g_fmt,
+        .vidioc_enum_fmt_vid_cap        = vidioc_enum_fmt,
+        .vidioc_s_fmt_vid_cap   = vidioc_s_fmt,
+        .vidioc_g_fmt_vbi_cap   = vidioc_g_fmt_vbi, /* VBI */
+        .vidioc_try_fmt_vid_cap = vidioc_try_fmt,
+
+        /* Input */
+        .vidioc_g_input         = vidioc_g_input,
+        .vidioc_s_input         = vidioc_s_input,
+        .vidioc_enum_input      = vidioc_enum_input,
+
+        /* Audio ioctls */
+        .vidioc_enumaudio       = vidioc_enumaudio,
+        .vidioc_g_audio         = vidioc_g_audio,
+        .vidioc_s_audio         = vidioc_s_audio,
+
+        /* Tuner ioctls */
+        .vidioc_g_tuner         = vidioc_g_tuner,
+        .vidioc_s_tuner         = vidioc_s_tuner,
+        .vidioc_s_std           = vidioc_s_std,
+        .vidioc_g_frequency     = vidioc_g_frequency,
+        .vidioc_s_frequency     = vidioc_s_frequency,
+
+        /* Buffer handlers */
+        .vidioc_reqbufs         = vidioc_reqbufs,
+        .vidioc_querybuf        = vidioc_querybuf,
+        .vidioc_qbuf            = vidioc_qbuf,
+        .vidioc_dqbuf           = vidioc_dqbuf,
+
+        /* Stream on/off */
+        .vidioc_streamon        = vidioc_streamon,
+        .vidioc_streamoff       = vidioc_streamoff,
+
+        /* Control handling */
+        .vidioc_queryctrl       = vidioc_queryctrl,
+        .vidioc_g_ctrl          = vidioc_g_ctrl,
+        .vidioc_s_ctrl          = vidioc_s_ctrl,
+};
+
+static struct video_device pd_video_template = {
+        .name = "Telegent-Video",
+        .fops = &pd_video_fops,
+        .minor = -1,
+        .release = video_device_release,
+        .tvnorms = V4L2_STD_ALL,
+        .ioctl_ops = &pd_video_ioctl_ops,
+};
+
+struct video_device *vdev_init(struct poseidon *pd, struct video_device *tmp)
+{
+        struct video_device *vfd;
+
+        vfd = video_device_alloc();
+        if (vfd == NULL)
+                return NULL;
+        *vfd            = *tmp;
+        vfd->minor      = -1;
+        vfd->v4l2_dev   = &pd->v4l2_dev;
+        /*vfd->parent   = &(pd->udev->dev); */
+        vfd->release    = video_device_release;
+        video_set_drvdata(vfd, pd);
+        return vfd;
+}
+
+void destroy_video_device(struct video_device **v_dev)
+{
+        struct video_device *dev = *v_dev;
+
+        if (dev == NULL)
+                return;
+
+        if (video_is_registered(dev))
+                video_unregister_device(dev);
+        else
+                video_device_release(dev);
+        *v_dev = NULL;
+}
+
+void pd_video_exit(struct poseidon *pd)
+{
+        struct video_data *video = &pd->video_data;
+        struct vbi_data *vbi = &pd->vbi_data;
+
+        destroy_video_device(&video->v_dev);
+        destroy_video_device(&vbi->v_dev);
+        log();
+}
+
+int pd_video_init(struct poseidon *pd)
+{
+        struct video_data *video = &pd->video_data;
+        struct vbi_data *vbi    = &pd->vbi_data;
+        int ret = -ENOMEM;
+
+        video->v_dev = vdev_init(pd, &pd_video_template);
+        if (video->v_dev == NULL)
+                goto out;
+
+        ret = video_register_device(video->v_dev, VFL_TYPE_GRABBER, -1);
+        if (ret != 0)
+                goto out;
+
+        /* VBI uses the same template as video */
+        vbi->v_dev = vdev_init(pd, &pd_video_template);
+        if (vbi->v_dev == NULL) {
+                ret = -ENOMEM;
+                goto out;
+        }
+        ret = video_register_device(vbi->v_dev, VFL_TYPE_VBI, -1);
+        if (ret != 0)
+                goto out;
+        log("register VIDEO/VBI devices");
+        return 0;
+out:
+        log("VIDEO/VBI devices register failed, : %d", ret);
+        pd_video_exit(pd);
+        return ret;
+}
+
diff --git a/drivers/media/video/tlg2300/vendorcmds.h b/drivers/media/video/tlg2300/vendorcmds.h
new file mode 100644
index 000000000000..ba6f4ae3b2c2
--- /dev/null
+++ b/drivers/media/video/tlg2300/vendorcmds.h
@@ -0,0 +1,243 @@
+#ifndef VENDOR_CMD_H_
+#define VENDOR_CMD_H_
+
+#define BULK_ALTERNATE_IFACE            (2)
+#define ISO_3K_BULK_ALTERNATE_IFACE     (1)
+#define REQ_SET_CMD                     (0X00)
+#define REQ_GET_CMD                     (0X80)
+
+enum tlg__analog_audio_standard {
+        TLG_TUNE_ASTD_NONE      = 0x00000000,
+        TLG_TUNE_ASTD_A2        = 0x00000001,
+        TLG_TUNE_ASTD_NICAM     = 0x00000002,
+        TLG_TUNE_ASTD_EIAJ      = 0x00000004,
+        TLG_TUNE_ASTD_BTSC      = 0x00000008,
+        TLG_TUNE_ASTD_FM_US     = 0x00000010,
+        TLG_TUNE_ASTD_FM_EUR    = 0x00000020,
+        TLG_TUNE_ASTD_ALL       = 0x0000003f
+};
+
+/*
+ * identifiers for Custom Parameter messages.
+ * @typedef cmd_custom_param_id_t
+ */
+enum cmd_custom_param_id {
+        CUST_PARM_ID_NONE               = 0x00,
+        CUST_PARM_ID_BRIGHTNESS_CTRL    = 0x01,
+        CUST_PARM_ID_CONTRAST_CTRL      = 0x02,
+        CUST_PARM_ID_HUE_CTRL           = 0x03,
+        CUST_PARM_ID_SATURATION_CTRL      = 0x04,
+        CUST_PARM_ID_AUDIO_SNR_THRESHOLD  = 0x10,
+        CUST_PARM_ID_AUDIO_AGC_THRESHOLD  = 0x11,
+        CUST_PARM_ID_MAX
+};
+
+struct  tuner_custom_parameter_s {
+        uint16_t        param_id;        /*  Parameter identifier  */
+        uint16_t        param_value;     /*  Parameter value       */
+};
+
+struct  tuner_ber_rate_s {
+        uint32_t        ber_rate;  /*  BER sample rate in seconds   */
+};
+
+struct tuner_atv_sig_stat_s {
+        uint32_t        sig_present;
+        uint32_t        sig_locked;
+        uint32_t        sig_lock_busy;
+        uint32_t        sig_strength;      /*  milliDb    */
+        uint32_t        tv_audio_chan;    /*  mono/stereo/sap*/
+        uint32_t        mvision_stat;      /*  macrovision status */
+};
+
+struct tuner_dtv_sig_stat_s {
+        uint32_t sig_present;   /*  Boolean*/
+        uint32_t sig_locked;    /*  Boolean */
+        uint32_t sig_lock_busy; /*  Boolean     (Can this time-out?) */
+        uint32_t sig_strength;  /*  milliDb*/
+};
+
+struct tuner_fm_sig_stat_s {
+        uint32_t sig_present;   /* Boolean*/
+        uint32_t sig_locked;     /* Boolean */
+        uint32_t sig_lock_busy;  /* Boolean */
+        uint32_t sig_stereo_mono;/* TBD*/
+        uint32_t sig_strength;   /* milliDb*/
+};
+
+enum _tag_tlg_tune_srv_cmd {
+        TLG_TUNE_PLAY_SVC_START = 1,
+        TLG_TUNE_PLAY_SVC_STOP
+};
+
+enum  _tag_tune_atv_audio_mode_caps {
+        TLG_TUNE_TVAUDIO_MODE_MONO      = 0x00000001,
+        TLG_TUNE_TVAUDIO_MODE_STEREO    = 0x00000002,
+        TLG_TUNE_TVAUDIO_MODE_LANG_A    = 0x00000010,/* Primary language*/
+        TLG_TUNE_TVAUDIO_MODE_LANG_B    = 0x00000020,/* 2nd avail language*/
+        TLG_TUNE_TVAUDIO_MODE_LANG_C    = 0x00000040
+};
+
+
+enum   _tag_tuner_atv_audio_rates {
+        ATV_AUDIO_RATE_NONE     = 0x00,/* Audio not supported*/
+        ATV_AUDIO_RATE_32K      = 0x01,/* Audio rate = 32 KHz*/
+        ATV_AUDIO_RATE_48K      = 0x02, /* Audio rate = 48 KHz*/
+        ATV_AUDIO_RATE_31_25K   = 0x04 /* Audio rate = 31.25KHz */
+};
+
+enum  _tag_tune_atv_vid_res_caps {
+        TLG_TUNE_VID_RES_NONE   = 0x00000000,
+        TLG_TUNE_VID_RES_720    = 0x00000001,
+        TLG_TUNE_VID_RES_704    = 0x00000002,
+        TLG_TUNE_VID_RES_360    = 0x00000004
+};
+
+enum _tag_tuner_analog_video_format {
+        TLG_TUNER_VID_FORMAT_YUV        = 0x00000001,
+        TLG_TUNER_VID_FORMAT_YCRCB      = 0x00000002,
+        TLG_TUNER_VID_FORMAT_RGB_565    = 0x00000004,
+};
+
+enum  tlg_ext_audio_support {
+        TLG_EXT_AUDIO_NONE      = 0x00,/*  No external audio input supported */
+        TLG_EXT_AUDIO_LR        = 0x01/*  LR external audio inputs supported*/
+};
+
+enum {
+        TLG_MODE_NONE                   = 0x00, /* No Mode specified*/
+        TLG_MODE_ANALOG_TV              = 0x01, /* Analog Television mode*/
+        TLG_MODE_ANALOG_TV_UNCOMP       = 0x01, /* Analog Television mode*/
+        TLG_MODE_ANALOG_TV_COMP         = 0x02, /* Analog TV mode (compressed)*/
+        TLG_MODE_FM_RADIO               = 0x04, /* FM Radio mode*/
+        TLG_MODE_DVB_T                  = 0x08, /* Digital TV (DVB-T)*/
+};
+
+enum  tlg_signal_sources_t {
+        TLG_SIG_SRC_NONE        = 0x00,/* Signal source not specified */
+        TLG_SIG_SRC_ANTENNA     = 0x01,/* Signal src is: Antenna */
+        TLG_SIG_SRC_CABLE       = 0x02,/* Signal src is: Coax Cable*/
+        TLG_SIG_SRC_SVIDEO      = 0x04,/* Signal src is: S_VIDEO   */
+        TLG_SIG_SRC_COMPOSITE   = 0x08 /* Signal src is: Composite Video */
+};
+
+enum tuner_analog_video_standard {
+        TLG_TUNE_VSTD_NONE      = 0x00000000,
+        TLG_TUNE_VSTD_NTSC_M    = 0x00000001,
+        TLG_TUNE_VSTD_NTSC_M_J  = 0x00000002,/* Japan   */
+        TLG_TUNE_VSTD_PAL_B     = 0x00000010,
+        TLG_TUNE_VSTD_PAL_D     = 0x00000020,
+        TLG_TUNE_VSTD_PAL_G     = 0x00000040,
+        TLG_TUNE_VSTD_PAL_H     = 0x00000080,
+        TLG_TUNE_VSTD_PAL_I     = 0x00000100,
+        TLG_TUNE_VSTD_PAL_M     = 0x00000200,
+        TLG_TUNE_VSTD_PAL_N     = 0x00000400,
+        TLG_TUNE_VSTD_SECAM_B   = 0x00001000,
+        TLG_TUNE_VSTD_SECAM_D   = 0x00002000,
+        TLG_TUNE_VSTD_SECAM_G   = 0x00004000,
+        TLG_TUNE_VSTD_SECAM_H   = 0x00008000,
+        TLG_TUNE_VSTD_SECAM_K   = 0x00010000,
+        TLG_TUNE_VSTD_SECAM_K1  = 0x00020000,
+        TLG_TUNE_VSTD_SECAM_L   = 0x00040000,
+        TLG_TUNE_VSTD_SECAM_L1  = 0x00080000,
+        TLG_TUNE_VSTD_PAL_N_COMBO = 0x00100000
+};
+
+enum tlg_mode_caps {
+        TLG_MODE_CAPS_NONE              = 0x00,  /*  No Mode specified  */
+        TLG_MODE_CAPS_ANALOG_TV_UNCOMP  = 0x01,  /*  Analog TV mode     */
+        TLG_MODE_CAPS_ANALOG_TV_COMP    = 0x02,  /*  Analog TV (compressed)*/
+        TLG_MODE_CAPS_FM_RADIO          = 0x04,  /*  FM Radio mode      */
+        TLG_MODE_CAPS_DVB_T             = 0x08,  /*  Digital TV (DVB-T) */
+};
+
+enum poseidon_vendor_cmds {
+        LAST_CMD_STAT           = 0x00,
+        GET_CHIP_ID             = 0x01,
+        GET_FW_ID               = 0x02,
+        PRODUCT_CAPS            = 0x03,
+
+        TUNE_MODE_CAP_ATV       = 0x10,
+        TUNE_MODE_CAP_ATVCOMP   = 0X10,
+        TUNE_MODE_CAP_DVBT      = 0x10,
+        TUNE_MODE_CAP_FM        = 0x10,
+        TUNE_MODE_SELECT        = 0x11,
+        TUNE_FREQ_SELECT        = 0x12,
+        SGNL_SRC_SEL            = 0x13,
+
+        VIDEO_STD_SEL           = 0x14,
+        VIDEO_STREAM_FMT_SEL    = 0x15,
+        VIDEO_ROSOLU_AVAIL      = 0x16,
+        VIDEO_ROSOLU_SEL        = 0x17,
+        VIDEO_CONT_PROTECT      = 0x20,
+
+        VCR_TIMING_MODSEL       = 0x21,
+        EXT_AUDIO_CAP           = 0x22,
+        EXT_AUDIO_SEL           = 0x23,
+        TEST_PATTERN_SEL        = 0x24,
+        VBI_DATA_SEL            = 0x25,
+        AUDIO_SAMPLE_RATE_CAP   = 0x28,
+        AUDIO_SAMPLE_RATE_SEL   = 0x29,
+        TUNER_AUD_MODE          = 0x2a,
+        TUNER_AUD_MODE_AVAIL    = 0x2b,
+        TUNER_AUD_ANA_STD       = 0x2c,
+        TUNER_CUSTOM_PARAMETER  = 0x2f,
+
+        DVBT_TUNE_MODE_SEL      = 0x30,
+        DVBT_BANDW_CAP          = 0x31,
+        DVBT_BANDW_SEL          = 0x32,
+        DVBT_GUARD_INTERV_CAP   = 0x33,
+        DVBT_GUARD_INTERV_SEL   = 0x34,
+        DVBT_MODULATION_CAP     = 0x35,
+        DVBT_MODULATION_SEL     = 0x36,
+        DVBT_INNER_FEC_RATE_CAP = 0x37,
+        DVBT_INNER_FEC_RATE_SEL = 0x38,
+        DVBT_TRANS_MODE_CAP     = 0x39,
+        DVBT_TRANS_MODE_SEL     = 0x3a,
+        DVBT_SEARCH_RANG        = 0x3c,
+
+        TUNER_SETUP_ANALOG      = 0x40,
+        TUNER_SETUP_DIGITAL     = 0x41,
+        TUNER_SETUP_FM_RADIO    = 0x42,
+        TAKE_REQUEST            = 0x43, /* Take effect of the command */
+        PLAY_SERVICE            = 0x44, /* Play start or Play stop */
+        TUNER_STATUS            = 0x45,
+        TUNE_PROP_DVBT          = 0x46,
+        ERR_RATE_STATS          = 0x47,
+        TUNER_BER_RATE          = 0x48,
+
+        SCAN_CAPS               = 0x50,
+        SCAN_SETUP              = 0x51,
+        SCAN_SERVICE            = 0x52,
+        SCAN_STATS              = 0x53,
+
+        PID_SET                 = 0x58,
+        PID_UNSET               = 0x59,
+        PID_LIST                = 0x5a,
+
+        IRD_CAP                 = 0x60,
+        IRD_MODE_SEL            = 0x61,
+        IRD_SETUP               = 0x62,
+
+        PTM_MODE_CAP            = 0x70,
+        PTM_MODE_SEL            = 0x71,
+        PTM_SERVICE             = 0x72,
+        TUNER_REG_SCRIPT        = 0x73,
+        CMD_CHIP_RST            = 0x74,
+};
+
+enum tlg_bw {
+        TLG_BW_5 = 5,
+        TLG_BW_6 = 6,
+        TLG_BW_7 = 7,
+        TLG_BW_8 = 8,
+        TLG_BW_12 = 12,
+        TLG_BW_15 = 15
+};
+
+struct cmd_firmware_vers_s {
+        uint8_t  fw_rev_major;
+        uint8_t  fw_rev_minor;
+        uint16_t fw_patch;
+};
+#endif /* VENDOR_CMD_H_ */
diff --git a/drivers/media/video/tuner-core.c b/drivers/media/video/tuner-core.c
index 5b3eaa16afd2..c4dab6cfd948 100644
--- a/drivers/media/video/tuner-core.c
+++ b/drivers/media/video/tuner-core.c
@@ -1078,6 +1078,7 @@ static int tuner_probe(struct i2c_client *client,
 
                                 goto register_client;
                         }
+                        kfree(t);
                         return -ENODEV;
                 case 0x42:
                 case 0x43:
diff --git a/drivers/media/video/tveeprom.c b/drivers/media/video/tveeprom.c
index d533ea57e7b1..0a877497b93f 100644
--- a/drivers/media/video/tveeprom.c
+++ b/drivers/media/video/tveeprom.c
@@ -680,10 +680,7 @@ void tveeprom_hauppauge_analog(struct i2c_client *c, struct tveeprom *tvee,
         tveeprom_info("Hauppauge model %d, rev %s, serial# %d\n",
                 tvee->model, tvee->rev_str, tvee->serial_number);
         if (tvee->has_MAC_address == 1)
-                tveeprom_info("MAC address is %02X-%02X-%02X-%02X-%02X-%02X\n",
-                        tvee->MAC_address[0], tvee->MAC_address[1],
-                        tvee->MAC_address[2], tvee->MAC_address[3],
-                        tvee->MAC_address[4], tvee->MAC_address[5]);
+                tveeprom_info("MAC address is %pM\n", tvee->MAC_address);
         tveeprom_info("tuner model is %s (idx %d, type %d)\n",
                 t_name1, tuner1, tvee->tuner_type);
         tveeprom_info("TV standards%s%s%s%s%s%s%s%s (eeprom 0x%02x)\n",
diff --git a/drivers/media/video/tvp7002.c b/drivers/media/video/tvp7002.c
new file mode 100644
index 000000000000..5a878bca02d4
--- /dev/null
+++ b/drivers/media/video/tvp7002.c
@@ -0,0 +1,1187 @@
+/* Texas Instruments Triple 8-/10-BIT 165-/110-MSPS Video and Graphics
+ * Digitizer with Horizontal PLL registers
+ *
+ * Copyright (C) 2009 Texas Instruments Inc
+ * Author: Santiago Nunez-Corrales <santiago.nunez@ridgerun.com>
+ *
+ * This code is partially based upon the TVP5150 driver
+ * written by Mauro Carvalho Chehab (mchehab@infradead.org),
+ * the TVP514x driver written by Vaibhav Hiremath <hvaibhav@ti.com>
+ * and the TVP7002 driver in the TI LSP 2.10.00.14. Revisions by
+ * Muralidharan Karicheri and Snehaprabha Narnakaje (TI).
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+#include <linux/delay.h>
+#include <linux/i2c.h>
+#include <linux/videodev2.h>
+#include <media/tvp7002.h>
+#include <media/v4l2-device.h>
+#include <media/v4l2-chip-ident.h>
+#include <media/v4l2-common.h>
+#include "tvp7002_reg.h"
+
+MODULE_DESCRIPTION("TI TVP7002 Video and Graphics Digitizer driver");
+MODULE_AUTHOR("Santiago Nunez-Corrales <santiago.nunez@ridgerun.com>");
+MODULE_LICENSE("GPL");
+
+/* Module Name */
+#define TVP7002_MODULE_NAME     "tvp7002"
+
+/* I2C retry attempts */
+#define I2C_RETRY_COUNT         (5)
+
+/* End of registers */
+#define TVP7002_EOR             0x5c
+
+/* Read write definition for registers */
+#define TVP7002_READ            0
+#define TVP7002_WRITE           1
+#define TVP7002_RESERVED        2
+
+/* Interlaced vs progressive mask and shift */
+#define TVP7002_IP_SHIFT        5
+#define TVP7002_INPR_MASK       (0x01 << TVP7002_IP_SHIFT)
+
+/* Shift for CPL and LPF registers */
+#define TVP7002_CL_SHIFT        8
+#define TVP7002_CL_MASK         0x0f
+
+/* Debug functions */
+static int debug;
+module_param(debug, bool, 0644);
+MODULE_PARM_DESC(debug, "Debug level (0-2)");
+
+/* Structure for register values */
+struct i2c_reg_value {
+        u8 reg;
+        u8 value;
+        u8 type;
+};
+
+/*
+ * Register default values (according to tvp7002 datasheet)
+ * In the case of read-only registers, the value (0xff) is
+ * never written. R/W functionality is controlled by the
+ * writable bit in the register struct definition.
+ */
+static const struct i2c_reg_value tvp7002_init_default[] = {
+        { TVP7002_CHIP_REV, 0xff, TVP7002_READ },
+        { TVP7002_HPLL_FDBK_DIV_MSBS, 0x67, TVP7002_WRITE },
+        { TVP7002_HPLL_FDBK_DIV_LSBS, 0x20, TVP7002_WRITE },
+        { TVP7002_HPLL_CRTL, 0xa0, TVP7002_WRITE },
+        { TVP7002_HPLL_PHASE_SEL, 0x80, TVP7002_WRITE },
+        { TVP7002_CLAMP_START, 0x32, TVP7002_WRITE },
+        { TVP7002_CLAMP_W, 0x20, TVP7002_WRITE },
+        { TVP7002_HSYNC_OUT_W, 0x60, TVP7002_WRITE },
+        { TVP7002_B_FINE_GAIN, 0x00, TVP7002_WRITE },
+        { TVP7002_G_FINE_GAIN, 0x00, TVP7002_WRITE },
+        { TVP7002_R_FINE_GAIN, 0x00, TVP7002_WRITE },
+        { TVP7002_B_FINE_OFF_MSBS, 0x80, TVP7002_WRITE },
+        { TVP7002_G_FINE_OFF_MSBS, 0x80, TVP7002_WRITE },
+        { TVP7002_R_FINE_OFF_MSBS, 0x80, TVP7002_WRITE },
+        { TVP7002_SYNC_CTL_1, 0x20, TVP7002_WRITE },
+        { TVP7002_HPLL_AND_CLAMP_CTL, 0x2e, TVP7002_WRITE },
+        { TVP7002_SYNC_ON_G_THRS, 0x5d, TVP7002_WRITE },
+        { TVP7002_SYNC_SEPARATOR_THRS, 0x47, TVP7002_WRITE },
+        { TVP7002_HPLL_PRE_COAST, 0x00, TVP7002_WRITE },
+        { TVP7002_HPLL_POST_COAST, 0x00, TVP7002_WRITE },
+        { TVP7002_SYNC_DETECT_STAT, 0xff, TVP7002_READ },
+        { TVP7002_OUT_FORMATTER, 0x47, TVP7002_WRITE },
+        { TVP7002_MISC_CTL_1, 0x01, TVP7002_WRITE },
+        { TVP7002_MISC_CTL_2, 0x00, TVP7002_WRITE },
+        { TVP7002_MISC_CTL_3, 0x01, TVP7002_WRITE },
+        { TVP7002_IN_MUX_SEL_1, 0x00, TVP7002_WRITE },
+        { TVP7002_IN_MUX_SEL_2, 0x67, TVP7002_WRITE },
+        { TVP7002_B_AND_G_COARSE_GAIN, 0x77, TVP7002_WRITE },
+        { TVP7002_R_COARSE_GAIN, 0x07, TVP7002_WRITE },
+        { TVP7002_FINE_OFF_LSBS, 0x00, TVP7002_WRITE },
+        { TVP7002_B_COARSE_OFF, 0x10, TVP7002_WRITE },
+        { TVP7002_G_COARSE_OFF, 0x10, TVP7002_WRITE },
+        { TVP7002_R_COARSE_OFF, 0x10, TVP7002_WRITE },
+        { TVP7002_HSOUT_OUT_START, 0x08, TVP7002_WRITE },
+        { TVP7002_MISC_CTL_4, 0x00, TVP7002_WRITE },
+        { TVP7002_B_DGTL_ALC_OUT_LSBS, 0xff, TVP7002_READ },
+        { TVP7002_G_DGTL_ALC_OUT_LSBS, 0xff, TVP7002_READ },
+        { TVP7002_R_DGTL_ALC_OUT_LSBS, 0xff, TVP7002_READ },
+        { TVP7002_AUTO_LVL_CTL_ENABLE, 0x80, TVP7002_WRITE },
+        { TVP7002_DGTL_ALC_OUT_MSBS, 0xff, TVP7002_READ },
+        { TVP7002_AUTO_LVL_CTL_FILTER, 0x53, TVP7002_WRITE },
+        { 0x29, 0x08, TVP7002_RESERVED },
+        { TVP7002_FINE_CLAMP_CTL, 0x07, TVP7002_WRITE },
+        /* PWR_CTL is controlled only by the probe and reset functions */
+        { TVP7002_PWR_CTL, 0x00, TVP7002_RESERVED },
+        { TVP7002_ADC_SETUP, 0x50, TVP7002_WRITE },
+        { TVP7002_COARSE_CLAMP_CTL, 0x00, TVP7002_WRITE },
+        { TVP7002_SOG_CLAMP, 0x80, TVP7002_WRITE },
+        { TVP7002_RGB_COARSE_CLAMP_CTL, 0x00, TVP7002_WRITE },
+        { TVP7002_SOG_COARSE_CLAMP_CTL, 0x04, TVP7002_WRITE },
+        { TVP7002_ALC_PLACEMENT, 0x5a, TVP7002_WRITE },
+        { 0x32, 0x18, TVP7002_RESERVED },
+        { 0x33, 0x60, TVP7002_RESERVED },
+        { TVP7002_MVIS_STRIPPER_W, 0xff, TVP7002_RESERVED },
+        { TVP7002_VSYNC_ALGN, 0x10, TVP7002_WRITE },
+        { TVP7002_SYNC_BYPASS, 0x00, TVP7002_WRITE },
+        { TVP7002_L_FRAME_STAT_LSBS, 0xff, TVP7002_READ },
+        { TVP7002_L_FRAME_STAT_MSBS, 0xff, TVP7002_READ },
+        { TVP7002_CLK_L_STAT_LSBS, 0xff, TVP7002_READ },
+        { TVP7002_CLK_L_STAT_MSBS, 0xff, TVP7002_READ },
+        { TVP7002_HSYNC_W, 0xff, TVP7002_READ },
+        { TVP7002_VSYNC_W, 0xff, TVP7002_READ },
+        { TVP7002_L_LENGTH_TOL, 0x03, TVP7002_WRITE },
+        { 0x3e, 0x60, TVP7002_RESERVED },
+        { TVP7002_VIDEO_BWTH_CTL, 0x01, TVP7002_WRITE },
+        { TVP7002_AVID_START_PIXEL_LSBS, 0x01, TVP7002_WRITE },
+        { TVP7002_AVID_START_PIXEL_MSBS, 0x2c, TVP7002_WRITE },
+        { TVP7002_AVID_STOP_PIXEL_LSBS, 0x06, TVP7002_WRITE },
+        { TVP7002_AVID_STOP_PIXEL_MSBS, 0x2c, TVP7002_WRITE },
+        { TVP7002_VBLK_F_0_START_L_OFF, 0x05, TVP7002_WRITE },
+        { TVP7002_VBLK_F_1_START_L_OFF, 0x00, TVP7002_WRITE },
+        { TVP7002_VBLK_F_0_DURATION, 0x1e, TVP7002_WRITE },
+        { TVP7002_VBLK_F_1_DURATION, 0x00, TVP7002_WRITE },
+        { TVP7002_FBIT_F_0_START_L_OFF, 0x00, TVP7002_WRITE },
+        { TVP7002_FBIT_F_1_START_L_OFF, 0x00, TVP7002_WRITE },
+        { TVP7002_YUV_Y_G_COEF_LSBS, 0xe3, TVP7002_WRITE },
+        { TVP7002_YUV_Y_G_COEF_MSBS, 0x16, TVP7002_WRITE },
+        { TVP7002_YUV_Y_B_COEF_LSBS, 0x4f, TVP7002_WRITE },
+        { TVP7002_YUV_Y_B_COEF_MSBS, 0x02, TVP7002_WRITE },
+        { TVP7002_YUV_Y_R_COEF_LSBS, 0xce, TVP7002_WRITE },
+        { TVP7002_YUV_Y_R_COEF_MSBS, 0x06, TVP7002_WRITE },
+        { TVP7002_YUV_U_G_COEF_LSBS, 0xab, TVP7002_WRITE },
+        { TVP7002_YUV_U_G_COEF_MSBS, 0xf3, TVP7002_WRITE },
+        { TVP7002_YUV_U_B_COEF_LSBS, 0x00, TVP7002_WRITE },
+        { TVP7002_YUV_U_B_COEF_MSBS, 0x10, TVP7002_WRITE },
+        { TVP7002_YUV_U_R_COEF_LSBS, 0x55, TVP7002_WRITE },
+        { TVP7002_YUV_U_R_COEF_MSBS, 0xfc, TVP7002_WRITE },
+        { TVP7002_YUV_V_G_COEF_LSBS, 0x78, TVP7002_WRITE },
+        { TVP7002_YUV_V_G_COEF_MSBS, 0xf1, TVP7002_WRITE },
+        { TVP7002_YUV_V_B_COEF_LSBS, 0x88, TVP7002_WRITE },
+        { TVP7002_YUV_V_B_COEF_MSBS, 0xfe, TVP7002_WRITE },
+        { TVP7002_YUV_V_R_COEF_LSBS, 0x00, TVP7002_WRITE },
+        { TVP7002_YUV_V_R_COEF_MSBS, 0x10, TVP7002_WRITE },
+        /* This signals end of register values */
+        { TVP7002_EOR, 0xff, TVP7002_RESERVED }
+};
+
+/* Register parameters for 480P */
+static const struct i2c_reg_value tvp7002_parms_480P[] = {
+        { TVP7002_HPLL_FDBK_DIV_MSBS, 0x35, TVP7002_WRITE },
+        { TVP7002_HPLL_FDBK_DIV_LSBS, 0x0a, TVP7002_WRITE },
+        { TVP7002_HPLL_CRTL, 0x02, TVP7002_WRITE },
+        { TVP7002_HPLL_PHASE_SEL, 0x14, TVP7002_WRITE },
+        { TVP7002_AVID_START_PIXEL_LSBS, 0x91, TVP7002_WRITE },
+        { TVP7002_AVID_START_PIXEL_MSBS, 0x00, TVP7002_WRITE },
+        { TVP7002_AVID_STOP_PIXEL_LSBS, 0x0B, TVP7002_WRITE },
+        { TVP7002_AVID_STOP_PIXEL_MSBS, 0x00, TVP7002_WRITE },
+        { TVP7002_VBLK_F_0_START_L_OFF, 0x03, TVP7002_WRITE },
+        { TVP7002_VBLK_F_1_START_L_OFF, 0x01, TVP7002_WRITE },
+        { TVP7002_VBLK_F_0_DURATION, 0x13, TVP7002_WRITE },
+        { TVP7002_VBLK_F_1_DURATION, 0x13, TVP7002_WRITE },
+        { TVP7002_ALC_PLACEMENT, 0x18, TVP7002_WRITE },
+        { TVP7002_CLAMP_START, 0x06, TVP7002_WRITE },
+        { TVP7002_CLAMP_W, 0x10, TVP7002_WRITE },
+        { TVP7002_HPLL_PRE_COAST, 0x03, TVP7002_WRITE },
+        { TVP7002_HPLL_POST_COAST, 0x03, TVP7002_WRITE },
+        { TVP7002_EOR, 0xff, TVP7002_RESERVED }
+};
+
+/* Register parameters for 576P */
+static const struct i2c_reg_value tvp7002_parms_576P[] = {
+        { TVP7002_HPLL_FDBK_DIV_MSBS, 0x36, TVP7002_WRITE },
+        { TVP7002_HPLL_FDBK_DIV_LSBS, 0x00, TVP7002_WRITE },
+        { TVP7002_HPLL_CRTL, 0x18, TVP7002_WRITE },
+        { TVP7002_HPLL_PHASE_SEL, 0x14, TVP7002_WRITE },
+        { TVP7002_AVID_START_PIXEL_LSBS, 0x9B, TVP7002_WRITE },
+        { TVP7002_AVID_START_PIXEL_MSBS, 0x00, TVP7002_WRITE },
+        { TVP7002_AVID_STOP_PIXEL_LSBS, 0x0F, TVP7002_WRITE },
+        { TVP7002_AVID_STOP_PIXEL_MSBS, 0x00, TVP7002_WRITE },
+        { TVP7002_VBLK_F_0_START_L_OFF, 0x00, TVP7002_WRITE },
+        { TVP7002_VBLK_F_1_START_L_OFF, 0x00, TVP7002_WRITE },
+        { TVP7002_VBLK_F_0_DURATION, 0x2D, TVP7002_WRITE },
+        { TVP7002_VBLK_F_1_DURATION, 0x00, TVP7002_WRITE },
+        { TVP7002_ALC_PLACEMENT, 0x18, TVP7002_WRITE },
+        { TVP7002_CLAMP_START, 0x06, TVP7002_WRITE },
+        { TVP7002_CLAMP_W, 0x10, TVP7002_WRITE },
+        { TVP7002_HPLL_PRE_COAST, 0x03, TVP7002_WRITE },
+        { TVP7002_HPLL_POST_COAST, 0x03, TVP7002_WRITE },
+        { TVP7002_EOR, 0xff, TVP7002_RESERVED }
+};
+
+/* Register parameters for 1080I60 */
+static const struct i2c_reg_value tvp7002_parms_1080I60[] = {
+        { TVP7002_HPLL_FDBK_DIV_MSBS, 0x89, TVP7002_WRITE },
+        { TVP7002_HPLL_FDBK_DIV_LSBS, 0x08, TVP7002_WRITE },
+        { TVP7002_HPLL_CRTL, 0x98, TVP7002_WRITE },
+        { TVP7002_HPLL_PHASE_SEL, 0x14, TVP7002_WRITE },
+        { TVP7002_AVID_START_PIXEL_LSBS, 0x06, TVP7002_WRITE },
+        { TVP7002_AVID_START_PIXEL_MSBS, 0x01, TVP7002_WRITE },
+        { TVP7002_AVID_STOP_PIXEL_LSBS, 0x8a, TVP7002_WRITE },
+        { TVP7002_AVID_STOP_PIXEL_MSBS, 0x08, TVP7002_WRITE },
+        { TVP7002_VBLK_F_0_START_L_OFF, 0x02, TVP7002_WRITE },
+        { TVP7002_VBLK_F_1_START_L_OFF, 0x02, TVP7002_WRITE },
+        { TVP7002_VBLK_F_0_DURATION, 0x16, TVP7002_WRITE },
+        { TVP7002_VBLK_F_1_DURATION, 0x17, TVP7002_WRITE },
+        { TVP7002_ALC_PLACEMENT, 0x5a, TVP7002_WRITE },
+        { TVP7002_CLAMP_START, 0x32, TVP7002_WRITE },
+        { TVP7002_CLAMP_W, 0x20, TVP7002_WRITE },
+        { TVP7002_HPLL_PRE_COAST, 0x01, TVP7002_WRITE },
+        { TVP7002_HPLL_POST_COAST, 0x00, TVP7002_WRITE },
+        { TVP7002_EOR, 0xff, TVP7002_RESERVED }
+};
+
+/* Register parameters for 1080P60 */
+static const struct i2c_reg_value tvp7002_parms_1080P60[] = {
+        { TVP7002_HPLL_FDBK_DIV_MSBS, 0x89, TVP7002_WRITE },
+        { TVP7002_HPLL_FDBK_DIV_LSBS, 0x08, TVP7002_WRITE },
+        { TVP7002_HPLL_CRTL, 0xE0, TVP7002_WRITE },
+        { TVP7002_HPLL_PHASE_SEL, 0x14, TVP7002_WRITE },
+        { TVP7002_AVID_START_PIXEL_LSBS, 0x06, TVP7002_WRITE },
+        { TVP7002_AVID_START_PIXEL_MSBS, 0x01, TVP7002_WRITE },
+        { TVP7002_AVID_STOP_PIXEL_LSBS, 0x8a, TVP7002_WRITE },
+        { TVP7002_AVID_STOP_PIXEL_MSBS, 0x08, TVP7002_WRITE },
+        { TVP7002_VBLK_F_0_START_L_OFF, 0x02, TVP7002_WRITE },
+        { TVP7002_VBLK_F_1_START_L_OFF, 0x02, TVP7002_WRITE },
+        { TVP7002_VBLK_F_0_DURATION, 0x16, TVP7002_WRITE },
+        { TVP7002_VBLK_F_1_DURATION, 0x17, TVP7002_WRITE },
+        { TVP7002_ALC_PLACEMENT, 0x5a, TVP7002_WRITE },
+        { TVP7002_CLAMP_START, 0x32, TVP7002_WRITE },
+        { TVP7002_CLAMP_W, 0x20, TVP7002_WRITE },
+        { TVP7002_HPLL_PRE_COAST, 0x01, TVP7002_WRITE },
+        { TVP7002_HPLL_POST_COAST, 0x00, TVP7002_WRITE },
+        { TVP7002_EOR, 0xff, TVP7002_RESERVED }
+};
+
+/* Register parameters for 1080I50 */
+static const struct i2c_reg_value tvp7002_parms_1080I50[] = {
+        { TVP7002_HPLL_FDBK_DIV_MSBS, 0xa5, TVP7002_WRITE },
+        { TVP7002_HPLL_FDBK_DIV_LSBS, 0x00, TVP7002_WRITE },
+        { TVP7002_HPLL_CRTL, 0x98, TVP7002_WRITE },
+        { TVP7002_HPLL_PHASE_SEL, 0x14, TVP7002_WRITE },
+        { TVP7002_AVID_START_PIXEL_LSBS, 0x06, TVP7002_WRITE },
+        { TVP7002_AVID_START_PIXEL_MSBS, 0x01, TVP7002_WRITE },
+        { TVP7002_AVID_STOP_PIXEL_LSBS, 0x8a, TVP7002_WRITE },
+        { TVP7002_AVID_STOP_PIXEL_MSBS, 0x08, TVP7002_WRITE },
+        { TVP7002_VBLK_F_0_START_L_OFF, 0x02, TVP7002_WRITE },
+        { TVP7002_VBLK_F_1_START_L_OFF, 0x02, TVP7002_WRITE },
+        { TVP7002_VBLK_F_0_DURATION, 0x16, TVP7002_WRITE },
+        { TVP7002_VBLK_F_1_DURATION, 0x17, TVP7002_WRITE },
+        { TVP7002_ALC_PLACEMENT, 0x5a, TVP7002_WRITE },
+        { TVP7002_CLAMP_START, 0x32, TVP7002_WRITE },
+        { TVP7002_CLAMP_W, 0x20, TVP7002_WRITE },
+        { TVP7002_HPLL_PRE_COAST, 0x01, TVP7002_WRITE },
+        { TVP7002_HPLL_POST_COAST, 0x00, TVP7002_WRITE },
+        { TVP7002_EOR, 0xff, TVP7002_RESERVED }
+};
+
+/* Register parameters for 720P60 */
+static const struct i2c_reg_value tvp7002_parms_720P60[] = {
+        { TVP7002_HPLL_FDBK_DIV_MSBS, 0x67, TVP7002_WRITE },
+        { TVP7002_HPLL_FDBK_DIV_LSBS, 0x02, TVP7002_WRITE },
+        { TVP7002_HPLL_CRTL, 0xa0, TVP7002_WRITE },
+        { TVP7002_HPLL_PHASE_SEL, 0x16, TVP7002_WRITE },
+        { TVP7002_AVID_START_PIXEL_LSBS, 0x47, TVP7002_WRITE },
+        { TVP7002_AVID_START_PIXEL_MSBS, 0x01, TVP7002_WRITE },
+        { TVP7002_AVID_STOP_PIXEL_LSBS, 0x4B, TVP7002_WRITE },
+        { TVP7002_AVID_STOP_PIXEL_MSBS, 0x06, TVP7002_WRITE },
+        { TVP7002_VBLK_F_0_START_L_OFF, 0x05, TVP7002_WRITE },
+        { TVP7002_VBLK_F_1_START_L_OFF, 0x00, TVP7002_WRITE },
+        { TVP7002_VBLK_F_0_DURATION, 0x2D, TVP7002_WRITE },
+        { TVP7002_VBLK_F_1_DURATION, 0x00, TVP7002_WRITE },
+        { TVP7002_ALC_PLACEMENT, 0x5a, TVP7002_WRITE },
+        { TVP7002_CLAMP_START, 0x32, TVP7002_WRITE },
+        { TVP7002_CLAMP_W, 0x20, TVP7002_WRITE },
+        { TVP7002_HPLL_PRE_COAST, 0x00, TVP7002_WRITE },
+        { TVP7002_HPLL_POST_COAST, 0x00, TVP7002_WRITE },
+        { TVP7002_EOR, 0xff, TVP7002_RESERVED }
+};
+
+/* Register parameters for 720P50 */
+static const struct i2c_reg_value tvp7002_parms_720P50[] = {
+        { TVP7002_HPLL_FDBK_DIV_MSBS, 0x7b, TVP7002_WRITE },
+        { TVP7002_HPLL_FDBK_DIV_LSBS, 0x0c, TVP7002_WRITE },
+        { TVP7002_HPLL_CRTL, 0x98, TVP7002_WRITE },
+        { TVP7002_HPLL_PHASE_SEL, 0x16, TVP7002_WRITE },
+        { TVP7002_AVID_START_PIXEL_LSBS, 0x47, TVP7002_WRITE },
+        { TVP7002_AVID_START_PIXEL_MSBS, 0x01, TVP7002_WRITE },
+        { TVP7002_AVID_STOP_PIXEL_LSBS, 0x4B, TVP7002_WRITE },
+        { TVP7002_AVID_STOP_PIXEL_MSBS, 0x06, TVP7002_WRITE },
+        { TVP7002_VBLK_F_0_START_L_OFF, 0x05, TVP7002_WRITE },
+        { TVP7002_VBLK_F_1_START_L_OFF, 0x00, TVP7002_WRITE },
+        { TVP7002_VBLK_F_0_DURATION, 0x2D, TVP7002_WRITE },
+        { TVP7002_VBLK_F_1_DURATION, 0x00, TVP7002_WRITE },
+        { TVP7002_ALC_PLACEMENT, 0x5a, TVP7002_WRITE },
+        { TVP7002_CLAMP_START, 0x32, TVP7002_WRITE },
+        { TVP7002_CLAMP_W, 0x20, TVP7002_WRITE },
+        { TVP7002_HPLL_PRE_COAST, 0x01, TVP7002_WRITE },
+        { TVP7002_HPLL_POST_COAST, 0x00, TVP7002_WRITE },
+        { TVP7002_EOR, 0xff, TVP7002_RESERVED }
+};
+
+/* Struct list for available formats */
+static const struct v4l2_fmtdesc tvp7002_fmt_list[] = {
+        {
+         .index = 0,
+         .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
+         .flags = 0,
+         .description = "8-bit UYVY 4:2:2 Format",
+         .pixelformat = V4L2_PIX_FMT_UYVY,
+        },
+};
+
+#define NUM_FORMATS             ARRAY_SIZE(tvp7002_fmt_list)
+
+/* Preset definition for handling device operation */
+struct tvp7002_preset_definition {
+        u32 preset;
+        const struct i2c_reg_value *p_settings;
+        enum v4l2_colorspace color_space;
+        enum v4l2_field scanmode;
+        u16 progressive;
+        u16 lines_per_frame;
+        u16 cpl_min;
+        u16 cpl_max;
+};
+
+/* Struct list for digital video presets */
+static const struct tvp7002_preset_definition tvp7002_presets[] = {
+        {
+                V4L2_DV_720P60,
+                tvp7002_parms_720P60,
+                V4L2_COLORSPACE_REC709,
+                V4L2_FIELD_NONE,
+                1,
+                0x2EE,
+                135,
+                153
+        },
+        {
+                V4L2_DV_1080I60,
+                tvp7002_parms_1080I60,
+                V4L2_COLORSPACE_REC709,
+                V4L2_FIELD_INTERLACED,
+                0,
+                0x465,
+                181,
+                205
+        },
+        {
+                V4L2_DV_1080I50,
+                tvp7002_parms_1080I50,
+                V4L2_COLORSPACE_REC709,
+                V4L2_FIELD_INTERLACED,
+                0,
+                0x465,
+                217,
+                245
+        },
+        {
+                V4L2_DV_720P50,
+                tvp7002_parms_720P50,
+                V4L2_COLORSPACE_REC709,
+                V4L2_FIELD_NONE,
+                1,
+                0x2EE,
+                163,
+                183
+        },
+        {
+                V4L2_DV_1080P60,
+                tvp7002_parms_1080P60,
+                V4L2_COLORSPACE_REC709,
+                V4L2_FIELD_NONE,
+                1,
+                0x465,
+                90,
+                102
+        },
+        {
+                V4L2_DV_480P59_94,
+                tvp7002_parms_480P,
+                V4L2_COLORSPACE_SMPTE170M,
+                V4L2_FIELD_NONE,
+                1,
+                0x20D,
+                0xffff,
+                0xffff
+        },
+        {
+                V4L2_DV_576P50,
+                tvp7002_parms_576P,
+                V4L2_COLORSPACE_SMPTE170M,
+                V4L2_FIELD_NONE,
+                1,
+                0x271,
+                0xffff,
+                0xffff
+        }
+};
+
+#define NUM_PRESETS     ARRAY_SIZE(tvp7002_presets)
+
+/* Device definition */
+struct tvp7002 {
+        struct v4l2_subdev sd;
+        const struct tvp7002_config *pdata;
+
+        int ver;
+        int streaming;
+
+        struct v4l2_pix_format pix;
+        const struct tvp7002_preset_definition *current_preset;
+        u8 gain;
+};
+
+/*
+ * to_tvp7002 - Obtain device handler TVP7002
+ * @sd: ptr to v4l2_subdev struct
+ *
+ * Returns device handler tvp7002.
+ */
+static inline struct tvp7002 *to_tvp7002(struct v4l2_subdev *sd)
+{
+        return container_of(sd, struct tvp7002, sd);
+}
+
+/*
+ * tvp7002_read - Read a value from a register in an TVP7002
+ * @sd: ptr to v4l2_subdev struct
+ * @reg: TVP7002 register address
+ * @dst: pointer to 8-bit destination
+ *
+ * Returns value read if successful, or non-zero (-1) otherwise.
+ */
+static int tvp7002_read(struct v4l2_subdev *sd, u8 addr, u8 *dst)
+{
+        struct i2c_client *c = v4l2_get_subdevdata(sd);
+        int retry;
+        int error;
+
+        for (retry = 0; retry < I2C_RETRY_COUNT; retry++) {
+                error = i2c_smbus_read_byte_data(c, addr);
+
+                if (error >= 0) {
+                        *dst = (u8)error;
+                        return 0;
+                }
+
+                msleep_interruptible(10);
+        }
+        v4l2_err(sd, "TVP7002 read error %d\n", error);
+        return error;
+}
+
+/*
+ * tvp7002_read_err() - Read a register value with error code
+ * @sd: pointer to standard V4L2 sub-device structure
+ * @reg: destination register
+ * @val: value to be read
+ * @error: pointer to error value
+ *
+ * Read a value in a register and save error value in pointer.
+ * Also update the register table if successful
+ */
+static inline void tvp7002_read_err(struct v4l2_subdev *sd, u8 reg,
+                                                        u8 *dst, int *err)
+{
+        if (!*err)
+                *err = tvp7002_read(sd, reg, dst);
+}
+
+/*
+ * tvp7002_write() - Write a value to a register in TVP7002
+ * @sd: ptr to v4l2_subdev struct
+ * @addr: TVP7002 register address
+ * @value: value to be written to the register
+ *
+ * Write a value to a register in an TVP7002 decoder device.
+ * Returns zero if successful, or non-zero otherwise.
+ */
+static int tvp7002_write(struct v4l2_subdev *sd, u8 addr, u8 value)
+{
+        struct i2c_client *c;
+        int retry;
+        int error;
+
+        c = v4l2_get_subdevdata(sd);
+
+        for (retry = 0; retry < I2C_RETRY_COUNT; retry++) {
+                error = i2c_smbus_write_byte_data(c, addr, value);
+
+                if (error >= 0)
+                        return 0;
+
+                v4l2_warn(sd, "Write: retry ... %d\n", retry);
+                msleep_interruptible(10);
+        }
+        v4l2_err(sd, "TVP7002 write error %d\n", error);
+        return error;
+}
+
+/*
+ * tvp7002_write_err() - Write a register value with error code
+ * @sd: pointer to standard V4L2 sub-device structure
+ * @reg: destination register
+ * @val: value to be written
+ * @error: pointer to error value
+ *
+ * Write a value in a register and save error value in pointer.
+ * Also update the register table if successful
+ */
+static inline void tvp7002_write_err(struct v4l2_subdev *sd, u8 reg,
+                                                        u8 val, int *err)
+{
+        if (!*err)
+                *err = tvp7002_write(sd, reg, val);
+}
+
+/*
+ * tvp7002_g_chip_ident() - Get chip identification number
+ * @sd: ptr to v4l2_subdev struct
+ * @chip: ptr to v4l2_dbg_chip_ident struct
+ *
+ * Obtains the chip's identification number.
+ * Returns zero or -EINVAL if read operation fails.
+ */
+static int tvp7002_g_chip_ident(struct v4l2_subdev *sd,
+                                        struct v4l2_dbg_chip_ident *chip)
+{
+        u8 rev;
+        int error;
+        struct i2c_client *client = v4l2_get_subdevdata(sd);
+
+        error = tvp7002_read(sd, TVP7002_CHIP_REV, &rev);
+
+        if (error < 0)
+                return error;
+
+        return v4l2_chip_ident_i2c_client(client, chip, V4L2_IDENT_TVP7002, rev);
+}
+
+/*
+ * tvp7002_write_inittab() - Write initialization values
+ * @sd: ptr to v4l2_subdev struct
+ * @regs: ptr to i2c_reg_value struct
+ *
+ * Write initialization values.
+ * Returns zero or -EINVAL if read operation fails.
+ */
+static int tvp7002_write_inittab(struct v4l2_subdev *sd,
+                                        const struct i2c_reg_value *regs)
+{
+        int error = 0;
+
+        /* Initialize the first (defined) registers */
+        while (TVP7002_EOR != regs->reg) {
+                if (TVP7002_WRITE == regs->type)
+                        tvp7002_write_err(sd, regs->reg, regs->value, &error);
+                regs++;
+        }
+
+        return error;
+}
+
+/*
+ * tvp7002_s_dv_preset() - Set digital video preset
+ * @sd: ptr to v4l2_subdev struct
+ * @std: ptr to v4l2_dv_preset struct
+ *
+ * Set the digital video preset for a TVP7002 decoder device.
+ * Returns zero when successful or -EINVAL if register access fails.
+ */
+static int tvp7002_s_dv_preset(struct v4l2_subdev *sd,
+                                        struct v4l2_dv_preset *dv_preset)
+{
+        struct tvp7002 *device = to_tvp7002(sd);
+        u32 preset;
+        int i;
+
+        for (i = 0; i < NUM_PRESETS; i++) {
+                preset = tvp7002_presets[i].preset;
+                if (preset == dv_preset->preset) {
+                        device->current_preset = &tvp7002_presets[i];
+                        return tvp7002_write_inittab(sd, tvp7002_presets[i].p_settings);
+                }
+        }
+
+        return -EINVAL;
+}
+
+/*
+ * tvp7002_g_ctrl() - Get a control
+ * @sd: ptr to v4l2_subdev struct
+ * @ctrl: ptr to v4l2_control struct
+ *
+ * Get a control for a TVP7002 decoder device.
+ * Returns zero when successful or -EINVAL if register access fails.
+ */
+static int tvp7002_g_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
+{
+        struct tvp7002 *device = to_tvp7002(sd);
+
+        switch (ctrl->id) {
+        case V4L2_CID_GAIN:
+                ctrl->value = device->gain;
+                return 0;
+        default:
+                return -EINVAL;
+        }
+}
+
+/*
+ * tvp7002_s_ctrl() - Set a control
+ * @sd: ptr to v4l2_subdev struct
+ * @ctrl: ptr to v4l2_control struct
+ *
+ * Set a control in TVP7002 decoder device.
+ * Returns zero when successful or -EINVAL if register access fails.
+ */
+static int tvp7002_s_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
+{
+        struct tvp7002 *device = to_tvp7002(sd);
+        int error = 0;
+
+        switch (ctrl->id) {
+        case V4L2_CID_GAIN:
+                tvp7002_write_err(sd, TVP7002_R_FINE_GAIN,
+                                                ctrl->value & 0xff, &error);
+                tvp7002_write_err(sd, TVP7002_G_FINE_GAIN,
+                                                ctrl->value & 0xff, &error);
+                tvp7002_write_err(sd, TVP7002_B_FINE_GAIN,
+                                                ctrl->value & 0xff, &error);
+
+                if (error < 0)
+                        return error;
+
+                /* Set only after knowing there is no error */
+                device->gain = ctrl->value & 0xff;
+                return 0;
+        default:
+                return -EINVAL;
+        }
+}
+
+/*
+ * tvp7002_queryctrl() - Query a control
+ * @sd: ptr to v4l2_subdev struct
+ * @ctrl: ptr to v4l2_queryctrl struct
+ *
+ * Query a control of a TVP7002 decoder device.
+ * Returns zero when successful or -EINVAL if register read fails.
+ */
+static int tvp7002_queryctrl(struct v4l2_subdev *sd, struct v4l2_queryctrl *qc)
+{
+        switch (qc->id) {
+        case V4L2_CID_GAIN:
+                /*
+                 * Gain is supported [0-255, default=0, step=1]
+                 */
+                return v4l2_ctrl_query_fill(qc, 0, 255, 1, 0);
+        default:
+                return -EINVAL;
+        }
+}
+
+/*
+ * tvp7002_try_fmt_cap() - V4L2 decoder interface handler for try_fmt
+ * @sd: pointer to standard V4L2 sub-device structure
+ * @f: pointer to standard V4L2 VIDIOC_TRY_FMT ioctl structure
+ *
+ * Implement the VIDIOC_TRY_FMT ioctl for the CAPTURE buffer type. This
+ * ioctl is used to negotiate the image capture size and pixel format
+ * without actually making it take effect.
+ */
+static int tvp7002_try_fmt_cap(struct v4l2_subdev *sd, struct v4l2_format *f)
+{
+        struct tvp7002 *device = to_tvp7002(sd);
+        struct v4l2_dv_enum_preset e_preset;
+        struct v4l2_pix_format *pix;
+        int error = 0;
+
+        pix = &f->fmt.pix;
+
+        /* Calculate height and width based on current standard */
+        error = v4l_fill_dv_preset_info(device->current_preset->preset, &e_preset);
+        if (error)
+                return -EINVAL;
+
+        pix->width = e_preset.width;
+        pix->height = e_preset.height;
+        pix->pixelformat = V4L2_PIX_FMT_UYVY;
+        pix->field = device->current_preset->scanmode;
+        pix->bytesperline = pix->width * 2;
+        pix->sizeimage = pix->bytesperline * pix->height;
+        pix->colorspace = device->current_preset->color_space;
+        pix->priv = 0;
+
+        v4l2_dbg(1, debug, sd, "Try FMT: pixelformat - %s, bytesperline - %d"
+                        "Width - %d, Height - %d", "8-bit UYVY 4:2:2 Format",
+                        pix->bytesperline, pix->width, pix->height);
+        return error;
+}
+
+/*
+ * tvp7002_s_fmt() - V4L2 decoder interface handler for s_fmt
+ * @sd: pointer to standard V4L2 sub-device structure
+ * @f: pointer to standard V4L2 VIDIOC_S_FMT ioctl structure
+ *
+ * If the requested format is supported, configures the HW to use that
+ * format, returns error code if format not supported or HW can't be
+ * correctly configured.
+ */
+static int tvp7002_s_fmt(struct v4l2_subdev *sd, struct v4l2_format *f)
+{
+        struct tvp7002 *decoder = to_tvp7002(sd);
+        int rval;
+
+        rval = tvp7002_try_fmt_cap(sd, f);
+        if (!rval)
+                decoder->pix = f->fmt.pix;
+        return rval;
+}
+
+/*
+ * tvp7002_g_fmt() - V4L2 decoder interface handler for tvp7002_g_fmt
+ * @sd: pointer to standard V4L2 sub-device structure
+ * @f: pointer to standard V4L2 v4l2_format structure
+ *
+ * Returns the decoder's current pixel format in the v4l2_format
+ * parameter.
+ */
+static int tvp7002_g_fmt(struct v4l2_subdev *sd, struct v4l2_format *f)
+{
+        struct tvp7002 *decoder = to_tvp7002(sd);
+
+        f->fmt.pix = decoder->pix;
+
+        v4l2_dbg(1, debug, sd, "Current FMT: bytesperline - %d"
+                        "Width - %d, Height - %d",
+                        decoder->pix.bytesperline,
+                        decoder->pix.width, decoder->pix.height);
+        return 0;
+}
+
+/*
+ * tvp7002_query_dv_preset() - query DV preset
+ * @sd: pointer to standard V4L2 sub-device structure
+ * @std_id: standard V4L2 v4l2_dv_preset
+ *
+ * Returns the current DV preset by TVP7002. If no active input is
+ * detected, returns -EINVAL
+ */
+static int tvp7002_query_dv_preset(struct v4l2_subdev *sd,
+                                                struct v4l2_dv_preset *qpreset)
+{
+        const struct tvp7002_preset_definition *presets = tvp7002_presets;
+        struct v4l2_dv_enum_preset e_preset;
+        struct tvp7002 *device;
+        u8 progressive;
+        u32 lpfr;
+        u32 cpln;
+        int error = 0;
+        u8 lpf_lsb;
+        u8 lpf_msb;
+        u8 cpl_lsb;
+        u8 cpl_msb;
+        int index;
+
+        device = to_tvp7002(sd);
+
+        /* Read standards from device registers */
+        tvp7002_read_err(sd, TVP7002_L_FRAME_STAT_LSBS, &lpf_lsb, &error);
+        tvp7002_read_err(sd, TVP7002_L_FRAME_STAT_MSBS, &lpf_msb, &error);
+
+        if (error < 0)
+                return error;
+
+        tvp7002_read_err(sd, TVP7002_CLK_L_STAT_LSBS, &cpl_lsb, &error);
+        tvp7002_read_err(sd, TVP7002_CLK_L_STAT_MSBS, &cpl_msb, &error);
+
+        if (error < 0)
+                return error;
+
+        /* Get lines per frame, clocks per line and interlaced/progresive */
+        lpfr = lpf_lsb | ((TVP7002_CL_MASK & lpf_msb) << TVP7002_CL_SHIFT);
+        cpln = cpl_lsb | ((TVP7002_CL_MASK & cpl_msb) << TVP7002_CL_SHIFT);
+        progressive = (lpf_msb & TVP7002_INPR_MASK) >> TVP7002_IP_SHIFT;
+
+        /* Do checking of video modes */
+        for (index = 0; index < NUM_PRESETS; index++, presets++)
+                if (lpfr  == presets->lines_per_frame &&
+                        progressive == presets->progressive) {
+                        if (presets->cpl_min == 0xffff)
+                                break;
+                        if (cpln >= presets->cpl_min && cpln <= presets->cpl_max)
+                                break;
+                }
+
+        if (index == NUM_PRESETS) {
+                v4l2_err(sd, "querystd error, lpf = %x, cpl = %x\n",
+                                                                lpfr, cpln);
+                return -EINVAL;
+        }
+
+        if (v4l_fill_dv_preset_info(presets->preset, &e_preset))
+                return -EINVAL;
+
+        /* Set values in found preset */
+        qpreset->preset = presets->preset;
+
+        /* Update lines per frame and clocks per line info */
+        v4l2_dbg(1, debug, sd, "Current preset: %d %d",
+                                        e_preset.width, e_preset.height);
+        return 0;
+}
+
+#ifdef CONFIG_VIDEO_ADV_DEBUG
+/*
+ * tvp7002_g_register() - Get the value of a register
+ * @sd: ptr to v4l2_subdev struct
+ * @vreg: ptr to v4l2_dbg_register struct
+ *
+ * Get the value of a TVP7002 decoder device register.
+ * Returns zero when successful, -EINVAL if register read fails or
+ * access to I2C client fails, -EPERM if the call is not allowed
+ * by diabled CAP_SYS_ADMIN.
+ */
+static int tvp7002_g_register(struct v4l2_subdev *sd,
+                                                struct v4l2_dbg_register *reg)
+{
+        struct i2c_client *client = v4l2_get_subdevdata(sd);
+        u8 val;
+        int ret;
+
+        if (!v4l2_chip_match_i2c_client(client, &reg->match))
+                return -EINVAL;
+        if (!capable(CAP_SYS_ADMIN))
+                return -EPERM;
+
+        ret = tvp7002_read(sd, reg->reg & 0xff, &val);
+        reg->val = val;
+        return ret;
+}
+
+/*
+ * tvp7002_s_register() - set a control
+ * @sd: ptr to v4l2_subdev struct
+ * @ctrl: ptr to v4l2_control struct
+ *
+ * Get the value of a TVP7002 decoder device register.
+ * Returns zero when successful, -EINVAL if register read fails or
+ * -EPERM if call not allowed.
+ */
+static int tvp7002_s_register(struct v4l2_subdev *sd,
+                                                struct v4l2_dbg_register *reg)
+{
+        struct i2c_client *client = v4l2_get_subdevdata(sd);
+
+        if (!v4l2_chip_match_i2c_client(client, &reg->match))
+                return -EINVAL;
+        if (!capable(CAP_SYS_ADMIN))
+                return -EPERM;
+
+        return tvp7002_write(sd, reg->reg & 0xff, reg->val & 0xff);
+}
+#endif
+
+/*
+ * tvp7002_enum_fmt() - Enum supported formats
+ * @sd: pointer to standard V4L2 sub-device structure
+ * @enable: pointer to format struct
+ *
+ * Enumerate supported formats.
+ */
+
+static int tvp7002_enum_fmt(struct v4l2_subdev *sd,
+                                                struct v4l2_fmtdesc *fmtdesc)
+{
+        /* Check requested format index is within range */
+        if (fmtdesc->index < 0 || fmtdesc->index >= NUM_FORMATS)
+                return -EINVAL;
+        *fmtdesc = tvp7002_fmt_list[fmtdesc->index];
+
+        return 0;
+}
+
+/*
+ * tvp7002_s_stream() - V4L2 decoder i/f handler for s_stream
+ * @sd: pointer to standard V4L2 sub-device structure
+ * @enable: streaming enable or disable
+ *
+ * Sets streaming to enable or disable, if possible.
+ */
+static int tvp7002_s_stream(struct v4l2_subdev *sd, int enable)
+{
+        struct tvp7002 *device = to_tvp7002(sd);
+        int error = 0;
+
+        if (device->streaming == enable)
+                return 0;
+
+        if (enable) {
+                /* Set output state on (low impedance means stream on) */
+                error = tvp7002_write(sd, TVP7002_MISC_CTL_2, 0x00);
+                device->streaming = enable;
+        } else {
+                /* Set output state off (high impedance means stream off) */
+                error = tvp7002_write(sd, TVP7002_MISC_CTL_2, 0x03);
+                if (error)
+                        v4l2_dbg(1, debug, sd, "Unable to stop streaming\n");
+
+                device->streaming = enable;
+        }
+
+        return error;
+}
+
+/*
+ * tvp7002_log_status() - Print information about register settings
+ * @sd: ptr to v4l2_subdev struct
+ *
+ * Log register values of a TVP7002 decoder device.
+ * Returns zero or -EINVAL if read operation fails.
+ */
+static int tvp7002_log_status(struct v4l2_subdev *sd)
+{
+        const struct tvp7002_preset_definition *presets = tvp7002_presets;
+        struct tvp7002 *device = to_tvp7002(sd);
+        struct v4l2_dv_enum_preset e_preset;
+        struct v4l2_dv_preset detected;
+        int i;
+
+        detected.preset = V4L2_DV_INVALID;
+        /* Find my current standard*/
+        tvp7002_query_dv_preset(sd, &detected);
+
+        /* Print standard related code values */
+        for (i = 0; i < NUM_PRESETS; i++, presets++)
+                if (presets->preset == detected.preset)
+                        break;
+
+        if (v4l_fill_dv_preset_info(device->current_preset->preset, &e_preset))
+                return -EINVAL;
+
+        v4l2_info(sd, "Selected DV Preset: %s\n", e_preset.name);
+        v4l2_info(sd, "   Pixels per line: %u\n", e_preset.width);
+        v4l2_info(sd, "   Lines per frame: %u\n\n", e_preset.height);
+        if (i == NUM_PRESETS) {
+                v4l2_info(sd, "Detected DV Preset: None\n");
+        } else {
+                if (v4l_fill_dv_preset_info(presets->preset, &e_preset))
+                        return -EINVAL;
+                v4l2_info(sd, "Detected DV Preset: %s\n", e_preset.name);
+                v4l2_info(sd, "  Pixels per line: %u\n", e_preset.width);
+                v4l2_info(sd, "  Lines per frame: %u\n\n", e_preset.height);
+        }
+        v4l2_info(sd, "Streaming enabled: %s\n",
+                                        device->streaming ? "yes" : "no");
+
+        /* Print the current value of the gain control */
+        v4l2_info(sd, "Gain: %u\n", device->gain);
+
+        return 0;
+}
+
+/* V4L2 core operation handlers */
+static const struct v4l2_subdev_core_ops tvp7002_core_ops = {
+        .g_chip_ident = tvp7002_g_chip_ident,
+        .log_status = tvp7002_log_status,
+        .g_ctrl = tvp7002_g_ctrl,
+        .s_ctrl = tvp7002_s_ctrl,
+        .queryctrl = tvp7002_queryctrl,
+#ifdef CONFIG_VIDEO_ADV_DEBUG
+        .g_register = tvp7002_g_register,
+        .s_register = tvp7002_s_register,
+#endif
+};
+
+/* Specific video subsystem operation handlers */
+static const struct v4l2_subdev_video_ops tvp7002_video_ops = {
+        .s_dv_preset = tvp7002_s_dv_preset,
+        .query_dv_preset = tvp7002_query_dv_preset,
+        .s_stream = tvp7002_s_stream,
+        .g_fmt = tvp7002_g_fmt,
+        .s_fmt = tvp7002_s_fmt,
+        .enum_fmt = tvp7002_enum_fmt,
+};
+
+/* V4L2 top level operation handlers */
+static const struct v4l2_subdev_ops tvp7002_ops = {
+        .core = &tvp7002_core_ops,
+        .video = &tvp7002_video_ops,
+};
+
+static struct tvp7002 tvp7002_dev = {
+        .streaming = 0,
+
+        .pix = {
+                .width = 1280,
+                .height = 720,
+                .pixelformat = V4L2_PIX_FMT_UYVY,
+                .field = V4L2_FIELD_NONE,
+                .bytesperline = 1280 * 2,
+                .sizeimage = 1280 * 2 * 720,
+                .colorspace = V4L2_COLORSPACE_REC709,
+                },
+
+        .current_preset = tvp7002_presets,
+        .gain = 0,
+};
+
+/*
+ * tvp7002_probe - Probe a TVP7002 device
+ * @sd: ptr to v4l2_subdev struct
+ * @ctrl: ptr to i2c_device_id struct
+ *
+ * Initialize the TVP7002 device
+ * Returns zero when successful, -EINVAL if register read fails or
+ * -EIO if i2c access is not available.
+ */
+static int tvp7002_probe(struct i2c_client *c, const struct i2c_device_id *id)
+{
+        struct v4l2_subdev *sd;
+        struct tvp7002 *device;
+        struct v4l2_dv_preset preset;
+        int polarity_a;
+        int polarity_b;
+        u8 revision;
+
+        int error;
+
+        /* Check if the adapter supports the needed features */
+        if (!i2c_check_functionality(c->adapter,
+                I2C_FUNC_SMBUS_READ_BYTE | I2C_FUNC_SMBUS_WRITE_BYTE_DATA))
+                return -EIO;
+
+        if (!c->dev.platform_data) {
+                v4l_err(c, "No platform data!!\n");
+                return -ENODEV;
+        }
+
+        device = kmalloc(sizeof(struct tvp7002), GFP_KERNEL);
+
+        if (!device)
+                return -ENOMEM;
+
+        *device = tvp7002_dev;
+        sd = &device->sd;
+        device->pdata = c->dev.platform_data;
+
+        /* Tell v4l2 the device is ready */
+        v4l2_i2c_subdev_init(sd, c, &tvp7002_ops);
+        v4l_info(c, "tvp7002 found @ 0x%02x (%s)\n",
+                                        c->addr, c->adapter->name);
+
+        error = tvp7002_read(sd, TVP7002_CHIP_REV, &revision);
+        if (error < 0)
+                goto found_error;
+
+        /* Get revision number */
+        v4l2_info(sd, "Rev. %02x detected.\n", revision);
+        if (revision != 0x02)
+                v4l2_info(sd, "Unknown revision detected.\n");
+
+        /* Initializes TVP7002 to its default values */
+        error = tvp7002_write_inittab(sd, tvp7002_init_default);
+
+        if (error < 0)
+                goto found_error;
+
+        /* Set polarity information after registers have been set */
+        polarity_a = 0x20 | device->pdata->hs_polarity << 5
+                        | device->pdata->vs_polarity << 2;
+        error = tvp7002_write(sd, TVP7002_SYNC_CTL_1, polarity_a);
+        if (error < 0)
+                goto found_error;
+
+        polarity_b = 0x01  | device->pdata->fid_polarity << 2
+                        | device->pdata->sog_polarity << 1
+                        | device->pdata->clk_polarity;
+        error = tvp7002_write(sd, TVP7002_MISC_CTL_3, polarity_b);
+        if (error < 0)
+                goto found_error;
+
+        /* Set registers according to default video mode */
+        preset.preset = device->current_preset->preset;
+        error = tvp7002_s_dv_preset(sd, &preset);
+
+found_error:
+        if (error < 0)
+                kfree(device);
+
+        return error;
+}
+
+/*
+ * tvp7002_remove - Remove TVP7002 device support
+ * @c: ptr to i2c_client struct
+ *
+ * Reset the TVP7002 device
+ * Returns zero.
+ */
+static int tvp7002_remove(struct i2c_client *c)
+{
+        struct v4l2_subdev *sd = i2c_get_clientdata(c);
+        struct tvp7002 *device = to_tvp7002(sd);
+
+        v4l2_dbg(1, debug, sd, "Removing tvp7002 adapter"
+                                "on address 0x%x\n", c->addr);
+
+        v4l2_device_unregister_subdev(sd);
+        kfree(device);
+        return 0;
+}
+
+/* I2C Device ID table */
+static const struct i2c_device_id tvp7002_id[] = {
+        { "tvp7002", 0 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, tvp7002_id);
+
+/* I2C driver data */
+static struct i2c_driver tvp7002_driver = {
+        .driver = {
+                .owner = THIS_MODULE,
+                .name = TVP7002_MODULE_NAME,
+        },
+        .probe = tvp7002_probe,
+        .remove = tvp7002_remove,
+        .id_table = tvp7002_id,
+};
+
+/*
+ * tvp7002_init - Initialize driver via I2C interface
+ *
+ * Register the TVP7002 driver.
+ * Return 0 on success or error code on failure.
+ */
+static int __init tvp7002_init(void)
+{
+        return i2c_add_driver(&tvp7002_driver);
+}
+
+/*
+ * tvp7002_exit - Remove driver via I2C interface
+ *
+ * Unregister the TVP7002 driver.
+ * Returns nothing.
+ */
+static void __exit tvp7002_exit(void)
+{
+        i2c_del_driver(&tvp7002_driver);
+}
+
+module_init(tvp7002_init);
+module_exit(tvp7002_exit);
diff --git a/drivers/media/video/tvp7002_reg.h b/drivers/media/video/tvp7002_reg.h
new file mode 100644
index 000000000000..0e34ca9bccf3
--- /dev/null
+++ b/drivers/media/video/tvp7002_reg.h
@@ -0,0 +1,150 @@
+/* Texas Instruments Triple 8-/10-BIT 165-/110-MSPS Video and Graphics
+ * Digitizer with Horizontal PLL registers
+ *
+ * Copyright (C) 2009 Texas Instruments Inc
+ * Author: Santiago Nunez-Corrales <santiago.nunez@ridgerun.com>
+ *
+ * This code is partially based upon the TVP5150 driver
+ * written by Mauro Carvalho Chehab (mchehab@infradead.org),
+ * the TVP514x driver written by Vaibhav Hiremath <hvaibhav@ti.com>
+ * and the TVP7002 driver in the TI LSP 2.10.00.14
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/* Naming conventions
+ * ------------------
+ *
+ * FDBK:  Feedback
+ * DIV:   Divider
+ * CTL:   Control
+ * SEL:   Select
+ * IN:    Input
+ * OUT:   Output
+ * R:     Red
+ * G:     Green
+ * B:     Blue
+ * OFF:   Offset
+ * THRS:  Threshold
+ * DGTL:  Digital
+ * LVL:   Level
+ * PWR:   Power
+ * MVIS:  Macrovision
+ * W:     Width
+ * H:     Height
+ * ALGN:  Alignment
+ * CLK:   Clocks
+ * TOL:   Tolerance
+ * BWTH:  Bandwidth
+ * COEF:  Coefficient
+ * STAT:  Status
+ * AUTO:  Automatic
+ * FLD:   Field
+ * L:     Line
+ */
+
+#define TVP7002_CHIP_REV                0x00
+#define TVP7002_HPLL_FDBK_DIV_MSBS      0x01
+#define TVP7002_HPLL_FDBK_DIV_LSBS      0x02
+#define TVP7002_HPLL_CRTL               0x03
+#define TVP7002_HPLL_PHASE_SEL          0x04
+#define TVP7002_CLAMP_START             0x05
+#define TVP7002_CLAMP_W                 0x06
+#define TVP7002_HSYNC_OUT_W             0x07
+#define TVP7002_B_FINE_GAIN             0x08
+#define TVP7002_G_FINE_GAIN             0x09
+#define TVP7002_R_FINE_GAIN             0x0a
+#define TVP7002_B_FINE_OFF_MSBS         0x0b
+#define TVP7002_G_FINE_OFF_MSBS         0x0c
+#define TVP7002_R_FINE_OFF_MSBS         0x0d
+#define TVP7002_SYNC_CTL_1              0x0e
+#define TVP7002_HPLL_AND_CLAMP_CTL      0x0f
+#define TVP7002_SYNC_ON_G_THRS          0x10
+#define TVP7002_SYNC_SEPARATOR_THRS     0x11
+#define TVP7002_HPLL_PRE_COAST          0x12
+#define TVP7002_HPLL_POST_COAST         0x13
+#define TVP7002_SYNC_DETECT_STAT        0x14
+#define TVP7002_OUT_FORMATTER           0x15
+#define TVP7002_MISC_CTL_1              0x16
+#define TVP7002_MISC_CTL_2              0x17
+#define TVP7002_MISC_CTL_3              0x18
+#define TVP7002_IN_MUX_SEL_1            0x19
+#define TVP7002_IN_MUX_SEL_2            0x1a
+#define TVP7002_B_AND_G_COARSE_GAIN     0x1b
+#define TVP7002_R_COARSE_GAIN           0x1c
+#define TVP7002_FINE_OFF_LSBS           0x1d
+#define TVP7002_B_COARSE_OFF            0x1e
+#define TVP7002_G_COARSE_OFF            0x1f
+#define TVP7002_R_COARSE_OFF            0x20
+#define TVP7002_HSOUT_OUT_START         0x21
+#define TVP7002_MISC_CTL_4              0x22
+#define TVP7002_B_DGTL_ALC_OUT_LSBS     0x23
+#define TVP7002_G_DGTL_ALC_OUT_LSBS     0x24
+#define TVP7002_R_DGTL_ALC_OUT_LSBS     0x25
+#define TVP7002_AUTO_LVL_CTL_ENABLE     0x26
+#define TVP7002_DGTL_ALC_OUT_MSBS       0x27
+#define TVP7002_AUTO_LVL_CTL_FILTER     0x28
+/* Reserved 0x29*/
+#define TVP7002_FINE_CLAMP_CTL          0x2a
+#define TVP7002_PWR_CTL                 0x2b
+#define TVP7002_ADC_SETUP               0x2c
+#define TVP7002_COARSE_CLAMP_CTL        0x2d
+#define TVP7002_SOG_CLAMP               0x2e
+#define TVP7002_RGB_COARSE_CLAMP_CTL    0x2f
+#define TVP7002_SOG_COARSE_CLAMP_CTL    0x30
+#define TVP7002_ALC_PLACEMENT           0x31
+/* Reserved 0x32 */
+/* Reserved 0x33 */
+#define TVP7002_MVIS_STRIPPER_W         0x34
+#define TVP7002_VSYNC_ALGN              0x35
+#define TVP7002_SYNC_BYPASS             0x36
+#define TVP7002_L_FRAME_STAT_LSBS       0x37
+#define TVP7002_L_FRAME_STAT_MSBS       0x38
+#define TVP7002_CLK_L_STAT_LSBS         0x39
+#define TVP7002_CLK_L_STAT_MSBS         0x3a
+#define TVP7002_HSYNC_W                 0x3b
+#define TVP7002_VSYNC_W                 0x3c
+#define TVP7002_L_LENGTH_TOL            0x3d
+/* Reserved 0x3e */
+#define TVP7002_VIDEO_BWTH_CTL          0x3f
+#define TVP7002_AVID_START_PIXEL_LSBS   0x40
+#define TVP7002_AVID_START_PIXEL_MSBS   0x41
+#define TVP7002_AVID_STOP_PIXEL_LSBS    0x42
+#define TVP7002_AVID_STOP_PIXEL_MSBS    0x43
+#define TVP7002_VBLK_F_0_START_L_OFF    0x44
+#define TVP7002_VBLK_F_1_START_L_OFF    0x45
+#define TVP7002_VBLK_F_0_DURATION       0x46
+#define TVP7002_VBLK_F_1_DURATION       0x47
+#define TVP7002_FBIT_F_0_START_L_OFF    0x48
+#define TVP7002_FBIT_F_1_START_L_OFF    0x49
+#define TVP7002_YUV_Y_G_COEF_LSBS       0x4a
+#define TVP7002_YUV_Y_G_COEF_MSBS       0x4b
+#define TVP7002_YUV_Y_B_COEF_LSBS       0x4c
+#define TVP7002_YUV_Y_B_COEF_MSBS       0x4d
+#define TVP7002_YUV_Y_R_COEF_LSBS       0x4e
+#define TVP7002_YUV_Y_R_COEF_MSBS       0x4f
+#define TVP7002_YUV_U_G_COEF_LSBS       0x50
+#define TVP7002_YUV_U_G_COEF_MSBS       0x51
+#define TVP7002_YUV_U_B_COEF_LSBS       0x52
+#define TVP7002_YUV_U_B_COEF_MSBS       0x53
+#define TVP7002_YUV_U_R_COEF_LSBS       0x54
+#define TVP7002_YUV_U_R_COEF_MSBS       0x55
+#define TVP7002_YUV_V_G_COEF_LSBS       0x56
+#define TVP7002_YUV_V_G_COEF_MSBS       0x57
+#define TVP7002_YUV_V_B_COEF_LSBS       0x58
+#define TVP7002_YUV_V_B_COEF_MSBS       0x59
+#define TVP7002_YUV_V_R_COEF_LSBS       0x5a
+#define TVP7002_YUV_V_R_COEF_MSBS       0x5b
+
diff --git a/drivers/media/video/tw9910.c b/drivers/media/video/tw9910.c
index 5b801a6e1eea..76be733eabfd 100644
--- a/drivers/media/video/tw9910.c
+++ b/drivers/media/video/tw9910.c
@@ -233,10 +233,10 @@ struct tw9910_hsync_ctrl {
 };
 
 struct tw9910_priv {
-        struct v4l2_subdev                subdev;
-        struct tw9910_video_info       *info;
-        const struct tw9910_scale_ctrl *scale;
-        u32                             revision;
+        struct v4l2_subdev              subdev;
+        struct tw9910_video_info        *info;
+        const struct tw9910_scale_ctrl  *scale;
+        u32                             revision;
 };
 
 static const struct tw9910_scale_ctrl tw9910_ntsc_scales[] = {
diff --git a/drivers/media/video/usbvision/usbvision-video.c b/drivers/media/video/usbvision/usbvision-video.c
index 1054546db908..7c17ec63c5da 100644
--- a/drivers/media/video/usbvision/usbvision-video.c
+++ b/drivers/media/video/usbvision/usbvision-video.c
@@ -1487,7 +1487,7 @@ static int __devinit usbvision_register_video(struct usb_usbvision *usbvision)
                 usbvision->vbi = usbvision_vdev_init(usbvision,
                                                      &usbvision_vbi_template,
                                                      "USBVision VBI");
-                if (usbvision->vdev == NULL) {
+                if (usbvision->vbi == NULL) {
                         goto err_exit;
                 }
                 if (video_register_device(usbvision->vbi,
diff --git a/drivers/media/video/uvc/uvc_ctrl.c b/drivers/media/video/uvc/uvc_ctrl.c
index ec8ef8c5560a..3b2e7800d56f 100644
--- a/drivers/media/video/uvc/uvc_ctrl.c
+++ b/drivers/media/video/uvc/uvc_ctrl.c
@@ -23,9 +23,13 @@
 
 #include "uvcvideo.h"
 
-#define UVC_CTRL_NDATA          2
 #define UVC_CTRL_DATA_CURRENT   0
 #define UVC_CTRL_DATA_BACKUP    1
+#define UVC_CTRL_DATA_MIN       2
+#define UVC_CTRL_DATA_MAX       3
+#define UVC_CTRL_DATA_RES       4
+#define UVC_CTRL_DATA_DEF       5
+#define UVC_CTRL_DATA_LAST      6
 
 /* ------------------------------------------------------------------------
  * Controls
@@ -755,6 +759,49 @@ struct uvc_control *uvc_find_control(struct uvc_video_chain *chain,
         return ctrl;
 }
 
+static int uvc_ctrl_populate_cache(struct uvc_video_chain *chain,
+        struct uvc_control *ctrl)
+{
+        int ret;
+
+        if (ctrl->info->flags & UVC_CONTROL_GET_DEF) {
+                ret = uvc_query_ctrl(chain->dev, UVC_GET_DEF, ctrl->entity->id,
+                                     chain->dev->intfnum, ctrl->info->selector,
+                                     uvc_ctrl_data(ctrl, UVC_CTRL_DATA_DEF),
+                                     ctrl->info->size);
+                if (ret < 0)
+                        return ret;
+        }
+
+        if (ctrl->info->flags & UVC_CONTROL_GET_MIN) {
+                ret = uvc_query_ctrl(chain->dev, UVC_GET_MIN, ctrl->entity->id,
+                                     chain->dev->intfnum, ctrl->info->selector,
+                                     uvc_ctrl_data(ctrl, UVC_CTRL_DATA_MIN),
+                                     ctrl->info->size);
+                if (ret < 0)
+                        return ret;
+        }
+        if (ctrl->info->flags & UVC_CONTROL_GET_MAX) {
+                ret = uvc_query_ctrl(chain->dev, UVC_GET_MAX, ctrl->entity->id,
+                                     chain->dev->intfnum, ctrl->info->selector,
+                                     uvc_ctrl_data(ctrl, UVC_CTRL_DATA_MAX),
+                                     ctrl->info->size);
+                if (ret < 0)
+                        return ret;
+        }
+        if (ctrl->info->flags & UVC_CONTROL_GET_RES) {
+                ret = uvc_query_ctrl(chain->dev, UVC_GET_RES, ctrl->entity->id,
+                                     chain->dev->intfnum, ctrl->info->selector,
+                                     uvc_ctrl_data(ctrl, UVC_CTRL_DATA_RES),
+                                     ctrl->info->size);
+                if (ret < 0)
+                        return ret;
+        }
+
+        ctrl->cached = 1;
+        return 0;
+}
+
 int uvc_query_v4l2_ctrl(struct uvc_video_chain *chain,
         struct v4l2_queryctrl *v4l2_ctrl)
 {
@@ -762,17 +809,12 @@ int uvc_query_v4l2_ctrl(struct uvc_video_chain *chain,
         struct uvc_control_mapping *mapping;
         struct uvc_menu_info *menu;
         unsigned int i;
-        __u8 *data;
         int ret;
 
         ctrl = uvc_find_control(chain, v4l2_ctrl->id, &mapping);
         if (ctrl == NULL)
                 return -EINVAL;
 
-        data = kmalloc(ctrl->info->size, GFP_KERNEL);
-        if (data == NULL)
-                return -ENOMEM;
-
         memset(v4l2_ctrl, 0, sizeof *v4l2_ctrl);
         v4l2_ctrl->id = mapping->id;
         v4l2_ctrl->type = mapping->v4l2_type;
@@ -782,14 +824,15 @@ int uvc_query_v4l2_ctrl(struct uvc_video_chain *chain,
         if (!(ctrl->info->flags & UVC_CONTROL_SET_CUR))
                 v4l2_ctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY;
 
-        if (ctrl->info->flags & UVC_CONTROL_GET_DEF) {
-                ret = uvc_query_ctrl(chain->dev, UVC_GET_DEF, ctrl->entity->id,
-                                     chain->dev->intfnum, ctrl->info->selector,
-                                     data, ctrl->info->size);
+        if (!ctrl->cached) {
+                ret = uvc_ctrl_populate_cache(chain, ctrl);
                 if (ret < 0)
-                        goto out;
-                v4l2_ctrl->default_value =
-                        mapping->get(mapping, UVC_GET_DEF, data);
+                        return ret;
+        }
+
+        if (ctrl->info->flags & UVC_CONTROL_GET_DEF) {
+                v4l2_ctrl->default_value = mapping->get(mapping, UVC_GET_DEF,
+                                uvc_ctrl_data(ctrl, UVC_CTRL_DATA_DEF));
         }
 
         switch (mapping->v4l2_type) {
@@ -806,56 +849,37 @@ int uvc_query_v4l2_ctrl(struct uvc_video_chain *chain,
                         }
                 }
 
-                ret = 0;
-                goto out;
+                return 0;
 
         case V4L2_CTRL_TYPE_BOOLEAN:
                 v4l2_ctrl->minimum = 0;
                 v4l2_ctrl->maximum = 1;
                 v4l2_ctrl->step = 1;
-                ret = 0;
-                goto out;
+                return 0;
 
         case V4L2_CTRL_TYPE_BUTTON:
                 v4l2_ctrl->minimum = 0;
                 v4l2_ctrl->maximum = 0;
                 v4l2_ctrl->step = 0;
-                ret = 0;
-                goto out;
+                return 0;
 
         default:
                 break;
         }
 
-        if (ctrl->info->flags & UVC_CONTROL_GET_MIN) {
-                ret = uvc_query_ctrl(chain->dev, UVC_GET_MIN, ctrl->entity->id,
-                                     chain->dev->intfnum, ctrl->info->selector,
-                                     data, ctrl->info->size);
-                if (ret < 0)
-                        goto out;
-                v4l2_ctrl->minimum = mapping->get(mapping, UVC_GET_MIN, data);
-        }
-        if (ctrl->info->flags & UVC_CONTROL_GET_MAX) {
-                ret = uvc_query_ctrl(chain->dev, UVC_GET_MAX, ctrl->entity->id,
-                                     chain->dev->intfnum, ctrl->info->selector,
-                                     data, ctrl->info->size);
-                if (ret < 0)
-                        goto out;
-                v4l2_ctrl->maximum = mapping->get(mapping, UVC_GET_MAX, data);
-        }
-        if (ctrl->info->flags & UVC_CONTROL_GET_RES) {
-                ret = uvc_query_ctrl(chain->dev, UVC_GET_RES, ctrl->entity->id,
-                                     chain->dev->intfnum, ctrl->info->selector,
-                                     data, ctrl->info->size);
-                if (ret < 0)
-                        goto out;
-                v4l2_ctrl->step = mapping->get(mapping, UVC_GET_RES, data);
-        }
+        if (ctrl->info->flags & UVC_CONTROL_GET_MIN)
+                v4l2_ctrl->minimum = mapping->get(mapping, UVC_GET_MIN,
+                                     uvc_ctrl_data(ctrl, UVC_CTRL_DATA_MIN));
 
-        ret = 0;
-out:
-        kfree(data);
-        return ret;
+        if (ctrl->info->flags & UVC_CONTROL_GET_MAX)
+                v4l2_ctrl->maximum = mapping->get(mapping, UVC_GET_MAX,
+                                     uvc_ctrl_data(ctrl, UVC_CTRL_DATA_MAX));
+
+        if (ctrl->info->flags & UVC_CONTROL_GET_RES)
+                v4l2_ctrl->step = mapping->get(mapping, UVC_GET_RES,
+                                  uvc_ctrl_data(ctrl, UVC_CTRL_DATA_RES));
+
+        return 0;
 }
 
 
@@ -997,19 +1021,57 @@ int uvc_ctrl_set(struct uvc_video_chain *chain,
 {
         struct uvc_control *ctrl;
         struct uvc_control_mapping *mapping;
-        s32 value = xctrl->value;
+        s32 value;
+        u32 step;
+        s32 min;
+        s32 max;
         int ret;
 
         ctrl = uvc_find_control(chain, xctrl->id, &mapping);
         if (ctrl == NULL || (ctrl->info->flags & UVC_CONTROL_SET_CUR) == 0)
                 return -EINVAL;
 
-        if (mapping->v4l2_type == V4L2_CTRL_TYPE_MENU) {
-                if (value < 0 || value >= mapping->menu_count)
-                        return -EINVAL;
-                value = mapping->menu_info[value].value;
+        /* Clamp out of range values. */
+        switch (mapping->v4l2_type) {
+        case V4L2_CTRL_TYPE_INTEGER:
+                if (!ctrl->cached) {
+                        ret = uvc_ctrl_populate_cache(chain, ctrl);
+                        if (ret < 0)
+                                return ret;
+                }
+
+                min = mapping->get(mapping, UVC_GET_MIN,
+                                   uvc_ctrl_data(ctrl, UVC_CTRL_DATA_MIN));
+                max = mapping->get(mapping, UVC_GET_MAX,
+                                   uvc_ctrl_data(ctrl, UVC_CTRL_DATA_MAX));
+                step = mapping->get(mapping, UVC_GET_RES,
+                                    uvc_ctrl_data(ctrl, UVC_CTRL_DATA_RES));
+
+                xctrl->value = min + (xctrl->value - min + step/2) / step * step;
+                xctrl->value = clamp(xctrl->value, min, max);
+                value = xctrl->value;
+                break;
+
+        case V4L2_CTRL_TYPE_BOOLEAN:
+                xctrl->value = clamp(xctrl->value, 0, 1);
+                value = xctrl->value;
+                break;
+
+        case V4L2_CTRL_TYPE_MENU:
+                if (xctrl->value < 0 || xctrl->value >= mapping->menu_count)
+                        return -ERANGE;
+                value = mapping->menu_info[xctrl->value].value;
+                break;
+
+        default:
+                value = xctrl->value;
+                break;
         }
 
+        /* If the mapping doesn't span the whole UVC control, the current value
+         * needs to be loaded from the device to perform the read-modify-write
+         * operation.
+         */
         if (!ctrl->loaded && (ctrl->info->size * 8) != mapping->size) {
                 if ((ctrl->info->flags & UVC_CONTROL_GET_CUR) == 0) {
                         memset(uvc_ctrl_data(ctrl, UVC_CTRL_DATA_CURRENT),
@@ -1027,6 +1089,7 @@ int uvc_ctrl_set(struct uvc_video_chain *chain,
                 ctrl->loaded = 1;
         }
 
+        /* Backup the current value in case we need to rollback later. */
         if (!ctrl->dirty) {
                 memcpy(uvc_ctrl_data(ctrl, UVC_CTRL_DATA_BACKUP),
                        uvc_ctrl_data(ctrl, UVC_CTRL_DATA_CURRENT),
@@ -1080,10 +1143,8 @@ int uvc_xu_ctrl_query(struct uvc_video_chain *chain,
         }
 
         if (!found) {
-                uvc_trace(UVC_TRACE_CONTROL,
-                        "Control " UVC_GUID_FORMAT "/%u not found.\n",
-                        UVC_GUID_ARGS(entity->extension.guidExtensionCode),
-                        xctrl->selector);
+                uvc_trace(UVC_TRACE_CONTROL, "Control %pUl/%u not found.\n",
+                        entity->extension.guidExtensionCode, xctrl->selector);
                 return -EINVAL;
         }
 
@@ -1159,9 +1220,9 @@ int uvc_ctrl_resume_device(struct uvc_device *dev)
                             (ctrl->info->flags & UVC_CONTROL_RESTORE) == 0)
                                 continue;
 
-                        printk(KERN_INFO "restoring control " UVC_GUID_FORMAT
-                                "/%u/%u\n", UVC_GUID_ARGS(ctrl->info->entity),
-                                ctrl->info->index, ctrl->info->selector);
+                        printk(KERN_INFO "restoring control %pUl/%u/%u\n",
+                                ctrl->info->entity, ctrl->info->index,
+                                ctrl->info->selector);
                         ctrl->dirty = 1;
                 }
 
@@ -1215,47 +1276,43 @@ static void uvc_ctrl_add_ctrl(struct uvc_device *dev,
                 ret = uvc_query_ctrl(dev, UVC_GET_LEN, ctrl->entity->id,
                         dev->intfnum, info->selector, (__u8 *)&size, 2);
                 if (ret < 0) {
-                        uvc_trace(UVC_TRACE_CONTROL, "GET_LEN failed on "
-                                "control " UVC_GUID_FORMAT "/%u (%d).\n",
-                                UVC_GUID_ARGS(info->entity), info->selector,
-                                ret);
+                        uvc_trace(UVC_TRACE_CONTROL,
+                                "GET_LEN failed on control %pUl/%u (%d).\n",
+                                info->entity, info->selector, ret);
                         return;
                 }
 
                 if (info->size != le16_to_cpu(size)) {
-                        uvc_trace(UVC_TRACE_CONTROL, "Control " UVC_GUID_FORMAT
-                                "/%u size doesn't match user supplied "
-                                "value.\n", UVC_GUID_ARGS(info->entity),
-                                info->selector);
+                        uvc_trace(UVC_TRACE_CONTROL, "Control %pUl/%u size "
+                                "doesn't match user supplied value.\n",
+                                info->entity, info->selector);
                         return;
                 }
 
                 ret = uvc_query_ctrl(dev, UVC_GET_INFO, ctrl->entity->id,
                         dev->intfnum, info->selector, &inf, 1);
                 if (ret < 0) {
-                        uvc_trace(UVC_TRACE_CONTROL, "GET_INFO failed on "
-                                "control " UVC_GUID_FORMAT "/%u (%d).\n",
-                                UVC_GUID_ARGS(info->entity), info->selector,
-                                ret);
+                        uvc_trace(UVC_TRACE_CONTROL,
+                                "GET_INFO failed on control %pUl/%u (%d).\n",
+                                info->entity, info->selector, ret);
                         return;
                 }
 
                 flags = info->flags;
                 if (((flags & UVC_CONTROL_GET_CUR) && !(inf & (1 << 0))) ||
                     ((flags & UVC_CONTROL_SET_CUR) && !(inf & (1 << 1)))) {
-                        uvc_trace(UVC_TRACE_CONTROL, "Control "
-                                UVC_GUID_FORMAT "/%u flags don't match "
-                                "supported operations.\n",
-                                UVC_GUID_ARGS(info->entity), info->selector);
+                        uvc_trace(UVC_TRACE_CONTROL, "Control %pUl/%u flags "
+                                "don't match supported operations.\n",
+                                info->entity, info->selector);
                         return;
                 }
         }
 
         ctrl->info = info;
-        ctrl->data = kmalloc(ctrl->info->size * UVC_CTRL_NDATA, GFP_KERNEL);
-        uvc_trace(UVC_TRACE_CONTROL, "Added control " UVC_GUID_FORMAT "/%u "
-                "to device %s entity %u\n", UVC_GUID_ARGS(ctrl->info->entity),
-                ctrl->info->selector, dev->udev->devpath, entity->id);
+        ctrl->data = kmalloc(ctrl->info->size * UVC_CTRL_DATA_LAST, GFP_KERNEL);
+        uvc_trace(UVC_TRACE_CONTROL, "Added control %pUl/%u to device %s "
+                "entity %u\n", ctrl->info->entity, ctrl->info->selector,
+                dev->udev->devpath, entity->id);
 }
 
 /*
@@ -1281,17 +1338,16 @@ int uvc_ctrl_add_info(struct uvc_control_info *info)
                         continue;
 
                 if (ctrl->selector == info->selector) {
-                        uvc_trace(UVC_TRACE_CONTROL, "Control "
-                                UVC_GUID_FORMAT "/%u is already defined.\n",
-                                UVC_GUID_ARGS(info->entity), info->selector);
+                        uvc_trace(UVC_TRACE_CONTROL,
+                                "Control %pUl/%u is already defined.\n",
+                                info->entity, info->selector);
                         ret = -EEXIST;
                         goto end;
                 }
                 if (ctrl->index == info->index) {
-                        uvc_trace(UVC_TRACE_CONTROL, "Control "
-                                UVC_GUID_FORMAT "/%u would overwrite index "
-                                "%d.\n", UVC_GUID_ARGS(info->entity),
-                                info->selector, info->index);
+                        uvc_trace(UVC_TRACE_CONTROL,
+                                "Control %pUl/%u would overwrite index %d.\n",
+                                info->entity, info->selector, info->index);
                         ret = -EEXIST;
                         goto end;
                 }
@@ -1332,10 +1388,9 @@ int uvc_ctrl_add_mapping(struct uvc_control_mapping *mapping)
                         continue;
 
                 if (info->size * 8 < mapping->size + mapping->offset) {
-                        uvc_trace(UVC_TRACE_CONTROL, "Mapping '%s' would "
-                                "overflow control " UVC_GUID_FORMAT "/%u\n",
-                                mapping->name, UVC_GUID_ARGS(info->entity),
-                                info->selector);
+                        uvc_trace(UVC_TRACE_CONTROL,
+                                "Mapping '%s' would overflow control %pUl/%u\n",
+                                mapping->name, info->entity, info->selector);
                         ret = -EOVERFLOW;
                         goto end;
                 }
@@ -1354,9 +1409,9 @@ int uvc_ctrl_add_mapping(struct uvc_control_mapping *mapping)
 
                 mapping->ctrl = info;
                 list_add_tail(&mapping->list, &info->mappings);
-                uvc_trace(UVC_TRACE_CONTROL, "Adding mapping %s to control "
-                        UVC_GUID_FORMAT "/%u.\n", mapping->name,
-                        UVC_GUID_ARGS(info->entity), info->selector);
+                uvc_trace(UVC_TRACE_CONTROL,
+                        "Adding mapping %s to control %pUl/%u.\n",
+                        mapping->name, info->entity, info->selector);
 
                 ret = 0;
                 break;
@@ -1378,6 +1433,7 @@ uvc_ctrl_prune_entity(struct uvc_device *dev, struct uvc_entity *entity)
                 struct usb_device_id id;
                 u8 index;
         } blacklist[] = {
+                { { USB_DEVICE(0x13d3, 0x509b) }, 9 }, /* Gain */
                 { { USB_DEVICE(0x1c4f, 0x3000) }, 6 }, /* WB Temperature */
                 { { USB_DEVICE(0x5986, 0x0241) }, 2 }, /* Hue */
         };
diff --git a/drivers/media/video/uvc/uvc_driver.c b/drivers/media/video/uvc/uvc_driver.c
index 391cccca7ffc..a814820a3f6e 100644
--- a/drivers/media/video/uvc/uvc_driver.c
+++ b/drivers/media/video/uvc/uvc_driver.c
@@ -43,8 +43,9 @@
 #define DRIVER_VERSION          "v0.1.0"
 #endif
 
+unsigned int uvc_clock_param = CLOCK_MONOTONIC;
 unsigned int uvc_no_drop_param;
-static unsigned int uvc_quirks_param;
+static unsigned int uvc_quirks_param = -1;
 unsigned int uvc_trace_param;
 unsigned int uvc_timeout_param = UVC_CTRL_STREAMING_TIMEOUT;
 
@@ -59,6 +60,11 @@ static struct uvc_format_desc uvc_fmts[] = {
                 .fcc            = V4L2_PIX_FMT_YUYV,
         },
         {
+                .name           = "YUV 4:2:2 (YUYV)",
+                .guid           = UVC_GUID_FORMAT_YUY2_ISIGHT,
+                .fcc            = V4L2_PIX_FMT_YUYV,
+        },
+        {
                 .name           = "YUV 4:2:0 (NV12)",
                 .guid           = UVC_GUID_FORMAT_NV12,
                 .fcc            = V4L2_PIX_FMT_NV12,
@@ -309,11 +315,10 @@ static int uvc_parse_format(struct uvc_device *dev,
                                 sizeof format->name);
                         format->fcc = fmtdesc->fcc;
                 } else {
-                        uvc_printk(KERN_INFO, "Unknown video format "
-                                UVC_GUID_FORMAT "\n",
-                                UVC_GUID_ARGS(&buffer[5]));
-                        snprintf(format->name, sizeof format->name,
-                                UVC_GUID_FORMAT, UVC_GUID_ARGS(&buffer[5]));
+                        uvc_printk(KERN_INFO, "Unknown video format %pUl\n",
+                                &buffer[5]);
+                        snprintf(format->name, sizeof(format->name), "%pUl\n",
+                                &buffer[5]);
                         format->fcc = 0;
                 }
 
@@ -1750,7 +1755,8 @@ static int uvc_probe(struct usb_interface *intf,
         dev->udev = usb_get_dev(udev);
         dev->intf = usb_get_intf(intf);
         dev->intfnum = intf->cur_altsetting->desc.bInterfaceNumber;
-        dev->quirks = id->driver_info | uvc_quirks_param;
+        dev->quirks = (uvc_quirks_param == -1)
+                    ? id->driver_info : uvc_quirks_param;
 
         if (udev->product != NULL)
                 strlcpy(dev->name, udev->product, sizeof dev->name);
@@ -1773,9 +1779,9 @@ static int uvc_probe(struct usb_interface *intf,
                 le16_to_cpu(udev->descriptor.idVendor),
                 le16_to_cpu(udev->descriptor.idProduct));
 
-        if (uvc_quirks_param != 0) {
-                uvc_printk(KERN_INFO, "Forcing device quirks 0x%x by module "
-                        "parameter for testing purpose.\n", uvc_quirks_param);
+        if (dev->quirks != id->driver_info) {
+                uvc_printk(KERN_INFO, "Forcing device quirks to 0x%x by module "
+                        "parameter for testing purpose.\n", dev->quirks);
                 uvc_printk(KERN_INFO, "Please report required quirks to the "
                         "linux-uvc-devel mailing list.\n");
         }
@@ -1892,6 +1898,45 @@ static int uvc_reset_resume(struct usb_interface *intf)
 }
 
 /* ------------------------------------------------------------------------
+ * Module parameters
+ */
+
+static int uvc_clock_param_get(char *buffer, struct kernel_param *kp)
+{
+        if (uvc_clock_param == CLOCK_MONOTONIC)
+                return sprintf(buffer, "CLOCK_MONOTONIC");
+        else
+                return sprintf(buffer, "CLOCK_REALTIME");
+}
+
+static int uvc_clock_param_set(const char *val, struct kernel_param *kp)
+{
+        if (strncasecmp(val, "clock_", strlen("clock_")) == 0)
+                val += strlen("clock_");
+
+        if (strcasecmp(val, "monotonic") == 0)
+                uvc_clock_param = CLOCK_MONOTONIC;
+        else if (strcasecmp(val, "realtime") == 0)
+                uvc_clock_param = CLOCK_REALTIME;
+        else
+                return -EINVAL;
+
+        return 0;
+}
+
+module_param_call(clock, uvc_clock_param_set, uvc_clock_param_get,
+                  &uvc_clock_param, S_IRUGO|S_IWUSR);
+MODULE_PARM_DESC(clock, "Video buffers timestamp clock");
+module_param_named(nodrop, uvc_no_drop_param, uint, S_IRUGO|S_IWUSR);
+MODULE_PARM_DESC(nodrop, "Don't drop incomplete frames");
+module_param_named(quirks, uvc_quirks_param, uint, S_IRUGO|S_IWUSR);
+MODULE_PARM_DESC(quirks, "Forced device quirks");
+module_param_named(trace, uvc_trace_param, uint, S_IRUGO|S_IWUSR);
+MODULE_PARM_DESC(trace, "Trace level bitmask");
+module_param_named(timeout, uvc_timeout_param, uint, S_IRUGO|S_IWUSR);
+MODULE_PARM_DESC(timeout, "Streaming control requests timeout");
+
+/* ------------------------------------------------------------------------
  * Driver initialization and cleanup
  */
 
@@ -2197,15 +2242,6 @@ static void __exit uvc_cleanup(void)
 module_init(uvc_init);
 module_exit(uvc_cleanup);
 
-module_param_named(nodrop, uvc_no_drop_param, uint, S_IRUGO|S_IWUSR);
-MODULE_PARM_DESC(nodrop, "Don't drop incomplete frames");
-module_param_named(quirks, uvc_quirks_param, uint, S_IRUGO|S_IWUSR);
-MODULE_PARM_DESC(quirks, "Forced device quirks");
-module_param_named(trace, uvc_trace_param, uint, S_IRUGO|S_IWUSR);
-MODULE_PARM_DESC(trace, "Trace level bitmask");
-module_param_named(timeout, uvc_timeout_param, uint, S_IRUGO|S_IWUSR);
-MODULE_PARM_DESC(timeout, "Streaming control requests timeout");
-
 MODULE_AUTHOR(DRIVER_AUTHOR);
 MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_LICENSE("GPL");
diff --git a/drivers/media/video/uvc/uvc_queue.c b/drivers/media/video/uvc/uvc_queue.c
index ea11839cba4a..4a925a31b0e0 100644
--- a/drivers/media/video/uvc/uvc_queue.c
+++ b/drivers/media/video/uvc/uvc_queue.c
@@ -502,7 +502,6 @@ struct uvc_buffer *uvc_queue_next_buffer(struct uvc_video_queue *queue,
         spin_unlock_irqrestore(&queue->irqlock, flags);
 
         buf->buf.sequence = queue->sequence++;
-        do_gettimeofday(&buf->buf.timestamp);
 
         wake_up(&buf->wait);
         return nextbuf;
diff --git a/drivers/media/video/uvc/uvc_v4l2.c b/drivers/media/video/uvc/uvc_v4l2.c
index 23239a4adefe..43152aa52227 100644
--- a/drivers/media/video/uvc/uvc_v4l2.c
+++ b/drivers/media/video/uvc/uvc_v4l2.c
@@ -539,7 +539,7 @@ static long uvc_v4l2_do_ioctl(struct file *file, unsigned int cmd, void *arg)
                 xctrl.id = ctrl->id;
                 xctrl.value = ctrl->value;
 
-                uvc_ctrl_begin(chain);
+                ret = uvc_ctrl_begin(chain);
                 if (ret < 0)
                         return ret;
 
@@ -549,6 +549,8 @@ static long uvc_v4l2_do_ioctl(struct file *file, unsigned int cmd, void *arg)
                         return ret;
                 }
                 ret = uvc_ctrl_commit(chain);
+                if (ret == 0)
+                        ctrl->value = xctrl.value;
                 break;
         }
 
diff --git a/drivers/media/video/uvc/uvc_video.c b/drivers/media/video/uvc/uvc_video.c
index 7dcf534a0cf3..6b0666be370f 100644
--- a/drivers/media/video/uvc/uvc_video.c
+++ b/drivers/media/video/uvc/uvc_video.c
@@ -410,6 +410,8 @@ static int uvc_video_decode_start(struct uvc_streaming *stream,
          * when the EOF bit is set to force synchronisation on the next packet.
          */
         if (buf->state != UVC_BUF_STATE_ACTIVE) {
+                struct timespec ts;
+
                 if (fid == stream->last_fid) {
                         uvc_trace(UVC_TRACE_FRAME, "Dropping payload (out of "
                                 "sync).\n");
@@ -419,6 +421,14 @@ static int uvc_video_decode_start(struct uvc_streaming *stream,
                         return -ENODATA;
                 }
 
+                if (uvc_clock_param == CLOCK_MONOTONIC)
+                        ktime_get_ts(&ts);
+                else
+                        ktime_get_real_ts(&ts);
+
+                buf->buf.timestamp.tv_sec = ts.tv_sec;
+                buf->buf.timestamp.tv_usec = ts.tv_nsec / NSEC_PER_USEC;
+
                 /* TODO: Handle PTS and SCR. */
                 buf->state = UVC_BUF_STATE_ACTIVE;
         }
diff --git a/drivers/media/video/uvc/uvcvideo.h b/drivers/media/video/uvc/uvcvideo.h
index 2337585001ea..2bba059259e6 100644
--- a/drivers/media/video/uvc/uvcvideo.h
+++ b/drivers/media/video/uvc/uvcvideo.h
@@ -113,6 +113,9 @@ struct uvc_xu_control {
 #define UVC_GUID_FORMAT_YUY2 \
         { 'Y',  'U',  'Y',  '2', 0x00, 0x00, 0x10, 0x00, \
          0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}
+#define UVC_GUID_FORMAT_YUY2_ISIGHT \
+        { 'Y',  'U',  'Y',  '2', 0x00, 0x00, 0x10, 0x00, \
+         0x80, 0x00, 0x00, 0x00, 0x00, 0x38, 0x9b, 0x71}
 #define UVC_GUID_FORMAT_NV12 \
         { 'N',  'V',  '1',  '2', 0x00, 0x00, 0x10, 0x00, \
          0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}
@@ -149,7 +152,7 @@ struct uvc_xu_control {
 #define UVC_MAX_STATUS_SIZE     16
 
 #define UVC_CTRL_CONTROL_TIMEOUT        300
-#define UVC_CTRL_STREAMING_TIMEOUT      3000
+#define UVC_CTRL_STREAMING_TIMEOUT      5000
 
 /* Devices quirks */
 #define UVC_QUIRK_STATUS_INTERVAL       0x00000001
@@ -242,7 +245,8 @@ struct uvc_control {
                            uvc_control_info. */
         __u8 dirty : 1,
              loaded : 1,
-             modified : 1;
+             modified : 1,
+             cached : 1;
 
         __u8 *data;
 };
@@ -533,6 +537,7 @@ struct uvc_driver {
 #define UVC_WARN_MINMAX         0
 #define UVC_WARN_PROBE_DEF      1
 
+extern unsigned int uvc_clock_param;
 extern unsigned int uvc_no_drop_param;
 extern unsigned int uvc_trace_param;
 extern unsigned int uvc_timeout_param;
@@ -552,16 +557,6 @@ extern unsigned int uvc_timeout_param;
 #define uvc_printk(level, msg...) \
         printk(level "uvcvideo: " msg)
 
-#define UVC_GUID_FORMAT "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-" \
-                        "%02x%02x%02x%02x%02x%02x"
-#define UVC_GUID_ARGS(guid) \
-        (guid)[3],  (guid)[2],  (guid)[1],  (guid)[0], \
-        (guid)[5],  (guid)[4], \
-        (guid)[7],  (guid)[6], \
-        (guid)[8],  (guid)[9], \
-        (guid)[10], (guid)[11], (guid)[12], \
-        (guid)[13], (guid)[14], (guid)[15]
-
 /* --------------------------------------------------------------------------
  * Internal functions.
  */
diff --git a/drivers/media/video/v4l2-compat-ioctl32.c b/drivers/media/video/v4l2-compat-ioctl32.c
index c4150bd26337..f77f84bfe714 100644
--- a/drivers/media/video/v4l2-compat-ioctl32.c
+++ b/drivers/media/video/v4l2-compat-ioctl32.c
@@ -288,7 +288,7 @@ static int get_v4l2_window32(struct v4l2_window *kp, struct v4l2_window32 __user
 
 static int put_v4l2_window32(struct v4l2_window *kp, struct v4l2_window32 __user *up)
 {
-        if (copy_to_user(&up->w, &kp->w, sizeof(up->w)) ||
+        if (copy_to_user(&up->w, &kp->w, sizeof(kp->w)) ||
                 put_user(kp->field, &up->field) ||
                 put_user(kp->chromakey, &up->chromakey) ||
                 put_user(kp->clipcount, &up->clipcount))
@@ -475,6 +475,9 @@ static int get_v4l2_buffer32(struct v4l2_buffer *kp, struct v4l2_buffer32 __user
                         return -EFAULT;
         switch (kp->memory) {
         case V4L2_MEMORY_MMAP:
+                if (get_user(kp->length, &up->length) ||
+                        get_user(kp->m.offset, &up->m.offset))
+                        return -EFAULT;
                 break;
         case V4L2_MEMORY_USERPTR:
                 {
diff --git a/drivers/media/video/videobuf-dma-sg.c b/drivers/media/video/videobuf-dma-sg.c
index fa78555b118b..fcd045e7a1c1 100644
--- a/drivers/media/video/videobuf-dma-sg.c
+++ b/drivers/media/video/videobuf-dma-sg.c
@@ -418,6 +418,8 @@ static void *__videobuf_alloc(size_t size)
         struct videobuf_buffer *vb;
 
         vb = kzalloc(size+sizeof(*mem),GFP_KERNEL);
+        if (!vb)
+                return vb;
 
         mem = vb->priv = ((char *)vb)+size;
         mem->magic=MAGIC_SG_MEM;
diff --git a/drivers/media/video/videobuf-vmalloc.c b/drivers/media/video/videobuf-vmalloc.c
index d6e6a28fb6b8..136e09383c06 100644
--- a/drivers/media/video/videobuf-vmalloc.c
+++ b/drivers/media/video/videobuf-vmalloc.c
@@ -138,6 +138,8 @@ static void *__videobuf_alloc(size_t size)
         struct videobuf_buffer *vb;
 
         vb = kzalloc(size+sizeof(*mem),GFP_KERNEL);
+        if (!vb)
+                return vb;
 
         mem = vb->priv = ((char *)vb)+size;
         mem->magic=MAGIC_VMAL_MEM;
diff --git a/drivers/media/video/vivi.c b/drivers/media/video/vivi.c
index 37632a064966..cdbe70385c12 100644
--- a/drivers/media/video/vivi.c
+++ b/drivers/media/video/vivi.c
@@ -1371,7 +1371,7 @@ static int __init vivi_create_instance(int inst)
         /* Now that everything is fine, let's add it to device list */
         list_add_tail(&dev->vivi_devlist, &vivi_devlist);
 
-        if (video_nr >= 0)
+        if (video_nr != -1)
                 video_nr++;
 
         dev->vfd = vfd;
diff --git a/drivers/media/video/zc0301/Kconfig b/drivers/media/video/zc0301/Kconfig
index edb00293cd59..a7e610e0be9e 100644
--- a/drivers/media/video/zc0301/Kconfig
+++ b/drivers/media/video/zc0301/Kconfig
@@ -1,7 +1,11 @@
 config USB_ZC0301
-        tristate "USB ZC0301[P] Image Processor and Control Chip support"
+        tristate "USB ZC0301[P] webcam support (DEPRECATED)"
         depends on VIDEO_V4L2
+        default n
         ---help---
+          This driver is DEPRECATED please use the gspca zc3xx module
+          instead.
+
           Say Y here if you want support for cameras based on the ZC0301 or
           ZC0301P Image Processors and Control Chips.
 
diff --git a/drivers/media/video/zoran/zoran_device.c b/drivers/media/video/zoran/zoran_device.c
index f6c2fb4fc3b4..e6ad4b205611 100644
--- a/drivers/media/video/zoran/zoran_device.c
+++ b/drivers/media/video/zoran/zoran_device.c
@@ -1196,7 +1196,8 @@ zoran_reap_stat_com (struct zoran *zr)
 static void zoran_restart(struct zoran *zr)
 {
         /* Now the stat_comm buffer is ready for restart */
-        int status = 0, mode;
+        unsigned int status = 0;
+        int mode;
 
         if (zr->codec_mode == BUZ_MODE_MOTION_COMPRESS) {
                 decoder_call(zr, video, g_input_status, &status);
@@ -1228,7 +1229,7 @@ error_handler (struct zoran *zr,
                u32           astat,
                u32           stat)
 {
-        int i, j;
+        int i;
 
         /* This is JPEG error handling part */
         if (zr->codec_mode != BUZ_MODE_MOTION_COMPRESS &&
@@ -1279,6 +1280,7 @@ error_handler (struct zoran *zr,
         /* Report error */
         if (zr36067_debug > 1 && zr->num_errors <= 8) {
                 long frame;
+                int j;
 
                 frame = zr->jpg_pend[zr->jpg_dma_tail & BUZ_MASK_FRAME];
                 printk(KERN_ERR
diff --git a/drivers/media/video/zoran/zoran_driver.c b/drivers/media/video/zoran/zoran_driver.c
index 2ddffed019ee..ec41303544e5 100644
--- a/drivers/media/video/zoran/zoran_driver.c
+++ b/drivers/media/video/zoran/zoran_driver.c
@@ -324,7 +324,7 @@ static int jpg_fbuffer_alloc(struct zoran_fh *fh)
                 /* Allocate fragment table for this buffer */
 
                 mem = (void *)get_zeroed_page(GFP_KERNEL);
-                if (mem == 0) {
+                if (!mem) {
                         dprintk(1,
                                 KERN_ERR
                                 "%s: %s - get_zeroed_page (frag_tab) failed for buffer %d\n",
@@ -1444,7 +1444,7 @@ zoran_set_norm (struct zoran *zr,
         }
 
         if (norm == V4L2_STD_ALL) {
-                int status = 0;
+                unsigned int status = 0;
                 v4l2_std_id std = 0;
 
                 decoder_call(zr, video, querystd, &std);
diff --git a/drivers/media/video/zr364xx.c b/drivers/media/video/zr364xx.c
index f0eae83e3d89..3d4bac252902 100644
--- a/drivers/media/video/zr364xx.c
+++ b/drivers/media/video/zr364xx.c
@@ -78,6 +78,7 @@
 #define METHOD0 0
 #define METHOD1 1
 #define METHOD2 2
+#define METHOD3 3
 
 
 /* Module parameters */
@@ -114,7 +115,7 @@ static struct usb_device_id device_table[] = {
         {USB_DEVICE(0x06d6, 0x003b), .driver_info = METHOD0 },
         {USB_DEVICE(0x0a17, 0x004e), .driver_info = METHOD2 },
         {USB_DEVICE(0x041e, 0x405d), .driver_info = METHOD2 },
-        {USB_DEVICE(0x08ca, 0x2102), .driver_info = METHOD2 },
+        {USB_DEVICE(0x08ca, 0x2102), .driver_info = METHOD3 },
         {USB_DEVICE(0x06d6, 0x003d), .driver_info = METHOD0 },
         {}                      /* Terminating entry */
 };
@@ -302,7 +303,7 @@ static message m2[] = {
 };
 
 /* init table */
-static message *init[3] = { m0, m1, m2 };
+static message *init[4] = { m0, m1, m2, m2 };
 
 
 /* JPEG static data in header (Huffman table, etc) */
@@ -967,6 +968,22 @@ static int zr364xx_vidioc_s_fmt_vid_cap(struct file *file, void *priv,
         m0d1[0] = mode;
         m1[2].value = 0xf000 + mode;
         m2[1].value = 0xf000 + mode;
+
+        /* special case for METHOD3, the modes are different */
+        if (cam->method == METHOD3) {
+                switch (mode) {
+                case 1:
+                        m2[1].value = 0xf000 + 4;
+                        break;
+                case 2:
+                        m2[1].value = 0xf000 + 0;
+                        break;
+                default:
+                        m2[1].value = 0xf000 + 1;
+                        break;
+                }
+        }
+
         header2[437] = cam->height / 256;
         header2[438] = cam->height % 256;
         header2[439] = cam->width / 256;
@@ -1582,6 +1599,22 @@ static int zr364xx_probe(struct usb_interface *intf,
         m0d1[0] = mode;
         m1[2].value = 0xf000 + mode;
         m2[1].value = 0xf000 + mode;
+
+        /* special case for METHOD3, the modes are different */
+        if (cam->method == METHOD3) {
+                switch (mode) {
+                case 1:
+                        m2[1].value = 0xf000 + 4;
+                        break;
+                case 2:
+                        m2[1].value = 0xf000 + 0;
+                        break;
+                default:
+                        m2[1].value = 0xf000 + 1;
+                        break;
+                }
+        }
+
         header2[437] = cam->height / 256;
         header2[438] = cam->height % 256;
         header2[439] = cam->width / 256;